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