// Copyright (c) Microsoft Corporation 1991-1996

// File:      recdocs.cpp

// History -  created from recent.c in explorer  - ZekeL - 5-MAR-98
//              combining functionality in to one place
//              now that the desktop lives here.


#include "shellprv.h"
#include "shobjprv.h"
#include "recdocs.h"
#include "fstreex.h"
#include "shcombox.h"
#include "ids.h"
#include <urlhist.h>
#include <runtask.h>

#define DM_RECENTDOCS 0x80000000

#define GETRECNAME(p) ((LPCTSTR)(p))
#define GETRECPIDL(p) ((LPCITEMIDLIST) (((LPBYTE) (p)) + CbFromCch(lstrlen(GETRECNAME(p)) +1)))

#define REGSTR_KEY_RECENTDOCS TEXT("RecentDocs")

#define MAX_RECMRU_BUF      (CbFromCch(3 * MAX_PATH))   // Max MRUBuf size


STDAPI RecentDocs_Install(BOOL bInstall)
{
    TCHAR szPath[MAX_PATH];

    // get the path to the favorites folder. Create it if it is missing and we
    // are installing, otherwise don't bother.

    if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_RECENT, bInstall)) {
        if (bInstall) {
            SHFOLDERCUSTOMSETTINGS fcs = {sizeof(fcs), FCSM_INFOTIP | FCSM_ICONFILE, 0};
            TCHAR szInfoTip[128];
            TCHAR szIconFile[MAX_PATH];

            //Get the infotip for the recent files Folder
            LoadString(HINST_THISDLL, IDS_RECENT, szInfoTip, ARRAYSIZE(szInfoTip));
            fcs.pszInfoTip = szInfoTip;

            // Get the IconFile and IconIndex for the Recent Files Folder
            GetSystemDirectory(szIconFile, ARRAYSIZE(szIconFile));
            PathAppend(szIconFile, TEXT("shdocvw.dll"));
            fcs.pszIconFile = szIconFile;
            fcs.iIconIndex = -20785;    // IDI_HISTFOLDER

            SHGetSetFolderCustomSettings(&fcs, szPath, FCS_WRITE);
        }
    }
    return NOERROR;
}

class CTaskAddDoc : public CRunnableTask
{
public:
    CTaskAddDoc();
    HRESULT Init(HANDLE hMem, DWORD dwProcId);

    // *** pure virtuals ***
    virtual STDMETHODIMP RunInitRT(void);

private:
    virtual ~CTaskAddDoc();

    void _AddToRecentDocs(LPCITEMIDLIST pidlItem, LPCTSTR pszPath);
    void _TryDeleteMRUItem(HANDLE hmru, DWORD cMax, LPCTSTR pszFileName, LPCITEMIDLIST pidlItem, HANDLE hmruOther, BOOL fOverwrite);
    LPBYTE _CreateMRUItem(LPCITEMIDLIST pidlItem, LPCTSTR pszItem, DWORD* pcbItem, UINT uFlags);
    BOOL _AddDocToRecentAndExtRecent(LPCITEMIDLIST pidlItem, LPCTSTR pszFileName, LPCTSTR pszExt);
    void _TryUpdateNetHood(LPCITEMIDLIST pidlFolder, LPCTSTR pszFolder);
    void _UpdateNetHood(LPCITEMIDLIST pidlFolder, LPCTSTR pszShare);

    //  private members
    HANDLE _hMem;
    DWORD  _dwProcId;
    HANDLE _hmruRecent;
    DWORD _cMaxRecent;
    LPITEMIDLIST _pidlTarget;
};



BOOL ShouldAddToRecentDocs(LPCITEMIDLIST pidl)
{
    HKEY hk;
    BOOL fRet = TRUE;  //  default to true

    SHGetClassKey(pidl, &hk, NULL);

    if (hk) {
        fRet = !(GetFileTypeAttributes(hk) & FTA_NoRecentDocs);
        SHCloseClassKey(hk);
    }
    return fRet;
}

