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