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