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