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