windows-xp/Source/XPSP1/NT/shell/shell32/viewstate.cpp

#include "shellprv.h"
#include "defviewp.h"
#include "ViewState.h"


CViewState::CViewState()
{
    ASSERT(_lParamSort == NULL);
    ASSERT(_iDirection == 0);
    ASSERT(_iLastColumnClick == 0);
    ASSERT(_ViewMode == 0);
    ASSERT(_ptScroll.x == 0 && _ptScroll.y == 0);
    ASSERT(_guidGroupID == GUID_NULL);
    ASSERT(_scidDetails.fmtid == GUID_NULL);
    ASSERT(_scidDetails.pid == 0);
    ASSERT(_hdsaColumnOrder == NULL);
    ASSERT(_hdsaColumnWidths == NULL);
    ASSERT(_hdsaColumnStates == NULL);
    ASSERT(_hdpaItemPos == NULL);
    ASSERT(_pbPositionData == NULL);

    _iDirection = 1;

    _fFirstViewed = TRUE;       // Assume this is the first time we are looking at a folder.
}

CViewState::~CViewState()
{
    if (_hdsaColumnOrder)
        DSA_Destroy(_hdsaColumnOrder);

    if (_hdsaColumnWidths)
        DSA_Destroy(_hdsaColumnWidths);

    if (_hdsaColumnStates)
        DSA_Destroy(_hdsaColumnStates);

    if (_hdsaColumns)
        DSA_Destroy(_hdsaColumns);

    ClearPositionData();

    LocalFree(_pbPositionData); // accepts NULL
}



// When initializing a new DefView, see if we can 
// propogate information from the previous one.
void CViewState::InitFromPreviousView(IUnknown* pPrevView)
{
    CDefView *pdsvPrev;
    if (SUCCEEDED(pPrevView->QueryInterface(IID_PPV_ARG(CDefView, &pdsvPrev))))
    {
        // preserve stuff like sort order
        _lParamSort = pdsvPrev->_vs._lParamSort;
        _iDirection = pdsvPrev->_vs._iDirection;
        _iLastColumnClick = pdsvPrev->_vs._iLastColumnClick;
        pdsvPrev->Release();
    }
}

void CViewState::InitFromHeader(DVSAVEHEADER_COMBO* pdv)
{
    _lParamSort = pdv->dvSaveHeader.dvState.lParamSort;
    _iDirection = pdv->dvSaveHeader.dvState.iDirection;
    // Patch this up. I guess at one time we persisted this wrong.
    if (_iDirection == 0)
        _iDirection = 1;
    _iLastColumnClick = pdv->dvSaveHeader.dvState.iLastColumnClick;
    _ViewMode = pdv->dvSaveHeader.ViewMode;
    _ptScroll = pdv->dvSaveHeader.ptScroll;
}

void CViewState::GetDefaults(CDefView* pdv, LPARAM* plParamSort, int* piDirection, int* piLastColumnClick)
{
    SHELLSTATE ss;
    SHGetSetSettings(&ss, SSF_SORTCOLUMNS, FALSE);
    if (plParamSort)
        *plParamSort = ss.lParamSort;

    if (piDirection)
        *piDirection = ss.iSortDirection ? ss.iSortDirection : 1;
    if (piLastColumnClick)
        *piLastColumnClick = -1;
    pdv->CallCB(SFVM_GETSORTDEFAULTS, (LPARAM)piDirection, (WPARAM)plParamSort);
}

void CViewState::InitWithDefaults(CDefView* pdv)
{
    GetDefaults(pdv, &_lParamSort, &_iDirection, &_iLastColumnClick);
}

int CALLBACK CViewState::_SavedItemCompare(void *p1, void *p2, LPARAM lParam)
{
    CDefView *pdv = reinterpret_cast<CDefView*>(lParam);

    UNALIGNED VIEWSTATE_POSITION *pdvi1 = (UNALIGNED VIEWSTATE_POSITION *)p1;
    UNALIGNED VIEWSTATE_POSITION *pdvi2 = (UNALIGNED VIEWSTATE_POSITION *)p2;

    // manually terminate these pidls because they are packed together
    // in the save buffer

    LPITEMIDLIST pFakeEnd1 = _ILNext(&pdvi1->idl);
    USHORT uSave1 = pFakeEnd1->mkid.cb;
    pFakeEnd1->mkid.cb = 0;

    LPITEMIDLIST pFakeEnd2 = _ILNext(&pdvi2->idl);
    USHORT uSave2 = pFakeEnd2->mkid.cb;
    pFakeEnd2->mkid.cb = 0;

    int nCmp = pdv->_Compare(&pdvi1->idl, &pdvi2->idl, reinterpret_cast<LPARAM>(pdv));

    pFakeEnd2->mkid.cb = uSave2;
    pFakeEnd1->mkid.cb = uSave1;

    return nCmp;
}

