windows-server-2003/shell/comctl32/v6/listbox_ctl2.c

#include "ctlspriv.h"
#pragma hdrstop
#include <limits.h>
#include "usrctl32.h"
#include "listbox.h"


//---------------------------------------------------------------------------//
//
//  Defines and common macros
//

#define LB_KEYDOWN  WM_USER+1

#define NOMODIFIER  0                       // No modifier is down
#define SHIFTDOWN   1                       // Shift alone
#define CTLDOWN     2                       // Ctl alone
#define SHCTLDOWN   (SHIFTDOWN + CTLDOWN)   // Ctrl + Shift

//
// Variables for incremental type search support
//
#define MAX_TYPESEARCH  256

//
// LATER IanJa: these vary by country!  For US they are VK_OEM_2 VK_OEM_5.
//       Change lboxctl2.c MapVirtualKey to character - and fix the spelling?
//
#define VERKEY_SLASH        0xBF    // Vertual key for '/' character
#define VERKEY_BACKSLASH    0xDC    // Vertual key for '\' character


//---------------------------------------------------------------------------//
//
// Forwards
//
VOID ListBox_NewITopEx(PLBIV, INT, DWORD);
VOID ListBox_FillDrawItem(PLBIV, INT, UINT, UINT, LPRECT);
VOID ListBox_BlockHilite(PLBIV, INT, BOOL);
VOID ListBox_AlterHilite(PLBIV, INT, INT, BOOL, INT, BOOL);


