windows-xp/Source/XPSP1/NT/sdktools/winobj/treectl.c

/****************************************************************************/
/*                                                                          */
/*  TREECTL.C -                                                             */
/*                                                                          */
/*      Windows Directory Tree Window Proc Routines                         */
/*                                                                          */
/****************************************************************************/

#define PUBLIC           // avoid collision with shell.h
#include "winfile.h"
#include "treectl.h"
#include "lfn.h"
#include "winnet.h"
#include "wfcopy.h"

#define WS_TREESTYLE (WS_CHILD | WS_VISIBLE | LBS_NOTIFY | WS_VSCROLL | WS_HSCROLL | LBS_OWNERDRAWFIXED | LBS_NOINTEGRALHEIGHT | LBS_WANTKEYBOARDINPUT | LBS_DISABLENOSCROLL)

WORD    cNodes;
// BOOL    bCancelTree; .......... moved to winfile.c


VOID  RectTreeItem(HWND hwndLB, register INT iItem, BOOL bFocusOn);
VOID  GetTreePathIndirect(PDNODE pNode, register LPSTR szDest);
VOID  GetTreePath(PDNODE pNode, register LPSTR szDest);
VOID  ScanDirLevel(PDNODE pParentNode, LPSTR szPath, DWORD view);
INT   InsertDirectory(HWND hwndTreeCtl, PDNODE pParentNode, WORD iParentNode, LPSTR szName, PDNODE *ppNode);
BOOL  ReadDirLevel(HWND hwndTreeCtl, PDNODE pParentNode, LPSTR szPath,
                     WORD nLevel, INT iParentNode, DWORD dwAttribs, BOOL bFullyExpand, LPSTR szAutoExpand);
VOID  FillTreeListbox(HWND hwndTreeCtl, LPSTR szDefaultDir, BOOL bFullyExpand, BOOL bDontSteal);
WORD  FindItemFromPath(HWND hwndLB, LPSTR lpszPath, BOOL bReturnParent, PDNODE *ppNode);

VOID  APIENTRY CheckEscapes(LPSTR);


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetTreePathIndirect() -                                                 */
/*                                                                          */
/*  build a complete path for a given node in the tree by recursivly        */
/*  traversing the tree structure                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
GetTreePathIndirect(
                   PDNODE pNode,
                   register LPSTR szDest
                   )
{
    register PDNODE    pParent;

    pParent = pNode->pParent;

    if (pParent)
        GetTreePathIndirect(pParent, szDest);

    lstrcat(szDest, pNode->szName);

    if (pParent)
        lstrcat(szDest, "\\");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetTreePath() -                                                         */
/*                                                                          */
/*  build a complete path for a given node in the tree                      */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
GetTreePath(
           PDNODE pNode,
           register LPSTR szDest
           )
{
    szDest[0] = 0L;
    GetTreePathIndirect(pNode, szDest);

    /* Remove the last backslash (unless it is the root directory). */
    if (pNode->pParent)
        szDest[lstrlen(szDest)-1] = 0L;
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  ScanDirLevel() -                                                        */
/*                                                                          */
/*  look down to see if this node has any sub directories                   */
/*
/*--------------------------------------------------------------------------*/
// szPath is ANSI

VOID
ScanDirLevel(
            PDNODE pParentNode,
            LPSTR szPath,
            DWORD view
            )
{
    BOOL bFound;
    LFNDTA lfndta;

    ENTER("ScanDirLevel");

    /* Add '*.*' to the current path. */
    lstrcpy(szMessage, szPath);
    AddBackslash(szMessage);
    lstrcat(szMessage, szStarDotStar);

    /* Search for the first subdirectory on this level. */
    // FixAnsiPathForDos(szMessage);
    bFound = WFFindFirst(&lfndta, szMessage, ATTR_DIR | view);

    while (bFound) {
        /* Is this not a '.' or '..' directory? */
        if ((lfndta.fd.cFileName[0] != '.') && (lfndta.fd.dwFileAttributes & ATTR_DIR)) {
            pParentNode->wFlags |= TF_HASCHILDREN;
            bFound = FALSE;
        } else
            /* Search for the next subdirectory. */
            bFound = WFFindNext(&lfndta);
    }

    WFFindClose(&lfndta);

    LEAVE("ScanDirLevel");
}



// wizzy cool recursive path compare routine
//
// p1 and p2 must be on the same level (p1->nLevels == p2->nLevels)

INT
ComparePath(
           PDNODE p1,
           PDNODE p2
           )
{
    INT ret;

    if (p1 == p2) {
        return 0;       // equal (base case)
    } else {

        ret = ComparePath(p1->pParent, p2->pParent);

        if (ret == 0) {
            // parents are equal

            ret = lstrcmp(p1->szName, p2->szName);
#if 0
            {
                CHAR buf[200];
                wsprintf(buf, "Compare(%s, %s) -> %d\r\n", (LPSTR)p1->szName, (LPSTR)p2->szName, ret);
                OutputDebugString(buf);
            }
#endif
        }

        // not equal parents, propagate up the call tree
        return ret;
    }
}


INT
CompareNodes(
            PDNODE p1,
            PDNODE p2
            )
{
    PDNODE p1save, p2save;
    INT ret;

    ENTER("CompareNodes");

    ASSERT(p1 && p2);

    PRINT(BF_PARMTRACE, "IN: p1=%s", p1->szName);
    PRINT(BF_PARMTRACE, "IN: p2=%s", p2->szName);

    p1save = p1;
    p2save = p2;

    // get p1 and p2 to the same level

    while (p1->nLevels > p2->nLevels)
        p1 = p1->pParent;

    while (p2->nLevels > p1->nLevels)
        p2 = p2->pParent;

    // compare those paths

    ret = ComparePath(p1, p2);

    if (ret == 0)
        ret = (INT)p1save->nLevels - (INT)p2save->nLevels;

    LEAVE("CompareNodes");
    return ret;
}


//
// InsertDirectory()
//
// wizzy quick n log n binary insert code!
//
// creates and inserts a new node in the tree, this also sets
// the TF_LASTLEVELENTRY bits to mark a branch as being the last
// for a given level as well as marking parents with
// TF_HASCHILDREN | TF_EXPANDED to indicate they have been expanded
// and have children.
//
// Returns iNode and fills ppNode with pNode.
//

INT
InsertDirectory(
               HWND hwndTreeCtl,
               PDNODE pParentNode,
               WORD iParentNode,
               LPSTR szName,
               PDNODE *ppNode
               )
{
    WORD  len, x;
    PDNODE pNode, pMid;
    HWND  hwndLB;
    INT   iMin;
    INT   iMax;
    INT   iMid;

    ENTER("InsertDirectory");
    PRINT(BF_PARMTRACE, "IN: pParentNode=%lx", pParentNode);
    PRINT(BF_PARMTRACE, "IN: iParentNode=%d", iParentNode);
    PRINT(BF_PARMTRACE, "IN: szName=%s", szName);

    len = (WORD)lstrlen(szName);

    pNode = (PDNODE)LocalAlloc(LPTR, sizeof(DNODE)+len);
    if (!pNode) {
        if (ppNode) {
            *ppNode = NULL;
        }
        return 0;
    }

    pNode->pParent = pParentNode;
    pNode->nLevels = pParentNode ? (pParentNode->nLevels + (BYTE)1) : (BYTE)0;
    pNode->wFlags  = (BYTE)NULL;
    pNode->iNetType = -1;
    if (IsLFN(szName)) {
        pNode->wFlags |= TF_LFN;
    }

    lstrcpy(pNode->szName, szName);

    if (pParentNode)
        pParentNode->wFlags |= TF_HASCHILDREN | TF_EXPANDED;      // mark the parent

    hwndLB = GetDlgItem(hwndTreeCtl, IDCW_TREELISTBOX);

    // computing the real text extent is too slow so we aproximate
    // with the following (note, we don't keep this on a per tree
    // basis so it is kinda bogus anyway)

    x = (WORD)(len + 2 * pNode->nLevels) * (WORD)dxText;

    if (x > xTreeMax) {
        xTreeMax = x;
    }

    iMax = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);

    if (iMax > 0) {

        // do a binary insert

        iMin = iParentNode + 1;
        iMax--;         // last index

        do {
            iMid = (iMax + iMin) / 2;

            SendMessage(hwndLB, LB_GETTEXT, iMid, (LPARAM)&pMid);

            if (CompareNodes(pNode, pMid) > 0)
                iMin = iMid + 1;
            else
                iMax = iMid - 1;

        } while (iMax > iMin);

        SendMessage(hwndLB, LB_GETTEXT, iMax, (LPARAM)&pMid);
        if (CompareNodes(pNode, pMid) > 0)
            iMax++;         // insert after this one
    }

    // now reset the TF_LASTLEVEL flags as appropriate

    // look for the first guy on our level above us and turn off
    // his TF_LASTLEVELENTRY flag so he draws a line down to us

    iMid = iMax - 1;

    while (iMid >= 0) {
        SendMessage(hwndLB, LB_GETTEXT, iMid--, (LPARAM)&pMid);
        if (pMid->nLevels == pNode->nLevels) {
            pMid->wFlags &= ~TF_LASTLEVELENTRY;
            break;
        } else if (pMid->nLevels < pNode->nLevels)
            break;
    }

    // if no one below me or the level of the guy below is less, then
    // this is the last entry for this level

    if (((INT)SendMessage(hwndLB, LB_GETTEXT, iMax, (LPARAM)&pMid) == LB_ERR) ||
        (pMid->nLevels < pNode->nLevels))
        pNode->wFlags |=  TF_LASTLEVELENTRY;

    SendMessage(hwndLB, LB_INSERTSTRING, iMax, (LPARAM)pNode);
    if (ppNode) {
        *ppNode = pNode;
    }

    LEAVE("InsertDirectory");
    return iMax;
}