BOOL CViewState::SyncPositions(CDefView* pdv)
{
    if (_ViewMode != pdv->_fs.ViewMode)
    {
        return FALSE;
    }

    if (_hdpaItemPos == NULL || DPA_GetPtrCount(_hdpaItemPos) == 0)
    {
        return FALSE;
    }

    if (DPA_Sort(_hdpaItemPos, _SavedItemCompare, (LPARAM)pdv))
    {
        UNALIGNED VIEWSTATE_POSITION * UNALIGNED * ppDVItem = (UNALIGNED VIEWSTATE_POSITION * UNALIGNED *)DPA_GetPtrPtr(_hdpaItemPos);
        UNALIGNED VIEWSTATE_POSITION * UNALIGNED *ppEndDVItems = ppDVItem + DPA_GetPtrCount(_hdpaItemPos);

        // Turn off auto-arrange and snap-to-grid if it's on at the mo.
        DWORD dwStyle = GetWindowStyle(pdv->_hwndListview);
        if (dwStyle & LVS_AUTOARRANGE)
            SetWindowLong(pdv->_hwndListview, GWL_STYLE, dwStyle & ~LVS_AUTOARRANGE);
            
        DWORD dwLVExStyle = ListView_GetExtendedListViewStyle(pdv->_hwndListview);
        if (dwLVExStyle & LVS_EX_SNAPTOGRID)
            ListView_SetExtendedListViewStyle(pdv->_hwndListview, dwLVExStyle & ~LVS_EX_SNAPTOGRID);

        HDSA hdsaPositionlessItems = NULL;
        int iCount = ListView_GetItemCount(pdv->_hwndListview);
        for (int i = 0; i < iCount; i++)
        {
            LPCITEMIDLIST pidl = pdv->_GetPIDL(i);

            // need to check for pidl because this could be on a background
            // thread and an fsnotify could be coming through to blow it away
            for ( ; pidl ; )
            {
                int nCmp;

                if (ppDVItem < ppEndDVItems)
                {
                    // We terminate the IDList manually after saving
                    // the needed information.  Note we will not GP fault
                    // since we added sizeof(ITEMIDLIST) onto the Alloc
                    LPITEMIDLIST pFakeEnd = _ILNext(&(*ppDVItem)->idl);
                    USHORT uSave = pFakeEnd->mkid.cb;
                    pFakeEnd->mkid.cb = 0;

                    nCmp = pdv->_Compare(&((*ppDVItem)->idl), (void *)pidl, (LPARAM)pdv);

                    pFakeEnd->mkid.cb = uSave;
                }
                else
                {
                    // do this by default.  this prevents overlap of icons
                    //
                    // i.e.  if we've run out of saved positions information,
                    // we need to just loop through and set all remaining items
                    // to position 0x7FFFFFFFF so that when it's really shown,
                    // the listview will pick a new (unoccupied) spot.
                    // breaking out now would leave it were the _Sort
                    // put it, but another item with saved state info could
                    // have come and be placed on top of it.
                    nCmp = 1;
                }

                if (nCmp > 0)
                {
                    // We did not find the item
                    // reset it's position to be recomputed

                    if (NULL == hdsaPositionlessItems)
                        hdsaPositionlessItems = DSA_Create(sizeof(int), 16);

                    if (hdsaPositionlessItems)
                        DSA_AppendItem(hdsaPositionlessItems, (void*)&i);

                    break;
                }
                else if (nCmp == 0) // They are equal
                {
                    UNALIGNED VIEWSTATE_POSITION * pDVItem = *ppDVItem;
                    
                    pdv->_SetItemPosition(i, pDVItem->pt.x, pDVItem->pt.y);

                    ppDVItem++; // move on to the next
                    break;
                }

                ppDVItem++; // move to the next
            }
        }

        if (hdsaPositionlessItems)
        {
            for (i = 0; i < DSA_GetItemCount(hdsaPositionlessItems); i++)
            {
                int* pIndex = (int*)DSA_GetItemPtr(hdsaPositionlessItems, i);
                pdv->_SetItemPosition(*pIndex, 0x7FFFFFFF, 0x7FFFFFFF);
            }

            DSA_Destroy(hdsaPositionlessItems);
        }

        // Turn auto-arrange and snap to grid back on if needed...
        if (dwLVExStyle & LVS_EX_SNAPTOGRID)
            ListView_SetExtendedListViewStyle(pdv->_hwndListview, dwLVExStyle);

        if (dwStyle & LVS_AUTOARRANGE)
            SetWindowLong(pdv->_hwndListview, GWL_STYLE, dwStyle);
    }
    return TRUE;
}

void CViewState::LoadPositionBlob(CDefView* pdv, DWORD cbSizeofStream, IStream* pstm)
{
    // Allocate a blob of memory to hold the position info.
    if (_pbPositionData) 
        LocalFree(_pbPositionData);

    _pbPositionData = (BYTE*)LocalAlloc(LPTR, cbSizeofStream);
    if (_pbPositionData == NULL)
        return;

    // Read into that blob.
    if (SUCCEEDED(pstm->Read(_pbPositionData, cbSizeofStream, NULL)))
    {
        // Walk the blob, and append to the DPA.
        UNALIGNED VIEWSTATE_POSITION *pDVItem = (UNALIGNED VIEWSTATE_POSITION *)(_pbPositionData);
        UNALIGNED VIEWSTATE_POSITION *pDVEnd = (UNALIGNED VIEWSTATE_POSITION *)(_pbPositionData + cbSizeofStream - sizeof(VIEWSTATE_POSITION));

        ClearPositionData();  // destroy _hdpaItemPos

        // Grow every 16 items
        _hdpaItemPos = DPA_Create(16);
        if (_hdpaItemPos)
        {
            for ( ; ; pDVItem = (UNALIGNED VIEWSTATE_POSITION *)_ILNext(&pDVItem->idl))
            {
                if (pDVItem > pDVEnd)
                {
                    break;  // Invalid list
                }

                // End normally when we reach a NULL IDList
                if (pDVItem->idl.mkid.cb == 0)
                {
                    break;
                }

                if (DPA_AppendPtr(_hdpaItemPos, pDVItem) < 0)
                {
                    break;
                }
            }
        }
    }
}