int cdecl RecentDocsCompareName(const void* p1, const void* p2, size_t cb)
{
    return lstrcmpi(GETRECNAME(p2), (LPCTSTR)p1);
}

int cdecl RecentDocsComparePidl(const void* p1, const void* p2, size_t cb)
{
    //  p2 is the one that is in the MRU and p1 is the one that we are passing in...
    return !ILIsEqual(GETRECPIDL(p2), (LPCITEMIDLIST)p1);
}

CTaskAddDoc::~CTaskAddDoc(void)
{
    TraceMsg(DM_RECENTDOCS, "[%X] CTaskAddDoc destroyed", this);
}

CTaskAddDoc::CTaskAddDoc(void) : CRunnableTask(RTF_DEFAULT)
{
    TraceMsg(DM_RECENTDOCS, "[%X] CTaskAddDoc created", this);
}


HRESULT CTaskAddDoc::Init(HANDLE hMem, DWORD dwProcId)
{
    if (hMem) {
        _hMem = hMem;
        _dwProcId = dwProcId;
        return S_OK;
    }
    return E_FAIL;
}

typedef struct _ARD {
    DWORD   dwOffsetPath;
    DWORD   dwOffsetPidl;
} XMITARD, * PXMITARD;


HRESULT CTaskAddDoc::RunInitRT(void)
{
    TraceMsg(DM_RECENTDOCS, "[%X] CTaskAddDoc::RunInitRT() running", this);

    PXMITARD px = (PXMITARD)SHLockShared(_hMem, _dwProcId);
    if (px) {
        LPITEMIDLIST pidl = px->dwOffsetPidl ? (LPITEMIDLIST)((LPBYTE)px + px->dwOffsetPidl) : NULL;
        LPTSTR pszPath = px->dwOffsetPath ? (LPTSTR)((LPBYTE)px + px->dwOffsetPath) : NULL;

        ASSERT(pszPath);

        _AddToRecentDocs(pidl, pszPath);

        SHUnlockShared(px);
        SHFreeShared(_hMem, _dwProcId);
    }

    return S_OK;
}


BOOL GetExtensionClassDescription(LPCTSTR lpszFile)
{
    LPTSTR lpszExt = PathFindExtension(lpszFile);
    if (*lpszExt) {
        TCHAR szClass[128];
        TCHAR szDescription[MAX_PATH];
        long cchClass = SIZEOF(szClass);
        if (SHRegQueryValue(HKEY_CLASSES_ROOT, lpszExt, szClass, &cchClass) != ERROR_SUCCESS) {
            // if this fails, use the extension cause it might be a pseudoclass
            lstrcpyn(szClass, lpszExt, ARRAYSIZE(szClass));
        }

        return GetClassDescription(HKEY_CLASSES_ROOT, szClass, szDescription, ARRAYSIZE(szDescription),
                                   GCD_MUSTHAVEOPENCMD | GCD_ALLOWPSUDEOCLASSES);
    }
    return FALSE;
}

STDAPI_(void) FlushRunDlgMRU(void);


//  _CleanRecentDocs()
//  cleans out the recent docs folder and the associate registry keys.