// this yeilds control to other apps and allows us to process
// messages and user input.  to avoid overrunning the stack
// from multiple tree reads being initiated at the same time
// we check how much space we have on the stack before we yield

extern WORD end;        // C compiler end of static data symbol
extern WORD pStackTop;


WORD
StackAvail(VOID)
{
#ifdef LATER
    _asm    mov ax,sp
    _asm    sub ax,pStackTop
    if (0) return 0;  // get rid of warning, optimized out
#endif

    return 0x7fff;  // Hack. shouldn't really matter. StackAvail in NT is a NOP
}


VOID
APIENTRY
wfYield()
{
    MSG msg;
#ifdef LATER
    WORD free_stack;
    free_stack = StackAvail();
#endif


#if 0
    {
        CHAR buf[30];

        wsprintf(buf, "free stack: %d\r\n", free_stack);
        OutputDebugString(buf);
    }
#endif

#if LATER
    if (free_stack < 1024*4) {
        CHAR buf[40];
        wsprintf(buf, "not enough stack %d\r\n", free_stack);
        OutputDebugString(buf);
        return;
    }
#endif

    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
        if (!TranslateMDISysAccel(hwndMDIClient, &msg) &&
            (!hwndFrame || !TranslateAccelerator(hwndFrame, hAccel, &msg))) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
}


// INT iReadLevel = 0;     ...............Moved to winfile.c


//--------------------------------------------------------------------------
//
// ReadDirLevel() -
//
// this does a depth first search of the dir tree.  note, a bredth
// first implementation did not perform any better.
//
// szPath               a directory path that MUST EXIST long enough
//                      to hold the full path to the largest directory
//                      that will be found (MAXPATHLEN).  this is an
//                      ANSI string.  (ie C:\ and C:\FOO are valid)
// nLevel               level in the tree
// iParentNode          index of parent node
// dwAttribs            attributes to filter with
// bFullyExpand         TRUE means expand this node fully
// szAutoExpand         list of directories to autoexpand ANSI
//                      (eg. for "C:\foo\bar\stuff"
//                      "foo" NULL "bar" NULL "stuff" NULL NULL)
//
// returns:
//      TRUE            tree read sucessful
//      FALSE           user abort or bogus tree read
//--------------------------------------------------------------------------

BOOL
ReadDirLevel(
            HWND  hwndTreeCtl,
            PDNODE pParentNode,
            LPSTR  szPath,
            WORD  nLevel,
            INT   iParentNode,
            DWORD dwAttribs,
            BOOL  bFullyExpand,
            LPSTR  szAutoExpand
            )
{
    LPSTR      szEndPath;
    LFNDTA    lfndta;
    INT       iNode;
    BOOL      bFound;
    PDNODE     pNode;
    BOOL      bAutoExpand;
    BOOL      bResult = TRUE;
    WORD      view;
    HWND      hwndParent;
    HWND      hwndDir;
    HANDLE    hDTA;
    LPMYDTA   lpmydta;
    INT       count;
    RECT rc;

    ENTER("ReadDirLevel");
    PRINT(BF_PARMTRACE, "IN: szPath=%s", szPath);
    PRINT(BF_PARMTRACE, "IN: nLevel=%d", (LPSTR)nLevel);
    PRINT(BF_PARMTRACE, "IN: bFullyExpand=%d", IntToPtr(bFullyExpand));
    PRINT(BF_PARMTRACE, "IN: szAutoExpand=%s", szAutoExpand);

    if (StackAvail() < 1024*2)
        return(TRUE);

    hwndParent = GetParent(hwndTreeCtl);

    view = (WORD)GetWindowLong(hwndParent, GWL_VIEW);

    // we optimize the tree read if we are not adding pluses and
    // we find a directory window that already has read all the
    // directories for the path we are about to search.  in this
    // case we look through the DTA structure in the dir window
    // to get all the directories (instead of calling FindFirst/FindNext).
    // in this case we have to disable yielding since the user could
    // potentialy close the dir window that we are reading, or change
    // directory.

    hDTA = NULL;

    if (!(view & VIEW_PLUSES)) {

        if ((hwndDir = HasDirWindow(hwndParent)) &&
            (GetWindowLong(hwndParent, GWL_ATTRIBS) & ATTR_DIR)) {

            SendMessage(hwndDir, FS_GETDIRECTORY, sizeof(szMessage), (LPARAM)szMessage);
            StripBackslash(szMessage);

            if (!lstrcmpi(szMessage, szPath)) {
                SendMessage(hwndDir, FS_GETFILESPEC, sizeof(szMessage), (LPARAM)szMessage);

                if (!lstrcmp(szMessage, szStarDotStar)) {
                    hDTA = (HANDLE)GetWindowLongPtr(hwndDir, GWLP_HDTA);
                    lpmydta = (LPMYDTA)LocalLock(hDTA);
                    count = (INT)lpmydta->my_nFileSizeLow; // holds number of entries, NOT size.
                }
            }
        }
    }

    SetWindowLong(hwndTreeCtl, GWL_READLEVEL, GetWindowLong(hwndTreeCtl, GWL_READLEVEL) + 1);
    iReadLevel++;         // global for menu code

    szEndPath = (LPSTR)(szPath + lstrlen(szPath));

    /* Add '\*.*' to the current path. */
    AddBackslash(szPath);
    lstrcat(szPath, szStarDotStar);

    if (hDTA) {
        // steal the entry from the dir window
        lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize);

        // search for any "real" directories

        while (count > 0 && (!(lpmydta->my_dwAttrs & ATTR_DIR) || (lpmydta->my_dwAttrs & ATTR_PARENT))) {
            lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize);
            count--;
        }

        if (count > 0) {
            bFound = TRUE;
            memcpy(&(lfndta.fd.dwFileAttributes), &(lpmydta->my_dwAttrs), IMPORTANT_DTA_SIZE);
            lstrcpy(lfndta.fd.cFileName, lpmydta->my_cFileName);
        } else
            bFound = FALSE;
    } else {
        // get first file from DOS
        lstrcpy(szMessage, szPath);
        FixAnsiPathForDos(szMessage);
        bFound = WFFindFirst(&lfndta, szMessage, dwAttribs);
    }

    // for net drive case where we can't actually see what is in these
    // direcotries we will build the tree automatically

    if (!bFound && *szAutoExpand) {
        LPSTR p;

        p = szAutoExpand;
        szAutoExpand += lstrlen(szAutoExpand) + 1;

        iNode = InsertDirectory(hwndTreeCtl, pParentNode, (WORD)iParentNode, p, &pNode);
        pParentNode->wFlags |= TF_DISABLED;

        /* Construct the path to this new subdirectory. */
        *szEndPath = 0;           // remove old stuff
        AddBackslash(szPath);
        lstrcat(szPath, p);

        if (pNode)
            ReadDirLevel(hwndTreeCtl, pNode, szPath, (WORD)(nLevel+1), iNode, dwAttribs, bFullyExpand, szAutoExpand);
    }

    while (bFound) {

        wfYield();

        if (bCancelTree) {
            bResult = FALSE;
            if (bCancelTree == 2)
                PostMessage(hwndFrame, WM_COMMAND, IDM_EXIT, 0L);
            goto DONE;
        }

        /* Is this not a '.' or '..' directory? */
        if ((lfndta.fd.cFileName[0] != '.') && (lfndta.fd.dwFileAttributes & ATTR_DIR)) {

            if (!hDTA)
                OemToAnsi(lfndta.fd.cFileName, lfndta.fd.cFileName);

            // we will try to auto expand this node if it matches

            if (*szAutoExpand && !lstrcmpi(szAutoExpand, lfndta.fd.cFileName)) {
                bAutoExpand = TRUE;
                szAutoExpand += lstrlen(szAutoExpand) + 1;
            } else {
                bAutoExpand = FALSE;
            }

            iNode = InsertDirectory(hwndTreeCtl, pParentNode, (WORD)iParentNode, lfndta.fd.cFileName, &pNode);

            if (bStatusBar && ((cNodes % 7) == 0)) {

                // make sure we are the active window before we
                // update the status bar

                if (hwndParent == (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)) {
                    wsprintf(szStatusTree, szDirsRead, cNodes);
                    // stomp over the status bar!
                    GetClientRect(hwndFrame, &rc);
                    rc.top = rc.bottom - dyStatus;
                    InvalidateRect(hwndFrame, &rc, FALSE);
                    // force the paint because we don't yield
                    UpdateWindow(hwndFrame);
                }
            }
            cNodes++;

            /* Construct the path to this new subdirectory. */
            *szEndPath = 0L;
            AddBackslash(szPath);
            lstrcat(szPath, lfndta.fd.cFileName);         // cFileName is ANSI now


            // either recurse or add pluses

            if (pNode) {
                if (bFullyExpand || bAutoExpand) {
                    if (!ReadDirLevel(hwndTreeCtl, pNode, szPath, (WORD)(nLevel+1), iNode, dwAttribs, bFullyExpand, szAutoExpand)) {
                        bResult = FALSE;
                        goto DONE;
                    }
                } else if (view & VIEW_PLUSES) {
                    ScanDirLevel(pNode, szPath, dwAttribs & ATTR_HS);
                }
            }
        }

        if (hDTA) {       // short cut, steal data from dir window
            count--;
            lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize);
            while (count > 0 && (!(lpmydta->my_dwAttrs & ATTR_DIR) || (lpmydta->my_dwAttrs & ATTR_PARENT))) {
                lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize);
                count--;
            }

            if (count > 0) {
                bFound = TRUE;
                memcpy(&(lfndta.fd.dwFileAttributes), &(lpmydta->my_dwAttrs), IMPORTANT_DTA_SIZE);
                lstrcpy(lfndta.fd.cFileName, lpmydta->my_cFileName);
            } else
                bFound = FALSE;
        } else {
            bFound = WFFindNext(&lfndta); // get it from dos
        }
    }

    *szEndPath = 0L;    // clean off any stuff we left on the end of the path

    DONE:

    if (!hDTA) {
        WFFindClose(&lfndta);
    } else {
        LocalUnlock(hDTA);
    }

    SetWindowLong(hwndTreeCtl, GWL_READLEVEL, GetWindowLong(hwndTreeCtl, GWL_READLEVEL) - 1);
    iReadLevel--;

    LEAVE("ReadDirLevel");
    return bResult;
}


