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