HRESULT CViewState::SavePositionBlob(CDefView* pdv, IStream* pstm)
{
    HRESULT hr = S_FALSE;   // success, but did nothing

    if (pdv->_fUserPositionedItems && pdv->_IsPositionedView())
    {
        VIEWSTATE_POSITION dvitem = {0};
        int iCount = ListView_GetItemCount(pdv->_hwndListview);
        for (int i = 0; SUCCEEDED(hr) && (i < iCount); i++)
        {
            ListView_GetItemPosition(pdv->_hwndListview, i, &dvitem.pt);

            hr = pstm->Write(&dvitem.pt, sizeof(dvitem.pt), NULL);
            if (SUCCEEDED(hr))
            {
                LPCITEMIDLIST pidl = pdv->_GetPIDL(i);
                if (pidl)
                    hr = pstm->Write(pidl, pidl->mkid.cb, NULL);
                else
                    hr = E_FAIL;
            }
        }

        if (SUCCEEDED(hr))
        {
            // Terminate the list with a NULL IDList
            dvitem.idl.mkid.cb = 0;
            hr = pstm->Write(&dvitem, sizeof(dvitem), NULL);
        }
    }
    return hr;
}

void CViewState::ClearPositionData()
{
    if (_hdpaItemPos)
    {
        DPA_Destroy(_hdpaItemPos);
        _hdpaItemPos = NULL;
    }
}

UINT CViewState::GetColumnCount()       
{ 
    if (!_hdsaColumns) 
        return 0; 

    return DSA_GetItemCount(_hdsaColumns);    
}

DWORD CViewState::GetColumnState(UINT uCol)
{
    if (_hdsaColumns && (uCol < GetColumnCount()))
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        return pci->csFlags;
    }

    return 0;
}

DWORD CViewState::GetTransientColumnState(UINT uCol)
{
    if (_hdsaColumns && (uCol < GetColumnCount()))
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        return pci->tsFlags;
    }

    return 0;
}

void CViewState::SetColumnState(UINT uCol, DWORD dwMask, DWORD dwNewBits)
{
    if (_hdsaColumns && uCol < GetColumnCount())
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        pci->csFlags = (pci->csFlags & ~dwMask) | (dwNewBits & dwMask);
    }
}

void CViewState::SetTransientColumnState(UINT uCol, DWORD dwMask, DWORD dwNewBits)
{
    if (_hdsaColumns && uCol < GetColumnCount())
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        pci->tsFlags = (pci->tsFlags & ~dwMask) | (dwNewBits & dwMask);
    }
}

LPTSTR CViewState::GetColumnName(UINT uCol)
{
    if (_hdsaColumns && (uCol < GetColumnCount()))
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        return pci->szName;
    }

    return NULL;
}

UINT CViewState::GetColumnCharCount(UINT uCol)
{
    if (_hdsaColumns && (uCol < GetColumnCount()))
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        return pci->cChars;
    }

    return 0;
}

int CViewState::GetColumnFormat(UINT uCol)
{
    if (_hdsaColumns && (uCol < GetColumnCount()))
    {
        COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, uCol);
        return pci->fmt;
    }

    return 0;
}


HRESULT CViewState::InitializeColumns(CDefView* pdv)
{
    if (_hdsaColumns != NULL)
        return S_OK;

    _hdsaColumns = DSA_Create(sizeof(COL_INFO), 6);

    if (!_hdsaColumns)
        return E_OUTOFMEMORY;

    for (UINT iReal = 0; ; iReal++)
    {
        DETAILSINFO di = {0};
        di.fmt  = LVCFMT_LEFT;
        di.cxChar = 20;
        di.str.uType = (UINT)-1;

        if (SUCCEEDED(pdv->_GetDetailsHelper(iReal, &di)))
        {
            COL_INFO ci = {0};

            StrRetToBuf(&di.str, NULL, ci.szName, ARRAYSIZE(ci.szName));
            ci.cChars = di.cxChar;
            ci.csFlags = pdv->_DefaultColumnState(iReal);
            ci.fmt = di.fmt;

            DSA_AppendItem(_hdsaColumns, &ci);
        }
        else
            break;
    }

    // Set up saved column state only if the saved state
    // contains information other than "nothing".

    if (_hdsaColumnStates)
    {
        UINT cStates = DSA_GetItemCount(_hdsaColumnStates);
        if (cStates > 0)
        {
            // 99/02/05 vtan: If there is a saved column state then
            // clear all the column "on" states to "off" and only
            // display what columns are specified. Start at 1 so
            // that name is always on.

            for (iReal = 1; iReal < GetColumnCount(); iReal++)
            {
                COL_INFO* pci = (COL_INFO*)DSA_GetItemPtr(_hdsaColumns, iReal);
                pci->csFlags &= ~SHCOLSTATE_ONBYDEFAULT;
            }

            for (UINT i = 0; i < cStates; i++)
            {
                DWORD dw;
                DSA_GetItem(_hdsaColumnStates, i, &dw);
                SetColumnState(dw, SHCOLSTATE_ONBYDEFAULT, SHCOLSTATE_ONBYDEFAULT);
            }
        }
    }

    return S_OK;
}