// this is used by StealTreeData() to avoid alias problems where
// the nodes in one tree point to parents in the other tree.
// basically, as we are duplicating the tree data structure we
// have to find the parent node that coorisponds with the parent
// of the tree we are copying from in the tree that we are building.
// since the tree is build in order we run up the listbox, looking
// for the parent (matched by it's level being one smaller than
// the level of the node being inserted).  when we find that we
// return the pointer to that node.

PDNODE
FindParent(
          INT iLevelParent,
          INT iStartInd,
          HWND hwndLB
          )
{
    PDNODE pNode;

    while (TRUE) {
        if (SendMessage(hwndLB, LB_GETTEXT, iStartInd, (LPARAM)&pNode) == LB_ERR)
            return NULL;

        if (pNode->nLevels == (BYTE)iLevelParent) {
            SendMessage(hwndLB, LB_GETTEXT, iStartInd, (LPARAM)&pNode);
            return pNode;
        }

        iStartInd--;
    }
}



BOOL
StealTreeData(
             HWND hwndTC,
             HWND hwndLB,
             LPSTR szDir
             )
{
    HWND hwndSrc, hwndT;
    CHAR szSrc[MAXPATHLEN];
    WORD wView;
    DWORD dwAttribs;

    ENTER("StealTreeData");

    // we need to match on these attributes as well as the name

    wView    = (WORD)(GetWindowLong(GetParent(hwndTC), GWL_VIEW) & VIEW_PLUSES);
    dwAttribs = (DWORD)GetWindowLong(GetParent(hwndTC), GWL_ATTRIBS) & ATTR_HS;

    // get the dir of this new window for compare below

    for (hwndSrc = GetWindow(hwndMDIClient, GW_CHILD); hwndSrc;
        hwndSrc = GetWindow(hwndSrc, GW_HWNDNEXT)) {

        // avoid finding ourselves, make sure has a tree
        // and make sure the tree attributes match

        if ((hwndT = HasTreeWindow(hwndSrc)) &&
            (hwndT != hwndTC) &&
            !GetWindowLong(hwndT, GWL_READLEVEL) &&
            (wView  == (WORD)(GetWindowLong(hwndSrc, GWL_VIEW) & VIEW_PLUSES)) &&
            (dwAttribs == (DWORD)(GetWindowLong(hwndSrc, GWL_ATTRIBS) & ATTR_HS))) {

            SendMessage(hwndSrc, FS_GETDIRECTORY, sizeof(szSrc), (LPARAM)szSrc);
            StripBackslash(szSrc);

            if (!lstrcmpi(szDir, szSrc))     // are they the same?
                break;                  // yes, do stuff below
        }
    }

    if (hwndSrc) {

        HWND hwndLBSrc;
        PDNODE pNode, pNewNode, pLastParent;
        INT i;

        hwndLBSrc = GetDlgItem(hwndT, IDCW_TREELISTBOX);

        // don't seal from a tree that hasn't been read yet!

        if ((INT)SendMessage(hwndLBSrc, LB_GETCOUNT, 0, 0L) == 0) {
            LEAVE("StealTreeData");
            return FALSE;
        }

        pLastParent = NULL;

        for (i = 0; SendMessage(hwndLBSrc, LB_GETTEXT, i, (LPARAM)&pNode) != LB_ERR; i++) {

            if (pNewNode = (PDNODE)LocalAlloc(LPTR, sizeof(DNODE)+lstrlen(pNode->szName))) {

                *pNewNode = *pNode;                             // dup the node
                lstrcpy(pNewNode->szName, pNode->szName);       // and the name

                // accelerate the case where we are on the same level to avoid
                // slow linear search!

                if (pLastParent && pLastParent->nLevels == (pNode->nLevels - (BYTE)1)) {
                    pNewNode->pParent = pLastParent;
                } else {
                    pNewNode->pParent = pLastParent = FindParent(pNode->nLevels-1, i-1, hwndLB);
                }

                PRINT(BF_PARMTRACE, "(stolen)Inserting...0x%lx", pNewNode);
                PRINT(BF_PARMTRACE, "   at %d", IntToPtr(i));
                SendMessage(hwndLB, LB_INSERTSTRING, i, (LPARAM)pNewNode);
                ASSERT((PDNODE)SendMessage(hwndLB, LB_GETITEMDATA, i, 0L) == pNewNode);
            }
        }

        LEAVE("StealTreeData");
        return TRUE;    // successful steal
    }

    LEAVE("StealTreeData");
    return FALSE;
}



VOID
FreeAllTreeData(
               HWND hwndLB
               )
{
    INT nIndex;
    PDNODE pNode;

    ENTER("FreeAllTreeData");

    // Free up the old tree (if any)

    nIndex = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
    while (--nIndex >= 0) {
        SendMessage(hwndLB, LB_GETTEXT, nIndex, (LPARAM)&pNode);
        LocalFree((HANDLE)pNode);
    }
    SendMessage(hwndLB, LB_RESETCONTENT, 0, 0L);

    LEAVE("FreeAllTreeData");
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FillTreeListbox() -                                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/
// szDefaultDir is ANSI

VOID
FillTreeListbox(
               HWND hwndTC,
               LPSTR szDefaultDir,
               BOOL bFullyExpand,
               BOOL bDontSteal
               )
{
    PDNODE pNode;
    INT   iNode;
    DWORD dwAttribs;
    CHAR  szTemp[MAXPATHLEN];
    CHAR  szExpand[MAXPATHLEN];
    LPSTR  p;
    HWND  hwndLB;

    ENTER("FillTreeListbox");

    hwndLB = GetDlgItem(hwndTC, IDCW_TREELISTBOX);

    FreeAllTreeData(hwndLB);

    SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L);

    bDontSteal = TRUE; // Force recalc for now

    if (bDontSteal || bFullyExpand || !StealTreeData(hwndTC, hwndLB, szDefaultDir)) {

        wsprintf(szTemp, "\\", DRIVEID(szDefaultDir) + 'A');
        iNode = InsertDirectory(hwndTC, NULL, 0, szTemp, &pNode);

        if (pNode) {

            dwAttribs = ATTR_DIR | (GetWindowLong(GetParent(hwndTC), GWL_ATTRIBS) & ATTR_HS);
            cNodes = 0;
            bCancelTree = FALSE;

            if (szDefaultDir) {
                lstrcpy(szExpand, szDefaultDir+3);      // skip "X:\"

                p = szExpand;

                while (*p) {                            // null out all slashes

                    while (*p && *p != '\\')
                        p = AnsiNext(p);

                    if (*p)
                        *p++ = 0L;
                }
                p++;
                *p = 0L;      // double null terminated
            } else
                *szExpand = 0;

            if (!ReadDirLevel(hwndTC, pNode, szTemp, 1, 0, dwAttribs, bFullyExpand, szExpand)) {
                lFreeSpace = -2L;
            }

        }
    }

    SendMessage(hwndLB, LB_SETHORIZONTALEXTENT, xTreeMax, 0L);

    if (szDefaultDir) {
        FindItemFromPath(hwndLB, szDefaultDir, FALSE, &pNode);
    }

    SendMessage(hwndLB, LB_SELECTSTRING, -1, (LPARAM)pNode);

    UpdateStatus(GetParent(hwndTC));  // Redraw the Status Bar

    SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);

    InvalidateRect(hwndLB, NULL, TRUE);
    UpdateWindow(hwndLB);                 // make this look a bit better

    LEAVE("FillTreeListbox");
}