void _CleanRecentDocs(void)
{
    LPITEMIDLIST pidlTargetLocal = SHCloneSpecialIDList(NULL, CSIDL_RECENT, TRUE);
    if (pidlTargetLocal) {
        HKEY hkey;
        TCHAR szDir[MAX_PATH];

        // first, delete all the files
        SHFILEOPSTRUCT sFileOp =
        {
            NULL,
            FO_DELETE,
            szDir,
            NULL,
            FOF_NOCONFIRMATION | FOF_SILENT,
        };

        SHGetPathFromIDList(pidlTargetLocal, szDir);
        PathAppend(szDir, c_szStarDotStar);
        szDir[lstrlen(szDir) + 1] = 0;     // double null terminate
        SHFileOperation(&sFileOp);


        ILFree(pidlTargetLocal);

        pidlTargetLocal = SHCloneSpecialIDList(NULL, CSIDL_NETHOOD, TRUE);

        if (pidlTargetLocal) {
            //  now we take care of cleaning out the nethood
            //  we have to more careful, cuz we let other people
            //  add their own stuff in here.

            HANDLE hmru = CreateSharedRecentMRUList(TEXT("NetHood"), NULL, SRMLF_COMPPIDL);

            if (hmru) {
                IShellFolder* psf;

                if (SUCCEEDED(SHBindToObject(NULL, IID_IShellFolder, pidlTargetLocal, (void**)&psf))) {
                    BOOL fUpdate = FALSE;
                    int iItem = 0;
                    LPITEMIDLIST pidlItem;

                    ASSERT(psf);

                    while (-1 != EnumSharedRecentMRUList(hmru, iItem++, NULL, &pidlItem)) {
                        ASSERT(pidlItem);
                        STRRET str;
                        if (SUCCEEDED(psf->GetDisplayNameOf(pidlItem, SHGDN_FORPARSING, &str))
                            && SUCCEEDED(StrRetToBuf(&str, pidlItem, szDir, ARRAYSIZE(szDir)))) {
                            szDir[lstrlen(szDir) + 1] = 0;     // double null terminate
                            SHFileOperation(&sFileOp);
                        }

                        ILFree(pidlItem);
                    }

                    if (fUpdate)
                        SHChangeNotify(SHCNE_UPDATEDIR, 0, (void*)pidlTargetLocal, NULL);

                    psf->Release();
                }

                FreeMRUList(hmru);
            }

            ILFree(pidlTargetLocal);
        }

        // now delete the registry stuff
        hkey = SHGetExplorerHkey(HKEY_CURRENT_USER, TRUE);
        if (hkey) {
            SHDeleteKey(hkey, REGSTR_KEY_RECENTDOCS);
            RegCloseKey(hkey);
        }

        //  reinit the the folder.
        RecentDocs_Install(TRUE);

        SHChangeNotifyHandleEvents();
    }

    FlushRunDlgMRU();

    return;
}


//  WARNING - _TryDeleteMRUItem() returns an allocated string that must be freed

void CTaskAddDoc::_TryDeleteMRUItem(HANDLE hmru, DWORD cMax, LPCTSTR pszFileName, LPCITEMIDLIST pidlItem, HANDLE hmruOther, BOOL fOverwrite)
{
    BYTE buf[MAX_RECMRU_BUF] = {0};

    DWORD cbItem = CbFromCch(lstrlen(pszFileName) + 1);
    int iItem = fOverwrite ? FindMRUData(hmru, pszFileName, cbItem, NULL) : -1;



    //  if iItem is not -1 then it is already existing item that we will replace.
    //  if it is -1 then we need to point iItem to the last in the list.
    if (iItem == -1) {
        //  torch the last one if we have the max number of items in the list.
        //  default to success, cuz if we dont find it we dont need to delete it
        iItem = cMax - 1;
    }

    //  if we cannot get it in order to delete it,
    //  then we will not overwrite the item.
    if (EnumMRUList(hmru, iItem, buf, SIZEOF(buf)) != -1) {
        //  convert the buf into the last segment of the pidl
        LPITEMIDLIST pidlFullLink = ILCombine(_pidlTarget, GETRECPIDL(buf));
        if (pidlFullLink) {
            // This is semi-gross, but some link types like calling cards are the
            // actual data.  If we delete and recreate they lose their info for the
            // run.  We will detect this by knowing that their pidl will be the
            // same as the one we are deleting...
            if (!ILIsEqual(pidlFullLink, pidlItem)) {
                TCHAR sz[MAX_PATH];

                // now remove out link to it
                SHGetPathFromIDList(pidlFullLink, sz);

                Win32DeleteFile(sz);
                TraceMsg(DM_RECENTDOCS, "[%X] CTaskAddDoc::_TryDeleteMRUItem() deleting '%s'", this, sz);

                if (hmruOther) {
                    //  deleted a shortcut,
                    //  need to try and remove it from the hmruOther...
                    iItem = FindMRUData(hmruOther, GETRECNAME(buf), CbFromCch(lstrlen(GETRECNAME(buf)) + 1), NULL);
                    if (iItem != -1)
                        DelMRUString(hmruOther, iItem);
                }
            }
            ILFree(pidlFullLink);
        }
    }
}