// When Loading or Saving from the View State Stream

HRESULT CViewState::LoadFromStream(CDefView* pdv, IStream* pstm)
{
    ULONG cbRead;
    DVSAVEHEADER_COMBO dv;
    ULARGE_INTEGER libStartPos;
    LARGE_INTEGER dlibMove  = {0};

    pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libStartPos);

    // See what format the persisted view is in:
    HRESULT hr = pstm->Read(&dv, sizeof(dv), &cbRead);

    if (SUCCEEDED(hr) &&
        sizeof(DVSAVEHEADER_COMBO) == cbRead &&
        dv.dvSaveHeader.cbSize == sizeof(WIN95HEADER) &&
        dv.dvSaveHeader.cbColOffset == 0 &&
        dv.dvSaveHeaderEx.dwSignature == IE4HEADER_SIGNATURE &&
        dv.dvSaveHeaderEx.cbSize >= sizeof(IE4HEADER))
    {
        InitFromHeader(&dv);

        if (dv.dvSaveHeaderEx.wVersion < IE4HEADER_VERSION)
        {
            // We used to store szExtended in here -- not any more
            dv.dvSaveHeaderEx.dwUnused = 0;
        }

        if (dv.dvSaveHeaderEx.cbColOffset >= sizeof(dv))
        {
            dlibMove.QuadPart = libStartPos.QuadPart + dv.dvSaveHeaderEx.cbColOffset;
            hr = pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
            if (SUCCEEDED(hr))
            {
                hr = LoadColumns(pdv, pstm);
            }
        }

        if (SUCCEEDED(hr))
        {
            dlibMove.QuadPart = libStartPos.QuadPart + dv.dvSaveHeader.cbPosOffset;
            hr = pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

            if (SUCCEEDED(hr))
            {
                LoadPositionBlob(pdv, dv.dvSaveHeaderEx.cbStreamSize, pstm);
            }
        }
    }

    return S_OK;
}

void SetSize(ULARGE_INTEGER libCurPosition, IStream* pstm)
{
    LARGE_INTEGER dlibMove;
    
    dlibMove.QuadPart = libCurPosition.QuadPart;
    pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
    pstm->SetSize(libCurPosition);
}

DWORD CViewState::_GetStreamSize(IStream* pstm)
{
    DWORD dwRet = 0;

    ULARGE_INTEGER uli;
    if (SUCCEEDED(IStream_Size(pstm, &uli)))
    {
        if (0 == uli.HighPart)
        {
            dwRet = uli.LowPart;
        }
    }

    return dwRet;
}

HRESULT CViewState::SaveToStream(CDefView* pdv, IStream* pstm)
{
    ULONG ulWrite;
    DVSAVEHEADER_COMBO dv = {0};
    LARGE_INTEGER dlibMove = {0};
    ULARGE_INTEGER libCurPosition;

    // Get the current info.
    Sync(pdv, FALSE);

    // Position the stream right after the headers, and save the starting
    // position at the same time
    dlibMove.QuadPart = sizeof(dv);
    pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libCurPosition);

    // Avoid 2 calls to seek by just subtracting
    libCurPosition.QuadPart -= sizeof(dv);

    // Save column order and size info
    HRESULT hr = SaveColumns(pdv, pstm);
    if (SUCCEEDED(hr))
    {
        dv.dvSaveHeader.cbSize = sizeof(dv.dvSaveHeader);

        // We save the view mode to determine if the scroll positions are
        // still valid on restore
        dv.dvSaveHeader.ViewMode = _ViewMode;
        dv.dvSaveHeader.ptScroll.x = _ptScroll.x;
        dv.dvSaveHeader.ptScroll.y = _ptScroll.y;
        dv.dvSaveHeader.dvState.lParamSort = (LONG)_lParamSort;
        dv.dvSaveHeader.dvState.iDirection = _iDirection;
        dv.dvSaveHeader.dvState.iLastColumnClick = _iLastColumnClick;

        // dvSaveHeaderEx.cbColOffset holds the true offset.
        // Win95 gets confused when cbColOffset points to the new
        // format. Zeroing this out tells Win95 to use default widths
        // (after uninstall of ie40).
        //
        // dv.dvSaveHeader.cbColOffset = 0;

        dv.dvSaveHeaderEx.dwSignature = IE4HEADER_SIGNATURE;
        dv.dvSaveHeaderEx.cbSize = sizeof(dv.dvSaveHeaderEx);
        dv.dvSaveHeaderEx.wVersion = IE4HEADER_VERSION;

        ULARGE_INTEGER libPosPosition;

        // Save the Position Information
        dlibMove.QuadPart = 0;
        pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libPosPosition);
        dv.dvSaveHeaderEx.cbColOffset = sizeof(dv);
        dv.dvSaveHeader.cbPosOffset = (USHORT)(libPosPosition.QuadPart - libCurPosition.QuadPart);

        // Save potision info, currently stream is positioned immediately after column info
        hr = SavePositionBlob(pdv, pstm);
        if (SUCCEEDED(hr))
        {
            ULARGE_INTEGER libEndPosition;
            // Win95 expects cbPosOffset to be at the end of the stream --
            // don't change it's value and never store anything after
            // the position information.

            // Calculate size of total information saved.
            // This is needed when we read the stream.
            dlibMove.QuadPart = 0;
            if (SUCCEEDED(pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libEndPosition)))
            {
                dv.dvSaveHeaderEx.cbStreamSize = (DWORD)(libEndPosition.QuadPart - libCurPosition.QuadPart);
            }

            // Now save the header information
            dlibMove.QuadPart = libCurPosition.QuadPart;
            pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
            hr = pstm->Write(&dv, sizeof(dv), &ulWrite);

            if (FAILED(hr) || ulWrite != sizeof(dv))
            {
                SetSize(libCurPosition, pstm);
                hr = S_OK;
            }

            // Make sure we save all information written so far
            libCurPosition.QuadPart += dv.dvSaveHeaderEx.cbStreamSize;
        }
    }

    return hr;
}

