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