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