//
// FindItemFromPath()
//
// find the PDNODE and LBIndex for a given path
//
// in:
//      hwndLB          listbox of tree
//      lpszPath        path to search for (ANSI)
//      bReturnParent   TRUE if you want the parent, not the node
//
//
// returns:
//      listbox index (0xFFFF if not found)
//      *ppNode is filled with pNode of node, or pNode of parent if bReturnParent is TRUE
//

WORD
FindItemFromPath(
                HWND hwndLB,
                LPSTR lpszPath,
                BOOL bReturnParent,
                PDNODE *ppNode
                )
{
    register WORD     i;
    register LPSTR     p;
    PDNODE             pNode;
    PDNODE             pPreviousNode;
    CHAR              szElement[1+MAXFILENAMELEN+1];

    ENTER("FindItemFromPath");

    if (lstrlen(lpszPath) < 3) {
        LEAVE("FindItemFromPath");
        return -1;
    }
    if (IsDBCSLeadByte( lpszPath[0] ) || lpszPath[1] != ':') {
        LEAVE("FindItemFromPath");
        return -1;
    }

    i = 0;
    pPreviousNode = NULL;

    while (*lpszPath) {
        /* NULL out szElement[1] so the backslash hack isn't repeated with
         * a first level directory of length 1.
         */
        szElement[1] = 0L;

        /* Copy the next section of the path into 'szElement' */
        p = szElement;
        while (*lpszPath && *lpszPath != '\\') {
            *p++ = *lpszPath;
            if (IsDBCSLeadByte( *lpszPath ))
                *p++ = lpszPath[1];     // copy 2nd byte of DBCS char.
            lpszPath = AnsiNext( lpszPath );
        }

        /* Add a backslash for the Root directory. */
        if ( !IsDBCSLeadByte( szElement[0] ) && szElement[1] == ':' )
            *p++ = '\\';

        /* NULL terminate 'szElement' */
        *p = 0L;

        /* Skip over the path's next Backslash. */
        if (*lpszPath)
            lpszPath = AnsiNext(lpszPath);
        else if (bReturnParent) {
            /* We're at the end of a path which includes a filename.  Return
             * the previously found parent.
             */
            if (ppNode) {
                *ppNode = pPreviousNode;
            }
            LEAVE("FindItemFromPath");
            return i;
        }

        while (TRUE) {
            /* Out of LB items?  Not found. */
            if (SendMessage(hwndLB, LB_GETTEXT, i, (LPARAM)&pNode) == LB_ERR)
                return -1;

            if (pNode->pParent == pPreviousNode) {
                if (!lstrcmpi(szElement, pNode->szName)) {
                    /* We've found the element... */
                    pPreviousNode = pNode;
                    break;
                }
            }
            i++;
        }
    }
    if (ppNode) {
        *ppNode = pPreviousNode;
    }

    LEAVE("FindItemFromPath");
    return i;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  RectTreeItem() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
RectTreeItem(
            HWND hwndLB,
            INT iItem,
            BOOL bFocusOn
            )
{
    INT           dx;
    INT           len;
    HDC           hdc;
    RECT          rc;
    RECT          rcClip;
    BOOL          bSel;
    WORD          wColor;
    PDNODE         pNode;
    HBRUSH        hBrush;
    HFONT hOld;
    CHAR          szPath[MAXPATHLEN];

    ENTER("RectTreeItem");

    if (iItem == -1) {
        LEAVE("RectTreeItem");
        return;
    }

    /* Are we over ourselves? (i.e. a selected item in the source listbox) */
    bSel = (BOOL)SendMessage(hwndLB, LB_GETSEL, iItem, 0L);
    if (bSel && (hwndDragging == hwndLB)) {
        LEAVE("RectTreeItem");
        return;
    }

    SendMessage(hwndLB, LB_GETTEXT, iItem, (LPARAM)&pNode);

    SendMessage(hwndLB, LB_GETITEMRECT, iItem, (LPARAM)&rc);

    hdc = GetDC(hwndLB);

    len = lstrlen(pNode->szName);
    lstrcpy(szPath, pNode->szName);

    if ((wTextAttribs & TA_LOWERCASE) && !(pNode->wFlags & TF_LFN))
        AnsiLower(szPath);

    hOld = SelectObject(hdc, hFont);
    MGetTextExtent(hdc, szPath, len, &dx, NULL);
    dx += dyBorder;
    if (hOld)
        SelectObject(hdc, hOld);
    rc.left = pNode->nLevels * dxText * 2;
    rc.right = rc.left + dxFolder + dx + 4 * dyBorderx2;

    GetClientRect(hwndLB, &rcClip);
    IntersectRect(&rc, &rc, &rcClip);

    if (bFocusOn) {
        if (bSel) {
            wColor = COLOR_WINDOW;
            InflateRect(&rc, -dyBorder, -dyBorder);
        } else
            wColor = COLOR_WINDOWFRAME;
        if (hBrush = CreateSolidBrush(GetSysColor(wColor))) {
            FrameRect(hdc, &rc, hBrush);
            DeleteObject(hBrush);
        }
    } else {
        InvalidateRect(hwndLB, &rc, TRUE);
        UpdateWindow(hwndLB);
    }
    ReleaseDC(hwndLB, hdc);
    LEAVE("RectTreeItem");
}


// return the drive of the first window to respond to the FS_GETDRIVE
// message.  this usually starts from the source or dest of a drop
// and travels up until we find a drive or hit the MDI client

INT
APIENTRY
GetDrive(
        HWND hwnd,
        POINT pt
        )
{
    CHAR chDrive;

    chDrive = 0L;
    while (hwnd && (hwnd != hwndMDIClient)) {
        chDrive = (CHAR)SendMessage(hwnd, FS_GETDRIVE, 0, MAKELONG((WORD)pt.x, (WORD)pt.y));

        if (chDrive)
            return chDrive;

        hwnd = GetParent(hwnd); // try the next higher up
    }

    return 0;
}

BOOL
IsNetPath(
         PDNODE pNode
         )
{
    CHAR szPath[MAXPATHLEN];
    INT i;

    if (pNode->iNetType == -1) {

        GetTreePath(pNode, szPath);

        if (WNetGetDirectoryType((LPSTR)szPath, (LPDWORD)&i, TRUE) == WN_SUCCESS)
            pNode->iNetType = i;
        else
            pNode->iNetType = 0;
    }
    return pNode->iNetType;
}


VOID
TCWP_DrawItem(
             LPDRAWITEMSTRUCT lpLBItem,
             HWND hwndLB,
             HWND hWnd
             )
{
    INT               x, y, dx, dy;
    INT               nLevel;
    HDC               hdc;
    WORD              len;
    RECT              rc;
    BOOL              bHasFocus, bDrawSelected;
    PDNODE            pNode, pNTemp;
    DWORD             rgbText;
    DWORD             rgbBackground;
    HBRUSH            hBrush, hOld;
    INT iBitmap;
    WORD view;
    CHAR      szPath[MAXPATHLEN];

    ENTER("TCWP_DrawItem");

    if (lpLBItem->itemID == (DWORD)-1) {
        return;
    }

    hdc = lpLBItem->hDC;
    pNode = (PDNODE)lpLBItem->itemData;

    lstrcpy(szPath, pNode->szName);
    if ((wTextAttribs & TA_LOWERCASE) && !(pNode->wFlags & TF_LFN))
        AnsiLower(szPath);

    len = (WORD)lstrlen(szPath);
    MGetTextExtent(hdc, szPath, len, &dx, NULL);
    dx += dyBorder;

    rc = lpLBItem->rcItem;
    rc.left = pNode->nLevels * dxText * 2;
    rc.right = rc.left + dxFolder + dx + 4 * dyBorderx2;

    if (lpLBItem->itemAction & (ODA_DRAWENTIRE | ODA_SELECT)) {

        // draw the branches of the tree first

        nLevel = pNode->nLevels;

        x = (nLevel * dxText * 2) - dxText + dyBorderx2;
        dy = lpLBItem->rcItem.bottom - lpLBItem->rcItem.top;
        y = lpLBItem->rcItem.top + (dy/2);

        if (hBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOWTEXT))) {

            hOld = SelectObject(hdc, hBrush);

            if (pNode->pParent) {
                /* Draw the horizontal line over to the (possible) folder. */
                PatBlt(hdc, x, y, dyText, dyBorder, PATCOPY);

                /* Draw the top part of the vertical line. */
                PatBlt(hdc, x, lpLBItem->rcItem.top, dyBorder, dy/2, PATCOPY);

                /* If not the end of a node, draw the bottom part... */
                if (!(pNode->wFlags & TF_LASTLEVELENTRY))
                    PatBlt(hdc, x, y+dyBorder, dyBorder, dy/2, PATCOPY);

                /* Draw the verticals on the left connecting other nodes. */
                pNTemp = pNode->pParent;
                while (pNTemp) {
                    nLevel--;
                    if (!(pNTemp->wFlags & TF_LASTLEVELENTRY))
                        PatBlt(hdc, (nLevel * dxText * 2) - dxText + dyBorderx2,
                               lpLBItem->rcItem.top, dyBorder,dy, PATCOPY);

                    pNTemp = pNTemp->pParent;
                }
            }

            if (hOld)
                SelectObject(hdc, hOld);

            DeleteObject(hBrush);
        }

        bDrawSelected = (lpLBItem->itemState & ODS_SELECTED);
        bHasFocus = (GetFocus() == lpLBItem->hwndItem);

        // draw text with the proper background or rect

        if (bHasFocus && bDrawSelected) {
            rgbText = SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
            rgbBackground = SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
        }

        ExtTextOut(hdc, x + dxText + dxFolder + 2 * dyBorderx2,
                   y-(dyText/2), ETO_OPAQUE, &rc,
                   szPath, len, NULL);

        // draw the bitmaps as needed

        // HACK: Don't draw the bitmap when moving

        if (fShowSourceBitmaps || (hwndDragging != hwndLB) || !bDrawSelected) {

            // Blt the proper folder bitmap

            view = (WORD)GetWindowLong(GetParent(hWnd), GWL_VIEW);

            if (bNetAdmin && IsNetPath(pNode)) {
                // we need this bitmap from lisa
                if (bDrawSelected)
                    iBitmap = BM_IND_OPENDFS;
                else
                    iBitmap = BM_IND_CLOSEDFS;

            } else if (!(view & VIEW_PLUSES) || !(pNode->wFlags & TF_HASCHILDREN)) {
                if (bDrawSelected)
                    iBitmap = BM_IND_OPEN;
                else
                    iBitmap = BM_IND_CLOSE;
            } else {
                if (pNode->wFlags & TF_EXPANDED) {
                    if (bDrawSelected)
                        iBitmap = BM_IND_OPENMINUS;
                    else
                        iBitmap = BM_IND_CLOSEMINUS;
                } else {
                    if (bDrawSelected)
                        iBitmap = BM_IND_OPENPLUS;
                    else
                        iBitmap = BM_IND_CLOSEPLUS;
                }
            }
            BitBlt(hdc, x + dxText + dyBorder, y-(dyFolder/2), dxFolder, dyFolder,
                   hdcMem, iBitmap * dxFolder, (bHasFocus && bDrawSelected) ? dyFolder : 0, SRCCOPY);
        }

        // restore text stuff and draw rect as required

        if (bDrawSelected) {
            if (bHasFocus) {
                SetTextColor(hdc, rgbText);
                SetBkColor(hdc, rgbBackground);
            } else {
                HBRUSH hbr;
                if (hbr = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT))) {
                    FrameRect(hdc, &rc, hbr);
                    DeleteObject(hbr);
                }
            }
        }


    }

    if (lpLBItem->itemAction == ODA_FOCUS)
        DrawFocusRect(hdc, &rc);

}