HRESULT CViewState::SaveToPropertyBag(CDefView* pdv, IPropertyBag* ppb)
{
    // Get the current info.
    Sync(pdv, FALSE);

    SHPropertyBag_WriteDWORD(ppb, VS_PROPSTR_MODE, _ViewMode);
    SHPropertyBag_WritePOINTSScreenRes(ppb, VS_PROPSTR_SCROLL, &_ptScroll);
    SHPropertyBag_WriteDWORD(ppb, VS_PROPSTR_SORT, static_cast<DWORD>(_lParamSort)); 
    SHPropertyBag_WriteInt(ppb, VS_PROPSTR_SORTDIR, _iDirection); 
    SHPropertyBag_WriteInt(ppb, VS_PROPSTR_COL, _iLastColumnClick);
    
    IStream* pstm = SHCreateMemStream(NULL, 0);
    if (pstm)
    {
        if (S_OK == SaveColumns(pdv, pstm))
        {
            SHPropertyBag_WriteStream(ppb, VS_PROPSTR_COLINFO, pstm);
        }
        else
        {
            SHPropertyBag_Delete(ppb, VS_PROPSTR_COLINFO);
        }
        pstm->Release();
    }

    pstm = SHCreateMemStream(NULL, 0);
    if (pstm)
    {
        if (S_OK == SavePositionBlob(pdv, pstm))
        {
            SHPropertyBag_WriteStreamScreenRes(ppb, VS_PROPSTR_ITEMPOS, pstm);
        }
        else
        {
            SHPropertyBag_DeleteScreenRes(ppb, VS_PROPSTR_ITEMPOS);
        }
        pstm->Release();
    }

    return S_OK;
}

HRESULT CViewState::LoadFromPropertyBag(CDefView* pdv, IPropertyBag* ppb)
{
    SHPropertyBag_ReadDWORDDef(ppb, VS_PROPSTR_MODE, &_ViewMode, FVM_ICON);
    SHPropertyBag_ReadDWORDDef(ppb, VS_PROPSTR_SORT, reinterpret_cast<DWORD*>(&_lParamSort), 0);
    SHPropertyBag_ReadIntDef(ppb, VS_PROPSTR_SORTDIR, &_iDirection, 1); 
    SHPropertyBag_ReadIntDef(ppb, VS_PROPSTR_COL, &_iLastColumnClick, -1); 

    if (FAILED(SHPropertyBag_ReadPOINTSScreenRes(ppb, VS_PROPSTR_SCROLL, &_ptScroll)))
    {
        _ptScroll.x = _ptScroll.y = 0;
    }

    IStream* pstm;
    if (SUCCEEDED(SHPropertyBag_ReadStream(ppb, VS_PROPSTR_COLINFO, &pstm)))
    {
        LoadColumns(pdv, pstm);
        pstm->Release();
    }

    if (SUCCEEDED(SHPropertyBag_ReadStreamScreenRes(ppb, VS_PROPSTR_ITEMPOS, &pstm)))
    {
        LoadPositionBlob(pdv, _GetStreamSize(pstm), pstm);
        pstm->Release();
    }

    return S_OK;
}

HDSA DSA_CreateFromStream(DWORD cbSize, int cItems, IStream* pstm)
{
    HDSA hdsa = DSA_Create(cbSize, cItems);
    if (hdsa)
    {
        BYTE* pb = (BYTE*)LocalAlloc(LPTR, cbSize);
        if (pb)
        {
            BOOL fFailedToRead = FALSE;
            ULONG cbRead;
            while (cItems--)
            {
                if (SUCCEEDED(pstm->Read(pb, cbSize, &cbRead) && cbRead == cbSize))
                {
                    DSA_AppendItem(hdsa, pb);
                }
                else
                {
                    fFailedToRead = TRUE;
                }
            }
            LocalFree(pb);

            if (fFailedToRead)
            {
                // The stream is probrably corrupt.
                DSA_Destroy(hdsa);
                hdsa = NULL;
            }
        }
    }

    return hdsa;
}

