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