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