// When Loading from a View Callback provided stream.
HRESULT CViewState::LoadColumns(CDefView* pdv, IStream* pstm)
{
    // Read the extended View state header
    HRESULT hr;
    ULONG cbRead;
    VIEWSTATEHEADER vsh;
    ULARGE_INTEGER libStartPos;
    LARGE_INTEGER dlibMove  = {0};

    // Store off the current stream pointer. If we are called directly, this is probrably Zero,
    // However this method gets called from ::Load, so this it definitly not zero in that case.
    pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libStartPos);

    // The VSH struct has many "Substructs" indicating the version of ths struct we are reading.
    // There is probrably a more efficient mechanism of version discovery, but this is easiest to read and understand.
    hr = pstm->Read(&vsh.Version1, sizeof(vsh.Version1), &cbRead);
    
    if (SUCCEEDED(hr) &&
        sizeof(vsh.Version1) == cbRead &&                       // Fail if we didn't read enough
        VIEWSTATEHEADER_SIGNATURE == vsh.Version1.dwSignature)  // Fail if the signature is bogus
    {
        if (vsh.Version1.uVersion >= VIEWSTATEHEADER_VERSION_1)
        {
            if (vsh.Version1.uCols > 0)
            {
                // Load the Column Ordering
                dlibMove.QuadPart = libStartPos.QuadPart + vsh.Version1.uOffsetColOrder;
                pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                if (_hdsaColumnOrder)   
                    DSA_Destroy(_hdsaColumnOrder);
                _hdsaColumnOrder = DSA_CreateFromStream(sizeof(int), vsh.Version1.uCols, pstm);
                // Load the Column Widths
                dlibMove.QuadPart = libStartPos.QuadPart + vsh.Version1.uOffsetWidths;
                pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                if (_hdsaColumnWidths) 
                    DSA_Destroy(_hdsaColumnWidths);
                _hdsaColumnWidths = DSA_CreateFromStream(sizeof(USHORT), vsh.Version1.uCols, pstm);
            }


            if (vsh.Version1.uVersion >= VIEWSTATEHEADER_VERSION_2 &&
                vsh.Version1.uCols > 0)
            {
                DWORD dwRead;

                // Seek to read the rest of the header
                dlibMove.QuadPart = libStartPos.QuadPart + sizeof(vsh.Version1);
                pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                hr = pstm->Read(&vsh.Version2, sizeof(vsh.Version2), &cbRead);
                
                if (SUCCEEDED(hr) &&
                    sizeof(vsh.Version2) == cbRead &&
                    vsh.Version2.uOffsetColStates)
                {
                    // Load the Column States
                    dlibMove.QuadPart = libStartPos.QuadPart + vsh.Version2.uOffsetColStates;
                    pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                    // This one is funky: There is a terminating sentinal....
                    if (_hdsaColumnStates) 
                        DSA_Destroy(_hdsaColumnStates);

                    _hdsaColumnStates = DSA_Create(sizeof(DWORD), 5);
                    if (_hdsaColumnStates)
                    {
                        do
                        {
                            if (SUCCEEDED(pstm->Read(&dwRead, sizeof(DWORD), &cbRead)) && 
                                cbRead == sizeof(DWORD) &&
                                dwRead != 0xFFFFFFFF)
                            {
                                DSA_AppendItem(_hdsaColumnStates, &dwRead);
                            }
                            else
                            {
                                break;
                            }
                        }
                        while (dwRead != 0xFFFFFFFF);
                    }
                }
            }

            if (vsh.Version1.uVersion >= VIEWSTATEHEADER_VERSION_3)
            {
                // Seek to read the rest of the header
                dlibMove.QuadPart = libStartPos.QuadPart + sizeof(vsh.Version1) + sizeof(vsh.Version2);
                pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                hr = pstm->Read(&vsh.Version3, sizeof(vsh.Version3), &cbRead);
                if (SUCCEEDED(hr) &&
                    sizeof(vsh.Version3) == cbRead &&
                    vsh.Version3.uOffsetGroup)
                {
                    GROUP_PERSIST gp;
                    dlibMove.QuadPart = libStartPos.QuadPart + vsh.Version3.uOffsetGroup;
                    pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

                    hr = pstm->Read(&gp, sizeof(gp), &cbRead);
                    if (SUCCEEDED(hr) &&
                        sizeof(gp) == cbRead)
                    {
                        _guidGroupID = gp.guidGroupID;
                        _scidDetails = gp.scidDetails;
                    }
                }
                
                _fFirstViewed = FALSE;
            }

            /////////////////////////////////////////////////////////////////////////////////////
            //                    *****             NEW Data             *****
            // 1) Add a version to the VIEWSTATEHEADER
            // 2) Add a version to VIEWSTATEHEADER_VERSION_*
            // 3) Check that version here
            /////////////////////////////////////////////////////////////////////////////////////
        }
    }

    return hr;
}