/* A helper for both ExpandLevel and TreeCtlWndProc.TC_COLLAPSELEVEL.
 * Code moved from TreeCtlWndProc to be shared.  EDH 13 Oct 91
 */
VOID
CollapseLevel(
             HWND hwndLB,
             PDNODE pNode,
             INT nIndex
             )
{
    DWORD_PTR dwTemp;
    PDNODE pParentNode = pNode;
    INT nIndexT = nIndex;

    /* Disable redrawing early. */
    SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L);

    nIndexT++;

    /* Remove all subdirectories. */

    while (TRUE) {
        /* Make sure we don't run off the end of the listbox. */
        if (SendMessage(hwndLB, LB_GETTEXT, nIndexT, (LPARAM)&dwTemp) == LB_ERR)
            break;

        pNode = (PDNODE)dwTemp;

        if (pNode->nLevels <= pParentNode->nLevels)
            break;

        LocalFree((HANDLE)pNode);

        SendMessage(hwndLB, LB_DELETESTRING, nIndexT, 0L);
    }

    pParentNode->wFlags &= ~TF_EXPANDED;
    SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);

    InvalidateRect(hwndLB, NULL, TRUE);

}


VOID
ExpandLevel(
           HWND hWnd,
           WORD wParam,
           INT nIndex,
           PSTR szPath
           )
{
    HWND hwndLB;
    DWORD_PTR dwTemp;
    PDNODE pNode;
    INT iNumExpanded;
    INT iBottomIndex;
    INT iTopIndex;
    INT iNewTopIndex;
    INT iExpandInView;
    INT iCurrentIndex;
    RECT rc;

    if (GetWindowLong(hWnd, GWL_READLEVEL))
        return;

    hwndLB = GetDlgItem(hWnd, IDCW_TREELISTBOX);

    if (nIndex == -1)
        if ((nIndex = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L)) == LB_ERR)
            return;

    SendMessage(hwndLB, LB_GETTEXT, nIndex, (LPARAM)&dwTemp);
    pNode = (PDNODE)dwTemp;

    // collapse the current contents so we avoid doubling existing "plus" dirs

    if (pNode->wFlags & TF_EXPANDED) {
        if (wParam)
            CollapseLevel(hwndLB, pNode, nIndex);
        else
            return;
    }

    GetTreePath(pNode, szPath);

    StripBackslash(szPath);   // remove the slash

    cNodes = 0;
    bCancelTree = FALSE;

    SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L);   // Disable redrawing.

    iCurrentIndex = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
    iNumExpanded = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
    iTopIndex = (INT)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L);
    GetClientRect(hwndLB, &rc);
    iBottomIndex = iTopIndex + (rc.bottom+1) / dyFileName;

    if (IsTheDiskReallyThere(hWnd, szPath, FUNC_EXPAND))
        ReadDirLevel(hWnd, pNode, szPath, (WORD)(pNode->nLevels + 1), nIndex,
                     (DWORD)(ATTR_DIR | (GetWindowLong(GetParent(hWnd), GWL_ATTRIBS) & ATTR_HS)),
                     (BOOL)wParam, szNULL);

    // this is how many will be in view

    iExpandInView = (iBottomIndex - (INT)iCurrentIndex);

    iNumExpanded = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L) - iNumExpanded;

    if (iNumExpanded >= iExpandInView) {

        iNewTopIndex = min((INT)iCurrentIndex, iTopIndex + iNumExpanded - iExpandInView + 1);

        SendMessage(hwndLB, LB_SETTOPINDEX, (WORD)iNewTopIndex, 0L);
    }

    SendMessage(hwndLB, LB_SETHORIZONTALEXTENT, xTreeMax, 0L);

    SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);

    if (iNumExpanded)
        InvalidateRect(hwndLB, NULL, TRUE);

    // Redraw the Status Bar

    UpdateStatus(GetParent(hWnd));
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  TreeControlWndProc() -                                                  */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* WndProc for the directory tree control. */