// in:
// pidlItem - full IDList for the item being added
// pszItem  - name (file spec) of the item (used in the display to the user)
// uFlags   - SHCL_ flags

LPBYTE CTaskAddDoc::_CreateMRUItem(LPCITEMIDLIST pidlItem, LPCTSTR pszItem,
                                   DWORD* pcbOut, UINT uFlags)
{
    TCHAR sz[MAX_PATH];
    LPBYTE pitem = NULL;

    // create the new one
    if (SHGetPathFromIDList(_pidlTarget, sz)) {
        LPITEMIDLIST pidlFullLink;

        if (SUCCEEDED(CreateLinkToPidl(pidlItem, sz, &pidlFullLink, uFlags)) &&
            pidlFullLink) {
            LPCITEMIDLIST pidlLinkLast = ILFindLastID(pidlFullLink);
            int cbLinkLast = ILGetSize(pidlLinkLast);
            DWORD cbItem = CbFromCch(lstrlen(pszItem) + 1);

            pitem = (LPBYTE)LocalAlloc(LPTR, cbItem + cbLinkLast);
            if (pitem) {
                memcpy(pitem, pszItem, cbItem);
                memcpy(pitem + cbItem, pidlLinkLast, cbLinkLast);
                *pcbOut = cbItem + cbLinkLast;
            }
            ILFree(pidlFullLink);
        }
    }

    return pitem;
}

int EnumSharedRecentMRUList(HANDLE hmru, int iItem, LPTSTR* ppszName, LPITEMIDLIST* ppidl)
{
    BYTE buf[MAX_RECMRU_BUF] = {0};
    int iRet;
    //  if both out params are NULL or iItem < 0 then this is a query for the size
    //  of the MRU list...
    if (ppszName)
        *ppszName = NULL;
    if (ppidl)
        *ppidl = NULL;

    if (iItem < 0 || (!ppszName && !ppidl))
        iRet = EnumMRUList(hmru, -1, NULL, 0);
    else if (-1 != (iRet = EnumMRUList(hmru, iItem, buf, SIZEOF(buf)))) {
        if (ppszName) {
            *ppszName = StrDup(GETRECNAME(buf));
            if (!*ppszName)
                iRet = -1;
        } else if (ppidl) {
            *ppidl = ILClone(GETRECPIDL(buf));
            if (!*ppidl)
                iRet = -1;
        }
    }

    return iRet;
}

#define MAXRECENT_DEFAULTDOC      10
#define MAXRECENT_MAJORDOC        20

