travellog.cpp

Go to the documentation of this file.

/*
 * ReactOS Explorer
 *
 * Copyright 2009 Andrew Hill <ash77 at domain reactos.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
Implements a class that keeps track of a PIDL history and allows
navigation forward and backward. This really should be in shdocvw, but it
is not registered for external instantiation, and the entire IBrowserService
hierarchy that normally spans browseui and shdocvw are collapsed into one
hierarchy in browseui, so I am moving it to browseui for now. If someone
decides to refactor code later, it wouldn't be difficult to move it.

TODO:
****Does original travel log update the current item in the Travel method before or after calling ITravelEntry::Invoke?
****Change to load maximum size from registry
****Add code to track current size
****Fix InsertMenuEntries to not exceed limit of menu item ids provided. Perhaps the method should try to be intelligent and if there are
        too many items, center around the current item? Could cause dispatch problems...
****Move tool tip text templates to resources
  **Simplify code in InsertMenuEntries
    Implement UpdateExternal
    Implement FindTravelEntry
    Implement Clone
    Implement Revert

*/
#include "precomp.h"

class CTravelEntry :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public ITravelEntry
{
public:
    CTravelEntry                            *fNextEntry;
    CTravelEntry                            *fPreviousEntry;
private:
    LPITEMIDLIST                            fPIDL;
    HGLOBAL                                 fPersistState;
public:
    CTravelEntry();
    ~CTravelEntry();
    HRESULT GetToolTipText(IUnknown *punk, LPWSTR pwzText) const;
    long GetSize() const;

    // *** ITravelEntry methods ***
    virtual HRESULT STDMETHODCALLTYPE Invoke(IUnknown *punk);
    virtual HRESULT STDMETHODCALLTYPE Update(IUnknown *punk, BOOL fIsLocalAnchor);
    virtual HRESULT STDMETHODCALLTYPE GetPidl(LPITEMIDLIST *ppidl);

BEGIN_COM_MAP(CTravelEntry)
    COM_INTERFACE_ENTRY_IID(IID_ITravelEntry, ITravelEntry)
END_COM_MAP()
};

class CTravelLog :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public ITravelLog
{
private:
    CTravelEntry                            *fListHead;
    CTravelEntry                            *fListTail;
    CTravelEntry                            *fCurrentEntry;
    long                                    fMaximumSize;
    long                                    fCurrentSize;
    unsigned long                           fEntryCount;
public:
    CTravelLog();
    ~CTravelLog();
    HRESULT Initialize();
    HRESULT FindRelativeEntry(int offset, CTravelEntry **foundEntry);
    void DeleteChain(CTravelEntry *startHere);
    void AppendEntry(CTravelEntry *afterEntry, CTravelEntry *newEntry);
public:

    // *** ITravelLog methods ***
    virtual HRESULT STDMETHODCALLTYPE AddEntry(IUnknown *punk, BOOL fIsLocalAnchor);
    virtual HRESULT STDMETHODCALLTYPE UpdateEntry(IUnknown *punk, BOOL fIsLocalAnchor);
    virtual HRESULT STDMETHODCALLTYPE UpdateExternal(IUnknown *punk, IUnknown *punkHLBrowseContext);
    virtual HRESULT STDMETHODCALLTYPE Travel(IUnknown *punk, int iOffset);
    virtual HRESULT STDMETHODCALLTYPE GetTravelEntry(IUnknown *punk, int iOffset, ITravelEntry **ppte);
    virtual HRESULT STDMETHODCALLTYPE FindTravelEntry(IUnknown *punk, LPCITEMIDLIST pidl, ITravelEntry **ppte);
    virtual HRESULT STDMETHODCALLTYPE GetToolTipText(IUnknown *punk, int iOffset, int idsTemplate, LPWSTR pwzText, DWORD cchText);
    virtual HRESULT STDMETHODCALLTYPE InsertMenuEntries(IUnknown *punk, HMENU hmenu, int nPos, int idFirst, int idLast, DWORD dwFlags);
    virtual HRESULT STDMETHODCALLTYPE Clone(ITravelLog **pptl);
    virtual DWORD STDMETHODCALLTYPE CountEntries(IUnknown *punk);
    virtual HRESULT STDMETHODCALLTYPE Revert();

BEGIN_COM_MAP(CTravelLog)
    COM_INTERFACE_ENTRY_IID(IID_ITravelLog, ITravelLog)
END_COM_MAP()
};

