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