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