HRESULT CViewState::SaveColumns(CDefView* pdv, IStream* pstm)
{
    HRESULT hr;
    USHORT uOffset;
    VIEWSTATEHEADER vsh = {0};
    ULARGE_INTEGER libStartPos = {0};
    LARGE_INTEGER dlibMove  = {0};

    // No point in persisting, if there aren't any columns around.
    // this is true for folders that are just opened and closed
    if (!pdv->_psd && !pdv->_pshf2 && !pdv->HasCB())
    {
        return S_FALSE;
    }

    // First, we persist a known bad quantity, just in case we wax the stream
    pstm->Seek(g_li0, STREAM_SEEK_CUR, &libStartPos);
    hr = pstm->Write(&vsh, sizeof(vsh), NULL);

    if (SUCCEEDED(hr))
    {
        vsh.Version1.dwSignature = VIEWSTATEHEADER_SIGNATURE;
        vsh.Version1.uVersion = VIEWSTATEHEADER_VERSION_CURRENT;
        vsh.Version1.uCols = _hdsaColumnOrder? (UINT) DSA_GetItemCount(_hdsaColumnOrder) : 0;

        uOffset = sizeof(VIEWSTATEHEADER);

        // No point in persisting if we don't have any columns
        if (vsh.Version1.uCols)
        {

            // Note- dependent on DSA storing data internally as byte-packed.
            if (_hdsaColumnOrder)
            {
                vsh.Version1.uOffsetColOrder = uOffset;
                uOffset += (USHORT)(sizeof(UINT) * DSA_GetItemCount(_hdsaColumnOrder));
                hr = pstm->Write(DSA_GetItemPtr(_hdsaColumnOrder, 0),  sizeof(UINT)   * DSA_GetItemCount(_hdsaColumnOrder), NULL);
            }

            if (_hdsaColumnWidths && SUCCEEDED(hr))
            {
                vsh.Version1.uOffsetWidths = uOffset;
                uOffset += (USHORT)(sizeof(USHORT) * DSA_GetItemCount(_hdsaColumnWidths));
                hr = pstm->Write(DSA_GetItemPtr(_hdsaColumnWidths, 0), sizeof(USHORT) * DSA_GetItemCount(_hdsaColumnWidths), NULL);
            }

            if (_hdsaColumnStates && SUCCEEDED(hr))
            {
                vsh.Version2.uOffsetColStates = uOffset; 
                uOffset += (USHORT)(sizeof(DWORD) *  DSA_GetItemCount(_hdsaColumnStates));
                pstm->Write(DSA_GetItemPtr(_hdsaColumnStates, 0), sizeof(DWORD)  * DSA_GetItemCount(_hdsaColumnStates), NULL);
            }
        }

        if (SUCCEEDED(hr))
        {
            GROUP_PERSIST gp = {0};
            vsh.Version3.uOffsetGroup = uOffset;
            uOffset += sizeof(GROUP_PERSIST);

            if (pdv->_fGroupView)
            {
                gp.guidGroupID = _guidGroupID;
                gp.scidDetails = _scidDetails;
            }

            hr = pstm->Write(&gp, sizeof(gp), NULL);
        }
    
        /////////////////////////////////////////////////////////////////////////////////////
        //                    *****             NEW Data             *****
        // 1) Add a version to the VIEWSTATEHEADER
        // 2) Add a version to VIEWSTATEHEADER_VERSION_*
        // 3) Add a "Loader" for your value
        // 4) Set the offset to uOffset.
        // 5) Write your data.
        // 6) Update the running total of dwOffset.
        /////////////////////////////////////////////////////////////////////////////////////

        dlibMove.QuadPart = libStartPos.QuadPart;

        // Store off the current position
        pstm->Seek(g_li0, STREAM_SEEK_CUR, &libStartPos);

        // Move to the beginning
        pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

        // Write out the correct header
        hr = pstm->Write(&vsh, sizeof(vsh), NULL);
        if (SUCCEEDED(hr))
        {
            // Reset the current pos
            dlibMove.QuadPart = libStartPos.QuadPart;
            pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL); 
        }
    }

    return hr;
}

BOOL CViewState::AppendColumn(UINT uCol, USHORT uWidth, INT uOrder)
{
    if (_hdsaColumnOrder == NULL || 
        _hdsaColumnWidths == NULL)
    {
        return FALSE;
    }

    // Slide every index above this one up
    for (INT u = 0; u < DSA_GetItemCount(_hdsaColumnOrder); u++)
    {
        UINT *p = (UINT *) DSA_GetItemPtr(_hdsaColumnOrder, u);
        if (!p)
            break; // safety...
        if (*p >= uCol)
            (*p)++;
    }

    DSA_AppendItem(_hdsaColumnWidths, &uWidth);
    DSA_AppendItem(_hdsaColumnOrder, &uOrder);
    // maybe we should store column ordering as absolute numbers
    return TRUE;
}

BOOL CViewState::RemoveColumn(UINT uCol)
{
    if (_hdsaColumnWidths == NULL || 
        _hdsaColumnWidths == NULL)
    {
        return FALSE;
    }

    if ((int)uCol >= DSA_GetItemCount(_hdsaColumnWidths))
        return FALSE;
    // Slide every index above this one down
    for (INT u = 0; u < DSA_GetItemCount(_hdsaColumnOrder); u++)
    {
        UINT *p = (UINT *) DSA_GetItemPtr(_hdsaColumnOrder, u);
        if (!p)
            break; // safety...
        if (*p > uCol)
            (*p)--;
    }

    DSA_DeleteItem(_hdsaColumnWidths, uCol);
    DSA_DeleteItem(_hdsaColumnOrder, uCol);
    return TRUE;
}

UINT CViewState::GetColumnWidth(UINT uCol, UINT uDefWid)
{
    if (!_hdsaColumnWidths)
        return uDefWid;

    USHORT uWidth = 0;
    if (uCol < (UINT) DSA_GetItemCount(_hdsaColumnWidths))
    {
        DSA_GetItem(_hdsaColumnWidths, uCol, &uWidth);
    }
    return uWidth ? uWidth : uDefWid;        // disallow zero width columns
}

