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