INT_PTR
APIENTRY
TreeControlWndProc(
                  register HWND hWnd,
                  UINT wMsg,
                  WPARAM wParam,
                  LPARAM lParam
                  )
{
    WORD      iSel;
    INT       i, j;
    WPARAM    nIndex;
    DWORD     dwTemp;
    PDNODE     pNode, pNodeNext;
    HWND      hwndLB;
    CHAR      szPath[MAXPATHLEN];

    STKCHK();

    hwndLB = GetDlgItem(hWnd, IDCW_TREELISTBOX);

    switch (wMsg) {
        case FS_GETDRIVE:
            MSG("TreeControlWndProc", "FS_GETDRIVE");
            return (GetWindowLong(GetParent(hWnd), GWL_TYPE) + 'A');

        case TC_COLLAPSELEVEL:
            MSG("TreeControlWndProc", "TC_COLLAPSELEVEL");
            {
                PDNODE     pParentNode;

                if (wParam)
                    nIndex = wParam;
                else {
                    nIndex = SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
                    if (nIndex == LB_ERR)
                        break;
                }

                SendMessage(hwndLB, LB_GETTEXT, nIndex, (LPARAM)&pParentNode);

                // short circuit if we are already in this state

                if (!(pParentNode->wFlags & TF_EXPANDED))
                    break;

                CollapseLevel(hwndLB, pParentNode, (int)nIndex);

                break;
            }

        case TC_EXPANDLEVEL:
            MSG("TreeControlWndProc", "TC_EXPANDLEVEL");
            ExpandLevel(hWnd, (WORD)wParam, (INT)-1, szPath);
            break;

        case TC_TOGGLELEVEL:
            MSG("TreeControlWndProc", "TC_TOGGLELEVEL");

            // don't do anything while the tree is being built

            if (GetWindowLong(hWnd, GWL_READLEVEL))
                return 1;

            SendMessage(hwndLB, LB_GETTEXT, (WPARAM)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L), (LPARAM)&pNode);

            if (pNode->wFlags & TF_EXPANDED)
                wMsg = TC_COLLAPSELEVEL;
            else
                wMsg = TC_EXPANDLEVEL;

            SendMessage(hWnd, wMsg, FALSE, 0L);
            break;

        case TC_GETDIR:
            // get a full path for a particular dir
            // wParam is the listbox index of path to get
            // lParam LOWORD is PSTR to buffer to fill in

            MSG("TreeControlWndProc", "TC_GETDIR");

            SendMessage(hwndLB, LB_GETTEXT, wParam, (LPARAM)&pNode);
            GetTreePath(pNode, (LPSTR)lParam);
            break;

        case TC_SETDIRECTORY:
            MSG("TreeControlWndProc", "TC_SETDIRECTORY");
            // set the selection in the tree to that for a given path

            {
                INT i;

                i = (INT)FindItemFromPath(hwndLB, (LPSTR)lParam, wParam ? TRUE : FALSE, NULL);

                if (i != -1)
                    SendMessage(hwndLB, LB_SETCURSEL, i, 0L);

                break;
            }

        case TC_SETDRIVE:
#define fFullyExpand    LOBYTE(wParam)
#define fDontSteal      HIBYTE(wParam)
#define szDir           (LPSTR)lParam  // NULL -> default == window text.

            MSG("TreeControlWndProc", "TC_SETDRIVE");

            {
                RECT rc;

                if (GetWindowLong(hWnd, GWL_READLEVEL))
                    break;

                // is the drive/dir specified?

                if (szDir) {
                    lstrcpy(szPath, szDir);                  // yes, use it
                } else {
                    SendMessage(GetParent(hWnd), FS_GETDIRECTORY, sizeof(szPath), (LPARAM)szPath); // no, use current
                    StripBackslash(szPath);
                }


                AnsiUpperBuff(szPath, 1);     // make sure

                SetWindowLong(GetParent(hWnd), GWL_TYPE, 2);

                // resize for new vol label

                GetClientRect(GetParent(hWnd), &rc);
                SendMessage(GetParent(hWnd), WM_SIZE, SIZENOMDICRAP, MAKELONG(rc.right, rc.bottom));

                // ensure the disk is available if the whole dir structure is
                // to be expanded

                if (!fFullyExpand || IsTheDiskReallyThere(hWnd, szPath, FUNC_EXPAND))
                    FillTreeListbox(hWnd, szPath, fFullyExpand, fDontSteal);

                // and force the dir half to update with a fake SELCHANGE message

                SendMessage(hWnd, WM_COMMAND, GET_WM_COMMAND_MPS(IDCW_TREELISTBOX, hWnd, LBN_SELCHANGE));
                break;
#undef fFullyExpand
#undef fDontSteal
#undef szDir
            }

        case WM_CHARTOITEM:
            MSG("TreeControlWndProc", "WM_CHARTOITEM");
            {
                WORD      w;
                CHAR      szB[2];
                INT       cItems;
                CHAR      ch;
                PDNODE     pNode;

                if (GET_WM_CHARTOITEM_CHAR(wParam, lParam) == '\\')   // backslash means the root
                    return 0L;

                cItems = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
                i = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);

                ch = GET_WM_CHARTOITEM_CHAR(wParam, lParam);
                if (i < 0 || ch <= ' ')       // filter all other control chars
                    return -2L;

                szB[1] = 0L;
                ch &= 255;

                for (j=1; j < cItems; j++) {
                    SendMessage(hwndLB, LB_GETTEXT, (i+j) % cItems, (LPARAM)&pNode);
                    szB[0] = pNode->szName[0];

                    /* Do it this way to be case insensitive. */
                    w = ch;
                    if (!lstrcmpi((LPSTR)&w, szB))
                        break;
                }

                if (j == cItems)
                    return -2L;

                SendMessage(hwndLB, LB_SETTOPINDEX, (i+j) % cItems, 0L);
                return((i+j) % cItems);
            }

        case WM_DESTROY:
            MSG("TreeControlWndProc", "WM_DESTROY");
            if (hwndLB == GetFocus()) {
                HWND hwnd;

                if (hwnd = HasDirWindow(GetParent(hWnd)))
                    SetFocus(hwnd);
                else
                    SetFocus(HasDrivesWindow(GetParent(hWnd)));
            }
            FreeAllTreeData(hwndLB);
            break;

        case WM_CREATE:
            TRACE(BF_WM_CREATE, "TreeControlWndProc - WM_CREATE");
            // create the owner draw list box for the tree
            {
                HWND hwnd;

                hwnd = CreateWindowEx(0L, szListbox, NULL, WS_TREESTYLE | WS_BORDER,
                                      0, 0, 0, 0, hWnd, (HMENU)IDCW_TREELISTBOX, hAppInstance, NULL);

                if (!hwnd)
                    return -1L;

                SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont, 0L);

                SetWindowLong(hWnd, GWL_READLEVEL, 0);
                break;
            }

        case WM_DRAWITEM:
            MSG("TreeControlWndProc", "WM_DRAWITEM");
            TCWP_DrawItem((LPDRAWITEMSTRUCT)lParam, hwndLB, hWnd);
            break;

        case WM_FILESYSCHANGE:
            MSG("TreeControlWndProc", "WM_FILESYSCHANGE");
            {
                HWND hwndParent;
                PDNODE pNodePrev;
                PDNODE pNodeT;

                if (!lParam || wParam == FSC_REFRESH)
                    break;

                nIndex = FindItemFromPath(hwndLB, (LPSTR)lParam, wParam == FSC_MKDIR, &pNode);

                if (nIndex == 0xFFFF)   /* Did we find it? */
                    break;

                lstrcpy(szPath, (LPSTR)lParam);
                StripPath(szPath);

                switch (wParam) {
                    case FSC_MKDIR:

                        // auto expand the branch so they can see the new
                        // directory just created

                        if (!(pNode->wFlags & TF_EXPANDED) &&
                            (nIndex == (WPARAM)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L)))
                            SendMessage(hWnd, TC_EXPANDLEVEL, FALSE, 0L);

                        // make sure this node isn't already here


                        if (FindItemFromPath(hwndLB, (LPSTR)lParam, FALSE, NULL) != 0xFFFF)
                            break;

                        // Insert it into the tree listbox

                        dwTemp = InsertDirectory(hWnd, pNode, (WORD)nIndex, szPath, &pNodeT);

                        // Add a plus if necessary

                        hwndParent = GetParent(hWnd);
                        if (GetWindowLong(hwndParent, GWL_VIEW) & VIEW_PLUSES) {
                            lstrcpy(szPath, (LPSTR)lParam);
                            ScanDirLevel((PDNODE)pNodeT, szPath, ATTR_DIR |
                                         (GetWindowLong(hwndParent, GWL_ATTRIBS) & ATTR_HS));

                            // Invalidate the window so the plus gets drawn if needed

                            if (((PDNODE)pNodeT)->wFlags & TF_HASCHILDREN)
                                InvalidateRect(hWnd, NULL, FALSE);
                        }

                        // if we are inserting before or at the current selection
                        // push the current selection down

                        nIndex = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
                        if ((INT)LOWORD(dwTemp) <= nIndex) {
                            SendMessage(hwndLB, LB_SETCURSEL, nIndex + 1, 0L);
                        }

                        break;

                    case FSC_RMDIR:
                        if (nIndex == 0)      /* NEVER delete the Root Dir! */
                            break;

                        if (pNode->wFlags & TF_LASTLEVELENTRY) {
                            // We are deleting the last subdirectory.
                            // If there are previous sibling directories, mark one
                            // as the last, else mark the parent as empty and unexpanded.
                            // It is necessary to do these checks if this bit
                            // is set, since if it isn't, there is another sibling
                            // with TF_LASTLEVELENTRY set, and so the parent is nonempty.
                            //
                            // Find the previous entry which has a level not deeper than
                            // the level of that being deleted.
                            i = (int)nIndex;
                            do {
                                SendMessage(hwndLB, LB_GETTEXT, --i, (LPARAM)&pNodePrev);
                            } while (pNodePrev->nLevels > pNode->nLevels);

                            if (pNodePrev->nLevels == pNode->nLevels) {
                                // The previous directory is a sibling... it becomes
                                // the new last level entry.
                                pNodePrev->wFlags |= TF_LASTLEVELENTRY;
                            } else {
                                // In order to find this entry, the parent must have
                                // been expanded, so if the parent of the deleted dir
                                // has no listbox entries under it, it may be assumed that
                                // the directory has no children.
                                pNodePrev->wFlags &= ~(TF_HASCHILDREN | TF_EXPANDED);
                            }
                        }

                        // Are we deleting the current selection?
                        // if so we move the selection to the item above the current.
                        // this should work in all cases because you can't delete
                        // the root.

                        if ((WPARAM)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L) == nIndex) {
                            SendMessage(hwndLB, LB_SETCURSEL, nIndex - 1, 0L);
                            SendMessage(hWnd, WM_COMMAND, GET_WM_COMMAND_MPS(0, 0, LBN_SELCHANGE));
                        }

                        SendMessage(hWnd, TC_COLLAPSELEVEL, nIndex, 0L);
                        SendMessage(hwndLB, LB_DELETESTRING, nIndex, 0L);

                        LocalFree((HANDLE)pNode);
                        break;
                }
                break;
            }

        case WM_COMMAND:
            {
                WORD id;

                id = GET_WM_COMMAND_ID(wParam, lParam);
                switch (GET_WM_COMMAND_CMD(wParam, lParam)) {
                    case LBN_SELCHANGE:
                        MSG("TreeControlWndProc", "LBN_SELCHANGE");
                        {
                            HWND hwndParent;
                            HWND hwndDir;
                            INT CurSel;

                            hwndParent = GetParent(hWnd);

                            CurSel = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
                            SendMessage(hWnd, TC_GETDIR, CurSel,(LPARAM)szPath);
                            AddBackslash(szPath);
                            SendMessage(hwndParent, FS_GETFILESPEC,  sizeof(szPath) - lstrlen(szPath), (LPARAM)szPath+lstrlen(szPath));

                            if (hwndDir = HasDirWindow(hwndParent)) {
                                // update the dir window

                                id = CD_PATH;

                                // don't allow abort on first or last directories


                                if (CurSel > 0 &&
                                    CurSel != ((INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L) - 1)) {
                                    id = CD_PATH | CD_ALLOWABORT;

                                }
                                SendMessage(hwndDir, FS_CHANGEDISPLAY, id, (LPARAM)szPath);

                            } else {
                                SetMDIWindowText(hwndParent, szPath);
                            }

                            UpdateStatus(hwndParent);
                            break;
                        }

                    case LBN_DBLCLK:
                        MSG("TreeControlWndProc", "LBN_DBLCLK");
                        SendMessage(hwndFrame, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_OPEN, 0, 0));
                        break;

                    case LBN_SETFOCUS:
                        MSG("TreeControlWndProc", "LBN_SETFOCUS");
                        SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, (LPARAM)GET_WM_COMMAND_HWND(wParam, lParam));
                        UpdateSelection(GET_WM_COMMAND_HWND(wParam, lParam));
                        UpdateStatus(GetParent(hWnd));  // update the status bar
                        break;

                    case LBN_KILLFOCUS:
                        MSG("TreeControlWndProc", "LBN_KILLFOCUS");
                        SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, 0);
                        UpdateSelection(GET_WM_COMMAND_HWND(wParam, lParam));
                        SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, (LPARAM)GET_WM_COMMAND_HWND(wParam, lParam));
                        break;
                }
            }
            break;


        case WM_LBTRACKPOINT:
            MSG("TreeControlWndProc", "WM_LBTRACKPOINT");
            // wParam is the listbox index that we are over
            // lParam is the mouse point

            /* Return 0 to do nothing, 1 to abort everything, or 2 to abort just dblclicks. */

            {
                HDC       hdc;
                INT       dx;
                INT       xNode;
                MSG       msg;
                RECT      rc;
                HFONT     hOld;
                POINT     pt;
                DRAGOBJECTDATA dodata;

                /* Someone clicked somewhere in the listbox. */

                // don't do anything while the tree is being built

                if (GetWindowLong(hWnd, GWL_READLEVEL))
                    return 1;

                /* Get the node they clicked on. */
                SendMessage(hwndLB, LB_GETTEXT, wParam, (LPARAM)&pNode);
                lstrcpy(szPath, pNode->szName);
                if ((wTextAttribs & TA_LOWERCASE) && !(pNode->wFlags & TF_LFN))
                    AnsiLower(szPath);

                //        if (pNode->wFlags | TF_DISABLED)
                //              return 2L;

                // too FAR to the left?

                i = LOWORD(lParam);

                xNode = pNode->nLevels * dxText * 2;
                if (i < xNode)
                    return 2; // yes, get out now

                // too FAR to the right?

                hdc = GetDC(hwndLB);
                hOld = SelectObject(hdc, hFont);
                MGetTextExtent(hdc, szPath, lstrlen(szPath), &dx, NULL);
                dx += (dyBorderx2*2);
                if (hOld)
                    SelectObject(hdc, hOld);
                ReleaseDC(hwndLB, hdc);

                if (i > xNode + dxFolder + dx + 4 * dyBorderx2)
                    return 2; // yes

                // Emulate a SELCHANGE notification and notify our parent
                SendMessage(hwndLB, LB_SETCURSEL, wParam, 0L);
                SendMessage(hWnd, WM_COMMAND, GET_WM_COMMAND_MPS(0, hwndLB, LBN_SELCHANGE));

                // make sure mouse still down

                if (!(GetKeyState(VK_LBUTTON) & 0x8000))
                    return 1;

                MPOINT2POINT(MAKEMPOINT(lParam), pt);
                ClientToScreen(hwndLB, (LPPOINT)&pt);
                ScreenToClient(hWnd, (LPPOINT)&pt);


                SetRect(&rc, pt.x - dxClickRect, pt.y - dyClickRect,
                        pt.x + dxClickRect, pt.y + dyClickRect);

                SetCapture(hWnd);
                while (GetMessage(&msg, NULL, 0, 0)) {

                    DispatchMessage(&msg);
                    if (msg.message == WM_LBUTTONUP)
                        break;

                    MPOINT2POINT(MAKEMPOINT(msg.lParam), pt);

                    if (GetCapture() != hWnd) {
                        msg.message = WM_LBUTTONUP;
                        break;
                    }

                    if ((msg.message == WM_MOUSEMOVE) && !(PtInRect(&rc, pt)))
                        break;
                }
                ReleaseCapture();

                /* Did the guy NOT drag anything? */
                if (msg.message == WM_LBUTTONUP)
                    return 1;

                /* Enter Danger Mouse's BatCave. */
                SendMessage(GetParent(hWnd), FS_GETDIRECTORY, sizeof(szPath), (LPARAM)szPath);
                StripBackslash(szPath);
                hwndDragging = hwndLB;
                iCurDrag = SINGLECOPYCURSOR;
                dodata.pch = szPath;
                dodata.hMemGlobal = 0;
                DragObject(hwndMDIClient, hWnd, (UINT)DOF_DIRECTORY, (DWORD)(ULONG_PTR)&dodata, LoadCursor(hAppInstance, MAKEINTRESOURCE(iCurDrag)));
                hwndDragging = NULL;
                fShowSourceBitmaps = TRUE;
                InvalidateRect(hwndLB, NULL, FALSE);

                return 2;
            }

        case WM_DRAGSELECT:
            MSG("TreeControlWndProc", "WM_DRAGSELECT");
            /* WM_DRAGSELECT is sent whenever a new window returns TRUE to a
             * QUERYDROPOBJECT.
             */
            iSelHilite = LOWORD(((LPDROPSTRUCT)lParam)->dwControlData);
            RectTreeItem(hwndLB, iSelHilite, (BOOL)wParam);
            break;

        case WM_DRAGMOVE:
            MSG("TreeControlWndProc", "WM_DRAGMOVE");

            /* WM_DRAGMOVE is sent when two consequetive TRUE QUERYDROPOBJECT
             * messages come from the same window.
             */

            /* Get the subitem we are over. */
            iSel = LOWORD(((LPDROPSTRUCT)lParam)->dwControlData);

            /* Is it a new one? */
            if (iSel == (WORD)iSelHilite)
                break;

            /* Yup, un-select the old item. */
            RectTreeItem(hwndLB, iSelHilite, FALSE);

            /* Select the new one. */
            iSelHilite = iSel;
            RectTreeItem(hwndLB, iSel, TRUE);
            break;

        case WM_DRAGLOOP:
            MSG("TreeControlWndProc", "WM_DRAGLOOP");

            // wParam     TRUE on dropable target
            //            FALSE not dropable target
            // lParam     lpds
            {
                BOOL bCopy;

#define lpds ((LPDROPSTRUCT)lParam)

                /* Are we over a drop-able sink? */
                if (wParam) {
                    if (GetKeyState(VK_CONTROL) < 0)      // CTRL
                        bCopy = TRUE;
                    else if (GetKeyState(VK_MENU)<0 || GetKeyState(VK_SHIFT)<0)   // ALT || SHIFT
                        bCopy = FALSE;
                    else
                        bCopy = (GetDrive(lpds->hwndSink, lpds->ptDrop) != GetDrive(lpds->hwndSource, lpds->ptDrop));
                } else {
                    bCopy = TRUE;
                }

                if (bCopy != fShowSourceBitmaps) {
                    RECT  rc;

                    fShowSourceBitmaps = bCopy;

                    iSel = (WORD)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);

                    if (!(BOOL)SendMessage(hwndLB, LB_GETITEMRECT, iSel, (LPARAM)&rc))
                        break;

                    InvalidateRect(hwndLB, &rc, FALSE);
                    UpdateWindow(hwndLB);

                    // hack, set the cursor to match the move/copy state
                    if (wParam)
                        SetCursor(GetMoveCopyCursor());
                }
                break;
            }

        case WM_QUERYDROPOBJECT:
            MSG("TreeControlWndProc", "WM_QUERYDROPOBJECT");
            // wParam     TRUE on NC area
            //            FALSE on client area
            // lParam     lpds

            // Do nothing
            return(FALSE);