//---------------------------------------------------------------------------//
//
// ListBox_TermDC
//
// Cleans up when done with listbox dc.
//
__inline void ListBox_TermDC(PLBIV plb)
{
    if (plb->hFont)
    {
        SelectObject(plb->hdc, GetStockObject(SYSTEM_FONT));
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_InitDC
//
// Initializes dc for listbox
//
void ListBox_InitDC(PLBIV plb)
{
    RECT rc;

    //
    // Set font
    //
    if (plb->hFont)
    {
        SelectObject(plb->hdc, plb->hFont);
    }

    //
    // Set clipping area
    //
    GetClientRect(plb->hwnd, &rc);
    IntersectClipRect(plb->hdc, rc.left, rc.top, rc.right, rc.bottom);

    OffsetWindowOrgEx(plb->hdc, plb->xOrigin, 0, NULL);
}


//---------------------------------------------------------------------------//
//
// ListBox_GetDC
//
// Returns a DC which can be used by a list box even if parentDC is in effect
//
BOOL ListBox_GetDC(PLBIV plb)
{
    if (plb->hdc)
    {
        return FALSE;
    }

    plb->hdc = GetDC(plb->hwnd);

    ListBox_InitDC(plb);

    return TRUE;
}


//---------------------------------------------------------------------------//
void ListBox_ReleaseDC(PLBIV plb)
{
    ListBox_TermDC(plb);
    ReleaseDC(plb->hwnd, plb->hdc);
    plb->hdc = NULL;
}


//---------------------------------------------------------------------------//
//
// ListBox_InvalidateRect()
//
// If the listbox is visible, invalidates a rectangle in the listbox.
// If the listbox is not visible, sets the defer update flag for the listbox
//
BOOL ListBox_InvalidateRect(PLBIV plb, LPRECT lprc, BOOL fErase)
{
    if (IsLBoxVisible(plb)) 
    {
        InvalidateRect(plb->hwnd, lprc, fErase);

        return TRUE;
    }

    if (!plb->fRedraw)
    {
        plb->fDeferUpdate = TRUE;
    }

    return FALSE;
}


//---------------------------------------------------------------------------//
//
// ListBox_GetBrush
//
// Gets background brush & colors for listbox.
//
HBRUSH ListBox_GetBrush(PLBIV plb, HBRUSH *phbrOld)
{
    HBRUSH  hbr;
    HBRUSH  hbrOld;
    HWND hwndParent = plb->hwndParent;

    SetBkMode(plb->hdc, OPAQUE);

    //
    // Get brush & colors
    //

    // copied from windows\core\ntuser\kernel\random.c
    if (hwndParent == NULL || hwndParent == GetDesktopWindow()) 
    {
        hbr = (HBRUSH)SendMessage(plb->hwnd, WM_CTLCOLORLISTBOX, (WPARAM)plb->hdc, (LPARAM)plb->hwnd);
    } 
    else
    {
        hbr = (HBRUSH)SendMessage(hwndParent, WM_CTLCOLORLISTBOX, (WPARAM)plb->hdc, (LPARAM)plb->hwnd);
    }

    ASSERT(hbr != 0);

    //
    // Select brush into dc
    //
    if (hbr != NULL) 
    {
        hbrOld = SelectObject(plb->hdc, hbr);
        if (phbrOld)
        {
            *phbrOld = hbrOld;
        }
    }

    return hbr;
}


//---------------------------------------------------------------------------//
//
// ListBox_GetItemRectHandler
//
// Return the rectangle that the item will be drawn in with respect to the
// listbox window.  Returns TRUE if any portion of the item's rectangle
// is visible (ie. in the listbox client rect) else returns FALSE.
//
BOOL ListBox_GetItemRectHandler(PLBIV plb, INT sItem, LPRECT lprc)
{
    INT sTmp;
    int clientbottom;

    //
    // Always allow an item number of 0 so that we can draw the caret which
    // indicates the listbox has the focus even though it is empty.
    //
    // FreeHand 3.1 passes in -1 as the itemNumber and expects
    // a non-null rectangle. So we check for -1 specifically.
    // BUGTAG: Fix for Bug #540 --Win95B-- SANKAR -- 2/20/95 --
    //

    if (sItem && (sItem != -1) && ((UINT)sItem >= (UINT)plb->cMac))
    {
        SetRectEmpty(lprc);
        TraceMsg(TF_STANDARD, "Invalid index");

        return LB_ERR;
    }

    GetClientRect(plb->hwnd, lprc);

    if (plb->fMultiColumn) 
    {
        //
        // itemHeight * sItem mod number ItemsPerColumn (itemsPerColumn)
        //
        lprc->top = plb->cyChar * (sItem % plb->itemsPerColumn);
        lprc->bottom = lprc->top + plb->cyChar;  //+(plb->OwnerDraw ? 0 : 1);

        ASSERT(plb->itemsPerColumn);

        if (plb->fRightAlign) 
        {
            lprc->right = lprc->right - plb->cxColumn *
                 ((sItem / plb->itemsPerColumn) - (plb->iTop / plb->itemsPerColumn));

            lprc->left = lprc->right - plb->cxColumn;
        } 
        else 
        {
            //
            // Remember, this is integer division here...
            //
            lprc->left += plb->cxColumn *
                      ((sItem / plb->itemsPerColumn) - (plb->iTop / plb->itemsPerColumn));

            lprc->right = lprc->left + plb->cxColumn;
        }
    } 
    else if (plb->OwnerDraw == OWNERDRAWVAR) 
    {
        //
        // Var height owner draw
        //
        lprc->right += plb->xOrigin;
        clientbottom = lprc->bottom;

        if (sItem >= plb->iTop) 
        {
            for (sTmp = plb->iTop; sTmp < sItem; sTmp++) 
            {
                lprc->top = lprc->top + ListBox_GetVarHeightItemHeight(plb, sTmp);
            }

            //
            // If item number is 0, it may be we are asking for the rect
            // associated with a nonexistant item so that we can draw a caret
            // indicating focus on an empty listbox.
            //
            lprc->bottom = lprc->top + (sItem < plb->cMac ? ListBox_GetVarHeightItemHeight(plb, sItem) : plb->cyChar);

            return (lprc->top < clientbottom);
        } 
        else 
        {
            //
            // Item we want the rect of is before plb->iTop.  Thus, negative
            // offsets for the rect and it is never visible.
            //
            for (sTmp = sItem; sTmp < plb->iTop; sTmp++) 
            {
                lprc->top = lprc->top - ListBox_GetVarHeightItemHeight(plb, sTmp);
            }

            lprc->bottom = lprc->top + ListBox_GetVarHeightItemHeight(plb, sItem);

            return FALSE;
        }
    } 
    else 
    {
        //
        // For fixed height listboxes
        //
        if (plb->fRightAlign && !(plb->fMultiColumn || plb->OwnerDraw) && plb->fHorzBar)
            lprc->right += plb->xOrigin + (plb->xRightOrigin - plb->xOrigin);
        else
            lprc->right += plb->xOrigin;
        lprc->top = (sItem - plb->iTop) * plb->cyChar;
        lprc->bottom = lprc->top + plb->cyChar;
    }

    return (sItem >= plb->iTop) &&
            (sItem < (plb->iTop + ListBox_CItemInWindow(plb, TRUE)));
}


//---------------------------------------------------------------------------//
//
// ListBox_PrintCallback
//
// Called back from DrawState
//
BOOL CALLBACK ListBox_PrintCallback(HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy)
{
    LPWSTR  lpstr = (LPWSTR)lData;
    PLBIV   plb = (PLBIV)wData;
    int     xStart;
    UINT    cLen;
    RECT    rc;
    UINT    oldAlign;

    if (!lpstr) 
    {
        return FALSE;
    }

    xStart = plb->fMultiColumn ? 0 : 2;

    if (plb->fRightAlign) 
    {
        oldAlign = SetTextAlign(hdc, TA_RIGHT | GetTextAlign(hdc));
        xStart = cx - xStart;
    }

    cLen = wcslen(lpstr);

    if (plb->fUseTabStops) 
    {
        TabbedTextOut(hdc, xStart, 0, lpstr, cLen,
            (plb->iTabPixelPositions ? plb->iTabPixelPositions[0] : 0),
            (plb->iTabPixelPositions ? (LPINT)&plb->iTabPixelPositions[1] : NULL),
            plb->fRightAlign ? cx : 0); //, TRUE, GetTextCharset(plb->hdc));
    } 
    else 
    {
        rc.left     = 0;
        rc.top      = 0;
        rc.right    = cx;
        rc.bottom   = cy;

        if (plb->wMultiple)
        {
            ExtTextOut(hdc, xStart, 0, ETO_OPAQUE, &rc, lpstr, cLen, NULL);
        }
        else if (plb->fMultiColumn)
        {
            ExtTextOut(hdc, xStart, 0, ETO_CLIPPED, &rc, lpstr, cLen, NULL);
        }
        else 
        {
            ExtTextOut(hdc, xStart, 0, 0, NULL, lpstr, cLen, NULL);

            //
            // When the listbox is in the incremental search mode and the item
            // is highlighted (so we only draw in the current item), draw the
            // caret for search indication.
            //
            if ((plb->iTypeSearch != 0) && (plb->OwnerDraw == 0) &&
                    (GetBkColor(hdc) == SYSRGB(HIGHLIGHT))) 
            {
                SIZE size;
                GetTextExtentPointW(hdc, lpstr, plb->iTypeSearch, &size);
                PatBlt(hdc, xStart + size.cx - 1, 1, 1, cy - 2, DSTINVERT);
            }
        }
    }

    if (plb->fRightAlign)
    {
        SetTextAlign(hdc, oldAlign);
    }

    return TRUE;
}


//---------------------------------------------------------------------------//
void ListBox_DrawItem(PLBIV plb, INT sItem, LPRECT lprect, BOOL fHilite, HBRUSH hbr)
{
    LPWSTR lpstr;
    DWORD rgbSave;
    DWORD rgbBkSave;
    UINT    uFlags;
    HDC     hdc = plb->hdc;
    UINT  oldAlign;
    HBRUSH hNewBrush;


    //
    // If the item is selected, then fill with highlight color
    //
    if (fHilite) 
    {
        FillRectClr(hdc, lprect, SYSRGB(HIGHLIGHT));
        
        rgbBkSave = SetBkColor(hdc, SYSRGB(HIGHLIGHT));
        rgbSave = SetTextColor(hdc, SYSRGB(HIGHLIGHTTEXT));
    } 
    else 
    {
        //
        // If fUseTabStops, we must fill the background, because later we use
        // LBTabTheTextOutForWimps(), which fills the background only partially
        // Fix for Bug #1509 -- 01/25/91 -- SANKAR --
        //
        if ((hbr != NULL) && ((sItem == plb->iSelBase) || (plb->fUseTabStops))) 
        {
            FillRect(hdc, lprect, hbr);
        }
    }

    uFlags = DST_COMPLEX;
    lpstr = GetLpszItem(plb, sItem);

    if (TESTFLAG(GET_STYLE(plb), WS_DISABLED)) 
    {
        if ((COLORREF)SYSRGB(GRAYTEXT) != GetBkColor(hdc))
        {
            SetTextColor(hdc, SYSRGB(GRAYTEXT));
        }
        else
        {
            uFlags |= DSS_UNION;
        }
    }

    if (plb->fRightAlign)
    {
        uFlags |= DSS_RIGHT;
    }

    if (plb->fRtoLReading)
    {
        oldAlign = SetTextAlign(hdc, TA_RTLREADING | GetTextAlign(hdc));
    }

    hNewBrush = CreateSolidBrush(SYSRGB(WINDOWTEXT));

    DrawState(hdc, hNewBrush,
        ListBox_PrintCallback,
        (LPARAM)lpstr,
        (WPARAM)plb,
        lprect->left,
        lprect->top,
        lprect->right-lprect->left,
        lprect->bottom-lprect->top,
        uFlags);

    if (hNewBrush)
    {
        DeleteObject(hNewBrush);
    }

    if (plb->fRtoLReading)
    {
        SetTextAlign(hdc, oldAlign);
    }

    if (fHilite) 
    {
        SetTextColor(hdc, rgbSave);
        SetBkColor(hdc, rgbBkSave);
    }
}


//---------------------------------------------------------------------------//
void ListBox_SetCaret(PLBIV plb, BOOL fSetCaret)
{
    RECT    rc;
    BOOL    fNewDC;

    if (plb->fCaret && ((BOOL) plb->fCaretOn != !!fSetCaret)) 
    {
        if (IsLBoxVisible(plb)) 
        {
            //
            // Turn the caret (located at plb->iSelBase) on
            //
            fNewDC = ListBox_GetDC(plb);

            ListBox_GetItemRectHandler(plb, plb->iSelBase, &rc);

            if (fNewDC) 
            {
                SetBkColor(plb->hdc, SYSRGB(WINDOW));
                SetTextColor(plb->hdc, SYSRGB(WINDOWTEXT));
            }

            if (plb->OwnerDraw) 
            {
                //
                // Fill in the drawitem struct
                //
                UINT itemState = (fSetCaret) ? ODS_FOCUS : 0;

                if (ListBox_IsSelected(plb, plb->iSelBase, HILITEONLY))
                {
                    itemState |= ODS_SELECTED;
                }

                ListBox_FillDrawItem(plb, plb->iSelBase, ODA_FOCUS, itemState, &rc);
            } 
            else if (!TESTFLAG(GET_EXSTYLE(plb), WS_EXP_UIFOCUSHIDDEN)) 
            {
                COLORREF crBk = SetBkColor(plb->hdc, SYSRGB(WINDOW));
                COLORREF crText = SetTextColor(plb->hdc, SYSRGB(WINDOWTEXT));

                DrawFocusRect(plb->hdc, &rc);

                SetBkColor(plb->hdc, crBk);
                SetTextColor(plb->hdc, crText);
            }

            if (fNewDC)
            {
                ListBox_ReleaseDC(plb);
            }
        }

        plb->fCaretOn = !!fSetCaret;
    }
}


//---------------------------------------------------------------------------//
BOOL ListBox_IsSelected(PLBIV plb, INT sItem, UINT wOpFlags)
{
    LPBYTE lp;

    if ((sItem >= plb->cMac) || (sItem < 0)) 
    {
        TraceMsg(TF_STANDARD, "Invalid index");

        return FALSE;
    }

    if (plb->wMultiple == SINGLESEL) 
    {
        return (sItem == plb->iSel);
    }

    lp = plb->rgpch + sItem +
             (plb->cMac * (plb->fHasStrings
                                ? sizeof(LBItem)
                                : (plb->fHasData
                                    ? sizeof(LBODItem)
                                    : 0)));
    sItem = *lp;

    if (wOpFlags == HILITEONLY) 
    {
        sItem >>= 4;
    } 
    else 
    {
        //
        // SELONLY
        //
        sItem &= 0x0F;
    }

    return sItem;
}


//---------------------------------------------------------------------------//
//
// ListBox_CItemInWindow
//
// Returns the number of items which can fit in a list box.  It
// includes the partially visible one at the bottom if fPartial is TRUE. For
// var height ownerdraw, return the number of items visible starting at iTop
// and going to the bottom of the client rect.
//
INT ListBox_CItemInWindow(PLBIV plb, BOOL fPartial)
{
    RECT rect;

    if (plb->OwnerDraw == OWNERDRAWVAR) 
    {
        return ListBox_VisibleItemsVarOwnerDraw(plb, fPartial);
    }

    if (plb->fMultiColumn) 
    {
        return plb->itemsPerColumn * (plb->numberOfColumns + (fPartial ? 1 : 0));
    }

    GetClientRect(plb->hwnd, &rect);

    //
    // fPartial must be considered only if the listbox height is not an
    // integral multiple of character height.
    // A part of the fix for Bug #3727 -- 01/14/91 -- SANKAR --
    //
    ASSERT(plb->cyChar);

    if (!plb->cyChar)
    {
        plb->cyChar = SYSFONT_CYCHAR;
    }

    return (INT)((rect.bottom / plb->cyChar) +
            ((rect.bottom % plb->cyChar)? (fPartial ? 1 : 0) : 0));
}


//---------------------------------------------------------------------------//
//
// ListBox_VScroll
// 
// Handles vertical scrolling of the listbox
//
void ListBox_VScroll(PLBIV plb, INT cmd, int yAmt)
{
    INT iTopNew;
    INT cItemPageScroll;
    DWORD dwTime = 0;

    if (plb->fMultiColumn) 
    {
        //
        // Don't allow vertical scrolling on a multicolumn list box.  Needed
        // in case app sends WM_VSCROLL messages to the listbox.
        //
        return;
    }

    cItemPageScroll = plb->cItemFullMax;

    if (cItemPageScroll > 1)
    {
        cItemPageScroll--;
    }

    if (plb->cMac) 
    {
        iTopNew = plb->iTop;

        switch (cmd) 
        {
        case SB_LINEUP:
            dwTime = yAmt;
            iTopNew--;

            break;

        case SB_LINEDOWN:
            dwTime = yAmt;
            iTopNew++;

            break;

        case SB_PAGEUP:
            if (plb->OwnerDraw == OWNERDRAWVAR) 
            {
                iTopNew = ListBox_Page(plb, plb->iTop, FALSE);
            } 
            else 
            {
                iTopNew -= cItemPageScroll;
            }

            break;

        case SB_PAGEDOWN:
            if (plb->OwnerDraw == OWNERDRAWVAR) 
            {
                iTopNew = ListBox_Page(plb, plb->iTop, TRUE);
            } 
            else 
            {
                iTopNew += cItemPageScroll;
            }

            break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION: 
            //
            // If the listbox contains more than 0xFFFF items
            // it means that the scrolbar can return a position
            // that cannot fit in a WORD (16 bits), so use
            // GetScrollInfo (which is slower) in this case.
            //
            if (plb->cMac < 0xFFFF) 
            {
                iTopNew = yAmt;
            } 
            else 
            {
                SCROLLINFO si;

                si.cbSize   = sizeof(SCROLLINFO);
                si.fMask    = SIF_TRACKPOS;

                GetScrollInfo( plb->hwnd, SB_VERT, &si);

                iTopNew = si.nTrackPos;
            }

            break;

        case SB_TOP:
            iTopNew = 0;

            break;

        case SB_BOTTOM:
            iTopNew = plb->cMac - 1;

            break;

        case SB_ENDSCROLL:
            plb->fSmoothScroll = TRUE;
            ListBox_SetCaret(plb, FALSE);
            ListBox_ShowHideScrollBars(plb);
            ListBox_SetCaret(plb, TRUE);

            return;
        }

        ListBox_NewITopEx(plb, iTopNew, dwTime);
    }
}


//---------------------------------------------------------------------------//
DWORD ListBox_GetScrollFlags(PLBIV plb, DWORD dwTime)
{
    DWORD dwFlags;
    BOOL bUIEffects, bLBSmoothScroll;

    SystemParametersInfo(SPI_GETUIEFFECTS, 0, &bUIEffects, 0);
    SystemParametersInfo(SPI_GETLISTBOXSMOOTHSCROLLING, 0, &bLBSmoothScroll, 0);

    if (dwTime != 0) 
    {
        dwFlags = MAKELONG(SW_SCROLLWINDOW | SW_SMOOTHSCROLL | SW_SCROLLCHILDREN, dwTime);
    } 
    else if (bUIEffects && bLBSmoothScroll && plb->fSmoothScroll) 
    {
        dwFlags = SW_SCROLLWINDOW | SW_SMOOTHSCROLL | SW_SCROLLCHILDREN;
        plb->fSmoothScroll = FALSE;
    } 
    else 
    {
        //
        // NoSmoothScrolling:
        //
        dwFlags = SW_SCROLLWINDOW | SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN;
    }

    return dwFlags;
}


//---------------------------------------------------------------------------//
//
// ListBox_HScroll
//
// Supports horizontal scrolling of listboxes
//
void ListBox_HScroll(PLBIV plb, INT cmd, int xAmt)
{
    int newOrigin = plb->xOrigin;
    int oldOrigin = plb->xOrigin;
    int windowWidth;
    RECT rc;
    DWORD dwTime = 0;

    //
    // Update the window so that we don't run into problems with invalid
    // regions during the horizontal scroll.
    //
    if (plb->fMultiColumn) 
    {
        //
        // Handle multicolumn scrolling in a separate segment
        //
        ListBox_HSrollMultiColumn(plb, cmd, xAmt);

        return;
    }

    GetClientRect(plb->hwnd, &rc);
    windowWidth = rc.right;

    if (plb->cMac) 
    {

        switch (cmd) 
        {
        case SB_LINEUP:
            dwTime = xAmt;
            newOrigin -= plb->cxChar;

            break;

        case SB_LINEDOWN:
            dwTime = xAmt;
            newOrigin += plb->cxChar;

            break;

        case SB_PAGEUP:
            newOrigin -= (windowWidth / 3) * 2;

            break;

        case SB_PAGEDOWN:
            newOrigin += (windowWidth / 3) * 2;

            break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            newOrigin = xAmt;

            break;

        case SB_TOP:
            newOrigin = 0;

            break;

        case SB_BOTTOM:
            newOrigin = plb->maxWidth;

            break;

        case SB_ENDSCROLL:
            plb->fSmoothScroll = TRUE;
            ListBox_SetCaret(plb, FALSE);
            ListBox_ShowHideScrollBars(plb);
            ListBox_SetCaret(plb, TRUE);

            return;
        }

        ListBox_SetCaret(plb, FALSE);

        plb->xOrigin = newOrigin;
        plb->xOrigin = ListBox_SetScrollParms(plb, SB_HORZ);

        if ((cmd == SB_BOTTOM) && plb->fRightAlign) 
        {
            //
            // so we know where to draw from.
            //
            plb->xRightOrigin = plb->xOrigin;
        }

        if(oldOrigin != plb->xOrigin)  
        {
            DWORD dwFlags;

            dwFlags = ListBox_GetScrollFlags(plb, dwTime);
            ScrollWindowEx(plb->hwnd, oldOrigin-plb->xOrigin,
                0, NULL, &rc, NULL, NULL, dwFlags);
            UpdateWindow(plb->hwnd);
        }

        ListBox_SetCaret(plb, TRUE);
    } 
    else 
    {
        //
        // this is a less-than-ideal fix for ImageMind ScreenSaver (Win95
        // B#8252) but it works and it doesn't hurt anybody -- JEFFBOG 10/28/94
        //
        ListBox_SetScrollParms(plb, SB_HORZ);
    }
}


//---------------------------------------------------------------------------//
void ListBox_Paint(PLBIV plb, HDC hdc, LPRECT lprcBounds)
{
    INT i;
    RECT rect;
    RECT    scratchRect;
    BOOL    fHilite;
    INT iLastItem;
    HBRUSH hbrSave = NULL;
    HBRUSH hbrControl;
    BOOL fCaretOn;
    RECT    rcBounds;
    HDC     hdcSave;

    if (lprcBounds == NULL) 
    {
        lprcBounds = &rcBounds;
        GetClientRect(plb->hwnd, lprcBounds);
    }

    hdcSave = plb->hdc;
    plb->hdc = hdc;

    //
    // Initialize dc.
    //
    ListBox_InitDC(plb);

    //
    // Turn caret off
    //
    fCaretOn = plb->fCaretOn;
    if (fCaretOn)
    {
        ListBox_SetCaret(plb, FALSE);
    }

    hbrSave = NULL;
    hbrControl = ListBox_GetBrush(plb, &hbrSave);

    //
    // Get listbox's client
    //
    GetClientRect(plb->hwnd, &rect);

    //
    // Adjust width of client rect for scrolled amount
    // fix for #140, t-arthb
    //
    if (plb->fRightAlign && !(plb->fMultiColumn || plb->OwnerDraw) && plb->fHorzBar)
    {
        rect.right += plb->xOrigin + (plb->xRightOrigin - plb->xOrigin);
    }
    else
    {
        rect.right += plb->xOrigin;
    }

    //
    // Get the index of the last item visible on the screen. This is also
    // valid for var height ownerdraw.
    //
    iLastItem = plb->iTop + ListBox_CItemInWindow(plb,TRUE);
    iLastItem = min(iLastItem, plb->cMac - 1);

    //
    // Fill in the background of the listbox if it's an empty listbox
    // or if we're doing a control print
    //
    if (iLastItem == -1)
    {
        FillRect(plb->hdc, &rect, hbrControl);
    }


    //
    // Allow AnimateWindow() catch the apps that do not use our DC when
    // drawing the list box
    //
    SetBoundsRect(plb->hdc, NULL, DCB_RESET | DCB_ENABLE);

    for (i = plb->iTop; i <= iLastItem; i++) 
    {
        //
        // Note that rect contains the clientrect from when we did the
        // GetClientRect so the width is correct.  We just need to adjust
        // the top and bottom of the rectangle to the item of interest.
        //
        rect.bottom = rect.top + plb->cyChar;

        if ((UINT)i < (UINT)plb->cMac) 
        {
            //
            // If var height, get the rectangle for the item.
            //
            if (plb->OwnerDraw == OWNERDRAWVAR || plb->fMultiColumn) 
            {
                ListBox_GetItemRectHandler(plb, i, &rect);
            }

            if (IntersectRect(&scratchRect, lprcBounds, &rect)) 
            {
                fHilite = !plb->fNoSel && ListBox_IsSelected(plb, i, HILITEONLY);

                if (plb->OwnerDraw) 
                {
                    //
                    // Fill in the drawitem struct
                    //
                    ListBox_FillDrawItem(plb, i, ODA_DRAWENTIRE,
                            (UINT)(fHilite ? ODS_SELECTED : 0), &rect);
                } 
                else 
                {
                    ListBox_DrawItem(plb, i, &rect, fHilite, hbrControl);
                }
            }
        }
        rect.top = rect.bottom;
    }

    if (hbrSave != NULL)
    {
        SelectObject(hdc, hbrSave);
    }

    if (fCaretOn)
    {
        ListBox_SetCaret(plb, TRUE);
    }

    ListBox_TermDC(plb);

    plb->hdc = hdcSave;
}


//---------------------------------------------------------------------------//
//
// ListBox_ISelFromPt
//
// In the loword, returns the closest item number the pt is on. The high
// word is 0 if the point is within bounds of the listbox client rect and is
// 1 if it is outside the bounds.  This will allow us to make the invertrect
// disappear if the mouse is outside the listbox yet we can still show the
// outline around the item that would be selected if the mouse is brought back
// in bounds...
BOOL ListBox_ISelFromPt(PLBIV plb, POINT pt, LPDWORD piItem)
{
    RECT rect;
    int y;
    UINT mouseHighWord = 0;
    INT sItem;
    INT sTmp;

    GetClientRect(plb->hwnd, &rect);

    if (pt.y < 0) 
    {
        //
        // Mouse is out of bounds above listbox
        //
        *piItem = plb->iTop;

        return TRUE;
    } 
    else if ((y = pt.y) > rect.bottom) 
    {
        y = rect.bottom;
        mouseHighWord = 1;
    }

    if (pt.x < 0 || pt.x > rect.right)
    {
        mouseHighWord = 1;
    }

    //
    // Now just need to check if y mouse coordinate intersects item's rectangle
    //
    if (plb->OwnerDraw != OWNERDRAWVAR) 
    {
        if (plb->fMultiColumn) 
        {
            if (y < plb->itemsPerColumn * plb->cyChar) 
            {
                if (plb->fRightAlign)
                {
                    sItem = plb->iTop + (INT)((y / plb->cyChar) +
                            ((rect.right - pt.x) / plb->cxColumn) * plb->itemsPerColumn);
                }
                else
                {
                    sItem = plb->iTop + (INT)((y / plb->cyChar) +
                            (pt.x / plb->cxColumn) * plb->itemsPerColumn);
                }
            } 
            else 
            {
                //
                // User clicked in blank space at the bottom of a column.
                // Just select the last item in the column.
                //
                mouseHighWord = 1;
                sItem = plb->iTop + (plb->itemsPerColumn - 1) +
                        (INT)((pt.x / plb->cxColumn) * plb->itemsPerColumn);
            }
        } 
        else 
        {
            sItem = plb->iTop + (INT)(y / plb->cyChar);
        }
    } 
    else 
    {
        //
        // VarHeightOwnerdraw so we gotta do this the hardway...   Set the x
        // coordinate of the mouse down point to be inside the listbox client
        // rectangle since we no longer care about it.  This lets us use the
        // point in rect calls.
        //
        pt.x = 8;
        pt.y = y;

        for (sTmp = plb->iTop; sTmp < plb->cMac; sTmp++) 
        {
            ListBox_GetItemRectHandler(plb, sTmp, &rect);

            if (PtInRect(&rect, pt)) 
            {
                *piItem = sTmp;

                return mouseHighWord;
            }
        }

        //
        // Point was at the empty area at the bottom of a not full listbox
        //
        *piItem = plb->cMac - 1;

        return mouseHighWord;
    }

    //
    // Check if user clicked on the blank area at the bottom of a not full list.
    // Assumes > 0 items in the listbox.
    //
    if (sItem > plb->cMac - 1) 
    {
        mouseHighWord = 1;
        sItem = plb->cMac - 1;
    }

    *piItem = sItem;

    return mouseHighWord;
}


//---------------------------------------------------------------------------//
//
// ListBox_SetSelected
//
// This is used for button initiated changes of selection state.
// 
// fSelected : TRUE  if the item is to be set as selected, FALSE otherwise
// 
// wOpFlags : HILITEONLY = Modify only the Display state (hi-nibble)
//            SELONLY    = Modify only the Selection state (lo-nibble)
//            HILITEANDSEL = Modify both of them;
//
void ListBox_SetSelected(PLBIV plb, INT iSel, BOOL fSelected, UINT wOpFlags)
{
    LPSTR lp;
    BYTE cMask;
    BYTE cSelStatus;

    if (iSel < 0 || iSel >= plb->cMac)
    {
        return;
    }

    if (plb->wMultiple == SINGLESEL) 
    {
        if (fSelected)
        {
            plb->iSel = iSel;
        }
    } 
    else 
    {
        cSelStatus = (BYTE)fSelected;

        switch (wOpFlags) 
        {
        case HILITEONLY:
            //
            // Mask out lo-nibble
            //
            cSelStatus = (BYTE)(cSelStatus << 4);
            cMask = 0x0F;

            break;

        case SELONLY:
            //
            // Mask out hi-nibble
            //
            cMask = 0xF0;

            break;

        case HILITEANDSEL:
            //
            // Mask the byte fully
            //
            cSelStatus |= (cSelStatus << 4);
            cMask = 0;

            break;
        }

        lp = (LPSTR)(plb->rgpch) + iSel +
                (plb->cMac * (plb->fHasStrings
                                ? sizeof(LBItem)
                                : (plb->fHasData ? sizeof(LBODItem) : 0)));

        *lp = (*lp & cMask) | cSelStatus;
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_LastFullVisible
//
// Returns the last fully visible item in the listbox. This is valid
// for ownerdraw var height and fixed height listboxes.
//
INT ListBox_LastFullVisible(PLBIV plb)
{
    INT iLastItem;

    if (plb->OwnerDraw == OWNERDRAWVAR || plb->fMultiColumn) 
    {
        iLastItem = plb->iTop + ListBox_CItemInWindow(plb, FALSE) - 1;
        iLastItem = max(iLastItem, plb->iTop);
    } 
    else 
    {
        iLastItem = min(plb->iTop + plb->cItemFullMax - 1, plb->cMac - 1);
    }

    return iLastItem;
}


//---------------------------------------------------------------------------//
void ListBox_InvertItem( PLBIV plb, INT i, BOOL fHilite)
{
    RECT rect;
    BOOL fCaretOn;
    HBRUSH hbrControl;
    BOOL    fNewDC;

    //
    // Skip if item isn't showing.
    //
    if (plb->fNoSel || (i < plb->iTop) || (i >= (plb->iTop + ListBox_CItemInWindow(plb, TRUE))))
    {
        return;
    }

    if (IsLBoxVisible(plb)) 
    {
        ListBox_GetItemRectHandler(plb, i, &rect);

        //
        // Only turn off the caret if it is on.  This avoids annoying caret
        // flicker when nesting CaretOns and CaretOffs.
        //
        fCaretOn = plb->fCaretOn;
        if (fCaretOn) 
        {
            ListBox_SetCaret(plb, FALSE);
        }

        fNewDC = ListBox_GetDC(plb);

        hbrControl = ListBox_GetBrush(plb, NULL);

        if (!plb->OwnerDraw) 
        {
            if (!fHilite) 
            {
                FillRect(plb->hdc, &rect, hbrControl);
                hbrControl = NULL;
            }

            ListBox_DrawItem(plb, i, &rect, fHilite, hbrControl);
        } 
        else 
        {
            //
            // We are ownerdraw so fill in the drawitem struct and send off
            // to the owner.
            //
            ListBox_FillDrawItem(plb, i, ODA_SELECT,
                    (UINT)(fHilite ? ODS_SELECTED : 0), &rect);
        }

        if (fNewDC)
        {
            ListBox_ReleaseDC(plb);
        }

        //
        // Turn the caret back on only if it was originally on.
        //
        if (fCaretOn) 
        {
            ListBox_SetCaret(plb, TRUE);
        }
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_ResetWorld
//
// Resets everyone's selection and hilite state except items in the
// range sStItem to sEndItem (Both inclusive).
void ListBox_ResetWorld(PLBIV plb, INT iStart, INT iEnd, BOOL fSelect)
{
    INT i;
    INT iLastInWindow;
    BOOL fCaretOn;

    //
    // If iStart and iEnd are not in correct order we swap them
    //
    if (iStart > iEnd) 
    {
        i = iStart;
        iStart = iEnd;
        iEnd = i;
    }

    if (plb->wMultiple == SINGLESEL) 
    {
        if (plb->iSel != -1 && ((plb->iSel < iStart) || (plb->iSel > iEnd))) 
        {
            ListBox_InvertItem(plb, plb->iSel, fSelect);
            plb->iSel = -1;
        }

        return;
    }

    iLastInWindow = plb->iTop + ListBox_CItemInWindow(plb, TRUE);

    fCaretOn = plb->fCaretOn;
    if (fCaretOn)
    {
        ListBox_SetCaret(plb, FALSE);
    }

    for (i = 0; i < plb->cMac; i++) 
    {
        if (i == iStart)
        {
            //
            // skip range to be preserved
            //
            i = iEnd;
        }
        else 
        {
            if ((plb->iTop <= i) && (i <= iLastInWindow) &&
                (fSelect != ListBox_IsSelected(plb, i, HILITEONLY)))
            {
                //
                // Only invert the item if it is visible and present Selection
                // state is different from what is required.
                //
                ListBox_InvertItem(plb, i, fSelect);
            }

            //
            // Set all items outside of preserved range to unselected
            //
            ListBox_SetSelected(plb, i, fSelect, HILITEANDSEL);
        }
    }

    if (fCaretOn)
    {
        ListBox_SetCaret(plb, TRUE);
    }

}


//---------------------------------------------------------------------------//
void ListBox_NotifyOwner(PLBIV plb, INT sEvt)
{
    HWND hwndParent = plb->hwndParent;
    if (hwndParent)
    {
        SendMessage(hwndParent, WM_COMMAND, MAKELONG(GetWindowID(plb->hwnd), sEvt), (LPARAM)(plb->hwnd));
    }
}


//---------------------------------------------------------------------------//
void ListBox_SetISelBase(PLBIV plb, INT sItem)
{
    ListBox_SetCaret(plb, FALSE);
    plb->iSelBase = sItem;
    ListBox_SetCaret(plb, TRUE);

    ListBox_InsureVisible(plb, plb->iSelBase, FALSE);

    if (IsWindowVisible(plb->hwnd) || (GetFocus() == plb->hwnd)) 
    {
        ListBox_Event(plb, EVENT_OBJECT_FOCUS, sItem);
    }
}


//---------------------------------------------------------------------------//
void ListBox_TrackMouse(PLBIV plb, UINT wMsg, POINT pt)
{
    INT iSelFromPt;
    INT iSelTemp;
    BOOL mousetemp;
    BOOL fMouseInRect;
    RECT rcClient;
    UINT wModifiers = 0;
    BOOL fSelected;
    UINT uEvent = 0;
    INT trackPtRetn;
    HWND hwnd = plb->hwnd;
    RECT rcWindow;

    //
    // Optimization:  do nothing if mouse not captured
    //
    if ((wMsg != WM_LBUTTONDOWN) && (wMsg != WM_LBUTTONDBLCLK)) 
    {
        if (!plb->fCaptured) 
        {
            return;
        }

        //
        // If we are processing a WM_MOUSEMOVE but the mouse has not moved from
        // the previous point, then we may be dealing with a mouse "jiggle" sent
        // from the kernel (see zzzInvalidateDCCache).  If we process this, we will
        // snap the listbox selection back to where the mouse cursor is pointing,
        // even if the user has not touched the mouse.  FritzS: NT5 bug 220722.
        // Some apps (like MSMoney98) rely on this, so added the bLastRITWasKeyboard
        // check.  MCostea #244450
        //
        if ((wMsg == WM_MOUSEMOVE) && RtlEqualMemory(&pt, &(plb->ptPrev), sizeof(POINT)) ) 
        {
            TraceMsg(TF_STANDARD, "ListBox_TrackMouse ignoring WM_MOUSEMOVE with no mouse movement");

            return;
        }
    }

    mousetemp = ListBox_ISelFromPt(plb, pt, &iSelFromPt);

    //
    // If we allow the user to cancel his selection then fMouseInRect is true if
    // the mouse is in the listbox client area otherwise it is false.  If we
    // don't allow the user to cancel his selection, then fMouseInRect will
    // always be true.  This allows us to implement cancelable selection
    // listboxes ie.  The selection reverts to the origional one if the user
    // releases the mouse outside of the listbox.
    //
    fMouseInRect = !mousetemp || !plb->pcbox;

    GetClientRect(plb->hwnd, &rcClient);

    switch (wMsg) 
    {
    case WM_LBUTTONDBLCLK:
    case WM_LBUTTONDOWN:
        //
        // We want to divert mouse clicks.  If the user clicks outside
        // of a dropped down listbox, we want to popup it up, using
        // the current selection.
        //
        if (plb->fCaptured) 
        {
            //
            // If plb->pcbox is NULL, this is a listbox that
            // received a WM_LBUTTONDOWN again w/o receiving
            // a WM_LBUTTONUP for the previous WM_LBUTTONDOWN bug
            //
            if (plb->pcbox && mousetemp) 
            {
                // Translate pt and rcClient to screen rel coords
                ClientToScreen(plb->hwnd, &pt);
                ClientToScreen(plb->hwnd, (LPPOINT)&rcClient.left );
                ClientToScreen(plb->hwnd, (LPPOINT)&rcClient.right );

                GetWindowRect(plb->hwnd, &rcWindow);

                if (!PtInRect(&rcWindow, pt)) 
                {
                    //
                    // Cancel selection if clicked outside of combo;
                    // Accept if clicked on combo button or item.
                    //
                    ComboBox_HideListBoxWindow(plb->pcbox, TRUE, FALSE);
                } 
                else if (!PtInRect(&rcClient, pt)) 
                {
                    //
                    // Let it pass through.  Save, restore capture in
                    // case user is clicking on scrollbar.
                    //
    
                    plb->fCaptured = FALSE;
                    
                    ReleaseCapture();

                    SendMessageW(plb->hwnd, WM_NCLBUTTONDOWN,
                        (WPARAM)SendMessageW(plb->hwnd, WM_NCHITTEST, 0, POINTTOPOINTS(pt)), POINTTOPOINTS(pt));

                    SetCapture(hwnd);
                    
                    plb->fCaptured = TRUE;
                }

                break;
            }

            plb->fCaptured = FALSE;
            ReleaseCapture();
        }

        if (plb->pcbox) 
        {
            //
            // If this listbox is in a combo box, set the focus to the combo
            // box window so that the edit control/static text is also
            // activated
            //
            SetFocus(plb->pcbox->hwndEdit);
        } 
        else 
        {
            //
            // Get the focus if the listbox is clicked in and we don't
            // already have the focus.  If we don't have the focus after
            // this, run away...
            //
            SetFocus(hwnd);

            if (!plb->fCaret)
            {
                return;
            }
        }

        if (plb->fAddSelMode) 
        {
            //
            // If it is in "Add" mode, quit it using shift f8 key...
            // However, since we can't send shift key state, we have to turn
            // this off directly...
            //

            //
            // Switch off the Caret blinking
            //
            KillTimer(hwnd, IDSYS_CARET);

            //
            // Make sure the caret does not vanish
            //
            ListBox_SetCaret(plb, TRUE);
            plb->fAddSelMode = FALSE;
        }

        if (!plb->cMac) 
        {
            //
            // Don't even bother handling the mouse if no items in the
            // listbox since the code below assumes >0 items in the
            // listbox.  We will just get the focus (the statement above) if
            // we don't already have it.
            //
            break;
        }

        if (mousetemp && plb->fCaptured) 
        {
            //
            // Mouse down occurred in a empty spot. And we're tracking the list.
            // Just ignore it.
            //
            break;
        }
        

        plb->fDoubleClick = (wMsg == WM_LBUTTONDBLCLK);

        if (!plb->fDoubleClick) 
        {
            //
            // This hack put in for the shell.  Tell the shell where in the
            // listbox the user clicked and at what item number.  The shell
            // can return 0 to continue normal mouse tracking or TRUE to
            // abort mouse tracking.
            //
            trackPtRetn = (INT)SendMessage(plb->hwndParent, WM_LBTRACKPOINT,
                    (DWORD)iSelFromPt, MAKELONG(pt.x+plb->xOrigin, pt.y));
            if (trackPtRetn) 
            {
                return;
            }
        }

        if (plb->pcbox) 
        {
            //
            // Save the last selection if this is a combo box.  So that it
            // can be restored if user decides to cancel the selection by up
            // clicking outside the listbox.
            //
            plb->iLastSelection = plb->iSel;
        }

        //
        // Save for timer
        //
        plb->ptPrev = pt;

        plb->fMouseDown = TRUE;
        SetCapture(hwnd);
        plb->fCaptured = TRUE;

        if (plb->fDoubleClick) 
        {
            //
            // Double click.  Fake a button up and exit
            //
            ListBox_TrackMouse(plb, WM_LBUTTONUP, pt);

            return;
        }

        //
        // Set the system timer so that we can autoscroll if the mouse is
        // outside the bounds of the listbox rectangle
        //
        SetTimer(hwnd, IDSYS_SCROLL, SCROLL_TIMEOUT(), NULL);

        //
        // If extended multiselection listbox, are any modifier key pressed?
        //
        if (plb->wMultiple == EXTENDEDSEL) 
        {
            if (GetKeyState(VK_SHIFT) < 0)
            {
                wModifiers = SHIFTDOWN;
            }
    
            if (GetKeyState(VK_CONTROL) < 0)
            {
                wModifiers += CTLDOWN;
            }

            //
            // Please Note that (SHIFTDOWN + CTLDOWN) == (SHCTLDOWN)
            //
        }


        switch (wModifiers) 
        {
        case NOMODIFIER:
MouseMoveHandler:
            if (plb->iSelBase != iSelFromPt) 
            {
                ListBox_SetCaret(plb, FALSE);
            }

            //
            // We only look at the mouse if the point it is pointing to is
            // not selected.  Since we are not in ExtendedSelMode, anywhere
            // the mouse points, we have to set the selection to that item.
            // Hence, if the item isn't selected, it means the mouse never
            // pointed to it before so we can select it.  We ignore already
            // selected items so that we avoid flashing the inverted
            // selection rectangle.  Also, we could get WM_SYSTIMER simulated
            // mouse moves which would cause flashing otherwise...
            //

            if ( mousetemp || (plb->pcbox && plb->pcbox->fButtonPressed))
            {
                // We're outside the list but haven't begun tracking the list yet.
                // Select the item that is already selected.
                iSelTemp = plb->iSel;
            }
            else
            {
                iSelTemp = (fMouseInRect ? iSelFromPt : -1);
            }

            //
            // If the LB is either SingleSel or Extended multisel, clear all
            // old selections except the new one being made.
            //
            if (plb->wMultiple != MULTIPLESEL) 
            {
                ListBox_ResetWorld(plb, iSelTemp, iSelTemp, FALSE);

                //
                // This will be TRUE if iSelTemp isn't -1 (like below)
                // and also if it is but there is a current selection.
                //
                if ((iSelTemp == -1) && (plb->iSel != -1)) 
                {
                    uEvent = EVENT_OBJECT_SELECTIONREMOVE;
                }
            }

            fSelected = ListBox_IsSelected(plb, iSelTemp, HILITEONLY);
            if (iSelTemp != -1) 
            {
                //
                // If it is MULTIPLESEL, then toggle; For others, only if
                // not selected already, select it.
                //
                if (((plb->wMultiple == MULTIPLESEL) && (wMsg != WM_LBUTTONDBLCLK)) || !fSelected) 
                {
                    ListBox_SetSelected(plb, iSelTemp, !fSelected, HILITEANDSEL);

                    //
                    // And invert it
                    //
                    ListBox_InvertItem(plb, iSelTemp, !fSelected);
                    fSelected = !fSelected;     // Set the new state
                    if (plb->wMultiple == MULTIPLESEL) 
                    {
                        uEvent = (fSelected ? EVENT_OBJECT_SELECTIONADD :
                                EVENT_OBJECT_SELECTIONREMOVE);
                    } 
                    else 
                    {
                        uEvent = EVENT_OBJECT_SELECTION;
                    }
                }
            }

            //
            // We have to set iSel in case this is a multisel lb.
            //
            plb->iSel = iSelTemp;

            //
            // Set the new anchor point
            //
            plb->iMouseDown = iSelFromPt;
            plb->iLastMouseMove = iSelFromPt;
            plb->fNewItemState = fSelected;

            break;

        case SHIFTDOWN:

            //
            // This is so that we can handle click and drag for multisel
            // listboxes using Shift modifier key .
            //
            plb->iLastMouseMove = plb->iSel = iSelFromPt;

            //
            // Check if an anchor point already exists
            //
            if (plb->iMouseDown == -1) 
            {
                plb->iMouseDown = iSelFromPt;

                //
                // Reset all the previous selections
                //
                ListBox_ResetWorld(plb, plb->iMouseDown, plb->iMouseDown, FALSE);

                //
                // Select the current position
                //
                ListBox_SetSelected(plb, plb->iMouseDown, TRUE, HILITEANDSEL);
                ListBox_InvertItem(plb, plb->iMouseDown, TRUE);

                //
                // We are changing the selction to this item only
                //
                uEvent = EVENT_OBJECT_SELECTION;
            } 
            else 
            {
                //
                // Reset all the previous selections
                //
                ListBox_ResetWorld(plb, plb->iMouseDown, plb->iMouseDown, FALSE);

                //
                // Select all items from anchor point upto current click pt
                //
                ListBox_AlterHilite(plb, plb->iMouseDown, iSelFromPt, HILITE, HILITEONLY, FALSE);
                uEvent = EVENT_OBJECT_SELECTIONWITHIN;
            }

            plb->fNewItemState = (UINT)TRUE;

            break;

        case CTLDOWN:

            //
            // This is so that we can handle click and drag for multisel
            // listboxes using Control modifier key.
            //

            //
            // Reset the anchor point to the current point
            //
            plb->iMouseDown = plb->iLastMouseMove = plb->iSel = iSelFromPt;

            //
            // The state we will be setting items to
            //
            plb->fNewItemState = (UINT)!ListBox_IsSelected(plb, iSelFromPt, (UINT)HILITEONLY);

            //
            // Toggle the current point
            //
            ListBox_SetSelected(plb, iSelFromPt, plb->fNewItemState, HILITEANDSEL);
            ListBox_InvertItem(plb, iSelFromPt, plb->fNewItemState);

            uEvent = (plb->fNewItemState ? EVENT_OBJECT_SELECTIONADD :
                    EVENT_OBJECT_SELECTIONREMOVE);
            break;

        case SHCTLDOWN:

            //
            // This is so that we can handle click and drag for multisel
            // listboxes using Shift and Control modifier keys.
            //

            //
            // Preserve all the previous selections
            //

            //
            // Deselect only the selection connected with the last
            // anchor point; If the last anchor point is associated with a
            // de-selection, then do not do it
            // 
            if (plb->fNewItemState) 
            {
                ListBox_AlterHilite(plb, plb->iMouseDown, plb->iLastMouseMove, FALSE, HILITEANDSEL, FALSE);
            }

            plb->iLastMouseMove = plb->iSel = iSelFromPt;

            //
            // Check if an anchor point already exists
            //
            if (plb->iMouseDown == -1) 
            {
                //
                // No existing anchor point; Make the current pt as anchor
                //
                plb->iMouseDown = iSelFromPt;
            }

            //
            // If one exists preserve the most recent anchor point
            //

            //
            // The state we will be setting items to
            //
            plb->fNewItemState = (UINT)ListBox_IsSelected(plb, plb->iMouseDown, HILITEONLY);

            //
            // Select all items from anchor point upto current click pt
            //
            ListBox_AlterHilite(plb, plb->iMouseDown, iSelFromPt, plb->fNewItemState, HILITEONLY, FALSE);
            uEvent = EVENT_OBJECT_SELECTIONWITHIN;

            break;
        }

        //
        // Set the new base point (the outline frame caret).  We do the check
        // first to avoid flashing the caret unnecessarly.
        //
        if (plb->iSelBase != iSelFromPt) 
        {
            //
            // Since ListBox_SetISelBase always turns on the caret, we don't need to
            // do it here...
            //
            ListBox_SetISelBase(plb, iSelFromPt);
        }

        //
        // ListBox_SetISelBase will change the focus and send a focus event.
        // Then we send the selection event.
        //
        if (uEvent) 
        {
            ListBox_Event(plb, uEvent, iSelFromPt);
        }

        if (wMsg == WM_LBUTTONDOWN && (GET_EXSTYLE(plb) & WS_EX_DRAGOBJECT)!=0) 
        {
            if (DragDetect(hwnd, pt)) 
            {
                //
                // User is trying to drag object...
                //

                //
                // Fake an up click so that the item is selected...
                //
                ListBox_TrackMouse(plb, WM_LBUTTONUP, pt);

                //
                // Notify parent
                // #ifndef WIN16 (32-bit Windows), plb->iSelBase gets
                // zero-extended to LONG wParam automatically by the compiler.
                //
                SendMessage(plb->hwndParent, WM_BEGINDRAG, plb->iSelBase, (LPARAM)hwnd);
            } 
            else 
            {
                ListBox_TrackMouse(plb, WM_LBUTTONUP, pt);
            }

            return;
        }

        break;

    case WM_MOUSEMOVE: 
    {
        int dist;
        int iTimer;

        //
        // Save for timer.
        //
        plb->ptPrev = pt;

        //
        // Autoscroll listbox if mouse button is held down and mouse is
        // moved outside of the listbox
        //
        if (plb->fMouseDown) 
        {
            if (plb->fMultiColumn) 
            {
                if ((pt.x < 0) || (pt.x >= rcClient.right - 1)) 
                {
                    //
                    // Reset timer interval based on distance from listbox.
                    // use a longer default interval because each multicolumn
                    // scrolling increment is larger
                    //
                    dist = pt.x < 0 ? -pt.x : (pt.x - rcClient.right + 1);
                    iTimer = ((SCROLL_TIMEOUT() * 3) / 2) - ((WORD) dist << 4);

                    if (plb->fRightAlign)
                    {
                        ListBox_HSrollMultiColumn(plb, (pt.x < 0 ? SB_LINEDOWN : SB_LINEUP), 0);
                    }
                    else
                    {
                        ListBox_HSrollMultiColumn(plb, (pt.x < 0 ? SB_LINEUP : SB_LINEDOWN), 0);
                    }

                    goto SetTimerAndSel;
                }
            } 
            else if ((pt.y < 0) || (pt.y >= rcClient.bottom - 1)) 
            {
                //
                // Reset timer interval based on distance from listbox.
                //
                dist = pt.y < 0 ? -pt.y : (pt.y - rcClient.bottom + 1);
                iTimer = SCROLL_TIMEOUT() - ((WORD) dist << 4);

                ListBox_VScroll(plb, (pt.y < 0 ? SB_LINEUP : SB_LINEDOWN), 0);
SetTimerAndSel:
                SetTimer(hwnd, IDSYS_SCROLL, max(iTimer, 1), NULL);
                ListBox_ISelFromPt(plb, pt, &iSelFromPt);
            }
        } 
        else 
        {
            //
            // Ignore if not in client since we don't autoscroll
            //
            if (!PtInRect(&rcClient, pt))
            {
                break;
            }
        }

        switch (plb->wMultiple) 
        {
        case SINGLESEL:

            //
            // If it is a single selection or plain multisel list box
            //
            goto MouseMoveHandler;

        case MULTIPLESEL:
        case EXTENDEDSEL:

            //
            // Handle mouse movement with extended selection of items
            //
            if (plb->iSelBase != iSelFromPt) 
            {
                ListBox_SetISelBase(plb, iSelFromPt);

                //
                // If this is an extended Multi sel list box, then
                // adjust the display of the range due to the mouse move
                //
                if (plb->wMultiple == EXTENDEDSEL) 
                {
                    ListBox_BlockHilite(plb, iSelFromPt, FALSE);
                    ListBox_Event(plb, EVENT_OBJECT_SELECTIONWITHIN, iSelFromPt);
                }
                plb->iLastMouseMove = iSelFromPt;
            }

            break;
        }

        break;
    }
    case WM_LBUTTONUP:
        if (plb->fMouseDown)
        {
            ListBox_ButtonUp(plb, LBUP_RELEASECAPTURE | LBUP_NOTIFY |
                (mousetemp ? LBUP_RESETSELECTION : 0) |
                (fMouseInRect ? LBUP_SUCCESS : 0));
        }
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_ButtonUp
//
// Called in response to both WM_CAPTURECHANGED and WM_LBUTTONUP.
//
void ListBox_ButtonUp(PLBIV plb, UINT uFlags)
{
    //
    // If the list box is an Extended listbox, then change the select status
    // of all items between the anchor and the last mouse position to the
    // newItemState
    //
    if (plb->wMultiple == EXTENDEDSEL)
    {
        ListBox_AlterHilite(plb, plb->iMouseDown, plb->iLastMouseMove,
            plb->fNewItemState, SELONLY, FALSE);
    }

    //
    // This is a combo box and user upclicked outside the listbox
    // so we want to restore the original selection.
    //
    if (plb->pcbox && (uFlags & LBUP_RESETSELECTION)) 
    {
        int iSelOld;

        iSelOld = plb->iSel;

        if (iSelOld >= 0)
        {
            ListBox_InvertItem(plb, plb->iSel, FALSE);
        }

        plb->iSel = plb->iLastSelection;
        ListBox_InvertItem(plb, plb->iSel, TRUE);

        //
        // Note that we always send selection events before we tell the
        // app.  This is on purpose--the app may turn around and select
        // something else when notified.  In which case our event would
        // be out of order.
        //
        ListBox_Event(plb, EVENT_OBJECT_SELECTION, plb->iSel);

        //
        // On win-95 and NT4 the check used to be !(uFlags & LBUP_NOTIFY) which
        // is a bug because we would notify even when the lb is not LBUP_NOTIFY
        //
        if ((uFlags & LBUP_NOTIFY) && plb->fNotify && (iSelOld != plb->iSel))
        {
            ListBox_NotifyOwner(plb, LBN_SELCHANGE);
        }
    }

    KillTimer(plb->hwnd, IDSYS_SCROLL);
    plb->fMouseDown = FALSE;

    if ( plb->fCaptured || (GetCapture() == plb->hwndParent) ) 
    {
        plb->fCaptured = FALSE;
        if (uFlags & LBUP_RELEASECAPTURE)
        {
            ReleaseCapture();
        }
    }

    //
    // Don't scroll item as long as any part of it is visible
    //
    if (plb->iSelBase < plb->iTop ||
        plb->iSelBase > plb->iTop + ListBox_CItemInWindow(plb, TRUE))
    {
        ListBox_InsureVisible(plb, plb->iSelBase, FALSE);
    }

    if (plb->fNotify) 
    {
        if (uFlags & LBUP_NOTIFY)  
        {
            if (uFlags & LBUP_SUCCESS) 
            {
                //
                // ArtMaster needs this SELCHANGE notification now!
                //
                if ((plb->fDoubleClick) && !TESTFLAG(GET_STATE2(plb), WS_S2_WIN31COMPAT))
                {
                    ListBox_NotifyOwner(plb, LBN_SELCHANGE);
                }

                //
                // Notify owner of click or double click on selection
                //
                ListBox_NotifyOwner(plb, (plb->fDoubleClick) ? LBN_DBLCLK : LBN_SELCHANGE);
            } 
            else 
            {
                //
                // Notify owner that the attempted selection was cancelled.
                //
                ListBox_NotifyOwner(plb, LBN_SELCANCEL);
            }
        } 
        else if (uFlags & LBUP_SELCHANGE) 
        {
            //
            // Did we do some semi-selecting with mouse moves, then hit Enter?
            // If so, we need to make sure the app knows that something was
            // really truly selected.
            //
            ASSERT(TESTFLAG(GET_STATE2(plb), WS_S2_WIN40COMPAT));

            if (plb->iLastSelection != plb->iSel)
            {
                ListBox_NotifyOwner(plb, LBN_SELCHANGE);
            }

        }
    }
}


//---------------------------------------------------------------------------//
INT ListBox_IncrementISel(PLBIV plb, INT iSel, INT sInc)
{
    //
    // Assumes cMac > 0, return iSel+sInc in range [0..cmac).
    //
    iSel += sInc;
    if (iSel < 0) 
    {
        return 0;
    } 
    else if (iSel >= plb->cMac) 
    {
        return plb->cMac - 1;
    }

    return iSel;
}


//---------------------------------------------------------------------------//
void ListBox_NewITop(PLBIV plb, INT iTopNew)
{
    ListBox_NewITopEx(plb, iTopNew, 0);
}


//---------------------------------------------------------------------------//
void ListBox_NewITopEx(PLBIV plb, INT iTopNew, DWORD dwTime)
{
    int  iTopOld;
    BOOL fCaretOn;
    BOOL fMulti = plb->fMultiColumn;


    //
    // Always try to turn off caret whether or not redraw is on
    //
    if (fCaretOn = plb->fCaretOn)
    {
        ListBox_SetCaret(plb, FALSE);
    }

    iTopOld = (fMulti) ? (plb->iTop / plb->itemsPerColumn) : plb->iTop;
    plb->iTop = iTopNew;
    iTopNew = ListBox_SetScrollParms(plb, (fMulti) ? SB_HORZ : SB_VERT);
    plb->iTop = (fMulti) ? (iTopNew * plb->itemsPerColumn) : iTopNew;

    if (!IsLBoxVisible(plb)) 
    {
        return;
    }

    if (iTopNew != iTopOld) 
    {
        int     xAmt, yAmt;
        RECT    rc;
        DWORD   dwFlags;

        GetClientRect(plb->hwnd, &rc);

        if (fMulti) 
        {
            yAmt = 0;
            if (abs(iTopNew - iTopOld) > plb->numberOfColumns)
            {
                //
                // Handle scrolling a large number of columns properly so that
                // we don't overflow the size of a rect.
                //
                xAmt = 32000;
            }
            else 
            {
                xAmt = (iTopOld - iTopNew) * plb->cxColumn;
                if (plb->fRightAlign)
                {
                    xAmt = -xAmt;
                }
            }
        } 
        else 
        {
            xAmt = 0;
            if (plb->OwnerDraw == OWNERDRAWVAR) 
            {
                //
                // Have to fake iTopOld for OWNERDRAWVAR listboxes so that
                // the scrolling amount calculations work properly.
                //
                plb->iTop = iTopOld;
                yAmt = ListBox_CalcVarITopScrollAmt(plb, iTopOld, iTopNew);
                plb->iTop = iTopNew;
            } 
            else if (abs(iTopNew - iTopOld) > plb->cItemFullMax)
            {
                yAmt = 32000;
            }
            else
            {
                yAmt = (iTopOld - iTopNew) * plb->cyChar;
            }
        }

        dwFlags = ListBox_GetScrollFlags(plb, dwTime);
        ScrollWindowEx(plb->hwnd, xAmt, yAmt, NULL, &rc, NULL, NULL, dwFlags);
        UpdateWindow(plb->hwnd);
    }

    //
    // Note that although we turn off the caret regardless of redraw, we
    // only turn it on if redraw is true. Slimy thing to fixup many
    // caret related bugs...
    //
    if (fCaretOn)
    {
        // Turn the caret back on only if we turned it off. This avoids
        // annoying caret flicker.
        ListBox_SetCaret(plb, TRUE);
    }
}


//---------------------------------------------------------------------------//
void ListBox_InsureVisible( PLBIV plb, INT iSel, BOOL fPartial)
{
    INT sLastVisibleItem;

    if (iSel < plb->iTop) 
    {
        ListBox_NewITop(plb, iSel);
    } 
    else 
    {
        if (fPartial) 
        {
            //
            // 1 must be subtracted to get the last visible item
            // A part of the fix for Bug #3727 -- 01/14/91 -- SANKAR
            //
            sLastVisibleItem = plb->iTop + ListBox_CItemInWindow(plb, TRUE) - (INT)1;
        } 
        else 
        {
            sLastVisibleItem = ListBox_LastFullVisible(plb);
        }

        if (plb->OwnerDraw != OWNERDRAWVAR) 
        {
            if (iSel > sLastVisibleItem) 
            {
                if (plb->fMultiColumn) 
                {
                    ListBox_NewITop(plb,
                        ((iSel / plb->itemsPerColumn) -
                        max(plb->numberOfColumns-1,0)) * plb->itemsPerColumn);
                } 
                else 
                {
                    ListBox_NewITop(plb, (INT)max(0, iSel - sLastVisibleItem + plb->iTop));
                }
            }
        } 
        else if (iSel > sLastVisibleItem)
        {
            ListBox_NewITop(plb, ListBox_Page(plb, iSel, FALSE));
        }
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_CareBlinker
//
// Timer callback function toggles Caret
// Since it is a callback, it is APIENTRY
//
VOID ListBox_CareBlinker(HWND hwnd, UINT wMsg, UINT_PTR nIDEvent, DWORD dwTime)
{
    PLBIV plb;

    //
    // Standard parameters for a timer callback function that aren't used.
    // Mentioned here to avoid compiler warnings
    //
    UNREFERENCED_PARAMETER(wMsg);
    UNREFERENCED_PARAMETER(nIDEvent);
    UNREFERENCED_PARAMETER(dwTime);

    plb = ListBox_GetPtr(hwnd);

    //
    // leave caret on, don't blink it off (prevents rapid blinks?)
    //
    if (ISREMOTESESSION() && plb->fCaretOn) 
    {
        return;
    }

    //
    // Check if the Caret is ON, if so, switch it OFF
    //
    ListBox_SetCaret(plb, !plb->fCaretOn);
}


//---------------------------------------------------------------------------//
//
// ListBox_KeyInput
//
// If msg == LB_KEYDOWN, vKey is the number of the item to go to,
// otherwise it is the virtual key.
//
void ListBox_KeyInput(PLBIV plb, UINT msg, UINT vKey)
{
    INT i;
    INT iNewISel;
    INT cItemPageScroll;
    PCBOX pcbox;
    BOOL fDropDownComboBox;
    BOOL fExtendedUIComboBoxClosed;
    UINT wModifiers = 0;
    BOOL fSelectKey = FALSE;    // assume it is a navigation key
    UINT uEvent = 0;
    HWND hwnd = plb->hwnd;

    BOOL hScrollBar = (GET_STYLE(plb)&WS_HSCROLL)!=0;

    pcbox = plb->pcbox;

    //
    // Is this a dropdown style combo box/listbox ?
    //
    fDropDownComboBox = pcbox && (pcbox->CBoxStyle & SDROPPABLE);

    //
    // Is this an extended ui combo box which is closed?
    //
    fExtendedUIComboBoxClosed = fDropDownComboBox && pcbox->fExtendedUI &&
                              !pcbox->fLBoxVisible;

    if (plb->fMouseDown || (!plb->cMac && vKey != VK_F4)) 
    {
        //
        // Ignore keyboard input if we are in the middle of a mouse down deal or
        // if there are no items in the listbox. Note that we let F4's go
        // through for combo boxes so that the use can pop up and down empty
        // combo boxes.
        //
        return;
    }

    //
    // Modifiers are considered only in EXTENDED sel list boxes.
    //
    if (plb->wMultiple == EXTENDEDSEL) 
    {
        //
        // If multiselection listbox, are any modifiers used ?
        //
        if (GetKeyState(VK_SHIFT) < 0)
        {
            wModifiers = SHIFTDOWN;
        }

        if (GetKeyState(VK_CONTROL) < 0)
        {
            wModifiers += CTLDOWN;
        }

        //
        // Please Note that (SHIFTDOWN + CTLDOWN) == (SHCTLDOWN)
        //
    }

    if (msg == LB_KEYDOWN) 
    {
        //
        // This is a listbox "go to specified item" message which means we want
        // to go to a particular item number (given by vKey) directly.  ie.  the
        // user has typed a character and we want to go to the item which
        // starts with that character.
        //
        iNewISel = (INT)vKey;

        goto TrackKeyDown;
    }

    cItemPageScroll = plb->cItemFullMax;

    if (cItemPageScroll > 1)
    {
        cItemPageScroll--;
    }

    if (plb->fWantKeyboardInput) 
    {
        //
        // Note: msg must not be LB_KEYDOWN here or we'll be in trouble...
        //
        iNewISel = (INT)SendMessage(plb->hwndParent, WM_VKEYTOITEM,
                MAKELONG(vKey, plb->iSelBase), (LPARAM)hwnd);

        if (iNewISel == -2) 
        {
            //
            // Don't move the selection...
            //
            return;
        }

        if (iNewISel != -1) 
        {
            //
            // Jump directly to the item provided by the app
            //
            goto TrackKeyDown;
        }

        //
        // else do default processing of the character.
        //
    }

    switch (vKey) 
    {
    //
    // LATER IanJa: not language independent!!!
    // We could use VkKeyScan() to find out which is the '\' key
    // This is VK_OEM_5 '\|' for US English only.
    // Germans, Italians etc. have to type CTRL+^ (etc) for this.
    // This is documented as File Manager behaviour for 3.0, but apparently
    // not for 3.1., although functionality remains. We should still fix it,
    // although German (etc?) '\' is generated with AltGr (Ctrl-Alt) (???)
    //
    case VERKEY_BACKSLASH:  
        //
        // '\' character for US English
        //

        //
        // Check if this is CONTROL-\ ; If so Deselect all items
        //
        if ((wModifiers & CTLDOWN) && (plb->wMultiple != SINGLESEL)) 
        {
            ListBox_SetCaret(plb, FALSE);
            ListBox_ResetWorld(plb, plb->iSelBase, plb->iSelBase, FALSE);

            //
            // And select the current item
            //
            ListBox_SetSelected(plb, plb->iSelBase, TRUE, HILITEANDSEL);
            ListBox_InvertItem(plb, plb->iSelBase, TRUE);

            uEvent = EVENT_OBJECT_SELECTION;
            goto CaretOnAndNotify;
        }

        return;

    case VK_DIVIDE:     
        //
        // NumPad '/' character on enhanced keyboard
        //

        //
        // LATER IanJa: not language independent!!!
        // We could use VkKeyScan() to find out which is the '/' key
        // This is VK_OEM_2 '/?' for US English only.
        // Germans, Italians etc. have to type CTRL+# (etc) for this.
        //
    case VERKEY_SLASH:  
        //
        // '/' character
        //

        //
        // Check if this is CONTROL-/ ; If so select all items
        //
        if ((wModifiers & CTLDOWN) && (plb->wMultiple != SINGLESEL)) 
        {
            ListBox_SetCaret(plb, FALSE);
            ListBox_ResetWorld(plb, -1, -1, TRUE);

            uEvent = EVENT_OBJECT_SELECTIONWITHIN;

CaretOnAndNotify:
            ListBox_SetCaret(plb, TRUE);
            ListBox_Event(plb, uEvent, plb->iSelBase);
            ListBox_NotifyOwner(plb, LBN_SELCHANGE);
        }

        return;

    case VK_F8:

        //
        // The "Add" mode is possible only in Multiselection listboxes...  Get
        // into it via SHIFT-F8...  (Yes, sometimes these UI people are sillier
        // than your "typical dumb user"...)
        //
        if (plb->wMultiple != SINGLESEL && wModifiers == SHIFTDOWN) 
        {
            //
            // We have to make the caret blink! Do something...
            //
            if (plb->fAddSelMode) 
            {
                //
                // Switch off the Caret blinking
                //
                KillTimer(hwnd, IDSYS_CARET);

                //
                // Make sure the caret does not vanish
                //
                ListBox_SetCaret(plb, TRUE);
            } 
            else 
            {
                //
                // Create a timer to make the caret blink
                //
                SetTimer(hwnd, IDSYS_CARET, GetCaretBlinkTime(),
                        ListBox_CareBlinker);
            }

            //
            // Toggle the Add mode flag
            //
            plb->fAddSelMode = (UINT)!plb->fAddSelMode;
        }

        return;

    case VK_SPACE:  
        //
        // Selection key is space
        //
        i = 0;
        fSelectKey = TRUE;

        break;

    case VK_PRIOR:
        if (fExtendedUIComboBoxClosed) 
        {
            //
            // Disable movement keys for TandyT.
            //
            return;
        }

        if (plb->OwnerDraw == OWNERDRAWVAR) 
        {
            i = ListBox_Page(plb, plb->iSelBase, FALSE) - plb->iSelBase;
        } 
        else 
        {
            i = -cItemPageScroll;
        }

        break;

    case VK_NEXT:
        if (fExtendedUIComboBoxClosed) 
        {
            //
            // Disable movement keys for TandyT.
            //
            return;
        }

        if (plb->OwnerDraw == OWNERDRAWVAR) 
        {
            i = ListBox_Page(plb, plb->iSelBase, TRUE) - plb->iSelBase;
        } 
        else 
        {
            i = cItemPageScroll;
        }

        break;

    case VK_HOME:
        if (fExtendedUIComboBoxClosed) 
        {
            //
            // Disable movement keys for TandyT.
            //
            return;
        }

        i = (INT_MIN/2)+1;  // A very big negative number

        break;

    case VK_END:
        if (fExtendedUIComboBoxClosed) 
        {
            //
            // Disable movement keys for TandyT.
            //
            return;
        }

        i = (INT_MAX/2)-1;  // A very big positive number

        break;

    case VK_LEFT:
        if (plb->fMultiColumn) 
        {
            if (plb->fRightAlign
#ifdef USE_MIRRORING
                                 ^ (!!TESTFLAG(GET_EXSTYLE(plb), WS_EX_LAYOUTRTL))

#endif
               )
            {
                goto ReallyRight;
            }

ReallyLeft:
            if (plb->iSelBase / plb->itemsPerColumn == 0) 
            {
                i = 0;
            } 
            else 
            {
                i = -plb->itemsPerColumn;
            }

            break;
        }

        if (hScrollBar) 
        {
            goto HandleHScrolling;
        } 
        else 
        {
            //
            // Fall through and handle this as if the up arrow was pressed.
            //
            vKey = VK_UP;
        }

        //
        // Fall through
        //

    case VK_UP:
        if (fExtendedUIComboBoxClosed)
        {
            //
            // Disable movement keys for TandyT.
            //
            return;
        }

        i = -1;

        break;

    case VK_RIGHT:
        if (plb->fMultiColumn) 
        {
            if (plb->fRightAlign
#ifdef USE_MIRRORING
                                 ^ (!!TESTFLAG(GET_EXSTYLE(plb), WS_EX_LAYOUTRTL))

#endif
               )
            {
                goto ReallyLeft;
            }

ReallyRight:
            if (plb->iSelBase / plb->itemsPerColumn == plb->cMac / plb->itemsPerColumn) 
            {
                i = 0;
            } 
            else 
            {
                i = plb->itemsPerColumn;
            }

            break;
        }

        if (hScrollBar) 
        {
HandleHScrolling:
            PostMessage(hwnd, WM_HSCROLL,
                    (vKey == VK_RIGHT ? SB_LINEDOWN : SB_LINEUP), 0L);
            return;
        } 
        else 
        {
            //
            // Fall through and handle this as if the down arrow was
            // pressed.
            //
            vKey = VK_DOWN;
        }

        //
        // Fall through
        //

    case VK_DOWN:
        if (fExtendedUIComboBoxClosed) 
        {
            //
            // If the combo box is closed, down arrow should open it.
            //
            if (!pcbox->fLBoxVisible) 
            {
                //
                // If the listbox isn't visible, just show it
                //
                ComboBox_ShowListBoxWindow(pcbox, TRUE);
            }

            return;
        }

        i = 1;

        break;

    case VK_ESCAPE:
    case VK_RETURN:
        if (!fDropDownComboBox || !pcbox->fLBoxVisible)
        {
            return;
        }

        //
        // |  If this is a dropped listbox for a combobox and the ENTER  |
        // |  key is pressed, close up the listbox, so FALLTHRU          |
        // V                                                             V
        //

    case VK_F4:
        if (fDropDownComboBox && !pcbox->fExtendedUI) 
        {
            //
            // If we are a dropdown combo box/listbox we want to process
            // this key.  BUT for TandtT, we don't do anything on VK_F4 if we
            // are in extended ui mode.
            //
            if (!pcbox->fLBoxVisible) 
            {
                //
                // If the listbox isn't visible, just show it
                //
                ComboBox_ShowListBoxWindow(pcbox, (vKey != VK_ESCAPE));
            } 
            else 
            {
                //
                // Ok, the listbox is visible.  So hide the listbox window.
                //
                ComboBox_HideListBoxWindow(pcbox, TRUE, (vKey != VK_ESCAPE));
            }
        }

        //
        // Fall through to the return
        //

    default:
        return;
    }

    //
    // Find out what the new selection should be
    //
    iNewISel = ListBox_IncrementISel(plb, plb->iSelBase, i);

    if (plb->wMultiple == SINGLESEL) 
    {
        if (plb->iSel == iNewISel) 
        {
            //
            // If we are single selection and the keystroke is moving us to an
            // item which is already selected, we don't have to do anything...
            //
            return;
        }

        uEvent = EVENT_OBJECT_SELECTION;

        plb->iTypeSearch = 0;
        if ((vKey == VK_UP || vKey == VK_DOWN) &&
                !ListBox_IsSelected(plb, plb->iSelBase, HILITEONLY)) 
        {
            //
            // If the caret is on an unselected item and the user just hits the
            // up or down arrow key (ie. with no shift or ctrl modifications),
            // then we will just select the item the cursor is at. This is
            // needed for proper behavior in combo boxes but do we always want
            // to run this code??? Note that this is only used in single
            // selection list boxes since it doesn't make sense in the
            // multiselection case. Note that an LB_KEYDOWN message must not be
            // checked here because the vKey will be an item number not a
            // VK_and we will goof. Thus, trackkeydown label is below this to
            // fix a bug caused by it being above this...
            //
            iNewISel = (plb->iSelBase == -1) ? 0 : plb->iSelBase;
        }
    }

TrackKeyDown:

    ListBox_SetISelBase(plb, iNewISel);

    ListBox_SetCaret(plb, FALSE);

    if (wModifiers & SHIFTDOWN) 
    {
        //
        // Check if iMouseDown is un-initialised
        //
        if (plb->iMouseDown == -1)
        {
            plb->iMouseDown = iNewISel;
        }

        if (plb->iLastMouseMove == -1)
        {
            plb->iLastMouseMove = iNewISel;
        }

        //
        // Check if we are in ADD mode
        //
        if (plb->fAddSelMode) 
        {
            //
            // Preserve all the pre-existing selections except the
            // ones connected with the last anchor point; If the last
            // Preserve all the previous selections
            //

            //
            // Deselect only the selection connected with the last
            // anchor point; If the last anchor point is associated
            // with de-selection, then do not do it
            //

            if (!plb->fNewItemState)
            {
                plb->iLastMouseMove = plb->iMouseDown;
            }

            //
            // We haven't done anything here because, ListBox_BlockHilite()
            // will take care of wiping out the selection between
            // Anchor point and iLastMouseMove and select the block
            // between anchor point and current cursor location
            //
        } 
        else 
        {
            //
            // We are not in ADD mode
            //

            //
            // Remove all selections except between the anchor point
            // and last mouse move because it will be taken care of in
            // ListBox_BlockHilite
            //
            ListBox_ResetWorld(plb, plb->iMouseDown, plb->iLastMouseMove, FALSE);
        }

        uEvent = EVENT_OBJECT_SELECTIONWITHIN;

        //
        // ListBox_BlockHilite takes care to deselect the block between
        // the anchor point and iLastMouseMove and select the block
        // between the anchor point and the current cursor location
        //

        //
        // Toggle all items to the same selection state as the item
        // item at the anchor point) from the anchor point to the
        // current cursor location.
        //
        plb->fNewItemState = ListBox_IsSelected(plb, plb->iMouseDown, SELONLY);
        ListBox_BlockHilite(plb, iNewISel, TRUE);

        plb->iLastMouseMove = iNewISel;

        //
        // Preserve the existing anchor point
        //
    } 
    else 
    {
        //
        // Check if this is in ADD mode
        //
        if ((plb->fAddSelMode) || (plb->wMultiple == MULTIPLESEL)) 
        {
            //
            // Preserve all pre-exisiting selections
            //
            if (fSelectKey) 
            {
                //
                // Toggle the selection state of the current item
                //
                plb->fNewItemState = !ListBox_IsSelected(plb, iNewISel, SELONLY);
                ListBox_SetSelected(plb, iNewISel, plb->fNewItemState, HILITEANDSEL);

                ListBox_InvertItem(plb, iNewISel, plb->fNewItemState);

                //
                // Set the anchor point at the current location
                //
                plb->iLastMouseMove = plb->iMouseDown = iNewISel;
                uEvent = (plb->fNewItemState ? EVENT_OBJECT_SELECTIONADD :
                        EVENT_OBJECT_SELECTIONREMOVE);
            }
        } 
        else 
        {
            //
            // We are NOT in ADD mode
            //

            //
            // Remove all existing selections except iNewISel, to
            // avoid flickering.
            //
            ListBox_ResetWorld(plb, iNewISel, iNewISel, FALSE);

            //
            // Select the current item
            //
            ListBox_SetSelected(plb, iNewISel, TRUE, HILITEANDSEL);
            ListBox_InvertItem(plb, iNewISel, TRUE);

            //
            // Set the anchor point at the current location
            //
            plb->iLastMouseMove = plb->iMouseDown = iNewISel;
            uEvent = EVENT_OBJECT_SELECTION;
        }
    }

    //
    //  Move the cursor to the new location
    //
    ListBox_InsureVisible(plb, iNewISel, FALSE);
    ListBox_ShowHideScrollBars(plb);

    ListBox_SetCaret(plb, TRUE);

    if (uEvent) 
    {
        ListBox_Event(plb, uEvent, iNewISel);
    }

    //
    // Should we notify our parent?
    //
    if (plb->fNotify) 
    {
        if (fDropDownComboBox && pcbox->fLBoxVisible) 
        {
            //
            // If we are in a drop down combo box/listbox and the listbox is
            // visible, we need to set the fKeyboardSelInListBox bit so that the
            // combo box code knows not to hide the listbox since the selchange
            // message is caused by the user keyboarding through...
            //
            pcbox->fKeyboardSelInListBox = TRUE;
            plb->iLastSelection = iNewISel;
        }

        ListBox_NotifyOwner(plb, LBN_SELCHANGE);
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_Compare
//
// Is lpstr1 equal/prefix/less-than/greater-than lsprst2 (case-insensitive) ?
// 
// LATER IanJa: this assume a longer string is never a prefix of a longer one.
// Also assumes that removing 1 or more characters from the end of a string will
// give a string tahs sort before the original.  These assumptions are not valid
// for all languages.  We nedd better support from NLS. (Consider French
// accents, Spanish c/ch, ligatures, German sharp-s/SS, etc.)
//
INT ListBox_Compare(LPCWSTR pwsz1, LPCWSTR pwsz2, DWORD dwLocaleId)
{
    UINT len1 = wcslen(pwsz1);
    UINT len2 = wcslen(pwsz2);
    INT result;

    //
    // CompareStringW returns:
    //  1 = pwsz1  <  pwsz2
    //  2 = pwsz1  == pwsz2
    //  3 = pwsz1  >  pwsz2
    //
    result = CompareStringW((LCID)dwLocaleId, NORM_IGNORECASE,
            pwsz1, min(len1,len2), pwsz2, min(len1, len2));

    if (result == CSTR_LESS_THAN) 
    {
       return LT;
    } 
    else if (result == CSTR_EQUAL) 
    {
        if (len1 == len2) 
        {
            return EQ;
        } 
        else if (len1 < len2) 
        {
            //
            // LATER IanJa: should not assume shorter string is a prefix
            // Spanish "c" and "ch", ligatures, German sharp-s/SS etc.
            //
            return PREFIX;
        }
    }

    return GT;
}


//---------------------------------------------------------------------------//
//
// Listbox_FindStringHandler
//
// Scans for a string in the listbox prefixed by or equal to lpstr.
// For OWNERDRAW listboxes without strings and without the sort style, we
// try to match the long app supplied values.
//
INT Listbox_FindStringHandler(PLBIV plb, LPWSTR lpstr, INT sStart, INT code, BOOL fWrap)
{
    //
    // Search for a prefix match (case-insensitive equal/prefix)
    // sStart == -1 means start from beginning, else start looking at sStart+1
    // assumes cMac > 0.
    //
    INT sInd;       // index of string
    INT sStop;      // index to stop searching at
    lpLBItem pRg;
    INT sortResult;

    //
    // Owner-Draw version of pRg
    //
    #define pODRg ((lpLBODItem)pRg)

    COMPAREITEMSTRUCT cis;
    LPWSTR listboxString;

    
    if (plb->fHasStrings && (!lpstr || !*lpstr))
    {
        return LB_ERR;
    }

    if (!plb->fHasData) 
    {
        TraceMsg(TF_STANDARD, "Listbox_FindStringHandler called on NODATA lb");

        return LB_ERR;
    }

    if ((sInd = sStart + 1) >= plb->cMac)
    {
        sInd = (fWrap ? 0 : plb->cMac - 1);
    }

    sStop = (fWrap ? sInd : 0);

    //
    // If at end and no wrap, stop right away
    //
    if (((sStart >= plb->cMac - 1) && !fWrap) || (plb->cMac < 1)) 
    {
        return LB_ERR;
    }

    //
    // Apps could pass in an invalid sStart like -2 and we would blow up.
    // Win 3.1 would not so we need to fixup sInd to be zero
    //
    if (sInd < 0)
    {
        sInd = 0;
    }

    pRg = (lpLBItem)(plb->rgpch);

    do 
    {
        if (plb->fHasStrings) 
        {
            //
            // Searching for string matches.
            //
            listboxString = (LPWSTR)((LPBYTE)plb->hStrings + pRg[sInd].offsz);

            if (code == PREFIX &&
                listboxString &&
                *lpstr != TEXT('[') &&
                *listboxString == TEXT('[')) 
            {
                //
                // If we are looking for a prefix string and the first items
                // in this string are [- then we ignore them.  This is so
                // that in a directory listbox, the user can goto drives
                // by selecting the drive letter.
                //
                listboxString++;

                if (*listboxString == TEXT('-'))
                {
                    listboxString++;
                }
            }

            if (ListBox_Compare(lpstr, listboxString, plb->dwLocaleId) <= code) 
            {
               goto FoundIt;
            }

        } 
        else 
        {
            if (plb->fSort) 
            {
                //
                // Send compare item messages to the parent for sorting
                //
                cis.CtlType = ODT_LISTBOX;
                cis.CtlID = GetDlgCtrlID(plb->hwnd);
                cis.hwndItem = plb->hwnd;
                cis.itemID1 = (UINT)-1;
                cis.itemData1 = (ULONG_PTR)lpstr;
                cis.itemID2 = (UINT)sInd;
                cis.itemData2 = pODRg[sInd].itemData;
                cis.dwLocaleId = plb->dwLocaleId;

                sortResult = (INT)SendMessage(plb->hwndParent, WM_COMPAREITEM,
                        cis.CtlID, (LPARAM)&cis);


                if (sortResult == -1) 
                {
                   sortResult = LT;
                } 
                else if (sortResult == 1) 
                {
                   sortResult = GT;
                } 
                else 
                {
                   sortResult = EQ;
                }

                if (sortResult <= code) 
                {
                    goto FoundIt;
                }
            } 
            else 
            {
                //
                // Searching for app supplied long data matches.
                //
                if ((ULONG_PTR)lpstr == pODRg[sInd].itemData)
                {
                    goto FoundIt;
                }
            }
        }

        //
        // Wrap round to beginning of list
        //
        if (++sInd == plb->cMac)
        {
            sInd = 0;
        }
    } 
    while (sInd != sStop);

    sInd = -1;

FoundIt:
    return sInd;
}


//---------------------------------------------------------------------------//
void ListBox_CharHandler(PLBIV plb, UINT inputChar, BOOL fAnsi)
{
    INT iSel;
    BOOL fControl;

    if (plb->cMac == 0 || plb->fMouseDown) 
    {
        //
        // Get out if we are in the middle of mouse routines or if we have no
        // items in the listbox, we just return without doing anything.
        //
        return;
    }

    fControl = (GetKeyState(VK_CONTROL) < 0);

    switch (inputChar) 
    {
    case VK_ESCAPE:
        plb->iTypeSearch = 0;
        if (plb->pszTypeSearch)
        {
            plb->pszTypeSearch[0] = 0;
        }

        break;

    case VK_BACK:
        if (plb->iTypeSearch) 
        {
            plb->pszTypeSearch[plb->iTypeSearch--] = 0;
            if (plb->fSort) 
            {
                iSel = -1;
                goto TypeSearch;
            }
        }

        break;

    case VK_SPACE:
        if (plb->fAddSelMode || plb->wMultiple == MULTIPLESEL)
        {
            break;
        }
        //
        // Otherwise, for single/extended selection listboxes not in add
        // selection mode, let the  space go thru as a type search character
        //

        //
        // FALL THRU
        //
    default:

        //
        // Move selection to first item beginning with the character the
        // user typed.  We don't want do this if we are using owner draw.
        //
        if (fAnsi && IsDBCSLeadByteEx(CP_ACP, (BYTE)inputChar)) 
        {
            WCHAR wch;
            LPWSTR lpwstr = &wch;

            inputChar = DbcsCombine(plb->hwnd, (BYTE)inputChar);
            if (inputChar == 0) 
            {
                TraceMsg(TF_STANDARD, "ListBox_CharHandler: cannot combine two DBCS. LB=0x%02x", inputChar);

                break;
            }

            //
            // If it is DBCS, let's ignore the ctrl status.
            //
            fControl = FALSE;

            //
            // Convert DBCS to UNICODE.
            // Note: Leading byte is in the low byte, trailing byte is in high byte.
            // Let's assume Little Endian CPUs only, so inputChar can directly be
            // input for MBSToWCSEx as an ANSI string.
            //
            if (MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)&inputChar, 2, lpwstr, 1) == 0) 
            {
                TraceMsg(TF_STANDARD, "ListBox_CharHandler: cannot convert 0x%04x to UNICODE.", inputChar);

                break;
            }

            inputChar = wch;
        }

        if (plb->fHasStrings) 
        {
            //
            // Incremental Type Search processing
            //
            // update szTypeSearch string and then move to the first item from
            // the current selection whose prefix matches szTypeSearch
            //
            // the szTypeSearch will continue to grow until a "long enough"
            // gap between key entries is encountered -- at which point any
            // more searching will start over
            //

            //
            // Undo CONTROL-char to char
            //
            if (fControl && inputChar < 0x20)
            {
                inputChar += 0x40;
            }

            if (plb->iTypeSearch == MAX_TYPESEARCH) 
            {
                MessageBeep(0);

                break;
            }

            iSel = -1;

            if (plb->pszTypeSearch == NULL)
            {
                plb->pszTypeSearch = (LPWSTR)ControlAlloc(GetProcessHeap(), sizeof(WCHAR) * (MAX_TYPESEARCH + 1));
            }

            if (plb->pszTypeSearch == NULL) 
            {
                MessageBeep(0);

                break;
            }

            plb->pszTypeSearch[plb->iTypeSearch++] = (WCHAR) inputChar;
            plb->pszTypeSearch[plb->iTypeSearch]   = 0;

TypeSearch:
            if (plb->fSort) 
            {
                //
                // Set timer to determine when to kill incremental searching
                //
                SetTimer(plb->hwnd, IDSYS_LBSEARCH,
                               GetDoubleClickTime()*4, NULL);
            } 
            else 
            {
                //
                // If this is not a sorted listbox, no incremental search.
                //
                plb->iTypeSearch = 0;
                iSel = plb->iSelBase;
            }

            //
            // Search for the item beginning with the given character starting
            // at iSel+1.  We will wrap the search to the beginning of the
            // listbox if we don't find the item.   If SHIFT is down and we are
            // a multiselection lb, then the item's state will be set to
            // plb->fNewItemState according to the current mode.
            //
            iSel = Listbox_FindStringHandler(plb, plb->pszTypeSearch, iSel, PREFIX, TRUE);
            if (iSel == -1) 
            {
                //
                // no match found -- check for prefix match
                // (i.e. "p" find FIRST item that starts with 'p',
                //       "pp" find NEXT item that starts with 'p')
                //
                if(plb->iTypeSearch)
                {
                    plb->iTypeSearch--;
                    if ((plb->iTypeSearch == 1) && (plb->pszTypeSearch[0] == plb->pszTypeSearch[1]))
                    {
                        plb->pszTypeSearch[1] = 0;
                        iSel = Listbox_FindStringHandler(plb, plb->pszTypeSearch, plb->iSelBase, PREFIX, TRUE);
                    }
                }
            }

            //
            // if match is found -- select it
            //
            if (iSel != -1)
            {
CtlKeyInput:
                ListBox_KeyInput(plb, LB_KEYDOWN, iSel);

            }
        } 
        else 
        {
            HWND hwndParent = plb->hwndParent;

            if (hwndParent != NULL) 
            {
                if(fAnsi)
                {
                    iSel = (INT)SendMessageA(hwndParent, WM_CHARTOITEM,
                        MAKELONG(inputChar, plb->iSelBase), (LPARAM)plb->hwnd);
                }
                else
                {
                    iSel = (INT)SendMessageW(hwndParent, WM_CHARTOITEM,
                        MAKELONG(inputChar, plb->iSelBase), (LPARAM)plb->hwnd);
                }
            } 
            else
            {
                iSel = -1;
            }

            if (iSel != -1 && iSel != -2)
            {
                goto CtlKeyInput;
            }
        }

        break;
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_GetSelItemsHandler
//
// effects: For multiselection listboxes, this returns the total number of
// selection items in the listbox if fCountOnly is true.  or it fills an array
// (lParam) with the items numbers of the first wParam selected items.
//
int ListBox_GetSelItemsHandler(PLBIV plb, BOOL fCountOnly, int wParam, LPINT lParam)
{
    int i;
    int itemsselected = 0;

    if (plb->wMultiple == SINGLESEL)
    {
        return LB_ERR;
    }

    for (i = 0; i < plb->cMac; i++) 
    {
        if (ListBox_IsSelected(plb, i, SELONLY)) 
        {
            if (!fCountOnly) 
            {
                if (itemsselected < wParam)
                {
                    *lParam++ = i;
                }
                else 
                {
                    //
                    // That's all the items we can fit in the array.
                    //
                    return itemsselected;
                }
            }

            itemsselected++;
        }
    }

    return itemsselected;
}


//---------------------------------------------------------------------------//
//
// ListBox_SetRedraw
//
// Handle WM_SETREDRAW message
//
void ListBox_SetRedraw(PLBIV plb, BOOL fRedraw)
{
    if (fRedraw)
    {
        fRedraw = TRUE;
    }

    if (plb->fRedraw != (UINT)fRedraw) 
    {
        plb->fRedraw = !!fRedraw;

        if (fRedraw) 
        {
            ListBox_SetCaret(plb, TRUE);
            ListBox_ShowHideScrollBars(plb);

            if (plb->fDeferUpdate) 
            {
                plb->fDeferUpdate = FALSE;
                RedrawWindow(plb->hwnd, NULL, NULL,
                        RDW_INVALIDATE | RDW_ERASE |
                        RDW_FRAME | RDW_ALLCHILDREN);
            }
        }
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_SetRange
//
// Selects the range of items between i and j, inclusive.
//
void ListBox_SetRange(PLBIV plb, int iStart, int iEnd, BOOL fnewstate)
{
    DWORD temp;
    RECT rc;

    if (iStart > iEnd) 
    {
        temp = iEnd;
        iEnd = iStart;
        iStart = temp;
    }

    //
    // We don't want to loop through items that don't exist.
    //
    iEnd = min(plb->cMac, iEnd);
    iStart = max(iStart, 0);
    if (iStart > iEnd)
    {
        return;
    }

    //
    // iEnd could be equal to MAXINT which is why we test temp and iEnd
    // as DWORDs.
    //
    for (temp = iStart; temp <= (DWORD)iEnd; temp++) 
    {
        if (ListBox_IsSelected(plb, temp, SELONLY) != fnewstate) 
        {
            ListBox_SetSelected(plb, temp, fnewstate, HILITEANDSEL);
            ListBox_GetItemRectHandler(plb, temp, &rc);

            ListBox_InvalidateRect(plb, (LPRECT)&rc, FALSE);
        }
    }

    ASSERT(plb->wMultiple);

    ListBox_Event(plb, EVENT_OBJECT_SELECTIONWITHIN, iStart);
}


//---------------------------------------------------------------------------//
int ListBox_SetCurSelHandler(PLBIV plb, int iSel) 
{

    if (!(plb->wMultiple || iSel < -1 || iSel >= plb->cMac)) 
    {
        ListBox_SetCaret(plb, FALSE);

        if (plb->iSel != -1) 
        {
            //
            // This prevents scrolling when iSel == -1
            //
            if (iSel != -1)
            {
                ListBox_InsureVisible(plb, iSel, FALSE);
            }

            //
            // Turn off old selection
            //
            ListBox_InvertItem(plb, plb->iSel, FALSE);
        }

        if (iSel != -1) 
        {
            ListBox_InsureVisible(plb, iSel, FALSE);
            plb->iSelBase = plb->iSel = iSel;

            //
            // Highlight new selection
            //
            ListBox_InvertItem(plb, plb->iSel, TRUE);
        } 
        else 
        {
            plb->iSel = -1;

            if (plb->cMac)
            {
                plb->iSelBase = min(plb->iSelBase, plb->cMac-1);
            }
            else
            {
                plb->iSelBase = 0;
            }
        }

        //
        // Send both focus and selection events
        //
        if (IsWindowVisible(plb->hwnd) || (GetFocus() == plb->hwnd)) 
        {
            ListBox_Event(plb, EVENT_OBJECT_FOCUS, plb->iSelBase);
            ListBox_Event(plb, EVENT_OBJECT_SELECTION, plb->iSel);
        }

        ListBox_SetCaret(plb, TRUE);

        return plb->iSel;
    }

    return LB_ERR;
}


//---------------------------------------------------------------------------//
//
// ListBox_SetItemDataHandler
//
// Makes the item at index contain the data given.
//
int ListBox_SetItemDataHandler(PLBIV plb, int index, LONG_PTR data)
{
    LPSTR lpItemText;

    //
    // v-ronaar: fix bug #25865, don't allow negative indices!
    //
    if ((index != -1) && ((UINT) index >= (UINT) plb->cMac)) 
    {
        TraceMsg(TF_STANDARD, "ListBox_SetItemDataHandler with invalid index %x", index);

        return LB_ERR;
    }

    //
    // No-data listboxes just ignore all LB_SETITEMDATA calls
    //
    if (!plb->fHasData) 
    {
        return TRUE;
    }

    lpItemText = (LPSTR)plb->rgpch;

    if (index == -1) 
    {
        //
        // index == -1 means set the data to all the items
        //
        if (plb->fHasStrings) 
        {
            for (index = 0; index < plb->cMac; index++) 
            {
                ((lpLBItem)lpItemText)->itemData = data;
                lpItemText += sizeof(LBItem);
            }
        } 
        else 
        {
            for (index = 0; index < plb->cMac; index++) 
            {
                ((lpLBODItem)lpItemText)->itemData = data;
                lpItemText += sizeof(LBODItem);
            }
        }

        return TRUE;
    }

    if (plb->fHasStrings) 
    {
        lpItemText = (LPSTR)(lpItemText + (index * sizeof(LBItem)));
        ((lpLBItem)lpItemText)->itemData = data;
    } 
    else 
    {
        lpItemText = (LPSTR)(lpItemText + (index * sizeof(LBODItem)));
        ((lpLBODItem)lpItemText)->itemData = data;
    }

    return TRUE;
}


//---------------------------------------------------------------------------//
void ListBox_CheckRedraw(PLBIV plb, BOOL fConditional, INT sItem)
{
    if (fConditional && plb->cMac &&
            (sItem > (plb->iTop + ListBox_CItemInWindow(plb, TRUE))))
    {
        return;
    }

    //
    // Don't do anything if the parent is not visible.
    //
    ListBox_InvalidateRect(plb, (LPRECT)NULL, TRUE);
}


//---------------------------------------------------------------------------//
void ListBox_CaretDestroy(PLBIV plb)
{
    //
    // We're losing the focus.  Act like up clicks are happening so we release
    // capture, set the current selection, notify the parent, etc.
    //
    if (plb->fCaptured)
    {
        //
        // If we have the capture and we lost the focus, that means we already
        // changed the selection and we have to notify also the parent about
        // this. So we need to add also the LBUP_SUCCESS flag in this case.
        //
        ListBox_ButtonUp(plb, LBUP_RELEASECAPTURE | LBUP_NOTIFY |
            (plb->fMouseDown ? LBUP_SUCCESS : 0));
    }

    if (plb->fAddSelMode) 
    {
        //
        // Switch off the Caret blinking
        //
        KillTimer(plb->hwnd, IDSYS_CARET);

        //
        // Make sure the caret goes away
        //
        ListBox_SetCaret(plb, FALSE);
        plb->fAddSelMode = FALSE;
    }

    plb->fCaret = FALSE;
}


//---------------------------------------------------------------------------//
LONG ListBox_SetSelHandler(PLBIV plb, BOOL fSelect, INT iSel)
{
    INT sItem;
    RECT rc;
    UINT uEvent = 0;

    //
    // Bug 17656. WinZip's accelerator key for 'DeSelect All' sends a LB_SETSEL
    // message with lparam = 0x0000ffff instead of 0xffffffff(-1). If iSel
    // is equal to  0x0000ffff and there are less than 0xffff elements in the
    // list we set iSel equal to 0xffffffff.
    //
    if ((iSel == (UINT)0xffff) && (iSel >= plb->cMac)) 
    {
        iSel = -1;

        TraceMsg(TF_STANDARD, "Sign extending iSel=0xffff to 0xffffffff");
    }


    if ((plb->wMultiple == SINGLESEL) || (iSel != -1 && iSel >= plb->cMac)) 
    {
        TraceMsg(TF_STANDARD, "Invalid index");

        return LB_ERR;
    }

    ListBox_SetCaret(plb, FALSE);

    if (iSel == -1)
    {
        //
        // Set/clear selection from all items if -1
        //
        for (sItem = 0; sItem < plb->cMac; sItem++) 
        {
            if (ListBox_IsSelected(plb, sItem, SELONLY) != fSelect) 
            {
                ListBox_SetSelected(plb, sItem, fSelect, HILITEANDSEL);

                if (ListBox_GetItemRectHandler(plb, sItem, &rc)) 
                {
                    ListBox_InvalidateRect(plb, &rc, FALSE);
                }
            }
        }

        ListBox_SetCaret(plb, TRUE);
        uEvent = EVENT_OBJECT_SELECTIONWITHIN;

    } 
    else 
    {
        if (fSelect) 
        {
            //
            // Check if the item if fully hidden and scroll it into view if it
            // is.  Note that we don't want to scroll partially visible items
            // into full view because this breaks the shell...
            //
            ListBox_InsureVisible(plb, iSel, TRUE);
            plb->iSelBase = plb->iSel = iSel;

            plb->iMouseDown = plb->iLastMouseMove = iSel;
            uEvent = EVENT_OBJECT_FOCUS;
        } 
        else 
        {
            uEvent = EVENT_OBJECT_SELECTIONREMOVE;
        }

        ListBox_SetSelected(plb, iSel, fSelect, HILITEANDSEL);

        //
        // Note that we set the caret on bit directly so that we avoid flicker
        // when drawing this item.  ie.  We turn on the caret, redraw the item and
        // turn it back on again.
        //
        if (!fSelect && plb->iSelBase != iSel) 
        {
            ListBox_SetCaret(plb, TRUE);
        } 
        else if (plb->fCaret) 
        {
            plb->fCaretOn = TRUE;
        }

        if (ListBox_GetItemRectHandler(plb, iSel, &rc)) 
        {
            ListBox_InvalidateRect(plb, &rc, FALSE);
        }
    }

    if (IsWindowVisible(plb->hwnd) || (GetFocus() == plb->hwnd)) 
    {
        if (uEvent == EVENT_OBJECT_FOCUS) 
        {
            ListBox_Event(plb, uEvent, plb->iSelBase);
            uEvent = EVENT_OBJECT_SELECTION;
        }

        ListBox_Event(plb, uEvent, iSel);
    }

    return 0;
}


//---------------------------------------------------------------------------//
//
// ListBox_FillDrawItem
//
// This fills the draw item struct with some constant data for the given
// item.  The caller will only have to modify a small part of this data
// for specific needs.
//
void ListBox_FillDrawItem(PLBIV plb, INT item, UINT itemAction, UINT itemState, LPRECT lprect)
{
    DRAWITEMSTRUCT dis;

    //
    // Fill the DRAWITEMSTRUCT with the unchanging constants
    //

    dis.CtlType = ODT_LISTBOX;
    dis.CtlID = GetDlgCtrlID(plb->hwnd);

    //
    // Use -1 if an invalid item number is being used.  This is so that the app
    // can detect if it should draw the caret (which indicates the lb has the
    // focus) in an empty listbox
    //
    dis.itemID = (UINT)(item < plb->cMac ? item : -1);
    dis.itemAction = itemAction;
    dis.hwndItem = plb->hwnd;
    dis.hDC = plb->hdc;
    dis.itemState = itemState |
            (UINT)((GET_STYLE(plb)&WS_DISABLED) ? ODS_DISABLED : 0);

    if (TESTFLAG(GET_EXSTYLE(plb), WS_EXP_UIFOCUSHIDDEN)) 
    {
        dis.itemState |= ODS_NOFOCUSRECT;
    }

    if (TESTFLAG(GET_EXSTYLE(plb), WS_EXP_UIACCELHIDDEN)) 
    {
        dis.itemState |= ODS_NOACCEL;
    }

    //
    // Set the app supplied data
    //
    if (!plb->cMac || !plb->fHasData) 
    {
        //
        // If no strings or no items, just use 0 for data.  This is so that we
        // can display a caret when there are no items in the listbox.
        // 
        // Lazy-eval listboxes of course have no data to pass - only itemID.
        //
        dis.itemData = 0L;
    } 
    else 
    {
        dis.itemData = ListBox_GetItemDataHandler(plb, item);
    }

    CopyRect(&dis.rcItem, lprect);

    //
    // Set the window origin to the horizontal scroll position.  This is so that
    // text can always be drawn at 0,0 and the view region will only start at
    // the horizontal scroll offset. We pass this as wParam
    //

    SendMessage(plb->hwndParent, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
}


//---------------------------------------------------------------------------//
//
// ListBox_BlockHilite
//
// In Extended selection mode for multiselection listboxes, when
// mouse is draged to a new position, the range being marked should be
// properly sized(parts of which will be highlighted/dehighlighted).
// NOTE: This routine assumes that iSelFromPt and LasMouseMove are not
// equal because only in that case this needs to be called;
// NOTE: This routine calculates the region whose display attribute is to
// be changed in an optimised way. Instead of de-highlighting the
// the old range completely and highlight the new range, it omits
// the regions that overlap and repaints only the non-pverlapping
// area.
// fKeyBoard = TRUE if this is called for Keyboard interface
// FALSE if called from Mouse interface routines
//
void ListBox_BlockHilite(PLBIV plb, INT iSelFromPt, BOOL fKeyBoard)
{
    INT sCurPosOffset;
    INT sLastPosOffset;
    INT sHiliteOrSel;
    BOOL fUseSelStatus;
    BOOL DeHiliteStatus;

    if (fKeyBoard) 
    {
        //
        // Set both Hilite and Selection states
        //
        sHiliteOrSel = HILITEANDSEL;

        //
        // Do not use the Selection state while de-hiliting
        //
        fUseSelStatus = FALSE;
        DeHiliteStatus = FALSE;
    } 
    else 
    {
        //
        // Set/Reset only the Hilite state
        //
        sHiliteOrSel = HILITEONLY;

        //
        // Use the selection state for de-hilighting
        //
        fUseSelStatus = TRUE;
        DeHiliteStatus = plb->fNewItemState;
    }

    //
    // The idea of the routine is to :
    //  1.  De-hilite the old range (iMouseDown to iLastMouseDown)  and
    //  2.  Hilite the new range (iMouseDwon to iSelFromPt)
    //

    //
    // Offset of current mouse position from the anchor point
    //
    sCurPosOffset = plb->iMouseDown - iSelFromPt;

    //
    // Offset of last mouse position from the anchor point
    //
    sLastPosOffset = plb->iMouseDown - plb->iLastMouseMove;

    //
    // Check if both current position and last position lie on the same
    // side of the anchor point.
    //
    if ((sCurPosOffset * sLastPosOffset) >= 0) 
    {
        //
        // Yes they are on the same side; So, highlight/dehighlight only
        // the difference.
        //
        if (abs(sCurPosOffset) > abs(sLastPosOffset)) 
        {
            ListBox_AlterHilite(plb, plb->iLastMouseMove, iSelFromPt,
                    plb->fNewItemState, sHiliteOrSel, FALSE);
        } 
        else 
        {
            ListBox_AlterHilite(plb, iSelFromPt, plb->iLastMouseMove, DeHiliteStatus,
                    sHiliteOrSel, fUseSelStatus);
        }
    } 
    else 
    {
        ListBox_AlterHilite(plb, plb->iMouseDown, plb->iLastMouseMove,
                DeHiliteStatus, sHiliteOrSel, fUseSelStatus);

        ListBox_AlterHilite(plb, plb->iMouseDown, iSelFromPt,
                plb->fNewItemState, sHiliteOrSel, FALSE);
    }
}


//---------------------------------------------------------------------------//
//
// ListBox_AlterHilite
//
// Changes the hilite state of (i..j] (ie. excludes i, includes j in case
// you've forgotten this notation) to fHilite. It inverts this changes
// the hilite state.
//
// OpFlags:  
//      HILITEONLY      Only change the display state of the items
//      SELONLY         Only Change the selection state of the items
//      HILITEANDSELECT Do both.
//
// fHilite:
//      HILITE/TRUE
//      DEHILITE/FALSE
//
// fSelStatus:
//      if TRUE, use the selection state of the item to hilite/dehilite
//      if FALSE, use the fHilite parameter to hilite/dehilite
//
void ListBox_AlterHilite(PLBIV plb, INT i, INT j, BOOL fHilite, INT OpFlags, BOOL fSelStatus)
{
    INT low;
    INT high;
    INT sLastInWindow;
    BOOL fCaretOn;
    BOOL fSelected;

    sLastInWindow = plb->iTop + ListBox_CItemInWindow(plb, TRUE);
    sLastInWindow = min(sLastInWindow, plb->cMac - 1);
    high = max(i, j) + 1;

    if (fCaretOn = plb->fCaretOn) 
    {
        ListBox_SetCaret(plb, FALSE);
    }

    for (low = min(i, j); low < high; low++) 
    {
        if (low != i) 
        {
            if (OpFlags & HILITEONLY) 
            {
                if (fSelStatus) 
                {
                    fSelected = ListBox_IsSelected(plb, low, SELONLY);
                } 
                else 
                {
                    fSelected = fHilite;
                }

                if (ListBox_IsSelected(plb, low, HILITEONLY) != fSelected) 
                {
                    if (plb->iTop <= low && low <= sLastInWindow) 
                    {
                        //
                        // Invert the item only if it is visible
                        //
                        ListBox_InvertItem(plb, low, fSelected);
                    }

                    ListBox_SetSelected(plb, low, fSelected, HILITEONLY);
                }
            }

            if (OpFlags & SELONLY) 
            {
                ListBox_SetSelected(plb, low, fHilite, SELONLY);
            }
        }
    }

    if (fCaretOn) 
    {
        ListBox_SetCaret(plb, TRUE);
    }
}