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

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