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