#define lpds ((LPDROPSTRUCT)lParam)

            /* Check for valid format. */
            switch (lpds->wFmt) {
                case DOF_EXECUTABLE:
                case DOF_DOCUMENT:
                case DOF_DIRECTORY:
                case DOF_MULTIPLE:
                    if (fShowSourceBitmaps)
                        i = iCurDrag | 1;       // copy
                    else
                        i = iCurDrag & 0xFFFE;
                    break;

                default:
                    return FALSE;
            }

            /* Must be dropping on the listbox client area. */
            if (lpds->hwndSink != hwndLB)
                return FALSE;

            if (LOWORD(lpds->dwControlData) == 0xFFFF)
                return FALSE;

            return (INT_PTR)GetMoveCopyCursor();

        case WM_DROPOBJECT:       // tree being dropped on do your thing
#define lpds ((LPDROPSTRUCT)lParam) // BUG: WM_DROPOBJECT structure packing!

            // Do nothing
            return(TRUE);

            MSG("TreeControlWndProc", "WM_DROPOBJECT");

            // dir (search) drop on tree:
            //    HIWORD(dwData)  0
            //    LOWORD(dwData)  LPSTR to files being dragged
            //
            // tree drop on tree:
            //    HIWORD(dwData)  index of source drag
            //    LOWORD(dwData)  LPSTR to path

            {
                LPSTR      pFrom;

                nIndex = LOWORD(lpds->dwControlData);
                pFrom = (LPSTR)(((LPDRAGOBJECTDATA)(lpds->dwData))->pch);

                // Get the destination

                SendMessage(hWnd, TC_GETDIR, nIndex, (LPARAM)szPath);
                CheckEscapes(szPath);

                // if source and dest are the same make this a NOP

                if (!lstrcmpi(szPath, pFrom))
                    return TRUE;

                AddBackslash(szPath);
                lstrcat(szPath, szStarDotStar);

                DMMoveCopyHelper(pFrom, szPath, fShowSourceBitmaps);

                RectTreeItem(hwndLB, (int)nIndex, FALSE);
            }
            return TRUE;