BOOL CViewState::SyncColumnOrder(CDefView* pdv, BOOL fSetListViewState)
{
    UINT cCols = pdv->_GetHeaderCount();
    if (fSetListViewState)
    {
        if (!_hdsaColumnOrder)
            return FALSE;

        if (cCols != (UINT) DSA_GetItemCount(_hdsaColumnOrder))
        {
            // this is a normal case if a folder is opened and there is no saved state. no need to spew.
            return TRUE;
        }

        UINT *pCols = (UINT *)LocalAlloc(LPTR, cCols * sizeof(*pCols));
        if (pCols)
        {
            for (UINT u = 0; u < cCols; u++)
            {
                DSA_GetItem(_hdsaColumnOrder, u, pCols + u);
            }

            ListView_SetColumnOrderArray(pdv->_hwndListview, cCols, pCols);
            LocalFree(pCols);
        }
    }
    else
    {
        BOOL bDefaultOrder = TRUE;
        if (cCols)
        {
            if (!_hdsaColumnOrder)
                _hdsaColumnOrder = DSA_Create(sizeof(UINT), 6);

            if (_hdsaColumnOrder)
            {
                UINT *pCols = (UINT *)LocalAlloc(LPTR, cCols * sizeof(*pCols));
                if (pCols)
                {
                    ListView_GetColumnOrderArray(pdv->_hwndListview, cCols, pCols);

                    DSA_DeleteAllItems(_hdsaColumnOrder);
                    for (UINT u = 0; u < cCols; u++)
                    {
                        DSA_AppendItem(_hdsaColumnOrder, &pCols[u]);
                        if (pCols[u] != u)
                        {
                            bDefaultOrder = FALSE;
                        }
                    }

                    LocalFree(pCols);
                }
            }
        }
        return bDefaultOrder;
    }

    return TRUE;
}

BOOL CViewState::SyncColumnWidths(CDefView* pdv, BOOL fSetListViewState)
{
    UINT cCols = pdv->_GetHeaderCount();
    if (fSetListViewState)
    {
        return FALSE;
    }
    else
    {
        USHORT us;
        LV_COLUMN lvc;
        BOOL bOk = TRUE;
    
        if (!cCols)
            return TRUE;

        HDSA dsaNewWidths = DSA_Create(sizeof(USHORT), cCols);
        if (!dsaNewWidths)
            return TRUE;

        for (UINT u = 0; u < cCols && bOk; ++u)
        {
            lvc.mask = LVCF_WIDTH;
            bOk = ListView_GetColumn(pdv->_hwndListview, u, &lvc);
            us = (USHORT) lvc.cx;    // make sure its a short
            DSA_AppendItem(dsaNewWidths, &us);
            // TraceMsg(TF_DEFVIEW, "  saving col %d width of %d", u, us);
        }

        if (bOk)
        {
            if (_hdsaColumnWidths)
                DSA_Destroy(_hdsaColumnWidths);
            _hdsaColumnWidths = dsaNewWidths;
        }
        else
            DSA_Destroy(dsaNewWidths);
        return !bOk;
    }
}

BOOL CViewState::SyncColumnStates(CDefView* pdv, BOOL fSetListViewstate)
{
    if (fSetListViewstate)
    {
        return FALSE;
    }
    else
    {
        // Save off Column States
        if (_hdsaColumnStates)
        {
            DSA_Destroy(_hdsaColumnStates);
            _hdsaColumnStates = NULL;
        }

        UINT cCol = GetColumnCount();

        if (cCol)
        {
            DWORD i;
            _hdsaColumnStates = DSA_Create(sizeof(DWORD), 5);
            if (_hdsaColumnStates)
            {
                for (i = 0; i < cCol; i++)
                {
                    if (pdv->_IsDetailsColumn(i))
                        DSA_AppendItem(_hdsaColumnStates, &i);
                }
                i = 0xFFFFFFFF;     // Terminating Sentinal
                DSA_AppendItem(_hdsaColumnStates,&i);
            }
        }
    }

    return TRUE;
}

// Syncronizes ListView with the current View State. 
// TRUE means take the view state object and set it into the listview.
HRESULT CViewState::Sync(CDefView* pdv, BOOL fSetListViewState)
{
    SyncColumnWidths(pdv, fSetListViewState);
    SyncColumnOrder(pdv, fSetListViewState);
    SyncColumnStates(pdv, fSetListViewState);

    if (fSetListViewState)
    {
        // Only do this the first time.
        if (pdv->_pcat == NULL)
        {
            if (_fFirstViewed)
            {
                // See if the desktop.ini specifies one
                pdv->_LoadCategory(&_guidGroupID);

                if (IsEqualGUID(_guidGroupID, GUID_NULL))
                {
                    ICategoryProvider* pcp;
                    if (SUCCEEDED(pdv->_pshf->CreateViewObject(NULL, IID_PPV_ARG(ICategoryProvider, &pcp))))
                    {
                        pcp->GetDefaultCategory(&_guidGroupID, &_scidDetails);
                        pcp->Release();
                    }
                }
            }

            if (!IsEqualGUID(_guidGroupID, GUID_NULL) || !IsEqualGUID(_scidDetails.fmtid, GUID_NULL))
                pdv->_CategorizeOnGUID(&_guidGroupID, &_scidDetails);
        }

        // this is only needed to sort the items who's positions are not known
        // it would be nice to optimize this case and only sort then
        pdv->_Sort();

        SyncPositions(pdv);
    }
    else
    {
        // Take what Listview has, and save it to me.

        _ViewMode = pdv->_fs.ViewMode;
        _ptScroll.x = (SHORT) GetScrollPos(pdv->_hwndListview, SB_HORZ);
        _ptScroll.y = (SHORT) GetScrollPos(pdv->_hwndListview, SB_VERT);
    }
    return S_OK;
}