git.oblomov.eu Git - wine/blob - dlls/user32/listbox.c

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