#undef lpds

        case WM_MEASUREITEM:
            MSG("TreeControlWndProc", "WM_MEASUREITEM");
#define pLBMItem ((LPMEASUREITEMSTRUCT)lParam)

            pLBMItem->itemHeight = (WORD)dyFileName;
            break;

        case WM_VKEYTOITEM:
            MSG("TreeControlWndProc", "WM_VKEYTOITEM");
            if (wParam == VK_ESCAPE) {
                bCancelTree = TRUE;
                return -2L;
            }

            i = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
            if (i < 0)
                return -2L;

            j = 1;
            SendMessage(hwndLB, LB_GETTEXT, i, (LPARAM)&pNode);

            switch (GET_WM_VKEYTOITEM_ITEM(wParam, lParam)) {
                case VK_LEFT:
                    while (SendMessage(hwndLB, LB_GETTEXT, --i, (LPARAM)&pNodeNext) != LB_ERR) {
                        if (pNode == pNode->pParent)
                            return(i);
                    }
                    goto SameSelection;

                case VK_RIGHT:
                    if ((SendMessage(hwndLB, LB_GETTEXT, i+1, (LPARAM)&pNodeNext) == LB_ERR)
                        || (pNodeNext->pParent != pNode)) {
                        goto SameSelection;
                    }
                    return(i+1);

                case VK_UP:
                    j = -1;
                    /** FALL THRU ***/

                case VK_DOWN:
                    /* If the control key is not down, use default behavior. */
                    if (GetKeyState(VK_CONTROL) >= 0)
                        return(-1L);

                    while (SendMessage(hwndLB, LB_GETTEXT, i += j, (LPARAM)&pNodeNext) != LB_ERR) {
                        if (pNodeNext->pParent == pNode->pParent)
                            return(i);
                    }

                    SameSelection:
                    MessageBeep(0);
                    return(-2L);

                case VK_F6:       // like excel
                case VK_TAB:
                    {
                        HWND hwndDir, hwndDrives;
                        BOOL bDir;

                        GetTreeWindows(GetParent(hWnd), NULL, &hwndDir, &hwndDrives);

                        // Check to see if we can change to the directory window

                        if (hwndDir) {
                            HWND hwndLB; /* Local scope ONLY */

                            hwndLB = GetDlgItem (hwndDir,IDCW_LISTBOX);
                            if (hwndLB) {
                                SendMessage (hwndLB,LB_GETTEXT,0, (LPARAM) &pNode);
                                bDir = pNode ? TRUE : FALSE;
                            }
                        }

                        if (GetKeyState(VK_SHIFT) < 0)
                            SetFocus(hwndDrives);
                        else
                            if (bDir)
                            SetFocus (hwndDir);
                        else
                            SetFocus (hwndDrives);
                        return -2L;   // I dealt with this!
                    }

                case VK_BACK:
                    {
                        BYTE nStartLevel;

                        if (i <= 0)
                            return -2L;     // root case

                        nStartLevel = pNode->nLevels;

                        do {
                            SendMessage(hwndLB, LB_GETTEXT, --i, (LPARAM)&pNodeNext);
                        } while (i > 0 && pNodeNext->nLevels >= nStartLevel);

                        return i;
                    }

                default:
                    if (GetKeyState(VK_CONTROL) < 0)
                        return SendMessage(GetDlgItem(GetParent(hWnd), IDCW_DRIVES), wMsg, wParam, lParam);
                    return -1L;
            }
            break;

        case WM_SETFOCUS:
        case WM_LBUTTONDOWN:
            MSG("TreeControlWndProc", "WM_LBUTTONDOWN");
            SetFocus(hwndLB);
            break;

        case WM_SIZE:
            MSG("TreeControlWndProc", "WM_SIZE");
            if (!IsIconic(GetParent(hWnd))) {
                INT iMax;

                MoveWindow(hwndLB, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);

                iMax = (INT)SendMessage(hwndLB, LB_GETCURSEL, 0, 0L);
                if (iMax >= 0) {
                    RECT rc;
                    INT top, bottom;

                    GetClientRect(hwndLB, &rc);
                    top = (INT)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L);
                    bottom = top + rc.bottom / dyFileName;
                    if (iMax < top || iMax > bottom)
                        SendMessage(hwndLB, LB_SETTOPINDEX, iMax - ((bottom - top) / 2), 0L);
                }
            }
            break;

        default:
            DEFMSG("TreeControlWndProc", (WORD)wMsg);
            return DefWindowProc(hWnd, wMsg, wParam, lParam);
    }
    return 0L;
}