HANDLE CreateSharedRecentMRUList(LPCTSTR pszClass, DWORD* pcMax, DWORD dwFlags)
{
    if (SHRestricted(REST_NORECENTDOCSHISTORY))
        return NULL;

    DWORD cMax;
    MRUCMPDATAPROC procCompare = RecentDocsCompareName;
    TCHAR szKey[MAX_PATH];
    LPCTSTR pszKey = REGSTR_PATH_EXPLORER TEXT("\\") REGSTR_KEY_RECENTDOCS;

    if (pszClass) {
        //  want to use the pszExt as a sub key
        lstrcpy(szKey, pszKey);
        StrCatBuff(szKey, TEXT("\\"), SIZECHARS(szKey));
        StrCatBuff(szKey, pszClass, SIZECHARS(szKey));
        pszKey = szKey;

        //  we need to find out how many
        DWORD dwType = REG_DWORD, dwMajor = 0, cbSize = SIZEOF(cbSize);
        SHGetValue(HKEY_CLASSES_ROOT, pszClass, TEXT("MajorDoc"), &dwType, (LPVOID)&dwMajor, &cbSize);
        cMax = dwMajor ? MAXRECENT_MAJORDOC : MAXRECENT_DEFAULTDOC;
    } else {
        //  this the root MRU
        cMax = SHRestricted(REST_MaxRecentDocs);

        //  default max docs...
        if (cMax < 1)
            cMax = MAXRECENTDOCS * MAXRECENT_DEFAULTDOC;
    }

    if (dwFlags & SRMLF_COMPPIDL)
        procCompare = RecentDocsComparePidl;

    MRUDATAINFO mi = {
        SIZEOF(MRUDATAINFO),
        cMax,
        MRU_BINARY | MRU_CACHEWRITE,
        HKEY_CURRENT_USER,
        pszKey,
        procCompare
    };

    if (pcMax)
        *pcMax = cMax;

    return CreateMRUList((MRUINFO*)&mi);

}

BOOL CTaskAddDoc::_AddDocToRecentAndExtRecent(LPCITEMIDLIST pidlItem, LPCTSTR pszFileName,
                                              LPCTSTR pszExt)
{
    DWORD cbItem = CbFromCch(lstrlen(pszFileName) + 1);
    DWORD cMax;
    HANDLE hmru = CreateSharedRecentMRUList(pszExt, &cMax, SRMLF_COMPNAME);

    _TryDeleteMRUItem(_hmruRecent, _cMaxRecent, pszFileName, pidlItem, hmru, TRUE);

    LPBYTE pitem = _CreateMRUItem(pidlItem, pszFileName, &cbItem, 0);
    if (pitem) {
        AddMRUData(_hmruRecent, pitem, cbItem);

        if (hmru) {
            //  we dont want to delete the file if it already existed, because
            //  the TryDelete on the RecentMRU would have already done that
            //  we only want to delete if we have some overflow from the ExtMRU
            _TryDeleteMRUItem(hmru, cMax, pszFileName, pidlItem, _hmruRecent, FALSE);

            //  can reuse the already created item to this mru
            AddMRUData(hmru, pitem, cbItem);

            FreeMRUList(hmru);
        }

        LocalFree(pitem);
    }

    //  its been freed but not nulled out...
    return (pitem != NULL);
}



//  WARNING:  UpdateNetHood() changes _pidlTarget to the NetHood then frees it!

void CTaskAddDoc::_UpdateNetHood(LPCITEMIDLIST pidlFolder, LPCTSTR pszShare)
{
    if (SHRestricted(REST_NORECENTDOCSNETHOOD))
        return;

    //  need to add this boy to the Network Places
    LPITEMIDLIST pidl = ILCreateFromPath(pszShare);
    if (pidl) {

        //  BUGBUG - must verify parentage here - ZekeL - 27-MAY-99
        //  http servers exist in both the webfolders namespace
        //  and the Internet namespace.  thus we must make sure
        //  that what ever parent the folder had, the share has
        //  the same one.

        if (ILIsParent(pidl, pidlFolder, FALSE)) {
            ASSERT(_pidlTarget);
            ILFree(_pidlTarget);

            _pidlTarget = SHCloneSpecialIDList(NULL, CSIDL_NETHOOD, TRUE);
            if (_pidlTarget) {
                DWORD cMax;
                HANDLE hmru = CreateSharedRecentMRUList(TEXT("NetHood"), &cMax, SRMLF_COMPNAME);
                if (hmru) {
                    _TryDeleteMRUItem(hmru, cMax, pszShare, pidl, NULL, TRUE);
                    DWORD cbItem = CbFromCch(lstrlen(pszShare) + 1);
                    LPBYTE pitem = _CreateMRUItem(pidl, pszShare, &cbItem, SHCL_MAKEFOLDERSHORTCUT);
                    if (pitem) {
                        AddMRUData(hmru, pitem, cbItem);
                        LocalFree(pitem);
                    }

                    FreeMRUList(hmru);
                }

                ILFree(_pidlTarget);
                _pidlTarget = NULL;
            }
        }

        ILFree(pidl);
    }
}

