You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1074 lines
27 KiB
1074 lines
27 KiB
//*******************************************************************************************
|
|
//
|
|
// Filename : folder.cpp
|
|
//
|
|
// CAB Files Shell Extension
|
|
//
|
|
// Copyright (c) 1994 - 1997 Microsoft Corporation. All rights reserved
|
|
//
|
|
//*******************************************************************************************
|
|
|
|
|
|
#include "pch.h"
|
|
|
|
#include "ccstock.h"
|
|
#include "thisdll.h"
|
|
#include "thisguid.h"
|
|
#include "ntquery.h"
|
|
#include "varutil.h"
|
|
|
|
#include "folder.h"
|
|
#include "enum.h"
|
|
#include "menu.h"
|
|
#include "dataobj.h"
|
|
|
|
#include "cabitms.h"
|
|
|
|
#include "resource.h"
|
|
|
|
STDAPI StringToStrRet(LPCTSTR pszName, STRRET *pStrRet)
|
|
{
|
|
#ifdef UNICODE
|
|
pStrRet->uType = STRRET_WSTR;
|
|
return SHStrDup(pszName, &pStrRet->pOleStr);
|
|
#else
|
|
pStrRet->uType = STRRET_CSTR;
|
|
lstrcpyn(pStrRet->cStr, pszName, ARRAYSIZE(pStrRet->cStr));
|
|
return NOERROR;
|
|
#endif
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
if (CLSID_CabFolder == riid)
|
|
{
|
|
// yuck - dataobject uses this when loading us from a stream:
|
|
// NOTE: we are doing an AddRef() in this case
|
|
*ppv = (CCabFolder*) this;
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CCabFolder, IShellFolder2),
|
|
QITABENTMULTI(CCabFolder, IShellFolder, IShellFolder2),
|
|
QITABENT(CCabFolder, IPersistFolder2),
|
|
QITABENTMULTI(CCabFolder, IPersistFolder, IPersistFolder2),
|
|
QITABENTMULTI(CCabFolder, IPersist, IPersistFolder2),
|
|
QITABENT(CCabFolder, IShellFolderViewCB),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CCabFolder::AddRef(void)
|
|
{
|
|
return(m_cRef.AddRef());
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CCabFolder::Release(void)
|
|
{
|
|
if (!m_cRef.Release())
|
|
{
|
|
delete this;
|
|
return(0);
|
|
}
|
|
|
|
return(m_cRef.GetRef());
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR pszDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//**********************************************************************
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Creates an item enumeration object
|
|
// (an IEnumIDList interface) that can be used to
|
|
// enumerate the contents of a folder.
|
|
//
|
|
// Parameters:
|
|
//
|
|
// HWND hwndOwner - handle to the owner window
|
|
// DWORD grFlags - flags about which items to include
|
|
// IEnumIDList **ppenumIDList - address that receives IEnumIDList
|
|
// interface pointer
|
|
//********************************************************************
|
|
|
|
STDMETHODIMP CCabFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenumIDList)
|
|
{
|
|
HRESULT hres;
|
|
CEnumCabObjs *pce = new CEnumCabObjs(this, grfFlags);
|
|
if (pce)
|
|
{
|
|
hres = pce->QueryInterface(IID_IEnumIDList, (void **)ppenumIDList);
|
|
}
|
|
else
|
|
{
|
|
*ppenumIDList = NULL;
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvObj)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void ** ppvObj)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
//**********************************************************************
|
|
//
|
|
// CCabFolder::CompareIDs
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Determines the relative ordering of two file
|
|
// objects or folders, given their item identifier lists
|
|
//
|
|
// Parameters:
|
|
//
|
|
// LPARAM lParam - type of comparison
|
|
// LPCITEMIDLIST pidl1 - address to ITEMIDLIST
|
|
// LPCITEMIDLIST pidl2 - address to ITEMIDLIST
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
//
|
|
//********************************************************************
|
|
|
|
STDMETHODIMP CCabFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
LPCABITEM pit1 = (LPCABITEM)pidl1;
|
|
LPCABITEM pit2 = (LPCABITEM)pidl2;
|
|
|
|
short nCmp = 0;
|
|
|
|
LPCWSTR pszName1, pszName2;
|
|
WSTR_ALIGNED_STACK_COPY(&pszName1, pit1->szName);
|
|
WSTR_ALIGNED_STACK_COPY(&pszName2, pit2->szName);
|
|
|
|
switch (lParam)
|
|
{
|
|
case CV_COL_NAME:
|
|
break;
|
|
|
|
case CV_COL_SIZE:
|
|
if (pit1->dwFileSize < pit2->dwFileSize)
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
else if (pit1->dwFileSize > pit2->dwFileSize)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
break;
|
|
|
|
case CV_COL_TYPE:
|
|
{
|
|
STRRET srName1, srName2;
|
|
|
|
GetTypeOf(pit1, &srName1);
|
|
GetTypeOf(pit2, &srName2);
|
|
|
|
#ifdef UNICODE
|
|
if (srName1.pOleStr && srName2.pOleStr)
|
|
{
|
|
nCmp = (SHORT)lstrcmp(srName1.pOleStr, srName2.pOleStr);
|
|
}
|
|
else
|
|
{
|
|
if (srName1.pOleStr)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
else
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
}
|
|
if (srName1.pOleStr)
|
|
{
|
|
CoTaskMemFree(srName1.pOleStr);
|
|
}
|
|
if (srName2.pOleStr)
|
|
{
|
|
CoTaskMemFree(srName2.pOleStr);
|
|
}
|
|
#else // UNICODE
|
|
nCmp = (SHORT)lstrcmp(srName1.cStr, srName2.cStr);
|
|
#endif // UNICODE
|
|
break;
|
|
}
|
|
|
|
case CV_COL_MODIFIED:
|
|
if (pit1->uFileDate < pit2->uFileDate)
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
else if (pit1->uFileDate > pit2->uFileDate)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
else if (pit1->uFileTime < pit2->uFileTime)
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
else if (pit1->uFileTime > pit2->uFileTime)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
break;
|
|
|
|
case CV_COL_PATH:
|
|
if (pit1->cPathChars == 0)
|
|
{
|
|
if (pit2->cPathChars != 0)
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
}
|
|
else if (pit2->cPathChars == 0)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
else if (pit1->cPathChars <= pit2->cPathChars)
|
|
{
|
|
nCmp = (short) StrCmpN(pszName1, pszName2, pit1->cPathChars-1);
|
|
|
|
if ((nCmp == 0) && (pit1->cPathChars < pit2->cPathChars))
|
|
{
|
|
nCmp = -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nCmp = (short) StrCmpN(pszName1, pszName2, pit2->cPathChars-1);
|
|
|
|
if (nCmp == 0)
|
|
{
|
|
nCmp = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (nCmp != 0)
|
|
{
|
|
return ResultFromShort(nCmp);
|
|
}
|
|
|
|
return ResultFromShort(lstrcmpi(pszName1 + pit1->cPathChars, pszName2 + pit2->cPathChars));
|
|
}
|
|
|
|
|
|
STDMETHODIMP CCabFolder::MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//**********************************************************************
|
|
//
|
|
// CCabFolder::CreateViewObject
|
|
//
|
|
// Purpose:
|
|
//
|
|
// IShellbrowser calls this to create a ShellView
|
|
// object
|
|
//
|
|
// Parameters:
|
|
//
|
|
// HWND hwndOwner -
|
|
//
|
|
// REFIID riid - interface ID
|
|
//
|
|
// void ** ppvObj - pointer to the Shellview object
|
|
//
|
|
// Return Value:
|
|
//
|
|
// NOERROR
|
|
// E_OUTOFMEMORY
|
|
// E_NOINTERFACE
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
// ShellBrowser interface calls this to request the ShellFolder
|
|
// to create a ShellView object
|
|
//
|
|
//********************************************************************
|
|
|
|
STDMETHODIMP CCabFolder::CreateViewObject(HWND hwndOwner, REFIID riid, void **ppvObj)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (riid == IID_IShellView)
|
|
{
|
|
SFV_CREATE sfvc = { 0 };
|
|
sfvc.cbSize = sizeof(sfvc);
|
|
sfvc.pshf = this;
|
|
sfvc.psfvcb = this;
|
|
hr = SHCreateShellFolderView(&sfvc, (IShellView **)ppvObj);
|
|
}
|
|
else
|
|
{
|
|
*ppvObj = NULL;
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// **************************************************************************************
|
|
//
|
|
// CCabFolder::GetAttributesOf
|
|
//
|
|
// Purpose
|
|
//
|
|
// Retrieves attributes of one of more file objects
|
|
//
|
|
// Parameters:
|
|
//
|
|
// UINT cidl - number of file objects
|
|
// LPCITEMIDLIST *apidl - pointer to array of ITEMIDLIST
|
|
// ULONG *rgfInOut - array of values that specify file object
|
|
// attributes
|
|
//
|
|
//
|
|
// Return Value:
|
|
//
|
|
// NOERROR
|
|
//
|
|
// Comments
|
|
//
|
|
// ***************************************************************************************
|
|
|
|
STDMETHODIMP CCabFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *rgfInOut)
|
|
{
|
|
*rgfInOut &= SFGAO_CANCOPY;
|
|
return NOERROR;
|
|
}
|
|
|
|
// **************************************************************************************
|
|
//
|
|
// CCabFolder::GetUIObjectOf
|
|
//
|
|
// Purpose
|
|
//
|
|
// Returns an interface that can be used to carry out actions on
|
|
// the specified file objects or folders
|
|
//
|
|
// Parameters:
|
|
//
|
|
// HWND hwndOwner - handle of the Owner window
|
|
//
|
|
// UINT cidl - Number of file objects
|
|
//
|
|
// LPCITEMIDLIST *apidl - array of file object pidls
|
|
//
|
|
// REFIID - Identifier of interface to return
|
|
//
|
|
// UINT * prgfInOut - reserved
|
|
//
|
|
// void **ppvObj - address that receives interface pointer
|
|
//
|
|
// Return Value:
|
|
//
|
|
// E_INVALIDARG
|
|
// E_NOINTERFACE
|
|
// E_OUTOFMEMORY
|
|
//
|
|
// Comments
|
|
// ***************************************************************************************
|
|
|
|
STDMETHODIMP CCabFolder::GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST *apidl,
|
|
REFIID riid, UINT *prgfInOut, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
if (riid == IID_IExtractIcon)
|
|
{
|
|
if (cidl != 1)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
LPCABITEM pci = (LPCABITEM)*apidl;
|
|
|
|
LPCWSTR pszName;
|
|
WSTR_ALIGNED_STACK_COPY(&pszName, pci->szName);
|
|
|
|
hr = SHCreateFileExtractIconW(pszName, pci->uFileAttribs, riid, ppv);
|
|
}
|
|
}
|
|
else if (riid == IID_IContextMenu)
|
|
{
|
|
if (cidl < 1)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
CCabItemMenu *pcim = new CCabItemMenu(hwndOwner, this, (LPCABITEM *)apidl, cidl);
|
|
if (pcim)
|
|
{
|
|
pcim->AddRef(); // weak 0-based refcount
|
|
hr = pcim->QueryInterface(riid, ppv);
|
|
pcim->Release();
|
|
}
|
|
}
|
|
}
|
|
else if (riid == IID_IDataObject)
|
|
{
|
|
if (cidl < 1)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
CCabObj *pco = new CCabObj(hwndOwner, this, (LPCABITEM *)apidl, cidl);
|
|
if (pco)
|
|
{
|
|
pco->AddRef(); // weak 0-based refcount
|
|
hr = pco->QueryInterface(riid, ppv);
|
|
pco->Release();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// CCabFolder::GetDisplayNameOf
|
|
//
|
|
// Purpose:
|
|
// Retrieves the display name for the specified file object or
|
|
// subfolder.
|
|
//
|
|
//
|
|
// Parameters:
|
|
//
|
|
// LPCITEMIDLIST pidl - pidl of the file object
|
|
// DWORD dwFlags - Flags of the type of display name to
|
|
// return
|
|
// LPSTRRET lpName - address holding the name returned
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
//*****************************************************************************
|
|
|
|
|
|
STDMETHODIMP CCabFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET lpName)
|
|
{
|
|
HRESULT hr;
|
|
LPCABITEM pit = (LPCABITEM)pidl;
|
|
if (pit)
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
if (dwFlags & SHGDN_FORPARSING)
|
|
{
|
|
if (dwFlags & SHGDN_INFOLDER)
|
|
{
|
|
ualstrcpyn(szTemp, pit->szName, ARRAYSIZE(szTemp)); // relative parse name
|
|
}
|
|
else
|
|
{
|
|
SHGetNameAndFlags(m_pidlHere, dwFlags, szTemp, ARRAYSIZE(szTemp), NULL);
|
|
|
|
TCHAR szName[MAX_PATH];
|
|
ualstrcpyn(szName, pit->szName, ARRAYSIZE(szName));
|
|
|
|
PathAppend(szTemp, szName);
|
|
}
|
|
hr = StringToStrRetW(szTemp, lpName);
|
|
}
|
|
else
|
|
{
|
|
GetNameOf(pit, lpName);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::SetNameOf(HWND hwndOwner, LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD dwRes, LPITEMIDLIST *ppidlOut)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
DEFINE_SCID(SCID_TYPE, PSGUID_STORAGE, PID_STG_STORAGETYPE);
|
|
DEFINE_SCID(SCID_NAME, PSGUID_STORAGE, PID_STG_NAME);
|
|
DEFINE_SCID(SCID_SIZE, PSGUID_STORAGE, PID_STG_SIZE);
|
|
DEFINE_SCID(SCID_WRITETIME, PSGUID_STORAGE, PID_STG_WRITETIME);
|
|
|
|
// the CV_COL_PATH column doesn't map to any well-known SCID types.
|
|
// since nobody will need to get a hold of the data, just refer to a bogus
|
|
// SCID. all this has to do is work within FindSCID.
|
|
#define PSGUID_CabFolder {0x0CD7A5C0L, 0x9F37, 0x11CE, 0xAE, 0x65, 0x08, 0x00, 0x2B, 0x2E, 0x12, 0x62} // CLSID_CabFolder
|
|
DEFINE_SCID(SCID_BOGUS, PSGUID_CabFolder, 0);
|
|
|
|
struct _CVCOLINFO
|
|
{
|
|
UINT iColumn;
|
|
UINT iTitle;
|
|
UINT cchCol;
|
|
UINT iFmt;
|
|
const SHCOLUMNID* pscid;
|
|
} s_aCVColInfo[] = {
|
|
{CV_COL_NAME, IDS_CV_COL_NAME, 20, LVCFMT_LEFT, &SCID_NAME},
|
|
{CV_COL_SIZE, IDS_CV_COL_SIZE, 10, LVCFMT_RIGHT, &SCID_SIZE},
|
|
{CV_COL_TYPE, IDS_CV_COL_TYPE, 20, LVCFMT_LEFT, &SCID_TYPE},
|
|
{CV_COL_MODIFIED, IDS_CV_COL_MODIFIED, 20, LVCFMT_LEFT, &SCID_WRITETIME},
|
|
{CV_COL_PATH, IDS_CV_COL_PATH, 30, LVCFMT_LEFT, &SCID_BOGUS},
|
|
};
|
|
|
|
STDMETHODIMP CCabFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *psd)
|
|
{
|
|
LPCABITEM pit = (LPCABITEM)pidl;
|
|
TCHAR szTemp[MAX_PATH];
|
|
|
|
if (iColumn >= CV_COL_MAX)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
psd->str.uType = STRRET_CSTR;
|
|
psd->str.cStr[0] = '\0';
|
|
|
|
if (!pit)
|
|
{
|
|
TCHAR szTitle[MAX_PATH];
|
|
LoadString(g_ThisDll.GetInstance(), s_aCVColInfo[iColumn].iTitle, szTitle, ARRAYSIZE(szTitle));
|
|
StringToStrRet(szTitle, &(psd->str));
|
|
psd->fmt = s_aCVColInfo[iColumn].iFmt;
|
|
psd->cxChar = s_aCVColInfo[iColumn].cchCol;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
switch (iColumn)
|
|
{
|
|
case CV_COL_NAME:
|
|
GetNameOf(pit, &psd->str);
|
|
break;
|
|
|
|
case CV_COL_PATH:
|
|
GetPathOf(pit, &psd->str);
|
|
break;
|
|
|
|
case CV_COL_SIZE:
|
|
{
|
|
ULARGE_INTEGER ullSize = {pit->dwFileSize, 0};
|
|
StrFormatKBSize(ullSize.QuadPart, szTemp, ARRAYSIZE(szTemp));
|
|
StringToStrRet(szTemp, &(psd->str));
|
|
break;
|
|
}
|
|
|
|
case CV_COL_TYPE:
|
|
GetTypeOf(pit, &psd->str);
|
|
break;
|
|
|
|
case CV_COL_MODIFIED:
|
|
{
|
|
FILETIME ft, uft;
|
|
if (DosDateTimeToFileTime(pit->uFileDate, pit->uFileTime, &ft) &&
|
|
LocalFileTimeToFileTime(&ft, &uft)) // Apply timezone
|
|
{
|
|
SHFormatDateTime(&uft, NULL, szTemp, ARRAYSIZE(szTemp));
|
|
StringToStrRet(szTemp, &(psd->str));
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::MapColumnToSCID(UINT iCol, SHCOLUMNID *pscid)
|
|
{
|
|
HRESULT hr;
|
|
ZeroMemory(pscid, sizeof(*pscid));
|
|
|
|
if (iCol < ARRAYSIZE(s_aCVColInfo))
|
|
{
|
|
*pscid = *s_aCVColInfo[iCol].pscid;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
return hr;
|
|
}
|
|
|
|
STDAPI_(int) FindSCID(const _CVCOLINFO* pcol, UINT nCols, const SHCOLUMNID* pscid)
|
|
{
|
|
for (UINT i = 0; i < nCols; i++)
|
|
{
|
|
if (IsEqualSCID(*pscid, *pcol[i].pscid))
|
|
return (int)i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
STDMETHODIMP CCabFolder::GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPCABITEM pit = (LPCABITEM)pidl;
|
|
|
|
int iCol = FindSCID(s_aCVColInfo, ARRAYSIZE(s_aCVColInfo), pscid);
|
|
if (iCol >= 0)
|
|
{
|
|
switch (iCol)
|
|
{
|
|
case CV_COL_SIZE:
|
|
pv->ullVal = pit->dwFileSize;
|
|
pv->vt = VT_UI8;
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case CV_COL_MODIFIED:
|
|
if (DosDateTimeToVariantTime(pit->uFileDate, pit->uFileTime, &pv->date))
|
|
{
|
|
pv->vt = VT_DATE;
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
SHELLDETAILS sd;
|
|
|
|
// Note that GetDetailsOf expects a relative pidl, since it is passed the SF itself.
|
|
// The columnid includes the absolute pidl, though.z
|
|
hr = GetDetailsOf(pidl, iCol, &sd);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = InitVariantFromStrRet(&sd.str, pidl, pv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// *** IPersist methods ***
|
|
|
|
STDMETHODIMP CCabFolder::GetClassID(CLSID *pclsid)
|
|
{
|
|
*pclsid = CLSID_CabFolder;
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// IPersistFolder
|
|
|
|
STDMETHODIMP CCabFolder::Initialize(LPCITEMIDLIST pidl)
|
|
{
|
|
if (m_pidlHere)
|
|
{
|
|
ILFree(m_pidlHere);
|
|
}
|
|
|
|
m_pidlHere = ILClone(pidl); // copy the pidl
|
|
return m_pidlHere ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT CCabFolder::GetCurFolder(LPITEMIDLIST *ppidl)
|
|
{
|
|
if (m_pidlHere)
|
|
{
|
|
*ppidl = ILClone(m_pidlHere);
|
|
return *ppidl ? NOERROR : E_OUTOFMEMORY;
|
|
}
|
|
|
|
*ppidl = NULL;
|
|
return S_FALSE; // success but empty
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// CCabFolder::CreateIDList
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Creates an item identifier list for the objects in the namespace
|
|
//
|
|
//
|
|
//*****************************************************************************
|
|
|
|
LPITEMIDLIST CCabFolder::CreateIDList(LPCTSTR pszName, DWORD dwFileSize,
|
|
UINT uFileDate, UINT uFileTime, UINT uFileAttribs)
|
|
{
|
|
// We'll assume no name is longer than MAX_PATH
|
|
// Note the terminating NULL is already in the sizeof(CABITEM)
|
|
BYTE bBuf[sizeof(CABITEM) + (sizeof(TCHAR) * MAX_PATH) + sizeof(WORD)];
|
|
CABITEM *pci = (CABITEM*)bBuf;
|
|
|
|
UINT uNameLen = lstrlen(pszName);
|
|
if (uNameLen >= MAX_PATH)
|
|
{
|
|
uNameLen = MAX_PATH;
|
|
}
|
|
|
|
pci->wSize = (WORD)(sizeof(CABITEM) + (sizeof(TCHAR) * uNameLen));
|
|
pci->dwFileSize = dwFileSize;
|
|
pci->uFileDate = (USHORT)uFileDate;
|
|
pci->uFileTime = (USHORT)uFileTime;
|
|
pci->uFileAttribs = (USHORT)uFileAttribs & (FILE_ATTRIBUTE_READONLY|
|
|
FILE_ATTRIBUTE_HIDDEN |
|
|
FILE_ATTRIBUTE_SYSTEM |
|
|
FILE_ATTRIBUTE_ARCHIVE);
|
|
lstrcpynW(pci->szName, pszName, uNameLen+1);
|
|
pci->cPathChars = 0;
|
|
LPCTSTR psz = pszName;
|
|
while (*psz)
|
|
{
|
|
if ((*psz == TEXT(':')) || (*psz == TEXT('/')) || (*psz == TEXT('\\')))
|
|
{
|
|
pci->cPathChars = (USHORT)(psz - pszName) + 1;
|
|
}
|
|
|
|
psz = CharNext(psz);
|
|
}
|
|
|
|
// Terminate the IDList
|
|
*(WORD *)(((LPSTR)pci)+pci->wSize) = 0;
|
|
|
|
return(ILClone((LPCITEMIDLIST)pci));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// CCabFolder::GetPath
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Get the Path for the current pidl
|
|
//
|
|
// Parameters:
|
|
//
|
|
// LPSTR szPath - return pointer for path string
|
|
//
|
|
// Comments:
|
|
//
|
|
//*****************************************************************************
|
|
|
|
BOOL CCabFolder::GetPath(LPTSTR szPath)
|
|
{
|
|
if (!m_pidlHere || !SHGetPathFromIDList(m_pidlHere, szPath))
|
|
{
|
|
*szPath = TEXT('\0');
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
// NOTE: we use GetShortPathName() to avoid losing characters during the
|
|
// UNICODE->ANSI->UNICODE roundtrip while calling FDICopy()
|
|
// NOTE: It is valid for GetShortPathName()'s src and dest pointers to be the same
|
|
|
|
// If this fails, we'll just ignore the error and try to use the long path name
|
|
GetShortPathName(szPath, szPath, MAX_PATH);
|
|
#endif // UNICODE
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
void CCabFolder::GetNameOf(LPCABITEM pit, LPSTRRET lpName)
|
|
{
|
|
#ifdef UNICODE
|
|
lpName->uType = STRRET_WSTR;
|
|
lpName->pOleStr = NULL;
|
|
#else
|
|
lpName->uType = STRRET_CSTR;
|
|
lpName->cStr[0] = '\0';
|
|
#endif
|
|
|
|
LPCWSTR pszName;
|
|
WSTR_ALIGNED_STACK_COPY(&pszName, pit->szName);
|
|
|
|
SHFILEINFO sfi;
|
|
if (SHGetFileInfo(pszName + pit->cPathChars, 0, &sfi, sizeof(sfi),
|
|
SHGFI_USEFILEATTRIBUTES | SHGFI_DISPLAYNAME))
|
|
{
|
|
StringToStrRet(sfi.szDisplayName, lpName);
|
|
}
|
|
}
|
|
|
|
|
|
void CCabFolder::GetPathOf(LPCABITEM pit, LPSTRRET lpName)
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
ualstrcpynW(szPath, pit->szName, ARRAYSIZE(szPath));
|
|
szPath[pit->cPathChars] = TEXT('\0');
|
|
StringToStrRet(szPath, lpName);
|
|
}
|
|
|
|
|
|
void CCabFolder::GetTypeOf(LPCABITEM pit, LPSTRRET lpName)
|
|
{
|
|
#ifdef UNICODE
|
|
lpName->uType = STRRET_WSTR;
|
|
lpName->pOleStr = NULL;
|
|
#else
|
|
lpName->uType = STRRET_CSTR;
|
|
lpName->cStr[0] = '\0';
|
|
#endif
|
|
|
|
LPCWSTR pszName;
|
|
WSTR_ALIGNED_STACK_COPY(&pszName, pit->szName);
|
|
|
|
SHFILEINFO sfi;
|
|
if (SHGetFileInfo(pszName + pit->cPathChars, 0, &sfi, sizeof(sfi),
|
|
SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME))
|
|
{
|
|
StringToStrRet(sfi.szTypeName, lpName);
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// CCabFolder::EnumToList
|
|
//
|
|
// Purpose:
|
|
//
|
|
// This notify callback is called by the FDI routines. It adds the
|
|
// file object from the cab file to the list.
|
|
//
|
|
// Parameters:
|
|
//
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
//*****************************************************************************
|
|
|
|
|
|
void CALLBACK CCabFolder::EnumToList(LPCTSTR pszFile, DWORD dwSize, UINT date,
|
|
UINT time, UINT attribs, LPARAM lParam)
|
|
{
|
|
CCabFolder *pThis = (CCabFolder *)lParam;
|
|
|
|
pThis->m_lItems.AddItem(pszFile, dwSize, date, time, attribs);
|
|
}
|
|
|
|
|
|
HRESULT CCabFolder::InitItems()
|
|
{
|
|
switch (m_lItems.GetState())
|
|
{
|
|
case CCabItemList::State_Init:
|
|
return NOERROR;
|
|
|
|
case CCabItemList::State_OutOfMem:
|
|
return E_OUTOFMEMORY;
|
|
|
|
case CCabItemList::State_UnInit:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Force the list to initialize
|
|
m_lItems.InitList();
|
|
|
|
TCHAR szHere[MAX_PATH];
|
|
|
|
// the m_pidl has been set to current dir
|
|
// get the path to the current directory
|
|
if (!GetPath(szHere))
|
|
{
|
|
return(E_UNEXPECTED);
|
|
}
|
|
|
|
CCabItems ciHere(szHere);
|
|
|
|
if (!ciHere.EnumItems(EnumToList, (LPARAM)this))
|
|
{
|
|
return(E_UNEXPECTED);
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT CabFolder_CreateInstance(REFIID riid, void **ppvObj)
|
|
{
|
|
HRESULT hres;
|
|
|
|
*ppvObj = NULL;
|
|
|
|
HINSTANCE hCabinetDll = LoadLibrary(TEXT("CABINET.DLL"));
|
|
if (hCabinetDll)
|
|
{
|
|
FreeLibrary(hCabinetDll);
|
|
|
|
CCabFolder *pfolder = new CCabFolder;
|
|
if (pfolder)
|
|
hres = pfolder->QueryInterface(riid, ppvObj);
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
hres = E_UNEXPECTED;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
UINT CCabItemList::GetState()
|
|
{
|
|
if (m_uStep == 0)
|
|
{
|
|
if (m_dpaList)
|
|
{
|
|
return(State_Init);
|
|
}
|
|
|
|
return(State_OutOfMem);
|
|
}
|
|
|
|
return(State_UnInit);
|
|
}
|
|
|
|
|
|
BOOL CCabItemList::StoreItem(LPITEMIDLIST pidl)
|
|
{
|
|
if (pidl)
|
|
{
|
|
if (InitList() && DPA_InsertPtr(m_dpaList, 0x7fff, (LPSTR)pidl)>=0)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
ILFree(pidl);
|
|
}
|
|
|
|
CleanList();
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL CCabItemList::AddItems(LPCABITEM *apit, UINT cpit)
|
|
{
|
|
for (UINT i=0; i<cpit; ++i)
|
|
{
|
|
if (!StoreItem(ILClone((LPCITEMIDLIST)apit[i])))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOL CCabItemList::AddItem(LPCTSTR pszName, DWORD dwFileSize,
|
|
UINT uFileDate, UINT uFileTime, UINT uFileAttribs)
|
|
{
|
|
return(StoreItem(CCabFolder::CreateIDList(pszName, dwFileSize, uFileDate, uFileTime,
|
|
uFileAttribs)));
|
|
}
|
|
|
|
|
|
int CCabItemList::FindInList(LPCTSTR pszName, DWORD dwFileSize,
|
|
UINT uFileDate, UINT uFileTime, UINT uFileAttribs)
|
|
{
|
|
// TODO: Linear search for now; binary later
|
|
for (int i=DPA_GetPtrCount(m_dpaList)-1; i>=0; --i)
|
|
{
|
|
LPCABITEM pcab = (*this)[i];
|
|
|
|
// all guys in the dpa are WORD-aligned but copy out anyway.
|
|
LPCWSTR pszNameCopy;
|
|
WSTR_ALIGNED_STACK_COPY(&pszNameCopy, pcab->szName);
|
|
|
|
if ((lstrcmpi(pszName, pszNameCopy) == 0) &&
|
|
(pcab->dwFileSize == dwFileSize) &&
|
|
(pcab->uFileDate == uFileDate) &&
|
|
(pcab->uFileTime == uFileTime) &&
|
|
(pcab->uFileAttribs == uFileAttribs))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(i);
|
|
}
|
|
|
|
|
|
BOOL CCabItemList::InitList()
|
|
{
|
|
switch (GetState())
|
|
{
|
|
case State_Init:
|
|
return(TRUE);
|
|
|
|
case State_OutOfMem:
|
|
return FALSE;
|
|
|
|
case State_UnInit:
|
|
default:
|
|
m_dpaList = DPA_Create(m_uStep);
|
|
m_uStep = 0;
|
|
|
|
return(InitList());
|
|
}
|
|
}
|
|
|
|
|
|
void CCabItemList::CleanList()
|
|
{
|
|
if (m_uStep != 0)
|
|
{
|
|
m_dpaList = NULL;
|
|
m_uStep = 0;
|
|
return;
|
|
}
|
|
|
|
if (!m_dpaList)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i=DPA_GetPtrCount(m_dpaList)-1; i>=0; --i)
|
|
{
|
|
ILFree((LPITEMIDLIST)((*this)[i]));
|
|
}
|
|
|
|
DPA_Destroy(m_dpaList);
|
|
m_dpaList = NULL;
|
|
}
|