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