BOOL PathIsOneOf(const UINT rgFolders[], LPCTSTR pszFolder);

BOOL _IsPlacesFolder(LPCTSTR pszFolder)
{
    static const UINT places[] = {
        CSIDL_PERSONAL,
        CSIDL_DESKTOPDIRECTORY,
        CSIDL_COMMON_DESKTOPDIRECTORY,
        CSIDL_NETHOOD,
        CSIDL_FAVORITES,
        (UINT)-1 // terminator
    };

    return PathIsOneOf(places, pszFolder);
}

void _AddToUrlHistory(LPCTSTR pszPath)
{
    ASSERT(pszPath);
    WCHAR szUrl[MAX_URL_STRING];
    DWORD cchUrl = SIZECHARS(szUrl);

    SHTCharToUnicode(pszPath, szUrl, cchUrl);

    //  the URL parsing APIs tolerate same in/out buffer
    if (SUCCEEDED(UrlCreateFromPathW(szUrl, szUrl, &cchUrl, 0))) {
        IUrlHistoryStg* puhs;
        if (SUCCEEDED(CoCreateInstance(CLSID_CUrlHistory, NULL, CLSCTX_INPROC_SERVER, IID_IUrlHistoryStg, (void**)&puhs))) {
            ASSERT(puhs);
            puhs->AddUrl(szUrl, NULL, 0);
            puhs->Release();
        }
    }
}

void CTaskAddDoc::_TryUpdateNetHood(LPCITEMIDLIST pidlFolder, LPCTSTR pszFolder)
{
    TCHAR sz[MAX_URL_STRING];
    DWORD cch = SIZECHARS(sz);
    BOOL fUpdate = FALSE;
    // changing szFolder, and changing _pidlTarget here...
    //  if this is an URL or a UNC share add it to the nethood

    if (UrlIs(pszFolder, URLIS_URL)
        && !UrlIs(pszFolder, URLIS_OPAQUE)
        && SUCCEEDED(UrlCombine(pszFolder, TEXT("/"), sz, &cch, 0)))
        fUpdate = TRUE;
    else if (PathIsUNC(pszFolder)
             && StrCpyN(sz, pszFolder, cch)
             && PathStripToRoot(sz))
        fUpdate = TRUE;

    if (fUpdate)
        _UpdateNetHood(pidlFolder, sz);
}



// Add the named file to the Recently opened MRU list, that is used
// by the shell to display the recent menu of the tray.

// this registry will hold two pidls:  the target pointing to followed by
// the pidl of the link created pointing it.  In both cases,
// only the last item id is stored. (we may want to change this... but
// then again, we may not)

