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