CTravelEntry::CTravelEntry()
{
    fNextEntry = NULL;
    fPreviousEntry = NULL;
    fPIDL = NULL;
    fPersistState = NULL;
}

CTravelEntry::~CTravelEntry()
{
    ILFree(fPIDL);
    GlobalFree(fPersistState);
}

HRESULT CTravelEntry::GetToolTipText(IUnknown *punk, LPWSTR pwzText) const
{
    HRESULT                                 hResult;

    hResult = ILGetDisplayNameEx(NULL, fPIDL, pwzText, ILGDN_NORMAL);
    if (FAILED(hResult))
        return hResult;
    return S_OK;
}

long CTravelEntry::GetSize() const
{
    return 0;
}

HRESULT STDMETHODCALLTYPE CTravelEntry::Invoke(IUnknown *punk)
{
    CComPtr<IPersistHistory>                persistHistory;
    CComPtr<IStream>                        globalStream;
    HRESULT                                 hResult;

    hResult = punk->QueryInterface(IID_IPersistHistory, (void **)&persistHistory);
    if (FAILED(hResult))
        return hResult;
    hResult = CreateStreamOnHGlobal(fPersistState, FALSE, &globalStream);
    if (FAILED(hResult))
        return hResult;
    hResult = persistHistory->LoadHistory(globalStream, NULL);
    if (FAILED(hResult))
        return hResult;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTravelEntry::Update(IUnknown *punk, BOOL fIsLocalAnchor)
{
    CComPtr<ITravelLogClient>               travelLogClient;
    CComPtr<IPersistHistory>                persistHistory;
    CComPtr<IStream>                        globalStream;
    WINDOWDATA                              windowData;
    HGLOBAL                                 globalStorage;
    HRESULT                                 hResult;

    ILFree(fPIDL);
    fPIDL = NULL;
    GlobalFree(fPersistState);
    fPersistState = NULL;
    hResult = punk->QueryInterface(IID_ITravelLogClient, (void **)&travelLogClient);
    if (FAILED(hResult))
        return hResult;
    hResult = travelLogClient->GetWindowData(&windowData);
    if (FAILED(hResult))
        return hResult;
    fPIDL = windowData.pidl;
    // TODO: Properly free the windowData
    hResult = punk->QueryInterface(IID_IPersistHistory, (void **)&persistHistory);
    if (FAILED(hResult))
        return hResult;
    globalStorage = GlobalAlloc(GMEM_FIXED, 0);
    hResult = CreateStreamOnHGlobal(globalStorage, FALSE, &globalStream);
    if (FAILED(hResult))
        return hResult;
    hResult = persistHistory->SaveHistory(globalStream);
    if (FAILED(hResult))
        return hResult;
    hResult = GetHGlobalFromStream(globalStream, &fPersistState);
    if (FAILED(hResult))
        return hResult;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTravelEntry::GetPidl(LPITEMIDLIST *ppidl)
{
    if (ppidl == NULL)
        return E_POINTER;
    *ppidl = ILClone(fPIDL);
    if (*ppidl == NULL)
        return E_OUTOFMEMORY;
    return S_OK;
}

CTravelLog::CTravelLog()
{
    fListHead = NULL;
    fListTail = NULL;
    fCurrentEntry = NULL;
    fMaximumSize = 0;
    fCurrentSize = 0;
    fEntryCount = 0;
}

CTravelLog::~CTravelLog()
{
    CTravelEntry                            *anEntry;
    CTravelEntry                            *next;

    anEntry = fListHead;
    while (anEntry != NULL)
    {
        next = anEntry->fNextEntry;
        anEntry->Release();
        anEntry = next;
    }
}

HRESULT CTravelLog::Initialize()
{
    fMaximumSize = 1024 * 1024;         // TODO: change to read this from registry
    // Software\Microsoft\Windows\CurrentVersion\Explorer\TravelLog
    // MaxSize
    return S_OK;
}

HRESULT CTravelLog::FindRelativeEntry(int offset, CTravelEntry **foundEntry)
{
    CTravelEntry                            *curEntry;

    *foundEntry = NULL;
    curEntry = fCurrentEntry;
    if (offset < 0)
    {
        while (offset < 0 && curEntry != NULL)
        {
            curEntry = curEntry->fPreviousEntry;
            offset++;
        }
    }
    else
    {
        while (offset > 0 && curEntry != NULL)
        {
            curEntry = curEntry->fNextEntry;
            offset--;
        }
    }
    if (curEntry == NULL)
        return E_INVALIDARG;
    *foundEntry = curEntry;
    return S_OK;
}

void CTravelLog::DeleteChain(CTravelEntry *startHere)
{
    CTravelEntry                            *saveNext;
    long                                    itemSize;

    if (startHere->fPreviousEntry != NULL)
    {
        startHere->fPreviousEntry->fNextEntry = NULL;
        fListTail = startHere->fPreviousEntry;
    }
    else
    {
        fListHead = NULL;
        fListTail = NULL;
    }
    while (startHere != NULL)
    {
        saveNext = startHere->fNextEntry;
        itemSize = startHere->GetSize();
        fCurrentSize -= itemSize;
        startHere->Release();
        startHere = saveNext;
        fEntryCount--;
    }
}

void CTravelLog::AppendEntry(CTravelEntry *afterEntry, CTravelEntry *newEntry)
{
    if (afterEntry == NULL)
    {
        fListHead = newEntry;
        fListTail = newEntry;
    }
    else
    {
        newEntry->fNextEntry = afterEntry->fNextEntry;
        afterEntry->fNextEntry = newEntry;
        newEntry->fPreviousEntry = afterEntry;
        if (newEntry->fNextEntry == NULL)
            fListTail = newEntry;
        else
            newEntry->fNextEntry->fPreviousEntry = newEntry;
    }
    fEntryCount++;
}

HRESULT STDMETHODCALLTYPE CTravelLog::AddEntry(IUnknown *punk, BOOL fIsLocalAnchor)
{
    CComObject<CTravelEntry>                *newEntry;
    long                                    itemSize;

    if (punk == NULL)
        return E_INVALIDARG;
    ATLTRY (newEntry = new CComObject<CTravelEntry>);
    if (newEntry == NULL)
        return E_OUTOFMEMORY;
    newEntry->AddRef();
    if (fCurrentEntry != NULL && fCurrentEntry->fNextEntry != NULL)
        DeleteChain(fCurrentEntry->fNextEntry);
    AppendEntry(fCurrentEntry, newEntry);
    itemSize = newEntry->GetSize();
    fCurrentSize += itemSize;
    fCurrentEntry = newEntry;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTravelLog::UpdateEntry(IUnknown *punk, BOOL fIsLocalAnchor)
{
    if (punk == NULL)
        return E_INVALIDARG;
    if (fCurrentEntry == NULL)
        return E_UNEXPECTED;
    return fCurrentEntry->Update(punk, fIsLocalAnchor);
}

HRESULT STDMETHODCALLTYPE CTravelLog::UpdateExternal(IUnknown *punk, IUnknown *punkHLBrowseContext)
{
    return E_NOTIMPL;
}

HRESULT STDMETHODCALLTYPE CTravelLog::Travel(IUnknown *punk, int iOffset)
{
    CTravelEntry                            *destinationEntry;
    HRESULT                                 hResult;
    
    hResult = FindRelativeEntry(iOffset, &destinationEntry);
    if (FAILED(hResult))
        return hResult;
    fCurrentEntry = destinationEntry;
    hResult = destinationEntry->Invoke(punk);
    if (FAILED(hResult))
        return hResult;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTravelLog::GetTravelEntry(IUnknown *punk, int iOffset, ITravelEntry **ppte)
{
    CTravelEntry                            *destinationEntry;
    HRESULT                                 hResult;
    
    hResult = FindRelativeEntry(iOffset, &destinationEntry);
    if (FAILED(hResult))
        return hResult;
    return destinationEntry->QueryInterface(IID_ITravelEntry, (void **)ppte);
}

HRESULT STDMETHODCALLTYPE CTravelLog::FindTravelEntry(IUnknown *punk, LPCITEMIDLIST pidl, ITravelEntry **ppte)
{
    if (ppte == NULL)
        return E_POINTER;
    if (punk == NULL || pidl == NULL)
        return E_INVALIDARG;
    return E_NOTIMPL;
}

HRESULT STDMETHODCALLTYPE CTravelLog::GetToolTipText(IUnknown *punk, int iOffset, int idsTemplate, LPWSTR pwzText, DWORD cchText)
{
    CTravelEntry                            *destinationEntry;
    wchar_t                                 tempString[MAX_PATH];
    wchar_t                                 templateString[200];
    HRESULT                                 hResult;
    
    if (pwzText == NULL)
        return E_POINTER;
    if (punk == NULL || cchText == 0)
        return E_INVALIDARG;
    hResult = FindRelativeEntry(iOffset, &destinationEntry);
    if (FAILED(hResult))
        return hResult;
    hResult = destinationEntry->GetToolTipText(punk, tempString);
    if (FAILED(hResult))
        return hResult;
    if (iOffset < 0)
    {
        wcscpy(templateString, L"Back to %s");
    }
    else
    {
        wcscpy(templateString, L"Forward to %s");
    }
    _snwprintf(pwzText, cchText, templateString, tempString);
    return S_OK;
}

static void FixAmpersands(wchar_t *buffer)
{
    wchar_t                                 tempBuffer[MAX_PATH * 2];
    wchar_t                                 ch;
    wchar_t                                 *srcPtr;
    wchar_t                                 *dstPtr;

    srcPtr = buffer;
    dstPtr = tempBuffer;
    while (*srcPtr != 0)
    {
        ch = *srcPtr++;
        *dstPtr++ = ch;
        if (ch == '&')
            *dstPtr++ = '&';
    }
    *dstPtr = 0;
    wcscpy(buffer, tempBuffer);
}

HRESULT STDMETHODCALLTYPE CTravelLog::InsertMenuEntries(IUnknown *punk, HMENU hmenu, int nPos, int idFirst, int idLast, DWORD dwFlags)
{
    CTravelEntry                            *currentItem;
    MENUITEMINFO                            menuItemInfo;
    wchar_t                                 itemTextBuffer[MAX_PATH * 2];
    HRESULT                                 hResult;

    // TLMENUF_BACK - include back entries
    // TLMENUF_INCLUDECURRENT - include current entry, if TLMENUF_CHECKCURRENT then check the entry
    // TLMENUF_FORE - include next entries
    // if fore+back, list from oldest to newest
    // if back, list from newest to oldest
    // if fore, list from newest to oldest

    // don't forget to patch ampersands before adding to menu
    if (punk == NULL)
        return E_INVALIDARG;
    if (idLast <= idFirst)
        return E_INVALIDARG;
    menuItemInfo.cbSize = sizeof(menuItemInfo);
    menuItemInfo.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STATE | MIIM_STRING;
    menuItemInfo.fType = MFT_STRING;
    menuItemInfo.wID = idFirst;
    menuItemInfo.fState = MFS_ENABLED;
    menuItemInfo.dwTypeData = itemTextBuffer;
    if ((dwFlags & TLMENUF_BACK) != 0)
    {
        if ((dwFlags & TLMENUF_FORE) != 0)
        {
            currentItem = fCurrentEntry;
            if (currentItem != NULL)
            {
                while (currentItem->fPreviousEntry != NULL)
                    currentItem = currentItem->fPreviousEntry;
            }
            while (currentItem != fCurrentEntry)
            {
                hResult = currentItem->GetToolTipText(punk, itemTextBuffer);
                if (SUCCEEDED(hResult))
                {
                    FixAmpersands(itemTextBuffer);
                    if (InsertMenuItem(hmenu, nPos, TRUE, &menuItemInfo))
                    {
                        nPos++;
                        menuItemInfo.wID++;
                    }
                }
                currentItem = currentItem->fNextEntry;
            }
        }
        else
        {
            currentItem = fCurrentEntry;
            if (currentItem != NULL)
                currentItem = currentItem->fPreviousEntry;
            while (currentItem != NULL)
            {
                hResult = currentItem->GetToolTipText(punk, itemTextBuffer);
                if (SUCCEEDED(hResult))
                {
                    FixAmpersands(itemTextBuffer);
                    if (InsertMenuItem(hmenu, nPos, TRUE, &menuItemInfo))
                    {
                        nPos++;
                        menuItemInfo.wID++;
                    }
                }
                currentItem = currentItem->fPreviousEntry;
            }
        }
    }
    if ((dwFlags & TLMENUF_INCLUDECURRENT) != 0)
    {
        if (fCurrentEntry != NULL)
        {
            hResult = fCurrentEntry->GetToolTipText(punk, itemTextBuffer);
            if (SUCCEEDED(hResult))
            {
                FixAmpersands(itemTextBuffer);
                if ((dwFlags & TLMENUF_CHECKCURRENT) != 0)
                    menuItemInfo.fState |= MFS_CHECKED;
                if (InsertMenuItem(hmenu, nPos, TRUE, &menuItemInfo))
                {
                    nPos++;
                    menuItemInfo.wID++;
                }
                menuItemInfo.fState &= ~MFS_CHECKED;
            }
        }
    }
    if ((dwFlags & TLMENUF_FORE) != 0)
    {
        currentItem = fCurrentEntry;
        if (currentItem != NULL)
            currentItem = currentItem->fNextEntry;
        while (currentItem != NULL)
        {
            hResult = currentItem->GetToolTipText(punk, itemTextBuffer);
            if (SUCCEEDED(hResult))
            {
                FixAmpersands(itemTextBuffer);
                if (InsertMenuItem(hmenu, nPos, TRUE, &menuItemInfo))
                {
                    nPos++;
                    menuItemInfo.wID++;
                }
            }
            currentItem = currentItem->fNextEntry;
        }
    }
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTravelLog::Clone(ITravelLog **pptl)
{
    if (pptl == NULL)
        return E_POINTER;
    *pptl = NULL;
    // duplicate the log
    return E_NOTIMPL;
}

DWORD STDMETHODCALLTYPE CTravelLog::CountEntries(IUnknown *punk)
{
    if (punk == NULL)
        return E_INVALIDARG;
    return fEntryCount;
}

HRESULT STDMETHODCALLTYPE CTravelLog::Revert()
{
    // remove the current entry?
    return E_NOTIMPL;
}

HRESULT CreateTravelLog(REFIID riid, void **ppv)
{
    CComObject<CTravelLog>                  *theTravelLog;
    HRESULT                                 hResult;

    if (ppv == NULL)
        return E_POINTER;
    *ppv = NULL;
    ATLTRY (theTravelLog = new CComObject<CTravelLog>);
    if (theTravelLog == NULL)
        return E_OUTOFMEMORY;
    hResult = theTravelLog->QueryInterface (riid, (void **)ppv);
    if (FAILED (hResult))
    {
        delete theTravelLog;
        return hResult;
    }
    hResult = theTravelLog->Initialize();
    if (FAILED(hResult))
        return hResult;
    return S_OK;
}