void CTaskAddDoc::_AddToRecentDocs(LPCITEMIDLIST pidlItem, LPCTSTR pszItem)
{
    TCHAR szUnescaped[MAX_PATH];
    LPTSTR pszFileName;

    //  if these are NULL the caller meant to call _CleanRecentDocs()
    ASSERT(pszItem && *pszItem);

    TraceMsg(DM_RECENTDOCS, "[%X] CTaskAddDoc::_AddToRecentDocs() called for '%s'", this, pszItem);
    // allow only classes with default commands

    //  dont add if:
    //     it is RESTRICTED
    //     it is in the temporary directory
    //     it actually has a file name
    //     it can be shell exec'd with "open" verb

    if ((SHRestricted(REST_NORECENTDOCSHISTORY)) ||
        (PathIsTemporary(pszItem)) ||
        (!(pszFileName = PathFindFileName(pszItem))) ||
        (!*pszFileName) ||
        (!GetExtensionClassDescription(pszFileName))
        )
        return;

    //  pretty up the URL file names.
    if (UrlIs(pszItem, URLIS_URL)) {
        StrCpyN(szUnescaped, pszFileName, SIZECHARS(szUnescaped));
        UrlUnescapeInPlace(szUnescaped, 0);
        pszFileName = szUnescaped;
    }

    //  otherwise we try our best.
    ASSERT(!_pidlTarget);
    _pidlTarget = SHCloneSpecialIDList(NULL, CSIDL_RECENT, TRUE);
    if (_pidlTarget) {
        _hmruRecent = CreateSharedRecentMRUList(NULL, &_cMaxRecent, SRMLF_COMPNAME);
        if (_hmruRecent) {
            if (_AddDocToRecentAndExtRecent(pidlItem, pszFileName, PathFindExtension(pszFileName))) {
                _AddToUrlHistory(pszItem);
                //  get the folder and do it to the folder
                LPITEMIDLIST pidlFolder = ILClone(pidlItem);

                if (pidlFolder) {
                    ILRemoveLastID(pidlFolder);
                    //  if it is a folder we already have quick
                    //  access to from the shell, dont put it in here

                    TCHAR szFolder[MAX_URL_STRING];
                    if (SUCCEEDED(SHGetNameAndFlags(pidlFolder, SHGDN_FORPARSING, szFolder, SIZECHARS(szFolder), NULL))
                        && !_IsPlacesFolder(szFolder)) {
                        //  get the friendly name for the folder
                        TCHAR szTitle[MAX_PATH];
                        if (FAILED(SHGetNameAndFlags(pidlFolder, SHGDN_NORMAL, szTitle, SIZECHARS(szTitle), NULL)))
                            StrCpyN(szTitle, PathFindFileName(szFolder), ARRAYSIZE(szTitle));

                        _AddDocToRecentAndExtRecent(pidlFolder, szTitle, TEXT("Folder"));

                        _TryUpdateNetHood(pidlFolder, szFolder);
                    }

                    ILFree(pidlFolder);
                }
                SHChangeNotifyHandleEvents();
            }

            FreeMRUList(_hmruRecent);
            _hmruRecent = NULL;
        }

        //cleanup
        if (_pidlTarget) {
            ILFree(_pidlTarget);
            _pidlTarget = NULL;
        }
    }
}

STDAPI_(void) OpenWithListSoftRegisterProcess(DWORD dwFlags, LPCTSTR pszExt);

void AddToRecentDocs(LPCITEMIDLIST pidl, LPCTSTR pszItem)
{
    HWND hwnd;
    DWORD cbSizePidl, cbSizePath;

    ASSERT(pidl && pszItem);

    if (!ShouldAddToRecentDocs(pidl))
        return;

    OpenWithListSoftRegisterProcess(0, PathFindExtension(pszItem));

    cbSizePidl = ILGetSize(pidl);
    cbSizePath = CbFromCch(lstrlen(pszItem) + 1);

    hwnd = GetShellWindow();
    if (hwnd) {
        PXMITARD px;
        DWORD dwProcId, dwOffset;
        HANDLE hARD;

        GetWindowThreadProcessId(hwnd, &dwProcId);

        hARD = SHAllocShared(NULL, SIZEOF(XMITARD) + cbSizePath + cbSizePidl, dwProcId);
        if (!hARD)
            return;         // Well, we are going to miss one, sorry.

        px = (PXMITARD)SHLockShared(hARD, dwProcId);
        if (!px) {
            SHFreeShared(hARD, dwProcId);
            return;         // Well, we are going to miss one, sorry.
        }

        px->dwOffsetPidl = 0;
        px->dwOffsetPath = 0;

        dwOffset = SIZEOF(XMITARD);
        if (pszItem) {
            px->dwOffsetPath = dwOffset;
            memcpy((LPBYTE)px + dwOffset, pszItem, cbSizePath);
            dwOffset += cbSizePath;
        }
        if (pidl) {
            px->dwOffsetPidl = dwOffset;
            memcpy((LPBYTE)px + dwOffset, pidl, cbSizePidl);
        }

        SHUnlockShared(px);

        PostMessage(hwnd, CWM_ADDTORECENT, (WPARAM)hARD, (LPARAM)dwProcId);
    }
}

