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