?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
riched20: Add tests for text limit behavior.
[wine/testsucceed.git] / dlls / user32 / listbox.c
blobe2bf43baf4cd96e116f852f420c27833e9a1e1bb
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( "index=%d notify=%s\n", index, send_notify ? "YES" : "NO" );
1421
1422 if (descr->style & LBS_NOSEL)
1423 {
1424 descr->selected_item = index;
1425 return LB_ERR;
1426 }
1427 if ((index < -1) || (index >= descr->nb_items)) return LB_ERR;
1428 if (descr->style & LBS_MULTIPLESEL)
1429 {
1430 if (index == -1) /* Select all items */
1431 return LISTBOX_SelectItemRange( descr, 0, descr->nb_items, on );
1432 else /* Only one item */
1433 return LISTBOX_SelectItemRange( descr, index, index, on );
1434 }
1435 else
1436 {
1437 INT oldsel = descr->selected_item;
1438 if (index == oldsel) return LB_OKAY;
1439 if (oldsel != -1) descr->items[oldsel].selected = FALSE;
1440 if (index != -1) descr->items[index].selected = TRUE;
1441 descr->selected_item = index;
1442 if (oldsel != -1) LISTBOX_RepaintItem( descr, oldsel, ODA_SELECT );
1443 if (index != -1) LISTBOX_RepaintItem( descr, index, ODA_SELECT );
1444 if (send_notify && descr->nb_items) SEND_NOTIFICATION( descr,
1445 (index != -1) ? LBN_SELCHANGE : LBN_SELCANCEL );
1446 else
1447 if( descr->lphc ) /* set selection change flag for parent combo */
1448 descr->lphc->wState |= CBF_SELCHANGE;
1449 }
1450 return LB_OKAY;
1451 }
1452
1453
1454 /***********************************************************************
1455 * LISTBOX_MoveCaret
1456 *
1457 * Change the caret position and extend the selection to the new caret.
1458 */
1459 static void LISTBOX_MoveCaret( LB_DESCR *descr, INT index, BOOL fully_visible )
1460 {
1461 INT oldfocus = descr->focus_item;
1462
1463 if ((index < 0) || (index >= descr->nb_items))
1464 return;
1465
1466 /* Important, repaint needs to be done in this order if
1467 you want to mimic Windows behavior:
1468 1. Remove the focus and paint the item
1469 2. Remove the selection and paint the item(s)
1470 3. Set the selection and repaint the item(s)
1471 4. Set the focus to 'index' and repaint the item */
1472
1473 /* 1. remove the focus and repaint the item */
1474 descr->focus_item = -1;
1475 if ((oldfocus != -1) && descr->caret_on && (descr->in_focus))
1476 LISTBOX_RepaintItem( descr, oldfocus, ODA_FOCUS );
1477
1478 /* 2. then turn off the previous selection */
1479 /* 3. repaint the new selected item */
1480 if (descr->style & LBS_EXTENDEDSEL)
1481 {
1482 if (descr->anchor_item != -1)
1483 {
1484 INT first = min( index, descr->anchor_item );
1485 INT last = max( index, descr->anchor_item );
1486 if (first > 0)
1487 LISTBOX_SelectItemRange( descr, 0, first - 1, FALSE );
1488 LISTBOX_SelectItemRange( descr, last + 1, -1, FALSE );
1489 LISTBOX_SelectItemRange( descr, first, last, TRUE );
1490 }
1491 }
1492 else if (!(descr->style & LBS_MULTIPLESEL))
1493 {
1494 /* Set selection to new caret item */
1495 LISTBOX_SetSelection( descr, index, TRUE, FALSE );
1496 }
1497
1498 /* 4. repaint the new item with the focus */
1499 descr->focus_item = index;
1500 LISTBOX_MakeItemVisible( descr, index, fully_visible );
1501 if (descr->caret_on && (descr->in_focus))
1502 LISTBOX_RepaintItem( descr, index, ODA_FOCUS );
1503 }
1504
1505
1506 /***********************************************************************
1507 * LISTBOX_InsertItem
1508 */
1509 static LRESULT LISTBOX_InsertItem( LB_DESCR *descr, INT index,
1510 LPWSTR str, ULONG_PTR data )
1511 {
1512 LB_ITEMDATA *item;
1513 INT max_items;
1514 INT oldfocus = descr->focus_item;
1515
1516 if (index == -1) index = descr->nb_items;
1517 else if ((index < 0) || (index > descr->nb_items)) return LB_ERR;
1518 if (!descr->items) max_items = 0;
1519 else max_items = HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(*item);
1520 if (descr->nb_items == max_items)
1521 {
1522 /* We need to grow the array */
1523 max_items += LB_ARRAY_GRANULARITY;
1524 if (descr->items)
1525 item = HeapReAlloc( GetProcessHeap(), 0, descr->items,
1526 max_items * sizeof(LB_ITEMDATA) );
1527 else
1528 item = HeapAlloc( GetProcessHeap(), 0,
1529 max_items * sizeof(LB_ITEMDATA) );
1530 if (!item)
1531 {
1532 SEND_NOTIFICATION( descr, LBN_ERRSPACE );
1533 return LB_ERRSPACE;
1534 }
1535 descr->items = item;
1536 }
1537
1538 /* Insert the item structure */
1539
1540 item = &descr->items[index];
1541 if (index < descr->nb_items)
1542 RtlMoveMemory( item + 1, item,
1543 (descr->nb_items - index) * sizeof(LB_ITEMDATA) );
1544 item->str = str;
1545 item->data = data;
1546 item->height = 0;
1547 item->selected = FALSE;
1548 descr->nb_items++;
1549
1550 /* Get item height */
1551
1552 if (descr->style & LBS_OWNERDRAWVARIABLE)
1553 {
1554 MEASUREITEMSTRUCT mis;
1555 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
1556
1557 mis.CtlType = ODT_LISTBOX;
1558 mis.CtlID = id;
1559 mis.itemID = index;
1560 mis.itemData = descr->items[index].data;
1561 mis.itemHeight = descr->item_height;
1562 SendMessageW( descr->owner, WM_MEASUREITEM, id, (LPARAM)&mis );
1563 item->height = mis.itemHeight ? mis.itemHeight : 1;
1564 TRACE("[%p]: measure item %d (%s) = %d\n",
1565 descr->self, index, str ? debugstr_w(str) : "", item->height );
1566 }
1567
1568 /* Repaint the items */
1569
1570 LISTBOX_UpdateScroll( descr );
1571 LISTBOX_InvalidateItems( descr, index );
1572
1573 /* Move selection and focused item */
1574 /* If listbox was empty, set focus to the first item */
1575 if (descr->nb_items == 1)
1576 LISTBOX_SetCaretIndex( descr, 0, FALSE );
1577 /* single select don't change selection index in win31 */
1578 else if ((ISWIN31) && !(IS_MULTISELECT(descr)))
1579 {
1580 descr->selected_item++;
1581 LISTBOX_SetSelection( descr, descr->selected_item-1, TRUE, FALSE );
1582 }
1583 else
1584 {
1585 if (index <= descr->selected_item)
1586 {
1587 descr->selected_item++;
1588 descr->focus_item = oldfocus; /* focus not changed */
1589 }
1590 }
1591 return LB_OKAY;
1592 }
1593
1594
1595 /***********************************************************************
1596 * LISTBOX_InsertString
1597 */
1598 static LRESULT LISTBOX_InsertString( LB_DESCR *descr, INT index, LPCWSTR str )
1599 {
1600 LPWSTR new_str = NULL;
1601 ULONG_PTR data = 0;
1602 LRESULT ret;
1603
1604 if (HAS_STRINGS(descr))
1605 {
1606 static const WCHAR empty_stringW[] = { 0 };
1607 if (!str) str = empty_stringW;
1608 if (!(new_str = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR) )))
1609 {
1610 SEND_NOTIFICATION( descr, LBN_ERRSPACE );
1611 return LB_ERRSPACE;
1612 }
1613 strcpyW(new_str, str);
1614 }
1615 else data = (ULONG_PTR)str;
1616
1617 if (index == -1) index = descr->nb_items;
1618 if ((ret = LISTBOX_InsertItem( descr, index, new_str, data )) != 0)
1619 {
1620 HeapFree( GetProcessHeap(), 0, new_str );
1621 return ret;
1622 }
1623
1624 TRACE("[%p]: added item %d %s\n",
1625 descr->self, index, HAS_STRINGS(descr) ? debugstr_w(new_str) : "" );
1626 return index;
1627 }
1628
1629
1630 /***********************************************************************
1631 * LISTBOX_DeleteItem
1632 *
1633 * Delete the content of an item. 'index' must be a valid index.
1634 */
1635 static void LISTBOX_DeleteItem( LB_DESCR *descr, INT index )
1636 {
1637 /* Note: Win 3.1 only sends DELETEITEM on owner-draw items,
1638 * while Win95 sends it for all items with user data.
1639 * It's probably better to send it too often than not
1640 * often enough, so this is what we do here.
1641 */
1642 if (IS_OWNERDRAW(descr) || descr->items[index].data)
1643 {
1644 DELETEITEMSTRUCT dis;
1645 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
1646
1647 dis.CtlType = ODT_LISTBOX;
1648 dis.CtlID = id;
1649 dis.itemID = index;
1650 dis.hwndItem = descr->self;
1651 dis.itemData = descr->items[index].data;
1652 SendMessageW( descr->owner, WM_DELETEITEM, id, (LPARAM)&dis );
1653 }
1654 if (HAS_STRINGS(descr))
1655 HeapFree( GetProcessHeap(), 0, descr->items[index].str );
1656 }
1657
1658
1659 /***********************************************************************
1660 * LISTBOX_RemoveItem
1661 *
1662 * Remove an item from the listbox and delete its content.
1663 */
1664 static LRESULT LISTBOX_RemoveItem( LB_DESCR *descr, INT index )
1665 {
1666 LB_ITEMDATA *item;
1667 INT max_items;
1668
1669 if ((index < 0) || (index >= descr->nb_items)) return LB_ERR;
1670
1671 /* We need to invalidate the original rect instead of the updated one. */
1672 LISTBOX_InvalidateItems( descr, index );
1673
1674 LISTBOX_DeleteItem( descr, index );
1675
1676 /* Remove the item */
1677
1678 item = &descr->items[index];
1679 if (index < descr->nb_items-1)
1680 RtlMoveMemory( item, item + 1,
1681 (descr->nb_items - index - 1) * sizeof(LB_ITEMDATA) );
1682 descr->nb_items--;
1683 if (descr->anchor_item == descr->nb_items) descr->anchor_item--;
1684
1685 /* Shrink the item array if possible */
1686
1687 max_items = HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(LB_ITEMDATA);
1688 if (descr->nb_items < max_items - 2*LB_ARRAY_GRANULARITY)
1689 {
1690 max_items -= LB_ARRAY_GRANULARITY;
1691 item = HeapReAlloc( GetProcessHeap(), 0, descr->items,
1692 max_items * sizeof(LB_ITEMDATA) );
1693 if (item) descr->items = item;
1694 }
1695 /* Repaint the items */
1696
1697 LISTBOX_UpdateScroll( descr );
1698 /* if we removed the scrollbar, reset the top of the list
1699 (correct for owner-drawn ???) */
1700 if (descr->nb_items == descr->page_size)
1701 LISTBOX_SetTopItem( descr, 0, TRUE );
1702
1703 /* Move selection and focused item */
1704 if (!IS_MULTISELECT(descr))
1705 {
1706 if (index == descr->selected_item)
1707 descr->selected_item = -1;
1708 else if (index < descr->selected_item)
1709 {
1710 descr->selected_item--;
1711 if (ISWIN31) /* win 31 do not change the selected item number */
1712 LISTBOX_SetSelection( descr, descr->selected_item + 1, TRUE, FALSE);
1713 }
1714 }
1715
1716 if (descr->focus_item >= descr->nb_items)
1717 {
1718 descr->focus_item = descr->nb_items - 1;
1719 if (descr->focus_item < 0) descr->focus_item = 0;
1720 }
1721 return LB_OKAY;
1722 }
1723
1724
1725 /***********************************************************************
1726 * LISTBOX_ResetContent
1727 */
1728 static void LISTBOX_ResetContent( LB_DESCR *descr )
1729 {
1730 INT i;
1731
1732 for(i = descr->nb_items - 1; i>=0; i--) LISTBOX_DeleteItem( descr, i);
1733 HeapFree( GetProcessHeap(), 0, descr->items );
1734 descr->nb_items = 0;
1735 descr->top_item = 0;
1736 descr->selected_item = -1;
1737 descr->focus_item = 0;
1738 descr->anchor_item = -1;
1739 descr->items = NULL;
1740 }
1741
1742
1743 /***********************************************************************
1744 * LISTBOX_SetCount
1745 */
1746 static LRESULT LISTBOX_SetCount( LB_DESCR *descr, INT count )
1747 {
1748 LRESULT ret;
1749
1750 if (HAS_STRINGS(descr))
1751 {
1752 SetLastError(ERROR_SETCOUNT_ON_BAD_LB);
1753 return LB_ERR;
1754 }
1755
1756 /* FIXME: this is far from optimal... */
1757 if (count > descr->nb_items)
1758 {
1759 while (count > descr->nb_items)
1760 if ((ret = LISTBOX_InsertString( descr, -1, 0 )) < 0)
1761 return ret;
1762 }
1763 else if (count < descr->nb_items)
1764 {
1765 while (count < descr->nb_items)
1766 if ((ret = LISTBOX_RemoveItem( descr, (descr->nb_items - 1) )) < 0)
1767 return ret;
1768 }
1769 return LB_OKAY;
1770 }
1771
1772
1773 /***********************************************************************
1774 * LISTBOX_Directory
1775 */
1776 static LRESULT LISTBOX_Directory( LB_DESCR *descr, UINT attrib,
1777 LPCWSTR filespec, BOOL long_names )
1778 {
1779 HANDLE handle;
1780 LRESULT ret = LB_OKAY;
1781 WIN32_FIND_DATAW entry;
1782 int pos;
1783
1784 /* don't scan directory if we just want drives exclusively */
1785 if (attrib != (DDL_DRIVES | DDL_EXCLUSIVE)) {
1786 /* scan directory */
1787 if ((handle = FindFirstFileW(filespec, &entry)) == INVALID_HANDLE_VALUE)
1788 {
1789 int le = GetLastError();
1790 if ((le != ERROR_NO_MORE_FILES) && (le != ERROR_FILE_NOT_FOUND)) return LB_ERR;
1791 }
1792 else
1793 {
1794 do
1795 {
1796 WCHAR buffer[270];
1797 if (entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1798 {
1799 static const WCHAR bracketW[] = { ']',0 };
1800 static const WCHAR dotW[] = { '.',0 };
1801 if (!(attrib & DDL_DIRECTORY) ||
1802 !strcmpW( entry.cFileName, dotW )) continue;
1803 buffer[0] = '[';
1804 if (!long_names && entry.cAlternateFileName[0])
1805 strcpyW( buffer + 1, entry.cAlternateFileName );
1806 else
1807 strcpyW( buffer + 1, entry.cFileName );
1808 strcatW(buffer, bracketW);
1809 }
1810 else /* not a directory */
1811 {
1812 #define ATTRIBS (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | \
1813 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE)
1814
1815 if ((attrib & DDL_EXCLUSIVE) &&
1816 ((attrib & ATTRIBS) != (entry.dwFileAttributes & ATTRIBS)))
1817 continue;
1818 #undef ATTRIBS
1819 if (!long_names && entry.cAlternateFileName[0])
1820 strcpyW( buffer, entry.cAlternateFileName );
1821 else
1822 strcpyW( buffer, entry.cFileName );
1823 }
1824 if (!long_names) CharLowerW( buffer );
1825 pos = LISTBOX_FindFileStrPos( descr, buffer );
1826 if ((ret = LISTBOX_InsertString( descr, pos, buffer )) < 0)
1827 break;
1828 } while (FindNextFileW( handle, &entry ));
1829 FindClose( handle );
1830 }
1831 }
1832
1833 /* scan drives */
1834 if ((ret >= 0) && (attrib & DDL_DRIVES))
1835 {
1836 WCHAR buffer[] = {'[','-','a','-',']',0};
1837 WCHAR root[] = {'A',':','\\',0};
1838 int drive;
1839 for (drive = 0; drive < 26; drive++, buffer[2]++, root[0]++)
1840 {
1841 if (GetDriveTypeW(root) <= DRIVE_NO_ROOT_DIR) continue;
1842 if ((ret = LISTBOX_InsertString( descr, -1, buffer )) < 0)
1843 break;
1844 }
1845 }
1846 return ret;
1847 }
1848
1849
1850 /***********************************************************************
1851 * LISTBOX_HandleVScroll
1852 */
1853 static LRESULT LISTBOX_HandleVScroll( LB_DESCR *descr, WORD scrollReq, WORD pos )
1854 {
1855 SCROLLINFO info;
1856
1857 if (descr->style & LBS_MULTICOLUMN) return 0;
1858 switch(scrollReq)
1859 {
1860 case SB_LINEUP:
1861 LISTBOX_SetTopItem( descr, descr->top_item - 1, TRUE );
1862 break;
1863 case SB_LINEDOWN:
1864 LISTBOX_SetTopItem( descr, descr->top_item + 1, TRUE );
1865 break;
1866 case SB_PAGEUP:
1867 LISTBOX_SetTopItem( descr, descr->top_item -
1868 LISTBOX_GetCurrentPageSize( descr ), TRUE );
1869 break;
1870 case SB_PAGEDOWN:
1871 LISTBOX_SetTopItem( descr, descr->top_item +
1872 LISTBOX_GetCurrentPageSize( descr ), TRUE );
1873 break;
1874 case SB_THUMBPOSITION:
1875 LISTBOX_SetTopItem( descr, pos, TRUE );
1876 break;
1877 case SB_THUMBTRACK:
1878 info.cbSize = sizeof(info);
1879 info.fMask = SIF_TRACKPOS;
1880 GetScrollInfo( descr->self, SB_VERT, &info );
1881 LISTBOX_SetTopItem( descr, info.nTrackPos, TRUE );
1882 break;
1883 case SB_TOP:
1884 LISTBOX_SetTopItem( descr, 0, TRUE );
1885 break;
1886 case SB_BOTTOM:
1887 LISTBOX_SetTopItem( descr, descr->nb_items, TRUE );
1888 break;
1889 }
1890 return 0;
1891 }
1892
1893
1894 /***********************************************************************
1895 * LISTBOX_HandleHScroll
1896 */
1897 static LRESULT LISTBOX_HandleHScroll( LB_DESCR *descr, WORD scrollReq, WORD pos )
1898 {
1899 SCROLLINFO info;
1900 INT page;
1901
1902 if (descr->style & LBS_MULTICOLUMN)
1903 {
1904 switch(scrollReq)
1905 {
1906 case SB_LINELEFT:
1907 LISTBOX_SetTopItem( descr, descr->top_item-descr->page_size,
1908 TRUE );
1909 break;
1910 case SB_LINERIGHT:
1911 LISTBOX_SetTopItem( descr, descr->top_item+descr->page_size,
1912 TRUE );
1913 break;
1914 case SB_PAGELEFT:
1915 page = descr->width / descr->column_width;
1916 if (page < 1) page = 1;
1917 LISTBOX_SetTopItem( descr,
1918 descr->top_item - page * descr->page_size, TRUE );
1919 break;
1920 case SB_PAGERIGHT:
1921 page = descr->width / descr->column_width;
1922 if (page < 1) page = 1;
1923 LISTBOX_SetTopItem( descr,
1924 descr->top_item + page * descr->page_size, TRUE );
1925 break;
1926 case SB_THUMBPOSITION:
1927 LISTBOX_SetTopItem( descr, pos*descr->page_size, TRUE );
1928 break;
1929 case SB_THUMBTRACK:
1930 info.cbSize = sizeof(info);
1931 info.fMask = SIF_TRACKPOS;
1932 GetScrollInfo( descr->self, SB_VERT, &info );
1933 LISTBOX_SetTopItem( descr, info.nTrackPos*descr->page_size,
1934 TRUE );
1935 break;
1936 case SB_LEFT:
1937 LISTBOX_SetTopItem( descr, 0, TRUE );
1938 break;
1939 case SB_RIGHT:
1940 LISTBOX_SetTopItem( descr, descr->nb_items, TRUE );
1941 break;
1942 }
1943 }
1944 else if (descr->horz_extent)
1945 {
1946 switch(scrollReq)
1947 {
1948 case SB_LINELEFT:
1949 LISTBOX_SetHorizontalPos( descr, descr->horz_pos - 1 );
1950 break;
1951 case SB_LINERIGHT:
1952 LISTBOX_SetHorizontalPos( descr, descr->horz_pos + 1 );
1953 break;
1954 case SB_PAGELEFT:
1955 LISTBOX_SetHorizontalPos( descr,
1956 descr->horz_pos - descr->width );
1957 break;
1958 case SB_PAGERIGHT:
1959 LISTBOX_SetHorizontalPos( descr,
1960 descr->horz_pos + descr->width );
1961 break;
1962 case SB_THUMBPOSITION:
1963 LISTBOX_SetHorizontalPos( descr, pos );
1964 break;
1965 case SB_THUMBTRACK:
1966 info.cbSize = sizeof(info);
1967 info.fMask = SIF_TRACKPOS;
1968 GetScrollInfo( descr->self, SB_HORZ, &info );
1969 LISTBOX_SetHorizontalPos( descr, info.nTrackPos );
1970 break;
1971 case SB_LEFT:
1972 LISTBOX_SetHorizontalPos( descr, 0 );
1973 break;
1974 case SB_RIGHT:
1975 LISTBOX_SetHorizontalPos( descr,
1976 descr->horz_extent - descr->width );
1977 break;
1978 }
1979 }
1980 return 0;
1981 }
1982
1983 static LRESULT LISTBOX_HandleMouseWheel(LB_DESCR *descr, SHORT delta )
1984 {
1985 short gcWheelDelta = 0;
1986 UINT pulScrollLines = 3;
1987
1988 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
1989
1990 gcWheelDelta -= delta;
1991
1992 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
1993 {
1994 int cLineScroll = (int) min((UINT) descr->page_size, pulScrollLines);
1995 cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
1996 LISTBOX_SetTopItem( descr, descr->top_item + cLineScroll, TRUE );
1997 }
1998 return 0;
1999 }
2000
2001 /***********************************************************************
2002 * LISTBOX_HandleLButtonDown
2003 */
2004 static LRESULT LISTBOX_HandleLButtonDown( LB_DESCR *descr, DWORD keys, INT x, INT y )
2005 {
2006 INT index = LISTBOX_GetItemFromPoint( descr, x, y );
2007 TRACE("[%p]: lbuttondown %d,%d item %d\n", descr->self, x, y, index );
2008 if (!descr->caret_on && (descr->in_focus)) return 0;
2009
2010 if (!descr->in_focus)
2011 {
2012 if( !descr->lphc ) SetFocus( descr->self );
2013 else SetFocus( (descr->lphc->hWndEdit) ? descr->lphc->hWndEdit : descr->lphc->self );
2014 }
2015
2016 if (index == -1) return 0;
2017
2018 if (descr->style & (LBS_EXTENDEDSEL | LBS_MULTIPLESEL))
2019 {
2020 /* we should perhaps make sure that all items are deselected
2021 FIXME: needed for !LBS_EXTENDEDSEL, too ?
2022 if (!(keys & (MK_SHIFT|MK_CONTROL)))
2023 LISTBOX_SetSelection( descr, -1, FALSE, FALSE);
2024 */
2025
2026 if (!(keys & MK_SHIFT)) descr->anchor_item = index;
2027 if (keys & MK_CONTROL)
2028 {
2029 LISTBOX_SetCaretIndex( descr, index, FALSE );
2030 LISTBOX_SetSelection( descr, index,
2031 !descr->items[index].selected,
2032 (descr->style & LBS_NOTIFY) != 0);
2033 }
2034 else
2035 {
2036 LISTBOX_MoveCaret( descr, index, FALSE );
2037
2038 if (descr->style & LBS_EXTENDEDSEL)
2039 {
2040 LISTBOX_SetSelection( descr, index,
2041 descr->items[index].selected,
2042 (descr->style & LBS_NOTIFY) != 0 );
2043 }
2044 else
2045 {
2046 LISTBOX_SetSelection( descr, index,
2047 !descr->items[index].selected,
2048 (descr->style & LBS_NOTIFY) != 0 );
2049 }
2050 }
2051 }
2052 else
2053 {
2054 descr->anchor_item = index;
2055 LISTBOX_MoveCaret( descr, index, FALSE );
2056 LISTBOX_SetSelection( descr, index,
2057 TRUE, (descr->style & LBS_NOTIFY) != 0 );
2058 }
2059
2060 descr->captured = TRUE;
2061 SetCapture( descr->self );
2062
2063 if (!descr->lphc)
2064 {
2065 if (descr->style & LBS_NOTIFY )
2066 SendMessageW( descr->owner, WM_LBTRACKPOINT, index,
2067 MAKELPARAM( x, y ) );
2068 if (GetWindowLongW( descr->self, GWL_EXSTYLE ) & WS_EX_DRAGDETECT)
2069 {
2070 POINT pt;
2071
2072 pt.x = x;
2073 pt.y = y;
2074
2075 if (DragDetect( descr->self, pt ))
2076 SendMessageW( descr->owner, WM_BEGINDRAG, 0, 0 );
2077 }
2078 }
2079 return 0;
2080 }
2081
2082
2083 /*************************************************************************
2084 * LISTBOX_HandleLButtonDownCombo [Internal]
2085 *
2086 * Process LButtonDown message for the ComboListBox
2087 *
2088 * PARAMS
2089 * pWnd [I] The windows internal structure
2090 * pDescr [I] The ListBox internal structure
2091 * keys [I] Key Flag (WM_LBUTTONDOWN doc for more info)
2092 * x [I] X Mouse Coordinate
2093 * y [I] Y Mouse Coordinate
2094 *
2095 * RETURNS
2096 * 0 since we are processing the WM_LBUTTONDOWN Message
2097 *
2098 * NOTES
2099 * This function is only to be used when a ListBox is a ComboListBox
2100 */
2101
2102 static LRESULT LISTBOX_HandleLButtonDownCombo( LB_DESCR *descr, UINT msg, DWORD keys, INT x, INT y)
2103 {
2104 RECT clientRect, screenRect;
2105 POINT mousePos;
2106
2107 mousePos.x = x;
2108 mousePos.y = y;
2109
2110 GetClientRect(descr->self, &clientRect);
2111
2112 if(PtInRect(&clientRect, mousePos))
2113 {
2114 /* MousePos is in client, resume normal processing */
2115 if (msg == WM_LBUTTONDOWN)
2116 {
2117 descr->lphc->droppedIndex = descr->nb_items ? descr->selected_item : -1;
2118 return LISTBOX_HandleLButtonDown( descr, keys, x, y);
2119 }
2120 else if (descr->style & LBS_NOTIFY)
2121 SEND_NOTIFICATION( descr, LBN_DBLCLK );
2122 }
2123 else
2124 {
2125 POINT screenMousePos;
2126 HWND hWndOldCapture;
2127
2128 /* Check the Non-Client Area */
2129 screenMousePos = mousePos;
2130 hWndOldCapture = GetCapture();
2131 ReleaseCapture();
2132 GetWindowRect(descr->self, &screenRect);
2133 ClientToScreen(descr->self, &screenMousePos);
2134
2135 if(!PtInRect(&screenRect, screenMousePos))
2136 {
2137 LISTBOX_SetCaretIndex( descr, descr->lphc->droppedIndex, FALSE );
2138 LISTBOX_SetSelection( descr, descr->lphc->droppedIndex, FALSE, FALSE );
2139 COMBO_FlipListbox( descr->lphc, FALSE, FALSE );
2140 }
2141 else
2142 {
2143 /* Check to see the NC is a scrollbar */
2144 INT nHitTestType=0;
2145 LONG style = GetWindowLongW( descr->self, GWL_STYLE );
2146 /* Check Vertical scroll bar */
2147 if (style & WS_VSCROLL)
2148 {
2149 clientRect.right += GetSystemMetrics(SM_CXVSCROLL);
2150 if (PtInRect( &clientRect, mousePos ))
2151 nHitTestType = HTVSCROLL;
2152 }
2153 /* Check horizontal scroll bar */
2154 if (style & WS_HSCROLL)
2155 {
2156 clientRect.bottom += GetSystemMetrics(SM_CYHSCROLL);
2157 if (PtInRect( &clientRect, mousePos ))
2158 nHitTestType = HTHSCROLL;
2159 }
2160 /* Windows sends this message when a scrollbar is clicked
2161 */
2162
2163 if(nHitTestType != 0)
2164 {
2165 SendMessageW(descr->self, WM_NCLBUTTONDOWN, nHitTestType,
2166 MAKELONG(screenMousePos.x, screenMousePos.y));
2167 }
2168 /* Resume the Capture after scrolling is complete
2169 */
2170 if(hWndOldCapture != 0)
2171 SetCapture(hWndOldCapture);
2172 }
2173 }
2174 return 0;
2175 }
2176
2177 /***********************************************************************
2178 * LISTBOX_HandleLButtonUp
2179 */
2180 static LRESULT LISTBOX_HandleLButtonUp( LB_DESCR *descr )
2181 {
2182 if (LISTBOX_Timer != LB_TIMER_NONE)
2183 KillSystemTimer( descr->self, LB_TIMER_ID );
2184 LISTBOX_Timer = LB_TIMER_NONE;
2185 if (descr->captured)
2186 {
2187 descr->captured = FALSE;
2188 if (GetCapture() == descr->self) ReleaseCapture();
2189 if ((descr->style & LBS_NOTIFY) && descr->nb_items)
2190 SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2191 }
2192 return 0;
2193 }
2194
2195
2196 /***********************************************************************
2197 * LISTBOX_HandleTimer
2198 *
2199 * Handle scrolling upon a timer event.
2200 * Return TRUE if scrolling should continue.
2201 */
2202 static LRESULT LISTBOX_HandleTimer( LB_DESCR *descr, INT index, TIMER_DIRECTION dir )
2203 {
2204 switch(dir)
2205 {
2206 case LB_TIMER_UP:
2207 if (descr->top_item) index = descr->top_item - 1;
2208 else index = 0;
2209 break;
2210 case LB_TIMER_LEFT:
2211 if (descr->top_item) index -= descr->page_size;
2212 break;
2213 case LB_TIMER_DOWN:
2214 index = descr->top_item + LISTBOX_GetCurrentPageSize( descr );
2215 if (index == descr->focus_item) index++;
2216 if (index >= descr->nb_items) index = descr->nb_items - 1;
2217 break;
2218 case LB_TIMER_RIGHT:
2219 if (index + descr->page_size < descr->nb_items)
2220 index += descr->page_size;
2221 break;
2222 case LB_TIMER_NONE:
2223 break;
2224 }
2225 if (index == descr->focus_item) return FALSE;
2226 LISTBOX_MoveCaret( descr, index, FALSE );
2227 return TRUE;
2228 }
2229
2230
2231 /***********************************************************************
2232 * LISTBOX_HandleSystemTimer
2233 *
2234 * WM_SYSTIMER handler.
2235 */
2236 static LRESULT LISTBOX_HandleSystemTimer( LB_DESCR *descr )
2237 {
2238 if (!LISTBOX_HandleTimer( descr, descr->focus_item, LISTBOX_Timer ))
2239 {
2240 KillSystemTimer( descr->self, LB_TIMER_ID );
2241 LISTBOX_Timer = LB_TIMER_NONE;
2242 }
2243 return 0;
2244 }
2245
2246
2247 /***********************************************************************
2248 * LISTBOX_HandleMouseMove
2249 *
2250 * WM_MOUSEMOVE handler.
2251 */
2252 static void LISTBOX_HandleMouseMove( LB_DESCR *descr,
2253 INT x, INT y )
2254 {
2255 INT index;
2256 TIMER_DIRECTION dir = LB_TIMER_NONE;
2257
2258 if (!descr->captured) return;
2259
2260 if (descr->style & LBS_MULTICOLUMN)
2261 {
2262 if (y < 0) y = 0;
2263 else if (y >= descr->item_height * descr->page_size)
2264 y = descr->item_height * descr->page_size - 1;
2265
2266 if (x < 0)
2267 {
2268 dir = LB_TIMER_LEFT;
2269 x = 0;
2270 }
2271 else if (x >= descr->width)
2272 {
2273 dir = LB_TIMER_RIGHT;
2274 x = descr->width - 1;
2275 }
2276 }
2277 else
2278 {
2279 if (y < 0) dir = LB_TIMER_UP; /* above */
2280 else if (y >= descr->height) dir = LB_TIMER_DOWN; /* below */
2281 }
2282
2283 index = LISTBOX_GetItemFromPoint( descr, x, y );
2284 if (index == -1) index = descr->focus_item;
2285 if (!LISTBOX_HandleTimer( descr, index, dir )) dir = LB_TIMER_NONE;
2286
2287 /* Start/stop the system timer */
2288
2289 if (dir != LB_TIMER_NONE)
2290 SetSystemTimer( descr->self, LB_TIMER_ID, LB_SCROLL_TIMEOUT, NULL);
2291 else if (LISTBOX_Timer != LB_TIMER_NONE)
2292 KillSystemTimer( descr->self, LB_TIMER_ID );
2293 LISTBOX_Timer = dir;
2294 }
2295
2296
2297 /***********************************************************************
2298 * LISTBOX_HandleKeyDown
2299 */
2300 static LRESULT LISTBOX_HandleKeyDown( LB_DESCR *descr, DWORD key )
2301 {
2302 INT caret = -1;
2303 BOOL bForceSelection = TRUE; /* select item pointed to by focus_item */
2304 if ((IS_MULTISELECT(descr)) || (descr->selected_item == descr->focus_item))
2305 bForceSelection = FALSE; /* only for single select list */
2306
2307 if (descr->style & LBS_WANTKEYBOARDINPUT)
2308 {
2309 caret = SendMessageW( descr->owner, WM_VKEYTOITEM,
2310 MAKEWPARAM(LOWORD(key), descr->focus_item),
2311 (LPARAM)descr->self );
2312 if (caret == -2) return 0;
2313 }
2314 if (caret == -1) switch(key)
2315 {
2316 case VK_LEFT:
2317 if (descr->style & LBS_MULTICOLUMN)
2318 {
2319 bForceSelection = FALSE;
2320 if (descr->focus_item >= descr->page_size)
2321 caret = descr->focus_item - descr->page_size;
2322 break;
2323 }
2324 /* fall through */
2325 case VK_UP:
2326 caret = descr->focus_item - 1;
2327 if (caret < 0) caret = 0;
2328 break;
2329 case VK_RIGHT:
2330 if (descr->style & LBS_MULTICOLUMN)
2331 {
2332 bForceSelection = FALSE;
2333 if (descr->focus_item + descr->page_size < descr->nb_items)
2334 caret = descr->focus_item + descr->page_size;
2335 break;
2336 }
2337 /* fall through */
2338 case VK_DOWN:
2339 caret = descr->focus_item + 1;
2340 if (caret >= descr->nb_items) caret = descr->nb_items - 1;
2341 break;
2342
2343 case VK_PRIOR:
2344 if (descr->style & LBS_MULTICOLUMN)
2345 {
2346 INT page = descr->width / descr->column_width;
2347 if (page < 1) page = 1;
2348 caret = descr->focus_item - (page * descr->page_size) + 1;
2349 }
2350 else caret = descr->focus_item-LISTBOX_GetCurrentPageSize(descr) + 1;
2351 if (caret < 0) caret = 0;
2352 break;
2353 case VK_NEXT:
2354 if (descr->style & LBS_MULTICOLUMN)
2355 {
2356 INT page = descr->width / descr->column_width;
2357 if (page < 1) page = 1;
2358 caret = descr->focus_item + (page * descr->page_size) - 1;
2359 }
2360 else caret = descr->focus_item + LISTBOX_GetCurrentPageSize(descr) - 1;
2361 if (caret >= descr->nb_items) caret = descr->nb_items - 1;
2362 break;
2363 case VK_HOME:
2364 caret = 0;
2365 break;
2366 case VK_END:
2367 caret = descr->nb_items - 1;
2368 break;
2369 case VK_SPACE:
2370 if (descr->style & LBS_EXTENDEDSEL) caret = descr->focus_item;
2371 else if (descr->style & LBS_MULTIPLESEL)
2372 {
2373 LISTBOX_SetSelection( descr, descr->focus_item,
2374 !descr->items[descr->focus_item].selected,
2375 (descr->style & LBS_NOTIFY) != 0 );
2376 }
2377 break;
2378 default:
2379 bForceSelection = FALSE;
2380 }
2381 if (bForceSelection) /* focused item is used instead of key */
2382 caret = descr->focus_item;
2383 if (caret >= 0)
2384 {
2385 if (((descr->style & LBS_EXTENDEDSEL) &&
2386 !(GetKeyState( VK_SHIFT ) & 0x8000)) ||
2387 !IS_MULTISELECT(descr))
2388 descr->anchor_item = caret;
2389 LISTBOX_MoveCaret( descr, caret, TRUE );
2390
2391 if (descr->style & LBS_MULTIPLESEL)
2392 descr->selected_item = caret;
2393 else
2394 LISTBOX_SetSelection( descr, caret, TRUE, FALSE);
2395 if (descr->style & LBS_NOTIFY)
2396 {
2397 if( descr->lphc )
2398 {
2399 /* make sure that combo parent doesn't hide us */
2400 descr->lphc->wState |= CBF_NOROLLUP;
2401 }
2402 if (descr->nb_items) SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2403 }
2404 }
2405 return 0;
2406 }
2407
2408
2409 /***********************************************************************
2410 * LISTBOX_HandleChar
2411 */
2412 static LRESULT LISTBOX_HandleChar( LB_DESCR *descr, WCHAR charW )
2413 {
2414 INT caret = -1;
2415 WCHAR str[2];
2416
2417 str[0] = charW;
2418 str[1] = '\0';
2419
2420 if (descr->style & LBS_WANTKEYBOARDINPUT)
2421 {
2422 caret = SendMessageW( descr->owner, WM_CHARTOITEM,
2423 MAKEWPARAM(charW, descr->focus_item),
2424 (LPARAM)descr->self );
2425 if (caret == -2) return 0;
2426 }
2427 if (caret == -1)
2428 caret = LISTBOX_FindString( descr, descr->focus_item, str, FALSE);
2429 if (caret != -1)
2430 {
2431 if ((!IS_MULTISELECT(descr)) && descr->selected_item == -1)
2432 LISTBOX_SetSelection( descr, caret, TRUE, FALSE);
2433 LISTBOX_MoveCaret( descr, caret, TRUE );
2434 if ((descr->style & LBS_NOTIFY) && descr->nb_items)
2435 SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2436 }
2437 return 0;
2438 }
2439
2440
2441 /***********************************************************************
2442 * LISTBOX_Create
2443 */
2444 static BOOL LISTBOX_Create( HWND hwnd, LPHEADCOMBO lphc )
2445 {
2446 LB_DESCR *descr;
2447 MEASUREITEMSTRUCT mis;
2448 RECT rect;
2449
2450 if (!(descr = HeapAlloc( GetProcessHeap(), 0, sizeof(*descr) )))
2451 return FALSE;
2452
2453 GetClientRect( hwnd, &rect );
2454 descr->self = hwnd;
2455 descr->owner = GetParent( descr->self );
2456 descr->style = GetWindowLongW( descr->self, GWL_STYLE );
2457 descr->width = rect.right - rect.left;
2458 descr->height = rect.bottom - rect.top;
2459 descr->items = NULL;
2460 descr->nb_items = 0;
2461 descr->top_item = 0;
2462 descr->selected_item = -1;
2463 descr->focus_item = 0;
2464 descr->anchor_item = -1;
2465 descr->item_height = 1;
2466 descr->page_size = 1;
2467 descr->column_width = 150;
2468 descr->horz_extent = (descr->style & WS_HSCROLL) ? 1 : 0;
2469 descr->horz_pos = 0;
2470 descr->nb_tabs = 0;
2471 descr->tabs = NULL;
2472 descr->caret_on = lphc ? FALSE : TRUE;
2473 if (descr->style & LBS_NOSEL) descr->caret_on = FALSE;
2474 descr->in_focus = FALSE;
2475 descr->captured = FALSE;
2476 descr->font = 0;
2477 descr->locale = GetUserDefaultLCID();
2478 descr->lphc = lphc;
2479
2480 if (is_old_app(descr) && ( descr->style & ( WS_VSCROLL | WS_HSCROLL ) ) )
2481 {
2482 /* Win95 document "List Box Differences" from MSDN:
2483 If a list box in a version 3.x application has either the
2484 WS_HSCROLL or WS_VSCROLL style, the list box receives both
2485 horizontal and vertical scroll bars.
2486 */
2487 descr->style |= WS_VSCROLL | WS_HSCROLL;
2488 }
2489
2490 if( lphc )
2491 {
2492 TRACE("[%p]: resetting owner %p -> %p\n", descr->self, descr->owner, lphc->self );
2493 descr->owner = lphc->self;
2494 }
2495
2496 SetWindowLongPtrW( descr->self, 0, (LONG_PTR)descr );
2497
2498 /* if (wnd->dwExStyle & WS_EX_NOPARENTNOTIFY) descr->style &= ~LBS_NOTIFY;
2499 */
2500 if (descr->style & LBS_EXTENDEDSEL) descr->style |= LBS_MULTIPLESEL;
2501 if (descr->style & LBS_MULTICOLUMN) descr->style &= ~LBS_OWNERDRAWVARIABLE;
2502 if (descr->style & LBS_OWNERDRAWVARIABLE) descr->style |= LBS_NOINTEGRALHEIGHT;
2503 descr->item_height = LISTBOX_SetFont( descr, 0 );
2504
2505 if (descr->style & LBS_OWNERDRAWFIXED)
2506 {
2507 if( descr->lphc && (descr->lphc->dwStyle & CBS_DROPDOWN))
2508 {
2509 /* WinWord gets VERY unhappy if we send WM_MEASUREITEM from here */
2510 descr->item_height = lphc->fixedOwnerDrawHeight;
2511 }
2512 else
2513 {
2514 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
2515 mis.CtlType = ODT_LISTBOX;
2516 mis.CtlID = id;
2517 mis.itemID = -1;
2518 mis.itemWidth = 0;
2519 mis.itemData = 0;
2520 mis.itemHeight = descr->item_height;
2521 SendMessageW( descr->owner, WM_MEASUREITEM, id, (LPARAM)&mis );
2522 descr->item_height = mis.itemHeight ? mis.itemHeight : 1;
2523 }
2524 }
2525
2526 TRACE("owner: %p, style: %08x, width: %d, height: %d\n", descr->owner, descr->style, descr->width, descr->height);
2527 return TRUE;
2528 }
2529
2530
2531 /***********************************************************************
2532 * LISTBOX_Destroy
2533 */
2534 static BOOL LISTBOX_Destroy( LB_DESCR *descr )
2535 {
2536 LISTBOX_ResetContent( descr );
2537 SetWindowLongPtrW( descr->self, 0, 0 );
2538 HeapFree( GetProcessHeap(), 0, descr );
2539 return TRUE;
2540 }
2541
2542
2543 /***********************************************************************
2544 * ListBoxWndProc_common
2545 */
2546 static LRESULT WINAPI ListBoxWndProc_common( HWND hwnd, UINT msg,
2547 WPARAM wParam, LPARAM lParam, BOOL unicode )
2548 {
2549 LB_DESCR *descr = (LB_DESCR *)GetWindowLongPtrW( hwnd, 0 );
2550 LPHEADCOMBO lphc = 0;
2551 LRESULT ret;
2552
2553 if (!descr)
2554 {
2555 if (!IsWindow(hwnd)) return 0;
2556
2557 if (msg == WM_CREATE)
2558 {
2559 CREATESTRUCTW *lpcs = (CREATESTRUCTW *)lParam;
2560 if (lpcs->style & LBS_COMBOBOX) lphc = (LPHEADCOMBO)lpcs->lpCreateParams;
2561 if (!LISTBOX_Create( hwnd, lphc )) return -1;
2562 TRACE("creating wnd=%p descr=%x\n", hwnd, GetWindowLongPtrW( hwnd, 0 ) );
2563 return 0;
2564 }
2565 /* Ignore all other messages before we get a WM_CREATE */
2566 return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
2567 DefWindowProcA( hwnd, msg, wParam, lParam );
2568 }
2569 if (descr->style & LBS_COMBOBOX) lphc = descr->lphc;
2570
2571 TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
2572 descr->self, SPY_GetMsgName(msg, descr->self), wParam, lParam );
2573
2574 switch(msg)
2575 {
2576 case LB_RESETCONTENT16:
2577 case LB_RESETCONTENT:
2578 LISTBOX_ResetContent( descr );
2579 LISTBOX_UpdateScroll( descr );
2580 InvalidateRect( descr->self, NULL, TRUE );
2581 return 0;
2582
2583 case LB_ADDSTRING16:
2584 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2585 /* fall through */
2586 case LB_ADDSTRING:
2587 {
2588 INT ret;
2589 LPWSTR textW;
2590 if(unicode || !HAS_STRINGS(descr))
2591 textW = (LPWSTR)lParam;
2592 else
2593 {
2594 LPSTR textA = (LPSTR)lParam;
2595 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2596 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2597 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2598 }
2599 wParam = LISTBOX_FindStringPos( descr, textW, FALSE );
2600 ret = LISTBOX_InsertString( descr, wParam, textW );
2601 if (!unicode && HAS_STRINGS(descr))
2602 HeapFree(GetProcessHeap(), 0, textW);
2603 return ret;
2604 }
2605
2606 case LB_INSERTSTRING16:
2607 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2608 wParam = (INT)(INT16)wParam;
2609 /* fall through */
2610 case LB_INSERTSTRING:
2611 {
2612 INT ret;
2613 LPWSTR textW;
2614 if(unicode || !HAS_STRINGS(descr))
2615 textW = (LPWSTR)lParam;
2616 else
2617 {
2618 LPSTR textA = (LPSTR)lParam;
2619 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2620 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2621 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2622 }
2623 ret = LISTBOX_InsertString( descr, wParam, textW );
2624 if(!unicode && HAS_STRINGS(descr))
2625 HeapFree(GetProcessHeap(), 0, textW);
2626 return ret;
2627 }
2628
2629 case LB_ADDFILE16:
2630 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2631 /* fall through */
2632 case LB_ADDFILE:
2633 {
2634 INT ret;
2635 LPWSTR textW;
2636 if(unicode || !HAS_STRINGS(descr))
2637 textW = (LPWSTR)lParam;
2638 else
2639 {
2640 LPSTR textA = (LPSTR)lParam;
2641 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2642 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2643 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2644 }
2645 wParam = LISTBOX_FindFileStrPos( descr, textW );
2646 ret = LISTBOX_InsertString( descr, wParam, textW );
2647 if(!unicode && HAS_STRINGS(descr))
2648 HeapFree(GetProcessHeap(), 0, textW);
2649 return ret;
2650 }
2651
2652 case LB_DELETESTRING16:
2653 case LB_DELETESTRING:
2654 if (LISTBOX_RemoveItem( descr, wParam) != LB_ERR)
2655 return descr->nb_items;
2656 else
2657 {
2658 SetLastError(ERROR_INVALID_INDEX);
2659 return LB_ERR;
2660 }
2661
2662 case LB_GETITEMDATA16:
2663 case LB_GETITEMDATA:
2664 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2665 {
2666 SetLastError(ERROR_INVALID_INDEX);
2667 return LB_ERR;
2668 }
2669 return descr->items[wParam].data;
2670
2671 case LB_SETITEMDATA16:
2672 case LB_SETITEMDATA:
2673 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2674 {
2675 SetLastError(ERROR_INVALID_INDEX);
2676 return LB_ERR;
2677 }
2678 descr->items[wParam].data = lParam;
2679 /* undocumented: returns TRUE, not LB_OKAY (0) */
2680 return TRUE;
2681
2682 case LB_GETCOUNT16:
2683 case LB_GETCOUNT:
2684 return descr->nb_items;
2685
2686 case LB_GETTEXT16:
2687 lParam = (LPARAM)MapSL(lParam);
2688 /* fall through */
2689 case LB_GETTEXT:
2690 return LISTBOX_GetText( descr, wParam, (LPWSTR)lParam, unicode );
2691
2692 case LB_GETTEXTLEN16:
2693 /* fall through */
2694 case LB_GETTEXTLEN:
2695 if ((INT)wParam >= descr->nb_items || (INT)wParam < 0)
2696 {
2697 SetLastError(ERROR_INVALID_INDEX);
2698 return LB_ERR;
2699 }
2700 if (!HAS_STRINGS(descr)) return sizeof(DWORD);
2701 if (unicode) return strlenW( descr->items[wParam].str );
2702 return WideCharToMultiByte( CP_ACP, 0, descr->items[wParam].str,
2703 strlenW(descr->items[wParam].str), NULL, 0, NULL, NULL );
2704
2705 case LB_GETCURSEL16:
2706 case LB_GETCURSEL:
2707 if (descr->nb_items == 0)
2708 return LB_ERR;
2709 if (!IS_MULTISELECT(descr))
2710 return descr->selected_item;
2711 if (descr->selected_item != -1)
2712 return descr->selected_item;
2713 return descr->focus_item;
2714 /* otherwise, if the user tries to move the selection with the */
2715 /* arrow keys, we will give the application something to choke on */
2716 case LB_GETTOPINDEX16:
2717 case LB_GETTOPINDEX:
2718 return descr->top_item;
2719
2720 case LB_GETITEMHEIGHT16:
2721 case LB_GETITEMHEIGHT:
2722 return LISTBOX_GetItemHeight( descr, wParam );
2723
2724 case LB_SETITEMHEIGHT16:
2725 lParam = LOWORD(lParam);
2726 /* fall through */
2727 case LB_SETITEMHEIGHT:
2728 return LISTBOX_SetItemHeight( descr, wParam, lParam, TRUE );
2729
2730 case LB_ITEMFROMPOINT:
2731 {
2732 POINT pt;
2733 RECT rect;
2734 int index;
2735 BOOL hit = TRUE;
2736
2737 /* The hiword of the return value is not a client area
2738 hittest as suggested by MSDN, but rather a hittest on
2739 the returned listbox item. */
2740
2741 if(descr->nb_items == 0)
2742 return 0x1ffff; /* win9x returns 0x10000, we copy winnt */
2743
2744 pt.x = (short)LOWORD(lParam);
2745 pt.y = (short)HIWORD(lParam);
2746
2747 SetRect(&rect, 0, 0, descr->width, descr->height);
2748
2749 if(!PtInRect(&rect, pt))
2750 {
2751 pt.x = min(pt.x, rect.right - 1);
2752 pt.x = max(pt.x, 0);
2753 pt.y = min(pt.y, rect.bottom - 1);
2754 pt.y = max(pt.y, 0);
2755 hit = FALSE;
2756 }
2757
2758 index = LISTBOX_GetItemFromPoint(descr, pt.x, pt.y);
2759
2760 if(index == -1)
2761 {
2762 index = descr->nb_items - 1;
2763 hit = FALSE;
2764 }
2765 return MAKELONG(index, hit ? 0 : 1);
2766 }
2767
2768 case LB_SETCARETINDEX16:
2769 case LB_SETCARETINDEX:
2770 if ((!IS_MULTISELECT(descr)) && (descr->selected_item != -1)) return LB_ERR;
2771 if (LISTBOX_SetCaretIndex( descr, wParam, !lParam ) == LB_ERR)
2772 return LB_ERR;
2773 else if (ISWIN31)
2774 return wParam;
2775 else
2776 return LB_OKAY;
2777
2778 case LB_GETCARETINDEX16:
2779 case LB_GETCARETINDEX:
2780 return descr->focus_item;
2781
2782 case LB_SETTOPINDEX16:
2783 case LB_SETTOPINDEX:
2784 return LISTBOX_SetTopItem( descr, wParam, TRUE );
2785
2786 case LB_SETCOLUMNWIDTH16:
2787 case LB_SETCOLUMNWIDTH:
2788 return LISTBOX_SetColumnWidth( descr, wParam );
2789
2790 case LB_GETITEMRECT16:
2791 {
2792 RECT rect;
2793 RECT16 *r16 = MapSL(lParam);
2794 ret = LISTBOX_GetItemRect( descr, (INT16)wParam, &rect );
2795 r16->left = rect.left;
2796 r16->top = rect.top;
2797 r16->right = rect.right;
2798 r16->bottom = rect.bottom;
2799 }
2800 return ret;
2801
2802 case LB_GETITEMRECT:
2803 return LISTBOX_GetItemRect( descr, wParam, (RECT *)lParam );
2804
2805 case LB_FINDSTRING16:
2806 wParam = (INT)(INT16)wParam;
2807 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2808 /* fall through */
2809 case LB_FINDSTRING:
2810 {
2811 INT ret;
2812 LPWSTR textW;
2813 if(unicode || !HAS_STRINGS(descr))
2814 textW = (LPWSTR)lParam;
2815 else
2816 {
2817 LPSTR textA = (LPSTR)lParam;
2818 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2819 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2820 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2821 }
2822 ret = LISTBOX_FindString( descr, wParam, textW, FALSE );
2823 if(!unicode && HAS_STRINGS(descr))
2824 HeapFree(GetProcessHeap(), 0, textW);
2825 return ret;
2826 }
2827
2828 case LB_FINDSTRINGEXACT16:
2829 wParam = (INT)(INT16)wParam;
2830 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2831 /* fall through */
2832 case LB_FINDSTRINGEXACT:
2833 {
2834 INT ret;
2835 LPWSTR textW;
2836 if(unicode || !HAS_STRINGS(descr))
2837 textW = (LPWSTR)lParam;
2838 else
2839 {
2840 LPSTR textA = (LPSTR)lParam;
2841 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2842 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2843 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2844 }
2845 ret = LISTBOX_FindString( descr, wParam, textW, TRUE );
2846 if(!unicode && HAS_STRINGS(descr))
2847 HeapFree(GetProcessHeap(), 0, textW);
2848 return ret;
2849 }
2850
2851 case LB_SELECTSTRING16:
2852 wParam = (INT)(INT16)wParam;
2853 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2854 /* fall through */
2855 case LB_SELECTSTRING:
2856 {
2857 INT index;
2858 LPWSTR textW;
2859
2860 if(HAS_STRINGS(descr))
2861 TRACE("LB_SELECTSTRING: %s\n", unicode ? debugstr_w((LPWSTR)lParam) :
2862 debugstr_a((LPSTR)lParam));
2863 if(unicode || !HAS_STRINGS(descr))
2864 textW = (LPWSTR)lParam;
2865 else
2866 {
2867 LPSTR textA = (LPSTR)lParam;
2868 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2869 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2870 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2871 }
2872 index = LISTBOX_FindString( descr, wParam, textW, FALSE );
2873 if(!unicode && HAS_STRINGS(descr))
2874 HeapFree(GetProcessHeap(), 0, textW);
2875 if (index != LB_ERR)
2876 {
2877 LISTBOX_MoveCaret( descr, index, TRUE );
2878 LISTBOX_SetSelection( descr, index, TRUE, FALSE );
2879 }
2880 return index;
2881 }
2882
2883 case LB_GETSEL16:
2884 wParam = (INT)(INT16)wParam;
2885 /* fall through */
2886 case LB_GETSEL:
2887 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2888 return LB_ERR;
2889 return descr->items[wParam].selected;
2890
2891 case LB_SETSEL16:
2892 lParam = (INT)(INT16)lParam;
2893 /* fall through */
2894 case LB_SETSEL:
2895 return LISTBOX_SetSelection( descr, lParam, wParam, FALSE );
2896
2897 case LB_SETCURSEL16:
2898 wParam = (INT)(INT16)wParam;
2899 /* fall through */
2900 case LB_SETCURSEL:
2901 if (IS_MULTISELECT(descr)) return LB_ERR;
2902 LISTBOX_SetCaretIndex( descr, wParam, TRUE );
2903 ret = LISTBOX_SetSelection( descr, wParam, TRUE, FALSE );
2904 if (lphc && ret != LB_ERR) ret = descr->selected_item;
2905 return ret;
2906
2907 case LB_GETSELCOUNT16:
2908 case LB_GETSELCOUNT:
2909 return LISTBOX_GetSelCount( descr );
2910
2911 case LB_GETSELITEMS16:
2912 return LISTBOX_GetSelItems16( descr, wParam, (LPINT16)MapSL(lParam) );
2913
2914 case LB_GETSELITEMS:
2915 return LISTBOX_GetSelItems( descr, wParam, (LPINT)lParam );
2916
2917 case LB_SELITEMRANGE16:
2918 case LB_SELITEMRANGE:
2919 if (LOWORD(lParam) <= HIWORD(lParam))
2920 return LISTBOX_SelectItemRange( descr, LOWORD(lParam),
2921 HIWORD(lParam), wParam );
2922 else
2923 return LISTBOX_SelectItemRange( descr, HIWORD(lParam),
2924 LOWORD(lParam), wParam );
2925
2926 case LB_SELITEMRANGEEX16:
2927 case LB_SELITEMRANGEEX:
2928 if ((INT)lParam >= (INT)wParam)
2929 return LISTBOX_SelectItemRange( descr, wParam, lParam, TRUE );
2930 else
2931 return LISTBOX_SelectItemRange( descr, lParam, wParam, FALSE);
2932
2933 case LB_GETHORIZONTALEXTENT16:
2934 case LB_GETHORIZONTALEXTENT:
2935 return descr->horz_extent;
2936
2937 case LB_SETHORIZONTALEXTENT16:
2938 case LB_SETHORIZONTALEXTENT:
2939 return LISTBOX_SetHorizontalExtent( descr, wParam );
2940
2941 case LB_GETANCHORINDEX16:
2942 case LB_GETANCHORINDEX:
2943 return descr->anchor_item;
2944
2945 case LB_SETANCHORINDEX16:
2946 wParam = (INT)(INT16)wParam;
2947 /* fall through */
2948 case LB_SETANCHORINDEX:
2949 if (((INT)wParam < -1) || ((INT)wParam >= descr->nb_items))
2950 {
2951 SetLastError(ERROR_INVALID_INDEX);
2952 return LB_ERR;
2953 }
2954 descr->anchor_item = (INT)wParam;
2955 return LB_OKAY;
2956
2957 case LB_DIR16:
2958 /* according to Win16 docs, DDL_DRIVES should make DDL_EXCLUSIVE
2959 * be set automatically (this is different in Win32) */
2960 if (wParam & DDL_DRIVES) wParam |= DDL_EXCLUSIVE;
2961 lParam = (LPARAM)MapSL(lParam);
2962 /* fall through */
2963 case LB_DIR:
2964 {
2965 INT ret;
2966 LPWSTR textW;
2967 if(unicode)
2968 textW = (LPWSTR)lParam;
2969 else
2970 {
2971 LPSTR textA = (LPSTR)lParam;
2972 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2973 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2974 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2975 }
2976 ret = LISTBOX_Directory( descr, wParam, textW, msg == LB_DIR );
2977 if(!unicode)
2978 HeapFree(GetProcessHeap(), 0, textW);
2979 return ret;
2980 }
2981
2982 case LB_GETLOCALE:
2983 return descr->locale;
2984
2985 case LB_SETLOCALE:
2986 {
2987 LCID ret;
2988 if (!IsValidLocale((LCID)wParam, LCID_INSTALLED))
2989 return LB_ERR;
2990 ret = descr->locale;
2991 descr->locale = (LCID)wParam;
2992 return ret;
2993 }
2994
2995 case LB_INITSTORAGE:
2996 return LISTBOX_InitStorage( descr, wParam );
2997
2998 case LB_SETCOUNT:
2999 return LISTBOX_SetCount( descr, (INT)wParam );
3000
3001 case LB_SETTABSTOPS16:
3002 return LISTBOX_SetTabStops( descr, (INT)(INT16)wParam, MapSL(lParam), TRUE );
3003
3004 case LB_SETTABSTOPS:
3005 return LISTBOX_SetTabStops( descr, wParam, (LPINT)lParam, FALSE );
3006
3007 case LB_CARETON16:
3008 case LB_CARETON:
3009 if (descr->caret_on)
3010 return LB_OKAY;
3011 descr->caret_on = TRUE;
3012 if ((descr->focus_item != -1) && (descr->in_focus))
3013 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3014 return LB_OKAY;
3015
3016 case LB_CARETOFF16:
3017 case LB_CARETOFF:
3018 if (!descr->caret_on)
3019 return LB_OKAY;
3020 descr->caret_on = FALSE;
3021 if ((descr->focus_item != -1) && (descr->in_focus))
3022 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3023 return LB_OKAY;
3024
3025 case LB_GETLISTBOXINFO:
3026 FIXME("LB_GETLISTBOXINFO: stub!\n");
3027 return 0;
3028
3029 case WM_DESTROY:
3030 return LISTBOX_Destroy( descr );
3031
3032 case WM_ENABLE:
3033 InvalidateRect( descr->self, NULL, TRUE );
3034 return 0;
3035
3036 case WM_SETREDRAW:
3037 LISTBOX_SetRedraw( descr, wParam != 0 );
3038 return 0;
3039
3040 case WM_GETDLGCODE:
3041 return DLGC_WANTARROWS | DLGC_WANTCHARS;
3042
3043 case WM_PRINTCLIENT:
3044 case WM_PAINT:
3045 {
3046 PAINTSTRUCT ps;
3047 HDC hdc = ( wParam ) ? ((HDC)wParam) : BeginPaint( descr->self, &ps );
3048 ret = LISTBOX_Paint( descr, hdc );
3049 if( !wParam ) EndPaint( descr->self, &ps );
3050 }
3051 return ret;
3052 case WM_SIZE:
3053 LISTBOX_UpdateSize( descr );
3054 return 0;
3055 case WM_GETFONT:
3056 return (LRESULT)descr->font;
3057 case WM_SETFONT:
3058 LISTBOX_SetFont( descr, (HFONT)wParam );
3059 if (lParam) InvalidateRect( descr->self, 0, TRUE );
3060 return 0;
3061 case WM_SETFOCUS:
3062 descr->in_focus = TRUE;
3063 descr->caret_on = TRUE;
3064 if (descr->focus_item != -1)
3065 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3066 SEND_NOTIFICATION( descr, LBN_SETFOCUS );
3067 return 0;
3068 case WM_KILLFOCUS:
3069 descr->in_focus = FALSE;
3070 if ((descr->focus_item != -1) && descr->caret_on)
3071 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3072 SEND_NOTIFICATION( descr, LBN_KILLFOCUS );
3073 return 0;
3074 case WM_HSCROLL:
3075 return LISTBOX_HandleHScroll( descr, LOWORD(wParam), HIWORD(wParam) );
3076 case WM_VSCROLL:
3077 return LISTBOX_HandleVScroll( descr, LOWORD(wParam), HIWORD(wParam) );
3078 case WM_MOUSEWHEEL:
3079 if (wParam & (MK_SHIFT | MK_CONTROL))
3080 return DefWindowProcW( descr->self, msg, wParam, lParam );
3081 return LISTBOX_HandleMouseWheel( descr, (SHORT)HIWORD(wParam) );
3082 case WM_LBUTTONDOWN:
3083 if (lphc)
3084 return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
3085 (INT16)LOWORD(lParam),
3086 (INT16)HIWORD(lParam) );
3087 return LISTBOX_HandleLButtonDown( descr, wParam,
3088 (INT16)LOWORD(lParam),
3089 (INT16)HIWORD(lParam) );
3090 case WM_LBUTTONDBLCLK:
3091 if (lphc)
3092 return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
3093 (INT16)LOWORD(lParam),
3094 (INT16)HIWORD(lParam) );
3095 if (descr->style & LBS_NOTIFY)
3096 SEND_NOTIFICATION( descr, LBN_DBLCLK );
3097 return 0;
3098 case WM_MOUSEMOVE:
3099 if ( lphc && ((lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE) )
3100 {
3101 BOOL captured = descr->captured;
3102 POINT mousePos;
3103 RECT clientRect;
3104
3105 mousePos.x = (INT16)LOWORD(lParam);
3106 mousePos.y = (INT16)HIWORD(lParam);
3107
3108 /*
3109 * If we are in a dropdown combobox, we simulate that
3110 * the mouse is captured to show the tracking of the item.
3111 */
3112 if (GetClientRect(descr->self, &clientRect) && PtInRect( &clientRect, mousePos ))
3113 descr->captured = TRUE;
3114
3115 LISTBOX_HandleMouseMove( descr, mousePos.x, mousePos.y);
3116
3117 descr->captured = captured;
3118 }
3119 else if (GetCapture() == descr->self)
3120 {
3121 LISTBOX_HandleMouseMove( descr, (INT16)LOWORD(lParam),
3122 (INT16)HIWORD(lParam) );
3123 }
3124 return 0;
3125 case WM_LBUTTONUP:
3126 if (lphc)
3127 {
3128 POINT mousePos;
3129 RECT clientRect;
3130
3131 /*
3132 * If the mouse button "up" is not in the listbox,
3133 * we make sure there is no selection by re-selecting the
3134 * item that was selected when the listbox was made visible.
3135 */
3136 mousePos.x = (INT16)LOWORD(lParam);
3137 mousePos.y = (INT16)HIWORD(lParam);
3138
3139 GetClientRect(descr->self, &clientRect);
3140
3141 /*
3142 * When the user clicks outside the combobox and the focus
3143 * is lost, the owning combobox will send a fake buttonup with
3144 * 0xFFFFFFF as the mouse location, we must also revert the
3145 * selection to the original selection.
3146 */
3147 if ( (lParam == (LPARAM)-1) || (!PtInRect( &clientRect, mousePos )) )
3148 LISTBOX_MoveCaret( descr, lphc->droppedIndex, FALSE );
3149 }
3150 return LISTBOX_HandleLButtonUp( descr );
3151 case WM_KEYDOWN:
3152 if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
3153 {
3154 /* for some reason Windows makes it possible to
3155 * show/hide ComboLBox by sending it WM_KEYDOWNs */
3156
3157 if( (!(lphc->wState & CBF_EUI) && wParam == VK_F4) ||
3158 ( (lphc->wState & CBF_EUI) && !(lphc->wState & CBF_DROPPED)
3159 && (wParam == VK_DOWN || wParam == VK_UP)) )
3160 {
3161 COMBO_FlipListbox( lphc, FALSE, FALSE );
3162 return 0;
3163 }
3164 }
3165 return LISTBOX_HandleKeyDown( descr, wParam );
3166 case WM_CHAR:
3167 {
3168 WCHAR charW;
3169 if(unicode)
3170 charW = (WCHAR)wParam;
3171 else
3172 {
3173 CHAR charA = (CHAR)wParam;
3174 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
3175 }
3176 return LISTBOX_HandleChar( descr, charW );
3177 }
3178 case WM_SYSTIMER:
3179 return LISTBOX_HandleSystemTimer( descr );
3180 case WM_ERASEBKGND:
3181 if ((IS_OWNERDRAW(descr)) && !(descr->style & LBS_DISPLAYCHANGED))
3182 {
3183 RECT rect;
3184 HBRUSH hbrush = (HBRUSH)SendMessageW( descr->owner, WM_CTLCOLORLISTBOX,
3185 wParam, (LPARAM)descr->self );
3186 TRACE("hbrush = %p\n", hbrush);
3187 if(!hbrush)
3188 hbrush = GetSysColorBrush(COLOR_WINDOW);
3189 if(hbrush)
3190 {
3191 GetClientRect(descr->self, &rect);
3192 FillRect((HDC)wParam, &rect, hbrush);
3193 }
3194 }
3195 return 1;
3196 case WM_DROPFILES:
3197 if( lphc ) return 0;
3198 return unicode ? SendMessageW( descr->owner, msg, wParam, lParam ) :
3199 SendMessageA( descr->owner, msg, wParam, lParam );
3200
3201 case WM_NCDESTROY:
3202 if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
3203 lphc->hWndLBox = 0;
3204 break;
3205
3206 case WM_NCACTIVATE:
3207 if (lphc) return 0;
3208 break;
3209
3210 default:
3211 if ((msg >= WM_USER) && (msg < 0xc000))
3212 WARN("[%p]: unknown msg %04x wp %08lx lp %08lx\n",
3213 hwnd, msg, wParam, lParam );
3214 }
3215
3216 return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
3217 DefWindowProcA( hwnd, msg, wParam, lParam );
3218 }
3219
3220 /***********************************************************************
3221 * ListBoxWndProcA
3222 */
3223 static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3224 {
3225 return ListBoxWndProc_common( hwnd, msg, wParam, lParam, FALSE );
3226 }
3227
3228 /***********************************************************************
3229 * ListBoxWndProcW
3230 */
3231 static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3232 {
3233 return ListBoxWndProc_common( hwnd, msg, wParam, lParam, TRUE );
3234 }
Quick hack tree for wine patches julliard doesn't want to commit