// put things in the shells recent docs list for the start menu

// in:
//      uFlags  SHARD_ (shell add recent docs) flags
//      pv      LPCSTR or LPCITEMIDLIST (path or pidl indicated by uFlags)
//              may be NULL, meaning clear the recent list

STDAPI_(void) SHAddToRecentDocs(UINT uFlags, LPCVOID pv)
{
    TCHAR szTemp[MAX_URL_STRING]; // for double null

    TraceMsg(DM_RECENTDOCS, "SHAddToRecentDocs() called with %d, [%X]", uFlags, pv);

    if (pv == NULL)     // we should nuke all recent docs.
    {
        //  we do this synchronously
        _CleanRecentDocs();
        return;
    }

    if (SHRestricted(REST_NORECENTDOCSHISTORY))
        // Don't bother tracking recent documents if restriction is set
        // for privacy.
        return;

    if (uFlags == SHARD_PIDL) {
        // pv is a LPCITEMIDLIST (pidl)
        if (SUCCEEDED(SHGetNameAndFlags((LPCITEMIDLIST)pv, SHGDN_FORPARSING, szTemp, SIZECHARS(szTemp), NULL))) {
            AddToRecentDocs((LPCITEMIDLIST)pv, szTemp);
        }
    } else if (uFlags == SHARD_PATH) {
        // pv is a LPTCSTR (path)
        LPITEMIDLIST pidl = ILCreateFromPath((LPCTSTR)pv);
        if (!pidl)
            pidl = SHSimpleIDListFromPath((LPCTSTR)pv);
        if (pidl) {
            AddToRecentDocs(pidl, (LPCTSTR)pv);
            ILFree(pidl);
        }
    }
#ifdef UNICODE
    else if (uFlags == SHARD_PATHA) {
        SHAnsiToUnicode((LPCSTR)pv, szTemp, ARRAYSIZE(szTemp));
        SHAddToRecentDocs(SHARD_PATH, szTemp);
    }
#else
    else if (uFlags == SHARD_PATHW) {
        SHUnicodeToAnsi((LPCWSTR)pv, szTemp, ARRAYSIZE(szTemp));
        SHAddToRecentDocs(SHARD_PATH, szTemp);
    }
#endif
}

WINSHELLAPI void ReceiveAddToRecentDocs(HANDLE hARD, DWORD dwProcId)
{
    //  NOTIMPL
    ASSERT(FALSE);
}

STDAPI CTaskAddDoc_Create(HANDLE hMem, DWORD dwProcId, IRunnableTask** pptask)
{
    HRESULT hres;
    CTaskAddDoc* ptad = new CTaskAddDoc();
    if (ptad) {
        hres = ptad->Init(hMem, dwProcId);
        if (SUCCEEDED(hres))
            hres = ptad->QueryInterface(IID_IRunnableTask, (void**)pptask);
        ptad->Release();
    } else
        hres = E_OUTOFMEMORY;
    return hres;
}

STDAPI RecentDocs_GetDisplayName(LPCITEMIDLIST pidl, LPTSTR pszName, DWORD cchName)
{
    HRESULT hr = E_FAIL;
    HANDLE hmru = CreateSharedRecentMRUList(NULL, NULL, SRMLF_COMPPIDL);
    if (hmru) {
        int iItem = FindMRUData(hmru, pidl, ILGetSize(pidl), NULL);
        if (-1 != iItem) {
            BYTE buf[MAX_RECMRU_BUF];

            if (-1 != EnumMRUList(hmru, iItem, buf, SIZEOF(buf))) {
                StrCpyN(pszName, GETRECNAME(buf), cchName);
                hr = S_OK;
            }
        }

        FreeMRUList(hmru);
    }

    return hr;
}