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.
6032 lines
198 KiB
6032 lines
198 KiB
#include "local.h"
|
|
|
|
#include "resource.h"
|
|
#include "cachesrch.h"
|
|
#include "sfview.h"
|
|
#include <shlwapi.h>
|
|
#include <limits.h>
|
|
#include "chcommon.h"
|
|
#include "hsfolder.h"
|
|
|
|
#include <mluisupp.h>
|
|
|
|
#define DM_HSFOLDER 0
|
|
|
|
#define DM_CACHESEARCH 0x40000000
|
|
|
|
const TCHAR c_szRegKeyTopNSites[] = TEXT("HistoryTopNSitesView");
|
|
#define REGKEYTOPNSITESLEN (ARRAYSIZE(c_szRegKeyTopNSites) - 1)
|
|
|
|
const TCHAR c_szHistPrefix[] = TEXT("Visited: ");
|
|
#define HISTPREFIXLEN (ARRAYSIZE(c_szHistPrefix)-1)
|
|
const TCHAR c_szHostPrefix[] = TEXT(":Host: ");
|
|
#define HOSTPREFIXLEN (ARRAYSIZE(c_szHostPrefix)-1)
|
|
const CHAR c_szIntervalPrefix[] = "MSHist";
|
|
#define INTERVALPREFIXLEN (ARRAYSIZE(c_szIntervalPrefix)-1)
|
|
const TCHAR c_szTextHeader[] = TEXT("Content-type: text/");
|
|
#define TEXTHEADERLEN (ARRAYSIZE(c_szTextHeader) - 1)
|
|
const TCHAR c_szHTML[] = TEXT("html");
|
|
#define HTMLLEN (ARRAYSIZE(c_szHTML) - 1)
|
|
#define TYPICAL_INTERVALS (4+7)
|
|
|
|
|
|
#define ALL_CHANGES (SHCNE_DELETE|SHCNE_MKDIR|SHCNE_RMDIR|SHCNE_CREATE|SHCNE_UPDATEDIR)
|
|
|
|
#define FORMAT_PARAMS (FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY|FORMAT_MESSAGE_MAX_WIDTH_MASK)
|
|
|
|
DWORD _DaysInInterval(HSFINTERVAL *pInterval);
|
|
void _KeyForInterval(HSFINTERVAL *pInterval, LPTSTR pszInterval, int cchInterval);
|
|
void _FileTimeDeltaDays(FILETIME *pftBase, FILETIME *pftNew, int Days);
|
|
|
|
// BEGIN OF JCORDELL CODE
|
|
#define QUANTA_IN_A_SECOND 10000000
|
|
#define SECONDS_IN_A_DAY 60 * 60 * 24
|
|
#define QUANTA_IN_A_DAY ((__int64) QUANTA_IN_A_SECOND * SECONDS_IN_A_DAY)
|
|
#define INT64_VALUE(pFT) ((((__int64)(pFT)->dwHighDateTime) << 32) + (__int64) (pFT)->dwLowDateTime)
|
|
#define DAYS_DIFF(s,e) ((int) (( INT64_VALUE(s) - INT64_VALUE(e) ) / QUANTA_IN_A_DAY))
|
|
|
|
BOOL GetDisplayNameForTimeInterval( const FILETIME *pStartTime, const FILETIME *pEndTime,
|
|
TCHAR *pszBuffer, int cchBuffer);
|
|
BOOL GetTooltipForTimeInterval( const FILETIME *pStartTime, const FILETIME *pEndTime,
|
|
TCHAR *pszBuffer, int cchBuffer);
|
|
// END OF JCORDELL CODE
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CHistFolderView Functions and Definitions
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
////////////////////////
|
|
//
|
|
// Column definition for the Cache Folder DefView
|
|
//
|
|
enum {
|
|
ICOLC_URL_SHORTNAME = 0,
|
|
ICOLC_URL_NAME,
|
|
ICOLC_URL_TYPE,
|
|
ICOLC_URL_SIZE,
|
|
ICOLC_URL_EXPIRES,
|
|
ICOLC_URL_MODIFIED,
|
|
ICOLC_URL_ACCESSED,
|
|
ICOLC_URL_LASTSYNCED,
|
|
ICOLC_URL_MAX // Make sure this is the last enum item
|
|
};
|
|
|
|
|
|
typedef struct _COLSPEC
|
|
{
|
|
short int iCol;
|
|
short int ids; // Id of string for title
|
|
short int cchCol; // Number of characters wide to make column
|
|
short int iFmt; // The format of the column;
|
|
} COLSPEC;
|
|
|
|
const COLSPEC s_HistIntervalFolder_cols[] = {
|
|
{ICOLH_URL_NAME, IDS_TIMEPERIOD_COL, 30, LVCFMT_LEFT},
|
|
};
|
|
|
|
const COLSPEC s_HistHostFolder_cols[] = {
|
|
{ICOLH_URL_NAME, IDS_HOSTNAME_COL, 30, LVCFMT_LEFT},
|
|
};
|
|
|
|
const COLSPEC s_HistFolder_cols[] = {
|
|
{ICOLH_URL_NAME, IDS_NAME_COL, 30, LVCFMT_LEFT},
|
|
{ICOLH_URL_TITLE, IDS_TITLE_COL, 30, LVCFMT_LEFT},
|
|
{ICOLH_URL_LASTVISITED, IDS_LASTVISITED_COL, 18, LVCFMT_LEFT},
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CreateSpecialViewPidl(USHORT usViewType, LPITEMIDLIST* ppidlOut, UINT cbExtra = 0, LPBYTE *ppbExtra = NULL);
|
|
|
|
HRESULT ConvertStandardHistPidlToSpecialViewPidl(LPCITEMIDLIST pidlStandardHist,
|
|
USHORT usViewType,
|
|
LPITEMIDLIST *ppidlOut);
|
|
|
|
#define IS_DIGIT_CHAR(x) (((x) >= '0') && ((x) <= '9'))
|
|
#define MIN_MM(x, y) (((x) < (y)) ? (x) : (y))
|
|
// _GetHostImportantPart:
|
|
// IN: pszHost -- a domain: for example, "www.wisc.edu"
|
|
// IN/ puLen -- the length of pszHost
|
|
// OUT: puLen -- the length of the new string
|
|
// RETURNS: The "important part" of a hostname (e.g. wisc)
|
|
//
|
|
// Another example: "www.foo.co.uk" ==> "foo"
|
|
|
|
LPTSTR _GetHostImportantPart(LPTSTR pszHost, UINT *puLen)
|
|
{
|
|
LPTSTR pszCurEndHostStr = pszHost + (*puLen - 1);
|
|
LPTSTR pszDomainBegin = pszHost;
|
|
LPTSTR pszSuffix, pszSuffix2;
|
|
UINT uSuffixLen;
|
|
BOOL fIsIP = FALSE;
|
|
LPTSTR pszTemp;
|
|
|
|
ASSERT(((UINT)lstrlen(pszHost)) == *puLen);
|
|
if (*puLen == 0)
|
|
return pszHost;
|
|
|
|
// Filter out IP Addresses
|
|
// Heurisitc: Everything after the last "dot"
|
|
// has to be a number.
|
|
for (pszTemp = (pszHost + *puLen - 1);
|
|
pszTemp >= pszHost; --pszTemp)
|
|
{
|
|
if (*pszTemp == '.')
|
|
break;
|
|
if (IS_DIGIT_CHAR(*pszTemp))
|
|
fIsIP = TRUE;
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (!fIsIP) {
|
|
// Now that we have the url we can strip
|
|
if ( ((StrCmpNI(TEXT("www."), pszHost, 4)) == 0) ||
|
|
((StrCmpNI(TEXT("ftp."), pszHost, 4)) == 0) )
|
|
pszDomainBegin += 4;
|
|
|
|
// try to strip out the suffix by finding the last "dot"
|
|
if ((pszSuffix = StrRChr(pszHost, pszCurEndHostStr, '.')) &&
|
|
(pszSuffix > pszDomainBegin) &&
|
|
((uSuffixLen = (UINT)(pszCurEndHostStr - pszSuffix)) <= 3)) {
|
|
// if it is before a two character country code then try
|
|
// to rip off some more.
|
|
if ( (uSuffixLen <= 2) &&
|
|
(pszSuffix2 = StrRChr(pszDomainBegin, pszSuffix - 1, '.')) &&
|
|
(pszSuffix2 > pszDomainBegin) &&
|
|
((pszSuffix - pszSuffix2) <= 4) )
|
|
pszSuffix = pszSuffix2;
|
|
}
|
|
else
|
|
pszSuffix = pszCurEndHostStr + 1;
|
|
|
|
*puLen = (UINT)(pszSuffix-pszDomainBegin);
|
|
}
|
|
return pszDomainBegin;
|
|
}
|
|
|
|
// a utility function for CHistFolder::GetDisplayNameOf
|
|
void _GetURLDispName(LPBASEPIDL pcei, LPTSTR pszName, UINT cchName)
|
|
{
|
|
TCHAR szStr[MAX_PATH];
|
|
UINT uHostLen, uImportantPartLen;
|
|
static TCHAR szBracketFmt[8] = TEXT(""); // " (%s)" with room for 0253 complex script marker char
|
|
|
|
ualstrcpyn(szStr, _GetURLTitle(pcei), ARRAYSIZE(szStr));
|
|
|
|
uImportantPartLen = uHostLen = lstrlen(szStr);
|
|
|
|
StrCpyN(pszName, _GetHostImportantPart(szStr, &uImportantPartLen), MIN_MM(uImportantPartLen + 1, cchName));
|
|
|
|
// don't add extra bit on the end if we haven't modified the string
|
|
if (uImportantPartLen != uHostLen && uImportantPartLen < cchName)
|
|
{
|
|
if (!szBracketFmt[0])
|
|
{
|
|
MLLoadString(IDS_HISTHOST_FMT, szBracketFmt, ARRAYSIZE(szBracketFmt));
|
|
}
|
|
|
|
wnsprintf(pszName + uImportantPartLen, cchName - uImportantPartLen, szBracketFmt, szStr);
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT HistFolderView_MergeMenu(UINT idMenu, LPQCMINFO pqcm)
|
|
{
|
|
HMENU hmenu = LoadMenu(MLGetHinst(), MAKEINTRESOURCE(idMenu));
|
|
if (hmenu)
|
|
{
|
|
MergeMenuHierarchy(pqcm->hmenu, hmenu, pqcm->idCmdFirst, pqcm->idCmdLast);
|
|
DestroyMenu(hmenu);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT HistFolderView_DidDragDrop(IDataObject *pdo, DWORD dwEffect)
|
|
{
|
|
if (dwEffect & DROPEFFECT_MOVE)
|
|
{
|
|
CHistItem *pHCItem;
|
|
BOOL fBulkDelete;
|
|
|
|
if (SUCCEEDED(pdo->QueryInterface(IID_IHist, (void **)&pHCItem)))
|
|
{
|
|
fBulkDelete = pHCItem->_cItems > LOTS_OF_FILES;
|
|
for (UINT i = 0; i < pHCItem->_cItems; i++)
|
|
{
|
|
if (DeleteUrlCacheEntry(HPidlToSourceUrl((LPBASEPIDL)pHCItem->_ppidl[i])))
|
|
{
|
|
if (!fBulkDelete)
|
|
{
|
|
_GenerateEvent(SHCNE_DELETE, pHCItem->_pHCFolder->_pidl, pHCItem->_ppidl[i], NULL);
|
|
}
|
|
}
|
|
}
|
|
if (fBulkDelete)
|
|
{
|
|
_GenerateEvent(SHCNE_UPDATEDIR, pHCItem->_pHCFolder->_pidl, NULL, NULL);
|
|
}
|
|
SHChangeNotifyHandleEvents();
|
|
pHCItem->Release();
|
|
return S_OK;
|
|
}
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
// There are copies of exactly this function in SHELL32
|
|
// Add the File Type page
|
|
HRESULT HistFolderView_OnAddPropertyPages(DWORD pv, SFVM_PROPPAGE_DATA * ppagedata)
|
|
{
|
|
IShellPropSheetExt * pspse;
|
|
HRESULT hr = CoCreateInstance(CLSID_FileTypes, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_PPV_ARG(IShellPropSheetExt, &pspse));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pspse->AddPages(ppagedata->pfn, ppagedata->lParam);
|
|
pspse->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT HistFolderView_OnGetSortDefaults(FOLDER_TYPE FolderType, int * piDirection, int * plParamSort)
|
|
{
|
|
*plParamSort = (int)ICOLH_URL_LASTVISITED;
|
|
*piDirection = 1;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CALLBACK CHistFolder::_sViewCallback(IShellView *psv, IShellFolder *psf,
|
|
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CHistFolder *pfolder = NULL;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case DVM_GETHELPTEXT:
|
|
{
|
|
TCHAR szText[MAX_PATH];
|
|
|
|
UINT id = LOWORD(wParam);
|
|
UINT cchBuf = HIWORD(wParam);
|
|
LPTSTR pszBuf = (LPTSTR)lParam;
|
|
|
|
MLLoadString(id + IDS_MH_FIRST, szText, ARRAYSIZE(szText));
|
|
|
|
// we know for a fact that this parameter is really a TCHAR
|
|
if ( IsOS( OS_NT ))
|
|
{
|
|
SHTCharToUnicode( szText, (LPWSTR) pszBuf, cchBuf );
|
|
}
|
|
else
|
|
{
|
|
SHTCharToAnsi( szText, (LPSTR) pszBuf, cchBuf );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SFVM_GETNOTIFY:
|
|
hr = psf->QueryInterface(CLSID_HistFolder, (void **)&pfolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*(LPCITEMIDLIST*)wParam = pfolder->_pidl; // evil alias
|
|
pfolder->Release();
|
|
}
|
|
else
|
|
wParam = 0;
|
|
*(LONG*)lParam = ALL_CHANGES;
|
|
break;
|
|
|
|
case DVM_DIDDRAGDROP:
|
|
hr = HistFolderView_DidDragDrop((IDataObject *)lParam, (DWORD)wParam);
|
|
break;
|
|
|
|
case DVM_INITMENUPOPUP:
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case DVM_INVOKECOMMAND:
|
|
_ArrangeFolder(hwnd, (UINT)wParam);
|
|
break;
|
|
|
|
case DVM_COLUMNCLICK:
|
|
ShellFolderView_ReArrange(hwnd, (UINT)wParam);
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case DVM_MERGEMENU:
|
|
hr = HistFolderView_MergeMenu(MENU_HISTORY, (LPQCMINFO)lParam);
|
|
break;
|
|
|
|
case DVM_DEFVIEWMODE:
|
|
*(FOLDERVIEWMODE *)lParam = FVM_DETAILS;
|
|
break;
|
|
|
|
case SFVM_ADDPROPERTYPAGES:
|
|
hr = HistFolderView_OnAddPropertyPages((DWORD)wParam, (SFVM_PROPPAGE_DATA *)lParam);
|
|
break;
|
|
|
|
case SFVM_GETSORTDEFAULTS:
|
|
hr = psf->QueryInterface(CLSID_HistFolder, (void **)&pfolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HistFolderView_OnGetSortDefaults(pfolder->_foldertype, (int *)wParam, (int *)lParam);
|
|
pfolder->Release();
|
|
}
|
|
else
|
|
{
|
|
wParam = 0;
|
|
lParam = 0;
|
|
}
|
|
break;
|
|
|
|
case SFVM_UPDATESTATUSBAR:
|
|
ResizeStatusBar(hwnd, FALSE);
|
|
// We did not set any text; let defview do it
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
|
|
case SFVM_SIZE:
|
|
ResizeStatusBar(hwnd, FALSE);
|
|
break;
|
|
|
|
case SFVM_GETPANE:
|
|
if (wParam == PANE_ZONE)
|
|
*(DWORD*)lParam = 1;
|
|
else
|
|
*(DWORD*)lParam = PANE_NONE;
|
|
|
|
break;
|
|
case SFVM_WINDOWCREATED:
|
|
ResizeStatusBar(hwnd, TRUE);
|
|
break;
|
|
|
|
case SFVM_GETZONE:
|
|
*(DWORD*)lParam = URLZONE_LOCAL_MACHINE; // Internet by default
|
|
break;
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT HistFolderView_CreateInstance(CHistFolder *pHCFolder, void **ppv)
|
|
{
|
|
CSFV csfv;
|
|
|
|
csfv.cbSize = sizeof(csfv);
|
|
csfv.pshf = (IShellFolder *)pHCFolder;
|
|
csfv.psvOuter = NULL;
|
|
csfv.pidl = pHCFolder->_pidl;
|
|
csfv.lEvents = SHCNE_DELETE; // SHCNE_DISKEVENTS | SHCNE_ASSOCCHANGED | SHCNE_GLOBALEVENTS;
|
|
csfv.pfnCallback = CHistFolder::_sViewCallback;
|
|
csfv.fvm = (FOLDERVIEWMODE)0; // Have defview restore the folder view mode
|
|
|
|
return SHCreateShellFolderViewEx(&csfv, (IShellView**)ppv);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CHistFolderEnum Object
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
CHistFolderEnum::CHistFolderEnum(DWORD grfFlags, CHistFolder *pHCFolder)
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcfe - CHistFolderEnum() called");
|
|
_cRef = 1;
|
|
DllAddRef();
|
|
|
|
_grfFlags = grfFlags,
|
|
_pHCFolder = pHCFolder;
|
|
pHCFolder->AddRef();
|
|
ASSERT(_hEnum == NULL &&
|
|
_cbCurrentInterval == 0 &&
|
|
_cbIntervals == 0 &&
|
|
_pshHashTable == NULL &&
|
|
_polFrequentPages == NULL &&
|
|
_pIntervalCache == NULL);
|
|
|
|
}
|
|
|
|
CHistFolderEnum::~CHistFolderEnum()
|
|
{
|
|
ASSERT(_cRef == 0); // we should always have a zero ref count here
|
|
TraceMsg(DM_HSFOLDER, "hcfe - ~CHistFolderEnum() called.");
|
|
_pHCFolder->Release();
|
|
if (_pceiWorking)
|
|
{
|
|
LocalFree(_pceiWorking);
|
|
_pceiWorking = NULL;
|
|
}
|
|
if (_pIntervalCache)
|
|
{
|
|
LocalFree(_pIntervalCache);
|
|
_pIntervalCache = NULL;
|
|
}
|
|
|
|
if (_hEnum)
|
|
{
|
|
FindCloseUrlCache(_hEnum);
|
|
_hEnum = NULL;
|
|
}
|
|
if (_pshHashTable)
|
|
delete _pshHashTable;
|
|
if (_polFrequentPages)
|
|
delete _polFrequentPages;
|
|
if (_pstatenum)
|
|
_pstatenum->Release();
|
|
DllRelease();
|
|
}
|
|
|
|
|
|
HRESULT CHistFolderEnum_CreateInstance(DWORD grfFlags, CHistFolder *pHCFolder, IEnumIDList **ppeidl)
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcfe - CreateInstance() called.");
|
|
|
|
*ppeidl = NULL; // null the out param
|
|
|
|
CHistFolderEnum *pHCFE = new CHistFolderEnum(grfFlags, pHCFolder);
|
|
if (!pHCFE)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*ppeidl = pHCFE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CHistFolderEnum, IEnumIDList),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
ULONG CHistFolderEnum::AddRef(void)
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG CHistFolderEnum::Release(void)
|
|
{
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::_NextHistInterval(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPBASEPIDL pcei = NULL;
|
|
TCHAR szCurrentInterval[INTERVAL_SIZE+1];
|
|
|
|
// chrisfra 3/27/97 on NT cache files are per user, not so on win95. how do
|
|
// we manage containers on win95 if different users are specified different history
|
|
// intervals
|
|
|
|
if (0 == _cbCurrentInterval)
|
|
{
|
|
hr = _pHCFolder->_ValidateIntervalCache();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = S_OK;
|
|
ENTERCRITICAL;
|
|
if (_pIntervalCache)
|
|
{
|
|
LocalFree(_pIntervalCache);
|
|
_pIntervalCache = NULL;
|
|
}
|
|
if (_pHCFolder->_pIntervalCache)
|
|
{
|
|
_pIntervalCache = (HSFINTERVAL *)LocalAlloc(LPTR,
|
|
_pHCFolder->_cbIntervals*sizeof(HSFINTERVAL));
|
|
if (_pIntervalCache == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
_cbIntervals = _pHCFolder->_cbIntervals;
|
|
CopyMemory(_pIntervalCache,
|
|
_pHCFolder->_pIntervalCache,
|
|
_cbIntervals*sizeof(HSFINTERVAL));
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
}
|
|
|
|
if (_pIntervalCache && _cbCurrentInterval < _cbIntervals)
|
|
{
|
|
_KeyForInterval(&_pIntervalCache[_cbCurrentInterval], szCurrentInterval,
|
|
ARRAYSIZE(szCurrentInterval));
|
|
pcei = _CreateIdCacheFolderPidl(TRUE,
|
|
_pIntervalCache[_cbCurrentInterval].usSign,
|
|
szCurrentInterval);
|
|
_cbCurrentInterval++;
|
|
}
|
|
if (pcei)
|
|
{
|
|
rgelt[0] = (LPITEMIDLIST)pcei;
|
|
if (pceltFetched) *pceltFetched = 1;
|
|
}
|
|
else
|
|
{
|
|
if (pceltFetched) *pceltFetched = 0;
|
|
rgelt[0] = NULL;
|
|
hr = S_FALSE;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// This function dispatches the different "views" on History that are possible
|
|
HRESULT CHistFolderEnum::_NextViewPart(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
switch(_pHCFolder->_uViewType) {
|
|
case VIEWPIDL_SEARCH:
|
|
return _NextViewPart_OrderSearch(celt, rgelt, pceltFetched);
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
return _NextViewPart_OrderToday(celt, rgelt, pceltFetched);
|
|
case VIEWPIDL_ORDER_SITE:
|
|
return _NextViewPart_OrderSite(celt, rgelt, pceltFetched);
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
return _NextViewPart_OrderFreq(celt, rgelt, pceltFetched);
|
|
default:
|
|
return E_NOTIMPL;
|
|
}
|
|
}
|
|
|
|
LPITEMIDLIST _Combine_ViewPidl(USHORT usViewType, LPITEMIDLIST pidl);
|
|
|
|
// This function wraps wininet's Find(First/Next)UrlCacheEntry API
|
|
// returns DWERROR code or zero if successful
|
|
DWORD _FindURLCacheEntry(IN LPCTSTR pszCachePrefix,
|
|
IN OUT LPINTERNET_CACHE_ENTRY_INFO pcei,
|
|
IN OUT HANDLE &hEnum,
|
|
IN OUT LPDWORD pdwBuffSize)
|
|
{
|
|
if (!hEnum)
|
|
{
|
|
if (! (hEnum = FindFirstUrlCacheEntry(pszCachePrefix, pcei, pdwBuffSize)) )
|
|
return GetLastError();
|
|
}
|
|
else if (!FindNextUrlCacheEntry(hEnum, pcei, pdwBuffSize))
|
|
return GetLastError();
|
|
return S_OK;
|
|
}
|
|
|
|
// Thie function provides an iterator over all entries in all (MSHIST-type) buckets
|
|
// in the cache
|
|
DWORD _FindURLFlatCacheEntry(IN HSFINTERVAL *pIntervalCache,
|
|
IN LPTSTR pszUserName, // filter out cache entries owned by user
|
|
IN BOOL fHostEntry, // retrieve host entries only (FALSE), or no host entries (TRUE)
|
|
IN OUT int &cbCurrentInterval, // should begin at the maximum number of intervals
|
|
IN OUT LPINTERNET_CACHE_ENTRY_INFO pcei,
|
|
IN OUT HANDLE &hEnum,
|
|
IN OUT LPDWORD pdwBuffSize
|
|
)
|
|
{
|
|
DWORD dwStoreBuffSize = *pdwBuffSize;
|
|
DWORD dwResult = ERROR_NO_MORE_ITEMS;
|
|
while (cbCurrentInterval >= 0)
|
|
{
|
|
if ((dwResult = _FindURLCacheEntry(pIntervalCache[cbCurrentInterval].szPrefix,
|
|
pcei, hEnum, pdwBuffSize)) != S_OK)
|
|
{
|
|
if (dwResult == ERROR_NO_MORE_ITEMS)
|
|
{
|
|
// This bucket is done, now go get the next one
|
|
FindCloseUrlCache(hEnum);
|
|
hEnum = NULL;
|
|
--cbCurrentInterval;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Do requested filtering...
|
|
BOOL fIsHost = (StrStr(pcei->lpszSourceUrlName, c_szHostPrefix) == NULL);
|
|
if ( ((!pszUserName) || // if requested, filter username
|
|
_FilterUserName(pcei, pIntervalCache[cbCurrentInterval].szPrefix, pszUserName)) &&
|
|
((!fHostEntry && !fIsHost) || // filter for host entries
|
|
(fHostEntry && fIsHost)) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// reset for next iteration
|
|
*pdwBuffSize = dwStoreBuffSize;
|
|
}
|
|
return dwResult;
|
|
}
|
|
|
|
// This guy will search the flat cache (MSHist buckets) for a particular URL
|
|
// * This function assumes that the Interval cache is good and loaded
|
|
// RETURNS: Windows Error code
|
|
DWORD CHistFolder::_SearchFlatCacheForUrl(LPCTSTR pszUrl, LPINTERNET_CACHE_ENTRY_INFO pcei, LPDWORD pdwBuffSize)
|
|
{
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = ARRAYSIZE(szUserName);
|
|
|
|
if (FAILED(_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
UINT uSuffixLen = lstrlen(pszUrl) + lstrlen(szUserName) + 1; // extra 1 for '@'
|
|
LPTSTR pszPrefixedUrl = ((LPTSTR)LocalAlloc(LPTR, (PREFIX_SIZE + uSuffixLen + 1) * sizeof(TCHAR)));
|
|
DWORD dwError = ERROR_FILE_NOT_FOUND;
|
|
|
|
if (pszPrefixedUrl != NULL)
|
|
{
|
|
// pszPrefixedUrl will have the format of "PREFIX username@
|
|
wnsprintf(pszPrefixedUrl + PREFIX_SIZE, uSuffixLen + 1, TEXT("%s@%s"), szUserName, pszUrl);
|
|
|
|
for (int i =_cbIntervals - 1; i >= 0; --i)
|
|
{
|
|
// memcpy doesn't null terminate
|
|
memcpy(pszPrefixedUrl, _pIntervalCache[i].szPrefix, PREFIX_SIZE * sizeof(TCHAR));
|
|
if (GetUrlCacheEntryInfo(pszPrefixedUrl, pcei, pdwBuffSize))
|
|
{
|
|
dwError = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
else if ( ((dwError = GetLastError()) != ERROR_FILE_NOT_FOUND) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
LocalFree(pszPrefixedUrl);
|
|
pszPrefixedUrl = NULL;
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Most Frequently Visited Sites;
|
|
|
|
// this structure is used by the enumeration of the cache
|
|
// to get the most frequently seen sites
|
|
class OrderList_CacheElement : public OrderedList::Element
|
|
{
|
|
public:
|
|
LPTSTR pszUrl;
|
|
DWORD dwHitRate;
|
|
__int64 llPriority;
|
|
int nDaysSinceLastHit;
|
|
LPSTATURL lpSTATURL;
|
|
|
|
static FILETIME ftToday;
|
|
static BOOL fInited;
|
|
|
|
OrderList_CacheElement(LPTSTR pszStr, DWORD dwHR, LPSTATURL lpSU)
|
|
{
|
|
s_initToday();
|
|
ASSERT(pszStr);
|
|
pszUrl = (pszStr ? StrDup(pszStr) : StrDup(TEXT("")));
|
|
dwHitRate = dwHR;
|
|
lpSTATURL = lpSU;
|
|
|
|
nDaysSinceLastHit = DAYS_DIFF(&ftToday, &(lpSTATURL->ftLastVisited));
|
|
|
|
// prevent division by zero
|
|
if (nDaysSinceLastHit < 0)
|
|
nDaysSinceLastHit = 0;
|
|
// scale division up by a little less than half of the __int64
|
|
llPriority = ((((__int64)dwHitRate) * LONG_MAX) /
|
|
((__int64)(nDaysSinceLastHit + 1)));
|
|
//dPriority = ((double)dwHitRate / (double)(nDaysSinceLastHit + 1));
|
|
}
|
|
|
|
virtual int compareWith(OrderedList::Element *pelt)
|
|
{
|
|
OrderList_CacheElement *polce;
|
|
if (pelt)
|
|
{
|
|
polce = reinterpret_cast<OrderList_CacheElement *>(pelt);
|
|
// we're cheating here a bit by returning 1 instead of testing
|
|
// for equality, but that's ok...
|
|
// return ( (dwHitRate < polce->dwHitRate) ? -1 : 1 );
|
|
return ( (llPriority < polce->llPriority) ? -1 : 1 );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
virtual ~OrderList_CacheElement()
|
|
{
|
|
if (pszUrl)
|
|
{
|
|
LocalFree(pszUrl);
|
|
pszUrl = NULL;
|
|
}
|
|
|
|
if (lpSTATURL)
|
|
{
|
|
if (lpSTATURL->pwcsUrl)
|
|
OleFree(lpSTATURL->pwcsUrl);
|
|
if (lpSTATURL->pwcsTitle)
|
|
OleFree(lpSTATURL->pwcsTitle);
|
|
delete lpSTATURL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
friend ostream& operator<<(ostream& os, OrderList_CacheElement& olce) {
|
|
os << " (" << olce.dwHitRate << "; " << olce.nDaysSinceLastHit
|
|
<< " days; pri=" << olce.llPriority << ") " << olce.pszUrl;
|
|
return os;
|
|
}
|
|
*/
|
|
|
|
static void s_initToday()
|
|
{
|
|
if (!fInited)
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
GetLocalTime(&sysTime);
|
|
SystemTimeToFileTime(&sysTime, &ftToday);
|
|
fInited = TRUE;
|
|
}
|
|
}
|
|
};
|
|
|
|
FILETIME OrderList_CacheElement::ftToday;
|
|
BOOL OrderList_CacheElement::fInited = FALSE;
|
|
|
|
// caller must delete OrderedList
|
|
OrderedList* CHistFolderEnum::_GetMostFrequentPages()
|
|
{
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1;
|
|
if (FAILED(_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
UINT uUserNameLen = lstrlen(szUserName);
|
|
|
|
// reinit the current time
|
|
OrderList_CacheElement::fInited = FALSE;
|
|
IUrlHistoryPriv *pUrlHistStg = _pHCFolder->_GetHistStg();
|
|
OrderedList *pol = NULL;
|
|
|
|
if (pUrlHistStg)
|
|
{
|
|
IEnumSTATURL *penum = NULL;
|
|
if (SUCCEEDED(pUrlHistStg->EnumUrls(&penum)) && penum)
|
|
{
|
|
DWORD dwSites = -1;
|
|
DWORD dwType = REG_DWORD;
|
|
DWORD dwSize = sizeof(DWORD);
|
|
|
|
EVAL(SHRegGetUSValue(REGSTR_PATH_MAIN, c_szRegKeyTopNSites, &dwType,
|
|
(void *)&dwSites, &dwSize, FALSE,
|
|
(void *)&dwSites, dwSize) == ERROR_SUCCESS);
|
|
|
|
if ( (dwType != REG_DWORD) ||
|
|
(dwSize != sizeof(DWORD)) ||
|
|
((int)dwSites < 0) )
|
|
{
|
|
dwSites = NUM_TOP_SITES;
|
|
SHRegSetUSValue(REGSTR_PATH_MAIN, c_szRegKeyTopNSites, REG_DWORD,
|
|
(void *)&dwSites, dwSize, SHREGSET_HKCU);
|
|
|
|
dwSites = NUM_TOP_SITES;
|
|
}
|
|
|
|
pol = new OrderedList(dwSites);
|
|
if (pol)
|
|
{
|
|
STATURL *psuThis = new STATURL;
|
|
if (psuThis)
|
|
{
|
|
penum->SetFilter(NULL, STATURL_QUERYFLAG_TOPLEVEL);
|
|
|
|
while (pol) {
|
|
psuThis->cbSize = sizeof(STATURL);
|
|
psuThis->pwcsUrl = NULL;
|
|
psuThis->pwcsTitle = NULL;
|
|
|
|
ULONG cFetched;
|
|
|
|
if (SUCCEEDED(penum->Next(1, psuThis, &cFetched)) && cFetched)
|
|
{
|
|
// test: the url (taken from the VISITED history bucket) is a "top-level"
|
|
// url that would be in the MSHIST (displayed to user) history bucket
|
|
// things ommitted will be certain error urls and frame children pages etc...
|
|
if ( (psuThis->dwFlags & STATURLFLAG_ISTOPLEVEL) &&
|
|
(psuThis->pwcsUrl) &&
|
|
(!IsErrorUrl(psuThis->pwcsUrl)) )
|
|
{
|
|
UINT uUrlLen = lstrlenW(psuThis->pwcsUrl);
|
|
UINT uPrefixLen = HISTPREFIXLEN + uUserNameLen + 1; // '@' and '\0'
|
|
LPTSTR pszPrefixedUrl =
|
|
((LPTSTR)LocalAlloc(LPTR, (uUrlLen + uPrefixLen + 1) * sizeof(TCHAR)));
|
|
if (pszPrefixedUrl)
|
|
{
|
|
wnsprintf(pszPrefixedUrl, uPrefixLen + 1 , TEXT("%s%s@"), c_szHistPrefix, szUserName);
|
|
|
|
StrCpyN(pszPrefixedUrl + uPrefixLen, psuThis->pwcsUrl, uUrlLen + 1);
|
|
|
|
PROPVARIANT vProp = {0};
|
|
if (SUCCEEDED(pUrlHistStg->GetProperty(pszPrefixedUrl + uPrefixLen,
|
|
PID_INTSITE_VISITCOUNT, &vProp)) &&
|
|
(vProp.vt == VT_UI4))
|
|
{
|
|
pol->insert(new OrderList_CacheElement(pszPrefixedUrl,
|
|
vProp.lVal,
|
|
psuThis));
|
|
// OrderList now owns this -- he'll free it
|
|
psuThis = new STATURL;
|
|
if (psuThis)
|
|
{
|
|
psuThis->cbSize = sizeof(STATURL);
|
|
psuThis->pwcsUrl = NULL;
|
|
psuThis->pwcsTitle = NULL;
|
|
}
|
|
else if (pol) {
|
|
delete pol;
|
|
pol = NULL;
|
|
}
|
|
}
|
|
|
|
LocalFree(pszPrefixedUrl);
|
|
pszPrefixedUrl = NULL;
|
|
}
|
|
else if (pol)
|
|
{ // couldn't allocate
|
|
delete pol;
|
|
pol = NULL;
|
|
}
|
|
}
|
|
if (psuThis && psuThis->pwcsUrl)
|
|
OleFree(psuThis->pwcsUrl);
|
|
|
|
if (psuThis && psuThis->pwcsTitle)
|
|
OleFree(psuThis->pwcsTitle);
|
|
}
|
|
else // nothing more from the enumeration...
|
|
break;
|
|
} //while
|
|
if (psuThis)
|
|
delete psuThis;
|
|
}
|
|
else if (pol) { //allocation failed
|
|
delete pol;
|
|
pol = NULL;
|
|
}
|
|
}
|
|
penum->Release();
|
|
}
|
|
/* DWORD dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
DWORD dwError; */
|
|
|
|
// This commented-out code does the same thing WITHOUT going through
|
|
// the IUrlHistoryPriv interface, but, instead going directly
|
|
// to wininet
|
|
/*
|
|
while ((dwError = _FindURLCacheEntry(c_szHistPrefix, _pceiWorking,
|
|
_hEnum, &dwBuffSize)) == S_OK) {
|
|
// if its a top-level history guy && is cache entry to valid username
|
|
if ( (((HISTDATA *)_pceiWorking->lpHeaderInfo)->dwFlags & PIDISF_HISTORY) && //top-level
|
|
(_FilterUserName(_pceiWorking, c_szHistPrefix, szUserName)) ) // username is good
|
|
{
|
|
// perf: we can avoid needlessly creating new cache elements if we're less lazy
|
|
pol->insert(new OrderList_CacheElement(_pceiWorking->lpszSourceUrlName,
|
|
_pceiWorking->dwHitRate,
|
|
_pceiWorking->LastModifiedTime));
|
|
}
|
|
dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
}
|
|
ASSERT(dwError == ERROR_NO_MORE_ITEMS);
|
|
*/
|
|
pUrlHistStg->Release();
|
|
} // no storage
|
|
|
|
return pol;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::_NextViewPart_OrderFreq(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if ( (!_polFrequentPages) && (!(_polFrequentPages = _GetMostFrequentPages())) )
|
|
return E_FAIL;
|
|
|
|
if (rgelt && pceltFetched) {
|
|
// loop to fetch as many elements as requested.
|
|
for (*pceltFetched = 0; *pceltFetched < celt;) {
|
|
// contruct a pidl out of the first element in the orderedlist cache
|
|
OrderList_CacheElement *polce = reinterpret_cast<OrderList_CacheElement *>
|
|
(_polFrequentPages->removeFirst());
|
|
if (polce) {
|
|
if (!(rgelt[*pceltFetched] =
|
|
reinterpret_cast<LPITEMIDLIST>
|
|
(_CreateHCacheFolderPidl(TRUE,
|
|
polce->pszUrl, polce->lpSTATURL->ftLastVisited,
|
|
polce->lpSTATURL,
|
|
polce->llPriority,
|
|
polce->dwHitRate))))
|
|
{
|
|
delete polce;
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
++(*pceltFetched);
|
|
delete polce;
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
hr = S_FALSE; // no more...
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// The Next method for view -- Order by Site
|
|
HRESULT CHistFolderEnum::_NextViewPart_OrderSite(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
DWORD dwError = S_OK;
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1; // len of this buffer
|
|
LPCTSTR pszStrippedUrl, pszHost, pszCachePrefix = NULL;
|
|
LPITEMIDLIST pcei = NULL;
|
|
LPCTSTR pszHostToMatch = NULL;
|
|
UINT nHostToMatchLen = 0;
|
|
|
|
if (FAILED(_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
if ((!_pceiWorking) &&
|
|
(!(_pceiWorking = (LPINTERNET_CACHE_ENTRY_INFO)LocalAlloc(LPTR, MAX_URLCACHE_ENTRY))))
|
|
return E_OUTOFMEMORY;
|
|
|
|
DWORD dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
|
|
// load all the intervals and do some cache maintenance:
|
|
if (FAILED(_pHCFolder->_ValidateIntervalCache()))
|
|
return E_OUTOFMEMORY;
|
|
|
|
/* To get all sites, we will search all the history buckets
|
|
for "Host"-type entries. These entries will be put into
|
|
a hash table as we enumerate so that redundant results are
|
|
not returned. */
|
|
|
|
if (!_pshHashTable)
|
|
{
|
|
// start a new case-insensitive hash table
|
|
_pshHashTable = new StrHash(TRUE);
|
|
if (_pshHashTable == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
// if we are looking for individual pages within a host,
|
|
// then we must find which host to match...
|
|
if (_pHCFolder->_uViewDepth == 1) {
|
|
LPCITEMIDLIST pidlHost = ILFindLastID(_pHCFolder->_pidl);
|
|
ASSERT(_IsValid_IDPIDL(pidlHost) &&
|
|
EQUIV_IDSIGN(((LPBASEPIDL)pidlHost)->usSign, IDDPIDL_SIGN));
|
|
ua_GetURLTitle( &pszHostToMatch, (LPBASEPIDL)pidlHost );
|
|
nHostToMatchLen = (pszHostToMatch ? lstrlen(pszHostToMatch) : 0);
|
|
|
|
}
|
|
|
|
// iterate backwards through containers so most recent
|
|
// information gets put into the final pidl
|
|
if (!_hEnum)
|
|
_cbCurrentInterval = (_pHCFolder->_cbIntervals - 1);
|
|
|
|
while((dwError = _FindURLFlatCacheEntry(_pHCFolder->_pIntervalCache, szUserName,
|
|
(_pHCFolder->_uViewDepth == 1),
|
|
_cbCurrentInterval,
|
|
_pceiWorking, _hEnum, &dwBuffSize)) == S_OK)
|
|
{
|
|
// reset for next iteration
|
|
dwBuffSize = MAX_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
// this guy takes out the "t-marcmi@" part of the URL
|
|
pszStrippedUrl = _StripHistoryUrlToUrl(_pceiWorking->lpszSourceUrlName);
|
|
if (_pHCFolder->_uViewDepth == 0) {
|
|
if ((DWORD)lstrlen(pszStrippedUrl) > HOSTPREFIXLEN) {
|
|
pszHost = &pszStrippedUrl[HOSTPREFIXLEN];
|
|
// insertUnique returns non-NULL if this key already exists
|
|
if (_pshHashTable->insertUnique(pszHost, TRUE, reinterpret_cast<void *>(1)))
|
|
continue; // already given out
|
|
pcei = (LPITEMIDLIST)_CreateIdCacheFolderPidl(TRUE, IDDPIDL_SIGN, pszHost);
|
|
}
|
|
break;
|
|
}
|
|
else if (_pHCFolder->_uViewDepth == 1) {
|
|
TCHAR szHost[INTERNET_MAX_HOST_NAME_LENGTH+1];
|
|
// is this entry a doc from the host we're looking for?
|
|
_GetURLHost(_pceiWorking, szHost, INTERNET_MAX_HOST_NAME_LENGTH, _GetLocalHost());
|
|
|
|
if ( (!StrCmpI(szHost, pszHostToMatch)) &&
|
|
(!_pshHashTable->insertUnique(pszStrippedUrl,
|
|
TRUE, reinterpret_cast<void *>(1))) )
|
|
{
|
|
STATURL suThis;
|
|
HRESULT hrLocal = E_FAIL;
|
|
IUrlHistoryPriv *pUrlHistStg = _pHCFolder->_GetHistStg();
|
|
|
|
if (pUrlHistStg) {
|
|
hrLocal = pUrlHistStg->QueryUrl(pszStrippedUrl, STATURL_QUERYFLAG_NOURL, &suThis);
|
|
pUrlHistStg->Release();
|
|
}
|
|
|
|
pcei = (LPITEMIDLIST)
|
|
_CreateHCacheFolderPidl(TRUE, _pceiWorking->lpszSourceUrlName,
|
|
_pceiWorking->LastModifiedTime,
|
|
(SUCCEEDED(hrLocal) ? &suThis : NULL), 0,
|
|
_pHCFolder->_GetHitCount(_StripHistoryUrlToUrl(_pceiWorking->lpszSourceUrlName)));
|
|
if (SUCCEEDED(hrLocal) && suThis.pwcsTitle)
|
|
OleFree(suThis.pwcsTitle);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pcei && rgelt) {
|
|
rgelt[0] = (LPITEMIDLIST)pcei;
|
|
if (pceltFetched)
|
|
*pceltFetched = 1;
|
|
}
|
|
else {
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
if (dwError != S_OK) {
|
|
if (pceltFetched)
|
|
*pceltFetched = 0;
|
|
if (_hEnum)
|
|
FindCloseUrlCache(_hEnum);
|
|
return S_FALSE;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
// "Next" method for View by "Order seen today"
|
|
HRESULT CHistFolderEnum::_NextViewPart_OrderToday(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
DWORD dwError = S_OK;
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1; // len of this buffer
|
|
LPCTSTR pszStrippedUrl, pszHost;
|
|
LPBASEPIDL pcei = NULL;
|
|
|
|
if (FAILED(_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
if ((!_pceiWorking) &&
|
|
(!(_pceiWorking = (LPINTERNET_CACHE_ENTRY_INFO)LocalAlloc(LPTR, MAX_URLCACHE_ENTRY))))
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!_hEnum) {
|
|
// load all the intervals and do some cache maintenance:
|
|
if (FAILED(_pHCFolder->_ValidateIntervalCache()))
|
|
return E_OUTOFMEMORY;
|
|
// get only entries for TODAY (important part)
|
|
SYSTEMTIME sysTime;
|
|
FILETIME fileTime;
|
|
GetLocalTime(&sysTime);
|
|
SystemTimeToFileTime(&sysTime, &fileTime);
|
|
if (FAILED(_pHCFolder->_GetInterval(&fileTime, FALSE, &_pIntervalCur)))
|
|
return E_FAIL; // couldn't get interval for Today
|
|
}
|
|
|
|
DWORD dwBuffSize = MAX_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
while ( (dwError = _FindURLCacheEntry(_pIntervalCur->szPrefix, _pceiWorking, _hEnum,
|
|
&dwBuffSize)) == S_OK )
|
|
{
|
|
dwBuffSize = MAX_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
// Make sure that his cache entry belongs to szUserName
|
|
if (_FilterUserName(_pceiWorking, _pIntervalCur->szPrefix, szUserName)) {
|
|
// this guy takes out the "t-marcmi@" part of the URL
|
|
pszStrippedUrl = _StripHistoryUrlToUrl(_pceiWorking->lpszSourceUrlName);
|
|
if ((DWORD)lstrlen(pszStrippedUrl) > HOSTPREFIXLEN) {
|
|
pszHost = &pszStrippedUrl[HOSTPREFIXLEN];
|
|
if (StrCmpNI(c_szHostPrefix, pszStrippedUrl, HOSTPREFIXLEN) == 0)
|
|
continue; // this is a HOST placeholder, not a real doc
|
|
}
|
|
|
|
IUrlHistoryPriv *pUrlHistStg = _pHCFolder->_GetHistStg();
|
|
STATURL suThis;
|
|
HRESULT hrLocal = E_FAIL;
|
|
|
|
if (pUrlHistStg) {
|
|
hrLocal = pUrlHistStg->QueryUrl(pszStrippedUrl, STATURL_QUERYFLAG_NOURL, &suThis);
|
|
pUrlHistStg->Release();
|
|
}
|
|
pcei = (LPBASEPIDL) _CreateHCacheFolderPidl(TRUE, _pceiWorking->lpszSourceUrlName,
|
|
_pceiWorking->LastModifiedTime,
|
|
(SUCCEEDED(hrLocal) ? &suThis : NULL), 0,
|
|
_pHCFolder->_GetHitCount(_StripHistoryUrlToUrl(_pceiWorking->lpszSourceUrlName)));
|
|
if (SUCCEEDED(hrLocal) && suThis.pwcsTitle)
|
|
OleFree(suThis.pwcsTitle);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pcei && rgelt) {
|
|
rgelt[0] = (LPITEMIDLIST)pcei;
|
|
if (pceltFetched)
|
|
*pceltFetched = 1;
|
|
}
|
|
|
|
if (dwError == ERROR_NO_MORE_ITEMS) {
|
|
if (pceltFetched)
|
|
*pceltFetched = 0;
|
|
if (_hEnum)
|
|
FindCloseUrlCache(_hEnum);
|
|
return S_FALSE;
|
|
}
|
|
else if (dwError == S_OK)
|
|
return S_OK;
|
|
else
|
|
return E_FAIL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
Search Mamagement Stuff:
|
|
|
|
In order to maintian state between binds to the IShellFolder from
|
|
the desktop, we base our state information for the searches off a
|
|
global database (linked list) that is keyed by a timestamp generated
|
|
when the search begins.
|
|
|
|
This FILETIME is in the pidl for the search.
|
|
********************************************************************/
|
|
|
|
class _CurrentSearches {
|
|
public:
|
|
LONG _cRef;
|
|
FILETIME _ftSearchKey;
|
|
LPWSTR _pwszSearchTarget;
|
|
IShellFolderSearchableCallback *_psfscOnAsyncSearch;
|
|
|
|
CacheSearchEngine::StreamSearcher _streamsearcher;
|
|
|
|
// Currently doing async search
|
|
BOOL _fSearchingAsync;
|
|
|
|
// On next pass, kill this search
|
|
BOOL _fKillSwitch;
|
|
|
|
// WARNING: DO NOT access these elements without a critical section!
|
|
_CurrentSearches *_pcsNext;
|
|
_CurrentSearches *_pcsPrev;
|
|
|
|
static _CurrentSearches* s_pcsCurrentCacheSearchThreads;
|
|
|
|
_CurrentSearches(FILETIME &ftSearchKey, LPCWSTR pwszSrch,
|
|
IShellFolderSearchableCallback *psfsc,
|
|
_CurrentSearches *pcsNext = s_pcsCurrentCacheSearchThreads) :
|
|
_streamsearcher(pwszSrch),
|
|
_fSearchingAsync(FALSE), _fKillSwitch(FALSE), _cRef(1)
|
|
{
|
|
_ftSearchKey = ftSearchKey;
|
|
_pcsNext = pcsNext;
|
|
_pcsPrev = NULL;
|
|
|
|
if (psfsc)
|
|
psfsc->AddRef();
|
|
|
|
_psfscOnAsyncSearch = psfsc;
|
|
SHStrDupW(pwszSrch, &_pwszSearchTarget);
|
|
}
|
|
|
|
ULONG AddRef() {
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG Release() {
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
// this will increment the refcount to be decremented by s_RemoveSearch
|
|
static void s_NewSearch(_CurrentSearches *pcsNew,
|
|
_CurrentSearches *&pcsHead = s_pcsCurrentCacheSearchThreads)
|
|
{
|
|
ENTERCRITICAL;
|
|
// make sure we're inserting at the front of the list
|
|
ASSERT(pcsNew->_pcsNext == pcsHead);
|
|
ASSERT(pcsNew->_pcsPrev == NULL);
|
|
|
|
pcsNew->AddRef();
|
|
if (pcsHead)
|
|
pcsHead->_pcsPrev = pcsNew;
|
|
pcsHead = pcsNew;
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
static void s_RemoveSearch(_CurrentSearches *pcsRemove,
|
|
_CurrentSearches *&pcsHead = s_pcsCurrentCacheSearchThreads);
|
|
|
|
// This searches for the search.
|
|
// To find this search searcher, use the search searcher searcher :)
|
|
static _CurrentSearches *s_FindSearch(const FILETIME &ftSearchKey,
|
|
_CurrentSearches *pcsHead = s_pcsCurrentCacheSearchThreads);
|
|
|
|
protected:
|
|
~_CurrentSearches() {
|
|
if (_psfscOnAsyncSearch)
|
|
_psfscOnAsyncSearch->Release();
|
|
CoTaskMemFree(_pwszSearchTarget);
|
|
}
|
|
};
|
|
|
|
// A linked list of current cache searchers:
|
|
// For multiple entries to occur in this list, the user would have to be
|
|
// searching the cache on two or more separate queries simultaneously
|
|
_CurrentSearches *_CurrentSearches::s_pcsCurrentCacheSearchThreads = NULL;
|
|
|
|
void _CurrentSearches::s_RemoveSearch(_CurrentSearches *pcsRemove, _CurrentSearches *&pcsHead)
|
|
{
|
|
ENTERCRITICAL;
|
|
if (pcsRemove->_pcsPrev)
|
|
pcsRemove->_pcsPrev->_pcsNext = pcsRemove->_pcsNext;
|
|
else
|
|
pcsHead = pcsRemove->_pcsNext;
|
|
|
|
if (pcsRemove->_pcsNext)
|
|
pcsRemove->_pcsNext->_pcsPrev = pcsRemove->_pcsPrev;
|
|
|
|
pcsRemove->Release();
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// Caller: Remember to Release() the returned data!!
|
|
_CurrentSearches *_CurrentSearches::s_FindSearch(const FILETIME &ftSearchKey,
|
|
_CurrentSearches *pcsHead)
|
|
{
|
|
ENTERCRITICAL;
|
|
_CurrentSearches *pcsTemp = pcsHead;
|
|
_CurrentSearches *pcsRet = NULL;
|
|
while (pcsTemp) {
|
|
if (((pcsTemp->_ftSearchKey).dwLowDateTime == ftSearchKey.dwLowDateTime) &&
|
|
((pcsTemp->_ftSearchKey).dwHighDateTime == ftSearchKey.dwHighDateTime))
|
|
{
|
|
pcsRet = pcsTemp;
|
|
break;
|
|
}
|
|
pcsTemp = pcsTemp->_pcsNext;
|
|
}
|
|
if (pcsRet)
|
|
pcsRet->AddRef();
|
|
LEAVECRITICAL;
|
|
return pcsRet;
|
|
}
|
|
/**********************************************************************/
|
|
|
|
HRESULT CHistFolderEnum::_NextViewPart_OrderSearch(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched) {
|
|
HRESULT hr = E_FAIL;
|
|
ULONG uFetched = 0;
|
|
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1];
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1;
|
|
if (FAILED(_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
UINT uUserNameLen = lstrlen(szUserName);
|
|
|
|
if (_pstatenum == NULL) {
|
|
// This hashtable will eventually be passed off to the background
|
|
// cache search thread so that it doesn't return duplicates.
|
|
ASSERT(NULL == _pshHashTable) // don't leak a _pshHashTable
|
|
_pshHashTable = new StrHash(TRUE);
|
|
if (_pshHashTable) {
|
|
IUrlHistoryPriv *pUrlHistStg = _pHCFolder->_GetHistStg();
|
|
if (pUrlHistStg) {
|
|
if (SUCCEEDED((hr = pUrlHistStg->EnumUrls(&_pstatenum))))
|
|
_pstatenum->SetFilter(NULL, STATURL_QUERYFLAG_TOPLEVEL);
|
|
pUrlHistStg->Release();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = S_OK;
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
ASSERT(_pstatenum && _pshHashTable);
|
|
|
|
for (uFetched; uFetched < celt;) {
|
|
STATURL staturl = { 0 };
|
|
staturl.cbSize = sizeof(staturl);
|
|
ULONG celtFetched = 0;
|
|
if (SUCCEEDED((hr = _pstatenum->Next(1, &staturl, &celtFetched)))) {
|
|
if (celtFetched) {
|
|
ASSERT(celtFetched == 1);
|
|
if (staturl.pwcsUrl && (staturl.dwFlags & STATURLFLAG_ISTOPLEVEL)) {
|
|
BOOL fMatch = FALSE;
|
|
|
|
// all this streamsearcher stuff is just like a 'smart' StrStr
|
|
CacheSearchEngine::StringStream ssUrl(staturl.pwcsUrl);
|
|
if ((!(fMatch =
|
|
(_pHCFolder->_pcsCurrentSearch->_streamsearcher).SearchCharStream(ssUrl))) &&
|
|
staturl.pwcsTitle)
|
|
{
|
|
CacheSearchEngine::StringStream ssTitle(staturl.pwcsTitle);
|
|
fMatch = (_pHCFolder->_pcsCurrentSearch->_streamsearcher).SearchCharStream(ssTitle);
|
|
}
|
|
|
|
if (fMatch){ // MATCH!
|
|
// Now, we have to convert the url to a prefixed (ansi, if necessary) url
|
|
UINT uUrlLen = lstrlenW(staturl.pwcsUrl);
|
|
UINT uPrefixLen = HISTPREFIXLEN + uUserNameLen + 1; // '@' and '\0'
|
|
LPTSTR pszPrefixedUrl =
|
|
((LPTSTR)LocalAlloc(LPTR, (uUrlLen + uPrefixLen + 1) * sizeof(TCHAR)));
|
|
if (pszPrefixedUrl){
|
|
wnsprintf(pszPrefixedUrl, uPrefixLen + uUrlLen + 1,
|
|
TEXT("%s%s@%ls"), c_szHistPrefix, szUserName,
|
|
staturl.pwcsUrl);
|
|
LPHEIPIDL pheiTemp =
|
|
_CreateHCacheFolderPidl(TRUE,
|
|
pszPrefixedUrl, staturl.ftLastVisited,
|
|
&staturl, 0,
|
|
_pHCFolder->_GetHitCount(pszPrefixedUrl + uPrefixLen));
|
|
if (pheiTemp) {
|
|
_pshHashTable->insertUnique(pszPrefixedUrl + uPrefixLen, TRUE,
|
|
reinterpret_cast<void *>(1));
|
|
rgelt[uFetched++] = (LPITEMIDLIST)pheiTemp;
|
|
hr = S_OK;
|
|
}
|
|
|
|
LocalFree(pszPrefixedUrl);
|
|
pszPrefixedUrl = NULL;
|
|
}
|
|
}
|
|
}
|
|
if (staturl.pwcsUrl)
|
|
OleFree(staturl.pwcsUrl);
|
|
|
|
if (staturl.pwcsTitle)
|
|
OleFree(staturl.pwcsTitle);
|
|
}
|
|
else {
|
|
hr = S_FALSE;
|
|
// Addref this for the ThreadProc who then frees it...
|
|
AddRef();
|
|
SHQueueUserWorkItem((LPTHREAD_START_ROUTINE)s_CacheSearchThreadProc,
|
|
(void *)this,
|
|
0,
|
|
(DWORD_PTR)NULL,
|
|
(DWORD_PTR *)NULL,
|
|
"shdocvw.dll",
|
|
0
|
|
);
|
|
break;
|
|
}
|
|
} // succeeded getnext url
|
|
} //for
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = uFetched;
|
|
} // succeeded initalising
|
|
return hr;
|
|
}
|
|
|
|
// helper function for s_CacheSearchThreadProc
|
|
BOOL_PTR CHistFolderEnum::s_DoCacheSearch(LPINTERNET_CACHE_ENTRY_INFO pcei,
|
|
LPTSTR pszUserName, UINT uUserNameLen,
|
|
CHistFolderEnum *penum,
|
|
_CurrentSearches *pcsThisThread, IUrlHistoryPriv *pUrlHistStg)
|
|
{
|
|
BOOL_PTR fFound = FALSE;
|
|
LPTSTR pszTextHeader;
|
|
|
|
// The header contains "Content-type: text/*"
|
|
if (pcei->lpHeaderInfo && (pszTextHeader = StrStrI(pcei->lpHeaderInfo, c_szTextHeader)))
|
|
{
|
|
// in some cases, urls in the cache differ from urls in the history
|
|
// by only the trailing slash -- we strip it out and test both
|
|
UINT uUrlLen = lstrlen(pcei->lpszSourceUrlName);
|
|
if (uUrlLen && (pcei->lpszSourceUrlName[uUrlLen - 1] == TEXT('/')))
|
|
{
|
|
pcei->lpszSourceUrlName[uUrlLen - 1] = TEXT('\0');
|
|
fFound = (BOOL_PTR)(penum->_pshHashTable->retrieve(pcei->lpszSourceUrlName));
|
|
pcei->lpszSourceUrlName[uUrlLen - 1] = TEXT('/');
|
|
}
|
|
|
|
DWORD dwSize = MAX_URLCACHE_ENTRY;
|
|
// see if its already been found and added...
|
|
if ((!fFound) && !(penum->_pshHashTable->retrieve(pcei->lpszSourceUrlName)))
|
|
{
|
|
BOOL fIsHTML = !StrCmpNI(pszTextHeader + TEXTHEADERLEN, c_szHTML, HTMLLEN);
|
|
// Now, try to find the url in history...
|
|
|
|
STATURL staturl;
|
|
HRESULT hrLocal;
|
|
hrLocal = pUrlHistStg->QueryUrl(pcei->lpszSourceUrlName, STATFLAG_NONAME, &staturl);
|
|
if (hrLocal == S_OK)
|
|
{
|
|
HANDLE hCacheStream;
|
|
|
|
hCacheStream = RetrieveUrlCacheEntryStream(pcei->lpszSourceUrlName, pcei, &dwSize, FALSE, 0);
|
|
if (hCacheStream)
|
|
{
|
|
if (CacheSearchEngine::SearchCacheStream(pcsThisThread->_streamsearcher,
|
|
hCacheStream, fIsHTML)) {
|
|
EVAL(UnlockUrlCacheEntryStream(hCacheStream, 0));
|
|
|
|
// Prefix the url so that we can create a pidl out of it -- for now, we will
|
|
// prefix it with "Visited: ", but "Bogus: " may be more appropriate.
|
|
UINT uUrlLen = lstrlen(pcei->lpszSourceUrlName);
|
|
UINT uPrefixLen = HISTPREFIXLEN + uUserNameLen + 1; // '@' and '\0'
|
|
UINT uBuffSize = uUrlLen + uPrefixLen + 1;
|
|
LPTSTR pszPrefixedUrl =
|
|
((LPTSTR)LocalAlloc(LPTR, uBuffSize * sizeof(TCHAR)));
|
|
if (pszPrefixedUrl)
|
|
{
|
|
wnsprintf(pszPrefixedUrl, uBuffSize, TEXT("%s%s@%s"), c_szHistPrefix, pszUserName,
|
|
pcei->lpszSourceUrlName);
|
|
|
|
// Create a pidl for this url
|
|
LPITEMIDLIST pidlFound = (LPITEMIDLIST)
|
|
penum->_pHCFolder->_CreateHCacheFolderPidlFromUrl(FALSE, pszPrefixedUrl);
|
|
if (pidlFound)
|
|
{
|
|
LPITEMIDLIST pidlNotify = ILCombine(penum->_pHCFolder->_pidl, pidlFound);
|
|
if (pidlNotify)
|
|
{
|
|
// add the item to the results list...
|
|
/* without the flush, the shell will coalesce these and turn
|
|
them info SHChangeNotify(SHCNE_UPDATEDIR,..), which will cause nsc
|
|
to do an EnumObjects(), which will start the search up again and again...
|
|
*/
|
|
SHChangeNotify(SHCNE_CREATE, SHCNF_IDLIST | SHCNF_FLUSH, pidlNotify, NULL);
|
|
ILFree(pidlNotify);
|
|
fFound = TRUE;
|
|
}
|
|
|
|
LocalFree(pidlFound);
|
|
pidlFound = NULL;
|
|
}
|
|
|
|
LocalFree(pszPrefixedUrl);
|
|
pszPrefixedUrl = NULL;
|
|
}
|
|
}
|
|
else
|
|
EVAL(UnlockUrlCacheEntryStream(hCacheStream, 0));
|
|
}
|
|
}
|
|
else
|
|
TraceMsg(DM_CACHESEARCH, "In Cache -- Not In History: %s", pcei->lpszSourceUrlName);
|
|
}
|
|
}
|
|
return fFound;
|
|
}
|
|
|
|
DWORD WINAPI CHistFolderEnum::s_CacheSearchThreadProc(CHistFolderEnum *penum)
|
|
{
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1];
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1;
|
|
|
|
if (FAILED(penum->_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
UINT uUserNameLen = lstrlen(szUserName);
|
|
|
|
BOOL fNoConflictingSearch = TRUE;
|
|
|
|
_CurrentSearches *pcsThisThread = NULL;
|
|
|
|
IUrlHistoryPriv *pUrlHistStg = penum->_pHCFolder->_GetHistStg();
|
|
|
|
if (pUrlHistStg)
|
|
{
|
|
|
|
pcsThisThread = _CurrentSearches::s_FindSearch(penum->_pHCFolder->_pcsCurrentSearch->_ftSearchKey);
|
|
|
|
if (pcsThisThread)
|
|
{
|
|
// if no one else is doing the same search
|
|
if (FALSE == InterlockedExchange((LONG *)&(pcsThisThread->_fSearchingAsync), TRUE))
|
|
{
|
|
if (pcsThisThread->_psfscOnAsyncSearch)
|
|
pcsThisThread->_psfscOnAsyncSearch->RunBegin(0);
|
|
|
|
BYTE ab[MAX_URLCACHE_ENTRY];
|
|
LPINTERNET_CACHE_ENTRY_INFO pcei = (LPINTERNET_CACHE_ENTRY_INFO)(&ab);
|
|
|
|
DWORD dwSize = MAX_URLCACHE_ENTRY;
|
|
HANDLE hCacheEnum = FindFirstUrlCacheEntry(NULL, pcei, &dwSize);
|
|
if (hCacheEnum)
|
|
{
|
|
while(!(pcsThisThread->_fKillSwitch))
|
|
{
|
|
s_DoCacheSearch(pcei, szUserName, uUserNameLen, penum, pcsThisThread, pUrlHistStg);
|
|
dwSize = MAX_URLCACHE_ENTRY;
|
|
if (!FindNextUrlCacheEntry(hCacheEnum, pcei, &dwSize))
|
|
{
|
|
ASSERT(GetLastError() == ERROR_NO_MORE_ITEMS);
|
|
break;
|
|
}
|
|
}
|
|
FindCloseUrlCache(hCacheEnum);
|
|
}
|
|
|
|
if (pcsThisThread->_psfscOnAsyncSearch)
|
|
pcsThisThread->_psfscOnAsyncSearch->RunEnd(0);
|
|
|
|
pcsThisThread->_fSearchingAsync = FALSE; // It's been removed - no chance of
|
|
// a race condition
|
|
}
|
|
pcsThisThread->Release();
|
|
}
|
|
ATOMICRELEASE(pUrlHistStg);
|
|
}
|
|
ATOMICRELEASE(penum);
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// this gets the local host name as known by the shell
|
|
// by default assume "My Computer" or whatever
|
|
//
|
|
void _GetLocalHost(LPTSTR psz, DWORD cch)
|
|
{
|
|
*psz = 0;
|
|
|
|
IShellFolder* psf;
|
|
if (SUCCEEDED(SHGetDesktopFolder(&psf)))
|
|
{
|
|
WCHAR sz[GUIDSTR_MAX + 3];
|
|
|
|
sz[0] = sz[1] = TEXT(':');
|
|
SHStringFromGUIDW(CLSID_MyComputer, sz+2, SIZECHARS(sz)-2);
|
|
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(psf->ParseDisplayName(NULL, NULL, sz, NULL, &pidl, NULL)))
|
|
{
|
|
STRRET sr;
|
|
if (SUCCEEDED(psf->GetDisplayNameOf(pidl, SHGDN_NORMAL, &sr)))
|
|
StrRetToBuf(&sr, pidl, psz, cch);
|
|
ILFree(pidl);
|
|
}
|
|
|
|
psf->Release();
|
|
}
|
|
|
|
if (!*psz)
|
|
MLLoadString(IDS_NOTNETHOST, psz, cch);
|
|
}
|
|
|
|
LPCTSTR CHistFolderEnum::_GetLocalHost(void)
|
|
{
|
|
if (!*_szLocalHost)
|
|
::_GetLocalHost(_szLocalHost, SIZECHARS(_szLocalHost));
|
|
|
|
return _szLocalHost;
|
|
}
|
|
|
|
//////////////////////////////////
|
|
//
|
|
// IEnumIDList Methods
|
|
//
|
|
HRESULT CHistFolderEnum::Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
DWORD dwBuffSize;
|
|
DWORD dwError;
|
|
LPTSTR pszSearchPattern = NULL;
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1; // len of this buffer
|
|
TCHAR szHistSearchPattern[PREFIX_SIZE + 1]; // search pattern for history items
|
|
TCHAR szHost[INTERNET_MAX_HOST_NAME_LENGTH+1];
|
|
|
|
TraceMsg(DM_HSFOLDER, "hcfe - Next() called.");
|
|
|
|
if (_pHCFolder->_uViewType)
|
|
return _NextViewPart(celt, rgelt, pceltFetched);
|
|
|
|
if ((IsLeaf(_pHCFolder->_foldertype) && 0 == (SHCONTF_NONFOLDERS & _grfFlags)) ||
|
|
(!IsLeaf(_pHCFolder->_foldertype) && 0 == (SHCONTF_FOLDERS & _grfFlags)))
|
|
{
|
|
dwError = 0xFFFFFFFF;
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (FOLDER_TYPE_Hist == _pHCFolder->_foldertype)
|
|
{
|
|
return _NextHistInterval(celt, rgelt, pceltFetched);
|
|
}
|
|
|
|
if (_pceiWorking == NULL)
|
|
{
|
|
_pceiWorking = (LPINTERNET_CACHE_ENTRY_INFO)LocalAlloc(LPTR, MAX_URLCACHE_ENTRY);
|
|
if (_pceiWorking == NULL)
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
|
|
// Set up things to enumerate history items, if appropriate, otherwise,
|
|
// we'll just pass in NULL and enumerate all items as before.
|
|
|
|
if (!_hEnum)
|
|
{
|
|
if (FAILED(_pHCFolder->_ValidateIntervalCache()))
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
|
|
if (FAILED(_pHCFolder->_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
StrCpyN(szHistSearchPattern, _pHCFolder->_pszCachePrefix, ARRAYSIZE(szHistSearchPattern));
|
|
|
|
// We can't pass in the whole search pattern that we want,
|
|
// because FindFirstUrlCacheEntry is busted. It will only look at the
|
|
// prefix if there is a cache container for that prefix. So, we can
|
|
// pass in "Visited: " and enumerate all the history items in the cache,
|
|
// but then we need to pull out only the ones with the correct username.
|
|
|
|
// StrCpy(szHistSearchPattern, szUserName);
|
|
|
|
pszSearchPattern = szHistSearchPattern;
|
|
|
|
TryAgain:
|
|
|
|
dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
dwError = S_OK;
|
|
|
|
if (!_hEnum) // _hEnum maintains our state as we iterate over all the cache entries
|
|
{
|
|
_hEnum = FindFirstUrlCacheEntry(pszSearchPattern, _pceiWorking, &dwBuffSize);
|
|
if (!_hEnum)
|
|
dwError = GetLastError();
|
|
}
|
|
|
|
else if (!FindNextUrlCacheEntry(_hEnum, _pceiWorking, &dwBuffSize))
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
|
|
if (S_OK == dwError)
|
|
{
|
|
LPBASEPIDL pcei = NULL;
|
|
|
|
TCHAR szTempStrippedUrl[MAX_URL_STRING];
|
|
LPCTSTR pszStrippedUrl;
|
|
BOOL fIsHost;
|
|
LPCTSTR pszHost;
|
|
|
|
//mm: Make sure that this cache entry belongs to szUserName (relevant to Win95)
|
|
if (!_FilterUserName(_pceiWorking, _pHCFolder->_pszCachePrefix, szUserName))
|
|
goto TryAgain;
|
|
|
|
StrCpyN(szTempStrippedUrl, _pceiWorking->lpszSourceUrlName, ARRAYSIZE(szTempStrippedUrl));
|
|
pszStrippedUrl = _StripHistoryUrlToUrl(szTempStrippedUrl);
|
|
if ((DWORD)lstrlen(pszStrippedUrl) > HOSTPREFIXLEN)
|
|
{
|
|
pszHost = &pszStrippedUrl[HOSTPREFIXLEN];
|
|
fIsHost = !StrCmpNI(c_szHostPrefix, pszStrippedUrl, HOSTPREFIXLEN);
|
|
}
|
|
else
|
|
{
|
|
fIsHost = FALSE;
|
|
}
|
|
//mm: this is most likely domains:
|
|
if (FOLDER_TYPE_HistInterval == _pHCFolder->_foldertype) // return unique domains
|
|
{
|
|
if (!fIsHost)
|
|
goto TryAgain;
|
|
|
|
pcei = _CreateIdCacheFolderPidl(TRUE, IDDPIDL_SIGN, pszHost);
|
|
}
|
|
else if (NULL != _pHCFolder->_pszDomain) //mm: this must be docs
|
|
{
|
|
TCHAR szSourceUrl[MAX_URL_STRING];
|
|
STATURL suThis;
|
|
HRESULT hrLocal = E_FAIL;
|
|
IUrlHistoryPriv *pUrlHistStg = NULL;
|
|
|
|
if (fIsHost)
|
|
goto TryAgain;
|
|
|
|
// Filter domain in history view!
|
|
_GetURLHost(_pceiWorking, szHost, INTERNET_MAX_HOST_NAME_LENGTH, _GetLocalHost());
|
|
|
|
if (StrCmpI(szHost, _pHCFolder->_pszDomain)) //mm: is this in our domain?!
|
|
goto TryAgain;
|
|
|
|
pUrlHistStg = _pHCFolder->_GetHistStg();
|
|
if (pUrlHistStg)
|
|
{
|
|
CHAR szTempUrl[MAX_URL_STRING];
|
|
|
|
SHTCharToAnsi(pszStrippedUrl, szTempUrl, ARRAYSIZE(szTempUrl));
|
|
hrLocal = pUrlHistStg->QueryUrlA(szTempUrl, STATURL_QUERYFLAG_NOURL, &suThis);
|
|
pUrlHistStg->Release();
|
|
}
|
|
|
|
StrCpyN(szSourceUrl, _pceiWorking->lpszSourceUrlName, ARRAYSIZE(szSourceUrl));
|
|
pcei = (LPBASEPIDL) _CreateHCacheFolderPidl(TRUE,
|
|
szSourceUrl,
|
|
_pceiWorking->LastModifiedTime,
|
|
(SUCCEEDED(hrLocal) ? &suThis : NULL), 0,
|
|
_pHCFolder->_GetHitCount(_StripHistoryUrlToUrl(szSourceUrl)));
|
|
|
|
if (SUCCEEDED(hrLocal) && suThis.pwcsTitle)
|
|
OleFree(suThis.pwcsTitle);
|
|
}
|
|
if (pcei)
|
|
{
|
|
rgelt[0] = (LPITEMIDLIST)pcei;
|
|
if (pceltFetched)
|
|
*pceltFetched = 1;
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
|
|
exitPoint:
|
|
|
|
if (dwError != S_OK)
|
|
{
|
|
if (_hEnum)
|
|
{
|
|
FindCloseUrlCache(_hEnum);
|
|
_hEnum = NULL;
|
|
}
|
|
if (pceltFetched)
|
|
*pceltFetched = 0;
|
|
rgelt[0] = NULL;
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::Skip(ULONG celt)
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcfe - Skip() called.");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::Reset()
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcfe - Reset() called.");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT CHistFolderEnum::Clone(IEnumIDList **ppenum)
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcfe - Clone() called.");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CHistFolder Object
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
CHistFolder::CHistFolder(FOLDER_TYPE FolderType)
|
|
{
|
|
TraceMsg(DM_HSFOLDER, "hcf - CHistFolder() called.");
|
|
_cRef = 1;
|
|
_foldertype = FolderType;
|
|
ASSERT( _uViewType == 0 &&
|
|
_uViewDepth == 0 &&
|
|
_pszCachePrefix == NULL &&
|
|
_pszDomain == NULL &&
|
|
_cbIntervals == 0 &&
|
|
_pIntervalCache == NULL &&
|
|
_fValidatingCache == FALSE &&
|
|
_dwIntervalCached == 0 &&
|
|
_ftDayCached.dwHighDateTime == 0 &&
|
|
_ftDayCached.dwLowDateTime == 0 &&
|
|
_pidl == NULL );
|
|
DllAddRef();
|
|
}
|
|
|
|
CHistFolder::~CHistFolder()
|
|
{
|
|
ASSERT(_cRef == 0); // should always have zero
|
|
TraceMsg(DM_HSFOLDER, "hcf - ~CHistFolder() called.");
|
|
if (_pIntervalCache)
|
|
{
|
|
LocalFree(_pIntervalCache);
|
|
_pIntervalCache = NULL;
|
|
}
|
|
if (_pszCachePrefix)
|
|
{
|
|
LocalFree(_pszCachePrefix);
|
|
_pszCachePrefix = NULL;
|
|
}
|
|
if (_pszDomain)
|
|
{
|
|
LocalFree(_pszDomain);
|
|
_pszDomain = NULL;
|
|
}
|
|
if (_pidl)
|
|
ILFree(_pidl);
|
|
if (_pUrlHistStg)
|
|
{
|
|
_pUrlHistStg->Release();
|
|
_pUrlHistStg = NULL;
|
|
}
|
|
if (_pcsCurrentSearch)
|
|
_pcsCurrentSearch->Release();
|
|
|
|
DllRelease();
|
|
}
|
|
|
|
LPITEMIDLIST _Combine_ViewPidl(USHORT usViewType, LPITEMIDLIST pidl)
|
|
{
|
|
LPITEMIDLIST pidlResult = NULL;
|
|
LPVIEWPIDL pviewpidl = (LPVIEWPIDL)SHAlloc(sizeof(VIEWPIDL) + sizeof(USHORT));
|
|
if (pviewpidl)
|
|
{
|
|
ZeroMemory(pviewpidl, sizeof(VIEWPIDL) + sizeof(USHORT));
|
|
pviewpidl->cb = sizeof(VIEWPIDL);
|
|
pviewpidl->usSign = VIEWPIDL_SIGN;
|
|
pviewpidl->usViewType = usViewType;
|
|
ASSERT(pviewpidl->usExtra == 0);//pcei->usSign;
|
|
if (pidl)
|
|
{
|
|
pidlResult = ILCombine((LPITEMIDLIST)pviewpidl, pidl);
|
|
SHFree(pviewpidl);
|
|
}
|
|
else
|
|
pidlResult = (LPITEMIDLIST)pviewpidl;
|
|
}
|
|
return pidlResult;
|
|
}
|
|
|
|
STDMETHODIMP CHistFolder::_GetDetail(LPCITEMIDLIST pidl, UINT iColumn, LPTSTR pszStr, UINT cchStr)
|
|
{
|
|
*pszStr = 0;
|
|
|
|
switch (iColumn)
|
|
{
|
|
case ICOLH_URL_NAME:
|
|
if (_IsLeaf())
|
|
StrCpyN(pszStr, _StripHistoryUrlToUrl(HPidlToSourceUrl((LPBASEPIDL)pidl)), cchStr);
|
|
else
|
|
_GetURLDispName((LPBASEPIDL)pidl, pszStr, cchStr);
|
|
break;
|
|
|
|
case ICOLH_URL_TITLE:
|
|
_GetHistURLDispName((LPHEIPIDL)pidl, pszStr, cchStr);
|
|
break;
|
|
|
|
case ICOLH_URL_LASTVISITED:
|
|
FileTimeToDateTimeStringInternal(&((LPHEIPIDL)pidl)->ftModified, pszStr, cchStr, TRUE);
|
|
break;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CHistFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pdi)
|
|
{
|
|
HRESULT hr;
|
|
|
|
const COLSPEC *pcol;
|
|
UINT nCols;
|
|
|
|
if (_foldertype == FOLDER_TYPE_Hist)
|
|
{
|
|
pcol = s_HistIntervalFolder_cols;
|
|
nCols = ARRAYSIZE(s_HistIntervalFolder_cols);
|
|
}
|
|
else if (_foldertype == FOLDER_TYPE_HistInterval)
|
|
{
|
|
pcol = s_HistHostFolder_cols;
|
|
nCols = ARRAYSIZE(s_HistHostFolder_cols);
|
|
}
|
|
else
|
|
{
|
|
pcol = s_HistFolder_cols;
|
|
nCols = ARRAYSIZE(s_HistFolder_cols);
|
|
}
|
|
|
|
if (pidl == NULL)
|
|
{
|
|
if (iColumn < nCols)
|
|
{
|
|
TCHAR szTemp[128];
|
|
pdi->fmt = pcol[iColumn].iFmt;
|
|
pdi->cxChar = pcol[iColumn].cchCol;
|
|
MLLoadString(pcol[iColumn].ids, szTemp, ARRAYSIZE(szTemp));
|
|
hr = StringToStrRet(szTemp, &pdi->str);
|
|
}
|
|
else
|
|
hr = E_FAIL; // enum done
|
|
}
|
|
else
|
|
{
|
|
// Make sure the pidl is dword aligned.
|
|
|
|
if(iColumn >= nCols)
|
|
hr = E_FAIL;
|
|
else
|
|
{
|
|
BOOL fRealigned;
|
|
hr = AlignPidl(&pidl, &fRealigned);
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
TCHAR szTemp[MAX_URL_STRING];
|
|
hr = _GetDetail(pidl, iColumn, szTemp, ARRAYSIZE(szTemp));
|
|
if (SUCCEEDED(hr))
|
|
hr = StringToStrRet(szTemp, &pdi->str);
|
|
|
|
}
|
|
if (fRealigned)
|
|
FreeRealignedPidl(pidl);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI HistFolder_CreateInstance(IUnknown* punkOuter, IUnknown **ppunk, LPCOBJECTINFO poi)
|
|
{
|
|
*ppunk = NULL; // null the out param
|
|
|
|
if (punkOuter)
|
|
return CLASS_E_NOAGGREGATION;
|
|
|
|
CHistFolder *phist = new CHistFolder(FOLDER_TYPE_Hist);
|
|
if (!phist)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*ppunk = SAFECAST(phist, IShellFolder2*);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CHistFolder::QueryInterface(REFIID iid, void **ppv)
|
|
{
|
|
static const QITAB qitHist[] = {
|
|
QITABENT(CHistFolder, IShellFolder2),
|
|
QITABENTMULTI(CHistFolder, IShellFolder, IShellFolder2),
|
|
QITABENT(CHistFolder, IShellIcon),
|
|
QITABENT(CHistFolder, IPersistFolder2),
|
|
QITABENTMULTI(CHistFolder, IPersistFolder, IPersistFolder2),
|
|
QITABENTMULTI(CHistFolder, IPersist, IPersistFolder2),
|
|
QITABENT(CHistFolder, IHistSFPrivate),
|
|
QITABENT(CHistFolder, IShellFolderViewType),
|
|
QITABENT(CHistFolder, IShellFolderSearchable),
|
|
{ 0 },
|
|
};
|
|
|
|
if (iid == IID_IPersistFolder)
|
|
{
|
|
if (FOLDER_TYPE_Hist != _foldertype)
|
|
{
|
|
*ppv = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
}
|
|
else if (iid == CLSID_HistFolder)
|
|
{
|
|
*ppv = (void *)(CHistFolder *)this;
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
return QISearch(this, qitHist, iid, ppv);
|
|
}
|
|
|
|
ULONG CHistFolder::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG CHistFolder::Release()
|
|
{
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
HRESULT CHistFolder::_ExtractInfoFromPidl()
|
|
{
|
|
LPITEMIDLIST pidlThis;
|
|
LPITEMIDLIST pidlLast = NULL;
|
|
LPITEMIDLIST pidlSecondLast = NULL;
|
|
|
|
ASSERT(!_uViewType);
|
|
|
|
pidlThis = _pidl;
|
|
while (pidlThis->mkid.cb)
|
|
{
|
|
pidlSecondLast = pidlLast;
|
|
pidlLast = pidlThis;
|
|
pidlThis = _ILNext(pidlThis);
|
|
}
|
|
switch (_foldertype)
|
|
{
|
|
case FOLDER_TYPE_Hist:
|
|
_pidlRest = pidlThis;
|
|
break;
|
|
case FOLDER_TYPE_HistInterval:
|
|
_pidlRest = pidlLast;
|
|
break;
|
|
case FOLDER_TYPE_HistDomain:
|
|
_pidlRest = pidlSecondLast;
|
|
break;
|
|
default:
|
|
_pidlRest = NULL;
|
|
}
|
|
|
|
HRESULT hr = NULL == _pidlRest ? E_FAIL : S_OK;
|
|
|
|
pidlThis = _pidlRest;
|
|
while (SUCCEEDED(hr) && pidlThis->mkid.cb)
|
|
{
|
|
if (_IsValid_IDPIDL(pidlThis))
|
|
{
|
|
LPBASEPIDL pcei = (LPBASEPIDL)pidlThis;
|
|
TCHAR szUrlTitle[MAX_URL_STRING];
|
|
PCTSTR pszUrlTitle = _GetURLTitleAlign((LPBASEPIDL)pidlThis, szUrlTitle, ARRAYSIZE(szUrlTitle));
|
|
|
|
if (EQUIV_IDSIGN(pcei->usSign, IDIPIDL_SIGN)) // This is our interval, it implies prefix
|
|
{
|
|
LPCTSTR pszCachePrefix;
|
|
|
|
if (_foldertype == FOLDER_TYPE_Hist)
|
|
_foldertype = FOLDER_TYPE_HistInterval;
|
|
|
|
hr = _LoadIntervalCache();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _GetPrefixForInterval(pszUrlTitle, &pszCachePrefix);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetCachePrefix(pszCachePrefix);
|
|
}
|
|
}
|
|
}
|
|
else // This is our domain
|
|
{
|
|
if (_foldertype == FOLDER_TYPE_HistInterval)
|
|
_foldertype = FOLDER_TYPE_HistDomain;
|
|
SetDomain(pszUrlTitle);
|
|
}
|
|
}
|
|
pidlThis = _ILNext(pidlThis);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
switch (_foldertype)
|
|
{
|
|
case FOLDER_TYPE_HistDomain:
|
|
if (_pszDomain == NULL)
|
|
hr = E_FAIL;
|
|
//FALL THROUGH INTENDED
|
|
case FOLDER_TYPE_HistInterval:
|
|
if (_pszCachePrefix == NULL)
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
void _SetValueSign(HSFINTERVAL *pInterval, FILETIME ftNow)
|
|
{
|
|
if (_DaysInInterval(pInterval) == 1 && !CompareFileTime(&(pInterval->ftStart), &ftNow))
|
|
{
|
|
pInterval->usSign = IDTPIDL_SIGN;
|
|
}
|
|
else
|
|
{
|
|
pInterval->usSign = IDIPIDL_SIGN;
|
|
}
|
|
}
|
|
|
|
void _SetVersion(HSFINTERVAL *pInterval, LPCSTR szInterval)
|
|
{
|
|
USHORT usVers = 0;
|
|
int i;
|
|
DWORD dwIntervalLen = lstrlenA(szInterval);
|
|
|
|
// Unknown versions are 0
|
|
if (dwIntervalLen == INTERVAL_SIZE)
|
|
{
|
|
for (i = INTERVAL_PREFIX_LEN; i < INTERVAL_PREFIX_LEN+INTERVAL_VERS_LEN; i++)
|
|
{
|
|
if ('0' > szInterval[i] || '9' < szInterval[i])
|
|
{
|
|
usVers = UNK_INTERVAL_VERS;
|
|
break;
|
|
}
|
|
usVers = usVers * 10 + (szInterval[i] - '0');
|
|
}
|
|
}
|
|
pInterval->usVers = usVers;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
#define _ValueToInterval _ValueToIntervalW
|
|
#else // UNICODE
|
|
#define _ValueToInterval _ValueToIntervalA
|
|
#endif // UNICODE
|
|
|
|
HRESULT _ValueToIntervalA(LPCSTR szInterval, FILETIME *pftStart, FILETIME *pftEnd)
|
|
{
|
|
int i;
|
|
int iBase;
|
|
HRESULT hr = E_FAIL;
|
|
SYSTEMTIME sysTime;
|
|
unsigned int digits[RANGE_LEN];
|
|
|
|
iBase = lstrlenA(szInterval)-RANGE_LEN;
|
|
for (i = 0; i < RANGE_LEN; i++)
|
|
{
|
|
digits[i] = szInterval[i+iBase] - '0';
|
|
if (digits[i] > 9) goto exitPoint;
|
|
}
|
|
|
|
ZeroMemory(&sysTime, sizeof(sysTime));
|
|
sysTime.wYear = digits[0]*1000 + digits[1]*100 + digits[2] * 10 + digits[3];
|
|
sysTime.wMonth = digits[4] * 10 + digits[5];
|
|
sysTime.wDay = digits[6] * 10 + digits[7];
|
|
if (!SystemTimeToFileTime(&sysTime, pftStart)) goto exitPoint;
|
|
|
|
ZeroMemory(&sysTime, sizeof(sysTime));
|
|
sysTime.wYear = digits[8]*1000 + digits[9]*100 + digits[10] * 10 + digits[11];
|
|
sysTime.wMonth = digits[12] * 10 + digits[13];
|
|
sysTime.wDay = digits[14] * 10 + digits[15];
|
|
if (!SystemTimeToFileTime(&sysTime, pftEnd)) goto exitPoint;
|
|
|
|
// Intervals are open on the end, so end should be strictly > start
|
|
if (CompareFileTime(pftStart, pftEnd) >= 0) goto exitPoint;
|
|
|
|
hr = S_OK;
|
|
|
|
exitPoint:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _ValueToIntervalW(LPCUWSTR wzInterval, FILETIME *pftStart, FILETIME *pftEnd)
|
|
{
|
|
CHAR szInterval[MAX_PATH];
|
|
LPCWSTR wzAlignedInterval;
|
|
|
|
WSTR_ALIGNED_STACK_COPY( &wzAlignedInterval,
|
|
wzInterval );
|
|
|
|
ASSERT(lstrlenW(wzAlignedInterval) < ARRAYSIZE(szInterval));
|
|
UnicodeToAnsi(wzAlignedInterval, szInterval, ARRAYSIZE(szInterval));
|
|
return _ValueToIntervalA((LPCSTR) szInterval, pftStart, pftEnd);
|
|
}
|
|
|
|
HRESULT CHistFolder::_LoadIntervalCache()
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwLastModified;
|
|
DWORD dwValueIndex;
|
|
DWORD dwPrefixIndex;
|
|
HSFINTERVAL *pIntervalCache = NULL;
|
|
struct {
|
|
INTERNET_CACHE_CONTAINER_INFOA cInfo;
|
|
char szBuffer[MAX_PATH+MAX_PATH];
|
|
} ContainerInfo;
|
|
DWORD dwContainerInfoSize;
|
|
CHAR chSave;
|
|
HANDLE hContainerEnum;
|
|
BOOL fContinue = TRUE;
|
|
FILETIME ftNow;
|
|
SYSTEMTIME st;
|
|
DWORD dwOptions;
|
|
|
|
GetLocalTime (&st);
|
|
SystemTimeToFileTime(&st, &ftNow);
|
|
_FileTimeDeltaDays(&ftNow, &ftNow, 0);
|
|
|
|
dwLastModified = _dwIntervalCached;
|
|
dwContainerInfoSize = sizeof(ContainerInfo);
|
|
if (_pIntervalCache == NULL || CompareFileTime(&ftNow, &_ftDayCached))
|
|
{
|
|
dwOptions = 0;
|
|
}
|
|
else
|
|
{
|
|
dwOptions = CACHE_FIND_CONTAINER_RETURN_NOCHANGE;
|
|
}
|
|
hContainerEnum = FindFirstUrlCacheContainerA(&dwLastModified,
|
|
&ContainerInfo.cInfo,
|
|
&dwContainerInfoSize,
|
|
dwOptions);
|
|
if (hContainerEnum == NULL)
|
|
{
|
|
DWORD err = GetLastError();
|
|
|
|
if (err == ERROR_NO_MORE_ITEMS)
|
|
{
|
|
fContinue = FALSE;
|
|
}
|
|
else if (err == ERROR_INTERNET_NO_NEW_CONTAINERS)
|
|
{
|
|
hr = S_OK;
|
|
goto exitPoint;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(err);
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
|
|
// Guarantee we return S_OK we have _pIntervalCache even if we haven't
|
|
// yet created the interval registry keys.
|
|
dwPrefixIndex = 0;
|
|
dwValueIndex = TYPICAL_INTERVALS;
|
|
pIntervalCache = (HSFINTERVAL *) LocalAlloc(LPTR, dwValueIndex*sizeof(HSFINTERVAL));
|
|
if (!pIntervalCache)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
|
|
// All of our intervals map to cache containers starting with
|
|
// c_szIntervalPrefix followed by YYYYMMDDYYYYMMDD
|
|
while (fContinue)
|
|
{
|
|
chSave = ContainerInfo.cInfo.lpszName[INTERVAL_PREFIX_LEN];
|
|
ContainerInfo.cInfo.lpszName[INTERVAL_PREFIX_LEN] = '\0';
|
|
if (!StrCmpIA(ContainerInfo.cInfo.lpszName, c_szIntervalPrefix))
|
|
{
|
|
ContainerInfo.cInfo.lpszName[INTERVAL_PREFIX_LEN] = chSave;
|
|
DWORD dwCNameLen;
|
|
|
|
if (dwPrefixIndex >= dwValueIndex)
|
|
{
|
|
HSFINTERVAL *pIntervalCacheNew;
|
|
|
|
pIntervalCacheNew = (HSFINTERVAL *) LocalReAlloc(pIntervalCache,
|
|
(dwValueIndex*2)*sizeof(HSFINTERVAL),
|
|
LMEM_ZEROINIT|LMEM_MOVEABLE);
|
|
if (pIntervalCacheNew == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
pIntervalCache = pIntervalCacheNew;
|
|
dwValueIndex *= 2;
|
|
}
|
|
|
|
dwCNameLen = lstrlenA(ContainerInfo.cInfo.lpszName);
|
|
if (dwCNameLen <= INTERVAL_SIZE && dwCNameLen >= INTERVAL_MIN_SIZE &&
|
|
lstrlenA(ContainerInfo.cInfo.lpszCachePrefix) == PREFIX_SIZE)
|
|
{
|
|
_SetVersion(&pIntervalCache[dwPrefixIndex], ContainerInfo.cInfo.lpszName);
|
|
if (pIntervalCache[dwPrefixIndex].usVers != UNK_INTERVAL_VERS)
|
|
{
|
|
AnsiToTChar(ContainerInfo.cInfo.lpszCachePrefix, pIntervalCache[dwPrefixIndex].szPrefix, ARRAYSIZE(pIntervalCache[dwPrefixIndex].szPrefix));
|
|
hr = _ValueToIntervalA( ContainerInfo.cInfo.lpszName,
|
|
&pIntervalCache[dwPrefixIndex].ftStart,
|
|
&pIntervalCache[dwPrefixIndex].ftEnd);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
_SetValueSign(&pIntervalCache[dwPrefixIndex], ftNow);
|
|
dwPrefixIndex++;
|
|
}
|
|
else
|
|
{
|
|
pIntervalCache[dwPrefixIndex].usVers = 0;
|
|
}
|
|
}
|
|
//
|
|
// HACK! IE5 bld 807 created containers with prefix length PREFIX_SIZE - 1.
|
|
// Delete these entries so history shows up for anyone upgrading over this
|
|
// build. Delete this code! (edwardp 8/8/98)
|
|
//
|
|
else if (dwCNameLen <= INTERVAL_SIZE && dwCNameLen >= INTERVAL_MIN_SIZE &&
|
|
lstrlenA(ContainerInfo.cInfo.lpszCachePrefix) == PREFIX_SIZE - 1)
|
|
{
|
|
DeleteUrlCacheContainerA(ContainerInfo.cInfo.lpszName, 0);
|
|
}
|
|
}
|
|
dwContainerInfoSize = sizeof(ContainerInfo);
|
|
fContinue = FindNextUrlCacheContainerA(hContainerEnum,
|
|
&ContainerInfo.cInfo,
|
|
&dwContainerInfoSize);
|
|
}
|
|
|
|
hr = S_OK;
|
|
_dwIntervalCached = dwLastModified;
|
|
_ftDayCached = ftNow;
|
|
|
|
{
|
|
ENTERCRITICAL;
|
|
if (_pIntervalCache)
|
|
{
|
|
LocalFree(_pIntervalCache);
|
|
_pIntervalCache = NULL;
|
|
}
|
|
_pIntervalCache = pIntervalCache;
|
|
LEAVECRITICAL;
|
|
}
|
|
_cbIntervals = dwPrefixIndex;
|
|
// because it will be freed by our destructor
|
|
pIntervalCache = NULL;
|
|
|
|
exitPoint:
|
|
if (hContainerEnum) FindCloseUrlCache(hContainerEnum);
|
|
if (pIntervalCache)
|
|
{
|
|
LocalFree(pIntervalCache);
|
|
pIntervalCache = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Returns true if *pftItem falls in the days *pftStart..*pftEnd inclusive
|
|
BOOL _InInterval(FILETIME *pftStart, FILETIME *pftEnd, FILETIME *pftItem)
|
|
{
|
|
return (CompareFileTime(pftStart,pftItem) <= 0 && CompareFileTime(pftItem,pftEnd) < 0);
|
|
}
|
|
|
|
// Truncates filetime increments beyond the day and then deltas by Days and converts back
|
|
// to FILETIME increments
|
|
void _FileTimeDeltaDays(FILETIME *pftBase, FILETIME *pftNew, int Days)
|
|
{
|
|
_int64 i64Base;
|
|
|
|
i64Base = (((_int64)pftBase->dwHighDateTime) << 32) | pftBase->dwLowDateTime;
|
|
i64Base /= FILE_SEC_TICKS;
|
|
i64Base /= DAY_SECS;
|
|
i64Base += Days;
|
|
i64Base *= FILE_SEC_TICKS;
|
|
i64Base *= DAY_SECS;
|
|
pftNew->dwHighDateTime = (DWORD) ((i64Base >> 32) & 0xFFFFFFFF);
|
|
pftNew->dwLowDateTime = (DWORD) (i64Base & 0xFFFFFFFF);
|
|
}
|
|
|
|
DWORD _DaysInInterval(HSFINTERVAL *pInterval)
|
|
{
|
|
_int64 i64Start;
|
|
_int64 i64End;
|
|
|
|
i64Start = (((_int64)pInterval->ftStart.dwHighDateTime) << 32) | pInterval->ftStart.dwLowDateTime;
|
|
i64Start /= FILE_SEC_TICKS;
|
|
i64Start /= DAY_SECS;
|
|
i64End = (((_int64)pInterval->ftEnd.dwHighDateTime) << 32) | pInterval->ftEnd.dwLowDateTime;
|
|
i64End /= FILE_SEC_TICKS;
|
|
i64End /= DAY_SECS;
|
|
// NOTE: the lower bound is closed, upper is open (ie first tick of next day)
|
|
return (DWORD) (i64End - i64Start);
|
|
}
|
|
|
|
// Returns S_OK if found, S_FALSE if not, error on error
|
|
// finds weekly interval in preference to daily if both exist
|
|
HRESULT CHistFolder::_GetInterval(FILETIME *pftItem, BOOL fWeekOnly, HSFINTERVAL **ppInterval)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HSFINTERVAL *pReturn = NULL;
|
|
int i;
|
|
HSFINTERVAL *pDailyInterval = NULL;
|
|
|
|
if (NULL == _pIntervalCache) goto exitPoint;
|
|
|
|
for (i = 0; i < _cbIntervals; i ++)
|
|
{
|
|
if (_pIntervalCache[i].usVers == OUR_VERS)
|
|
{
|
|
if (_InInterval(&_pIntervalCache[i].ftStart,
|
|
&_pIntervalCache[i].ftEnd,
|
|
pftItem))
|
|
{
|
|
if (7 != _DaysInInterval(&_pIntervalCache[i]))
|
|
{
|
|
if (!fWeekOnly)
|
|
{
|
|
pDailyInterval = &_pIntervalCache[i];
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
pReturn = &_pIntervalCache[i];
|
|
hr = S_OK;
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pReturn = pDailyInterval;
|
|
hr = pReturn ? S_OK : S_FALSE;
|
|
|
|
exitPoint:
|
|
if (ppInterval) *ppInterval = pReturn;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_GetPrefixForInterval(LPCTSTR pszInterval, LPCTSTR *ppszCachePrefix)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
int i;
|
|
LPCTSTR pszReturn = NULL;
|
|
FILETIME ftStart;
|
|
FILETIME ftEnd;
|
|
|
|
if (NULL == _pIntervalCache) goto exitPoint;
|
|
|
|
hr = _ValueToInterval(pszInterval, &ftStart, &ftEnd);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
for (i = 0; i < _cbIntervals; i ++)
|
|
{
|
|
if(_pIntervalCache[i].usVers == OUR_VERS)
|
|
{
|
|
if (CompareFileTime(&_pIntervalCache[i].ftStart,&ftStart) == 0 &&
|
|
CompareFileTime(&_pIntervalCache[i].ftEnd,&ftEnd) == 0)
|
|
{
|
|
pszReturn = _pIntervalCache[i].szPrefix;
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
hr = pszReturn ? S_OK : S_FALSE;
|
|
|
|
exitPoint:
|
|
if (ppszCachePrefix) *ppszCachePrefix = pszReturn;
|
|
return hr;
|
|
}
|
|
|
|
void _KeyForInterval(HSFINTERVAL *pInterval, LPTSTR pszInterval, int cchInterval)
|
|
{
|
|
SYSTEMTIME stStart;
|
|
SYSTEMTIME stEnd;
|
|
CHAR szVers[3];
|
|
#ifndef UNIX
|
|
CHAR szTempBuff[MAX_PATH];
|
|
#else
|
|
CHAR szTempBuff[INTERVAL_SIZE+1];
|
|
#endif
|
|
|
|
ASSERT(pInterval->usVers!=UNK_INTERVAL_VERS && pInterval->usVers < 100);
|
|
|
|
if (pInterval->usVers)
|
|
{
|
|
wnsprintfA(szVers, ARRAYSIZE(szVers), "%02lu", (ULONG) (pInterval->usVers));
|
|
}
|
|
else
|
|
{
|
|
szVers[0] = '\0';
|
|
}
|
|
FileTimeToSystemTime(&pInterval->ftStart, &stStart);
|
|
FileTimeToSystemTime(&pInterval->ftEnd, &stEnd);
|
|
wnsprintfA(szTempBuff, ARRAYSIZE(szTempBuff),
|
|
"%s%s%04lu%02lu%02lu%04lu%02lu%02lu",
|
|
c_szIntervalPrefix,
|
|
szVers,
|
|
(ULONG) stStart.wYear,
|
|
(ULONG) stStart.wMonth,
|
|
(ULONG) stStart.wDay,
|
|
(ULONG) stEnd.wYear,
|
|
(ULONG) stEnd.wMonth,
|
|
(ULONG) stEnd.wDay);
|
|
|
|
AnsiToTChar(szTempBuff, pszInterval, cchInterval);
|
|
}
|
|
|
|
LPITEMIDLIST CHistFolder::_HostPidl(LPCTSTR pszHostUrl, HSFINTERVAL *pInterval)
|
|
{
|
|
ASSERT(!_uViewType)
|
|
LPITEMIDLIST pidlReturn;
|
|
LPITEMIDLIST pidl;
|
|
struct _HOSTIDL
|
|
{
|
|
USHORT cb;
|
|
USHORT usSign;
|
|
TCHAR szHost[INTERNET_MAX_HOST_NAME_LENGTH+1];
|
|
} HostIDL;
|
|
struct _INTERVALIDL
|
|
{
|
|
USHORT cb;
|
|
USHORT usSign;
|
|
TCHAR szInterval[INTERVAL_SIZE+1];
|
|
struct _HOSTIDL hostIDL;
|
|
USHORT cbTrail;
|
|
} IntervalIDL;
|
|
LPBYTE pb;
|
|
USHORT cbSave;
|
|
|
|
ASSERT(_pidlRest);
|
|
pidl = _pidlRest;
|
|
cbSave = pidl->mkid.cb;
|
|
pidl->mkid.cb = 0;
|
|
|
|
ZeroMemory(&IntervalIDL, sizeof(IntervalIDL));
|
|
IntervalIDL.usSign = pInterval->usSign;
|
|
_KeyForInterval(pInterval, IntervalIDL.szInterval, ARRAYSIZE(IntervalIDL.szInterval));
|
|
IntervalIDL.cb = (USHORT)(2*sizeof(USHORT)+ (lstrlen(IntervalIDL.szInterval) + 1) * sizeof(TCHAR));
|
|
|
|
pb = ((LPBYTE) (&IntervalIDL)) + IntervalIDL.cb;
|
|
StrCpyN((LPTSTR)(pb+2*sizeof(USHORT)), pszHostUrl,
|
|
(sizeof(IntervalIDL) - (IntervalIDL.cb + (3 * sizeof(USHORT)))) / sizeof(TCHAR));
|
|
|
|
HostIDL.usSign = (USHORT)IDDPIDL_SIGN;
|
|
HostIDL.cb = (USHORT)(2*sizeof(USHORT)+(lstrlen((LPTSTR)(pb+2*sizeof(USHORT))) + 1) * sizeof(TCHAR));
|
|
|
|
memcpy(pb, &HostIDL, 2*sizeof(USHORT));
|
|
*(USHORT *)(&pb[HostIDL.cb]) = 0; // terminate the HostIDL ItemID
|
|
|
|
pidlReturn = ILCombine(_pidl, (LPITEMIDLIST) (&IntervalIDL));
|
|
pidl->mkid.cb = cbSave;
|
|
return pidlReturn;
|
|
}
|
|
|
|
// Notify that an event has occured that affects a specific element in
|
|
// history for special viewtypes
|
|
HRESULT CHistFolder::_ViewType_NotifyEvent(IN LPITEMIDLIST pidlRoot,
|
|
IN LPITEMIDLIST pidlHost,
|
|
IN LPITEMIDLIST pidlPage,
|
|
IN LONG wEventId)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ASSERT(pidlRoot && pidlHost && pidlPage);
|
|
|
|
// VIEPWIDL_ORDER_TODAY
|
|
LPITEMIDLIST pidlToday = _Combine_ViewPidl(VIEWPIDL_ORDER_TODAY, pidlPage);
|
|
if (pidlToday)
|
|
{
|
|
LPITEMIDLIST pidlNotify = ILCombine(pidlRoot, pidlToday);
|
|
if (pidlNotify)
|
|
{
|
|
SHChangeNotify(wEventId, SHCNF_IDLIST, pidlNotify, NULL);
|
|
ILFree(pidlNotify);
|
|
}
|
|
ILFree(pidlToday);
|
|
}
|
|
|
|
// VIEWPIDL_ORDER_SITE
|
|
LPITEMIDLIST pidlSite = _Combine_ViewPidl(VIEWPIDL_ORDER_SITE, pidlHost);
|
|
if (pidlSite)
|
|
{
|
|
LPITEMIDLIST pidlSitePage = ILCombine(pidlSite, pidlPage);
|
|
if (pidlSitePage)
|
|
{
|
|
LPITEMIDLIST pidlNotify = ILCombine(pidlRoot, pidlSitePage);
|
|
if (pidlNotify)
|
|
{
|
|
SHChangeNotify(wEventId, SHCNF_IDLIST, pidlNotify, NULL);
|
|
ILFree(pidlNotify);
|
|
}
|
|
ILFree(pidlSitePage);
|
|
}
|
|
ILFree(pidlSite);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
LPCTSTR CHistFolder::_GetLocalHost(void)
|
|
{
|
|
if (!*_szLocalHost)
|
|
::_GetLocalHost(_szLocalHost, SIZECHARS(_szLocalHost));
|
|
|
|
return _szLocalHost;
|
|
}
|
|
|
|
// NOTE: modifies pszUrl.
|
|
HRESULT CHistFolder::_NotifyWrite(LPTSTR pszUrl, int cchUrl, FILETIME *pftModified, LPITEMIDLIST * ppidlSelect)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
USHORT cbSave;
|
|
LPITEMIDLIST pidl;
|
|
LPITEMIDLIST pidlNotify;
|
|
LPITEMIDLIST pidlTemp;
|
|
LPITEMIDLIST pidlHost;
|
|
LPHEIPIDL phei = NULL;
|
|
HSFINTERVAL *pInterval;
|
|
FILETIME ftExpires = {0,0};
|
|
BOOL fNewHost;
|
|
LPCTSTR pszStrippedUrl = _StripHistoryUrlToUrl(pszUrl);
|
|
LPCTSTR pszHostUrl = pszStrippedUrl + HOSTPREFIXLEN;
|
|
DWORD cchFree = cchUrl - (DWORD)(pszStrippedUrl-pszUrl);
|
|
CHAR szAnsiUrl[MAX_URL_STRING];
|
|
|
|
ASSERT(_pidlRest);
|
|
pidl = _pidlRest;
|
|
cbSave = pidl->mkid.cb;
|
|
pidl->mkid.cb = 0;
|
|
|
|
/// Should also be able to get hitcount
|
|
STATURL suThis;
|
|
HRESULT hrLocal = E_FAIL;
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
if (pUrlHistStg)
|
|
{
|
|
hrLocal = pUrlHistStg->QueryUrl(_StripHistoryUrlToUrl(pszUrl),
|
|
STATURL_QUERYFLAG_NOURL, &suThis);
|
|
pUrlHistStg->Release();
|
|
}
|
|
|
|
phei = _CreateHCacheFolderPidl(FALSE, pszUrl, *pftModified,
|
|
(SUCCEEDED(hrLocal) ? &suThis : NULL), 0,
|
|
_GetHitCount(_StripHistoryUrlToUrl(pszUrl)));
|
|
|
|
if (SUCCEEDED(hrLocal) && suThis.pwcsTitle)
|
|
OleFree(suThis.pwcsTitle);
|
|
|
|
if (phei == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (cchFree <= HOSTPREFIXLEN)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
|
|
StrCpyN((LPTSTR)pszStrippedUrl, c_szHostPrefix, cchFree); // whack on the PIDL!
|
|
cchFree -= HOSTPREFIXLEN;
|
|
|
|
_GetURLHostFromUrl(HPidlToSourceUrl((LPBASEPIDL)phei),
|
|
(LPTSTR)pszHostUrl, cchFree, _GetLocalHost());
|
|
|
|
// chrisfra 4/9/97 we could take a small performance hit here and always
|
|
// update host entry. this would allow us to efficiently sort domains by most
|
|
// recent access.
|
|
|
|
fNewHost = FALSE;
|
|
dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
SHTCharToAnsi(pszUrl, szAnsiUrl, ARRAYSIZE(szAnsiUrl));
|
|
|
|
if (!GetUrlCacheEntryInfoA(szAnsiUrl, NULL, 0))
|
|
{
|
|
fNewHost = TRUE;
|
|
if (!CommitUrlCacheEntryA(szAnsiUrl, NULL, ftExpires, *pftModified,
|
|
URLHISTORY_CACHE_ENTRY|STICKY_CACHE_ENTRY,
|
|
NULL, 0, NULL, 0))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
}
|
|
|
|
|
|
hr = _GetInterval(pftModified, FALSE, &pInterval);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
pidlTemp = _HostPidl(pszHostUrl, pInterval);
|
|
if (pidlTemp == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
|
|
// Get just the host part of the pidl
|
|
pidlHost = ILFindLastID(pidlTemp);
|
|
ASSERT(pidlHost);
|
|
|
|
if (fNewHost)
|
|
{
|
|
SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, pidlTemp, NULL);
|
|
|
|
// We also need to notify special history views if they are listening:
|
|
// For now, just "View by Site" is relevant...
|
|
LPITEMIDLIST pidlViewSuffix = _Combine_ViewPidl(VIEWPIDL_ORDER_SITE, pidlHost);
|
|
if (pidlViewSuffix)
|
|
{
|
|
LPITEMIDLIST pidlNotify = ILCombine(_pidl, pidlViewSuffix);
|
|
if (pidlNotify)
|
|
{
|
|
SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, pidlNotify, NULL);
|
|
ILFree(pidlNotify);
|
|
}
|
|
ILFree(pidlViewSuffix);
|
|
}
|
|
}
|
|
|
|
pidlNotify = ILCombine(pidlTemp, (LPITEMIDLIST) phei);
|
|
if (pidlNotify == NULL)
|
|
{
|
|
ILFree(pidlTemp);
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
// Create (if its not there already) and Rename (if its there)
|
|
// Sending both notifys will be faster than trying to figure out
|
|
// which one is appropriate
|
|
SHChangeNotify(SHCNE_CREATE, SHCNF_IDLIST, pidlNotify, NULL);
|
|
|
|
// Also notify events for specail viewpidls!
|
|
_ViewType_NotifyEvent(_pidl, pidlHost, (LPITEMIDLIST)phei, SHCNE_CREATE);
|
|
|
|
if (ppidlSelect)
|
|
{
|
|
*ppidlSelect = pidlNotify;
|
|
}
|
|
else
|
|
{
|
|
ILFree(pidlNotify);
|
|
}
|
|
|
|
ILFree(pidlTemp);
|
|
exitPoint:
|
|
if (phei)
|
|
{
|
|
LocalFree(phei);
|
|
phei = NULL;
|
|
}
|
|
|
|
pidl->mkid.cb = cbSave;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_NotifyInterval(HSFINTERVAL *pInterval, LONG lEventID)
|
|
{
|
|
// special history views are not relevant here...
|
|
if (_uViewType)
|
|
return S_FALSE;
|
|
|
|
USHORT cbSave = 0;
|
|
LPITEMIDLIST pidl;
|
|
LPITEMIDLIST pidlNotify = NULL;
|
|
LPITEMIDLIST pidlNotify2 = NULL;
|
|
LPITEMIDLIST pidlNotify3 = NULL;
|
|
HRESULT hr = S_OK;
|
|
struct _INTERVALIDL
|
|
{
|
|
USHORT cb;
|
|
USHORT usSign;
|
|
TCHAR szInterval[INTERVAL_SIZE+1];
|
|
USHORT cbTrail;
|
|
} IntervalIDL,IntervalIDL2;
|
|
|
|
ASSERT(_pidlRest);
|
|
pidl = _pidlRest;
|
|
cbSave = pidl->mkid.cb;
|
|
pidl->mkid.cb = 0;
|
|
|
|
ZeroMemory(&IntervalIDL, sizeof(IntervalIDL));
|
|
IntervalIDL.usSign = pInterval->usSign;
|
|
_KeyForInterval(pInterval, IntervalIDL.szInterval, ARRAYSIZE(IntervalIDL.szInterval));
|
|
IntervalIDL.cb = (USHORT)(2*sizeof(USHORT) + (lstrlen(IntervalIDL.szInterval) + 1)*sizeof(TCHAR));
|
|
|
|
if (lEventID&SHCNE_RENAMEFOLDER || // was TODAY, now is a weekday
|
|
(lEventID&SHCNE_RMDIR && 1 == _DaysInInterval(pInterval)) ) // one day, maybe TODAY
|
|
{
|
|
memcpy(&IntervalIDL2, &IntervalIDL, sizeof(IntervalIDL));
|
|
IntervalIDL2.usSign = (USHORT)IDTPIDL_SIGN;
|
|
pidlNotify2 = ILCombine(_pidl, (LPITEMIDLIST) (&IntervalIDL));
|
|
pidlNotify = ILCombine(_pidl, (LPITEMIDLIST) (&IntervalIDL2));
|
|
if (pidlNotify2 == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
if (lEventID&SHCNE_RMDIR)
|
|
{
|
|
pidlNotify3 = pidlNotify2;
|
|
pidlNotify2 = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pidlNotify = ILCombine(_pidl, (LPITEMIDLIST) (&IntervalIDL));
|
|
}
|
|
if (pidlNotify == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
SHChangeNotify(lEventID, SHCNF_IDLIST, pidlNotify, pidlNotify2);
|
|
if (pidlNotify3) SHChangeNotify(lEventID, SHCNF_IDLIST, pidlNotify3, NULL);
|
|
|
|
exitPoint:
|
|
ILFree(pidlNotify);
|
|
ILFree(pidlNotify2);
|
|
ILFree(pidlNotify3);
|
|
if (cbSave) pidl->mkid.cb = cbSave;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_CreateInterval(FILETIME *pftStart, DWORD dwDays)
|
|
{
|
|
HSFINTERVAL interval;
|
|
TCHAR szInterval[INTERVAL_SIZE+1];
|
|
UINT err;
|
|
FILETIME ftNow;
|
|
SYSTEMTIME stNow;
|
|
CHAR szIntervalAnsi[INTERVAL_SIZE+1], szCachePrefixAnsi[INTERVAL_SIZE+1];
|
|
|
|
#define CREATE_OPTIONS (INTERNET_CACHE_CONTAINER_AUTODELETE | \
|
|
INTERNET_CACHE_CONTAINER_NOSUBDIRS | \
|
|
INTERNET_CACHE_CONTAINER_NODESKTOPINIT)
|
|
|
|
// _FileTimeDeltaDays guarantees times just at the 0th tick of the day
|
|
_FileTimeDeltaDays(pftStart, &interval.ftStart, 0);
|
|
_FileTimeDeltaDays(pftStart, &interval.ftEnd, dwDays);
|
|
interval.usVers = OUR_VERS;
|
|
GetLocalTime(&stNow);
|
|
SystemTimeToFileTime(&stNow, &ftNow);
|
|
_FileTimeDeltaDays(&ftNow, &ftNow, 0);
|
|
_SetValueSign(&interval, ftNow);
|
|
|
|
_KeyForInterval(&interval, szInterval, ARRAYSIZE(szInterval));
|
|
|
|
interval.szPrefix[0] = ':';
|
|
StrCpyN(&interval.szPrefix[1], &szInterval[INTERVAL_PREFIX_LEN+INTERVAL_VERS_LEN],
|
|
ARRAYSIZE(interval.szPrefix) - 1);
|
|
StrCatBuff(interval.szPrefix, TEXT(": "), ARRAYSIZE(interval.szPrefix));
|
|
|
|
SHTCharToAnsi(szInterval, szIntervalAnsi, ARRAYSIZE(szIntervalAnsi));
|
|
SHTCharToAnsi(interval.szPrefix, szCachePrefixAnsi, ARRAYSIZE(szCachePrefixAnsi));
|
|
|
|
if (CreateUrlCacheContainerA(szIntervalAnsi, // Name
|
|
szCachePrefixAnsi, // CachePrefix
|
|
NULL, // Path
|
|
0, // Cache Limit
|
|
0, // Container Type
|
|
CREATE_OPTIONS, // Create Options
|
|
NULL, // Create Buffer
|
|
0)) // Create Buffer size
|
|
{
|
|
_NotifyInterval(&interval, SHCNE_MKDIR);
|
|
err = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
err = GetLastError();
|
|
}
|
|
return ERROR_SUCCESS == err ? S_OK : HRESULT_FROM_WIN32(err);
|
|
}
|
|
|
|
HRESULT CHistFolder::_PrefixUrl(LPCTSTR pszStrippedUrl,
|
|
FILETIME *pftLastModifiedTime,
|
|
LPTSTR pszPrefixedUrl,
|
|
DWORD cchPrefixedUrl)
|
|
{
|
|
HRESULT hr;
|
|
HSFINTERVAL *pInterval;
|
|
|
|
hr = _GetInterval(pftLastModifiedTime, FALSE, &pInterval);
|
|
if (S_OK == hr)
|
|
{
|
|
if ((DWORD)((lstrlen(pszStrippedUrl) + lstrlen(pInterval->szPrefix) + 1) * sizeof(TCHAR)) > cchPrefixedUrl)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
StrCpyN(pszPrefixedUrl, pInterval->szPrefix, cchPrefixedUrl);
|
|
StrCatBuff(pszPrefixedUrl, pszStrippedUrl, cchPrefixedUrl);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CHistFolder::_WriteHistory(LPCTSTR pszPrefixedUrl, FILETIME ftExpires, FILETIME ftModified,
|
|
BOOL fSendNotify, LPITEMIDLIST * ppidlSelect)
|
|
{
|
|
TCHAR szNewPrefixedUrl[INTERNET_MAX_URL_LENGTH+1];
|
|
HRESULT hr = E_INVALIDARG;
|
|
LPCTSTR pszUrlMinusContainer;
|
|
|
|
pszUrlMinusContainer = _StripContainerUrlUrl(pszPrefixedUrl);
|
|
|
|
if (pszUrlMinusContainer)
|
|
{
|
|
hr = _PrefixUrl(pszUrlMinusContainer,
|
|
&ftModified,
|
|
szNewPrefixedUrl,
|
|
ARRAYSIZE(szNewPrefixedUrl));
|
|
if (S_OK == hr)
|
|
{
|
|
CHAR szAnsiUrl[MAX_URL_STRING+1];
|
|
|
|
SHTCharToAnsi(szNewPrefixedUrl, szAnsiUrl, ARRAYSIZE(szAnsiUrl));
|
|
if (!CommitUrlCacheEntryA(
|
|
szAnsiUrl,
|
|
NULL,
|
|
ftExpires,
|
|
ftModified,
|
|
URLHISTORY_CACHE_ENTRY|STICKY_CACHE_ENTRY,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else
|
|
{
|
|
if (fSendNotify)
|
|
_NotifyWrite(szNewPrefixedUrl, ARRAYSIZE(szNewPrefixedUrl),
|
|
&ftModified, ppidlSelect);
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// This function will update any shell that might be listening to us
|
|
// to redraw the directory.
|
|
// It will do this by generating a SHCNE_UPDATE for all possible pidl roots
|
|
// that the shell could have. Hopefully, this should be sufficient...
|
|
// Specifically, this is meant to be called by ClearHistory.
|
|
HRESULT CHistFolder::_ViewType_NotifyUpdateAll()
|
|
{
|
|
LPITEMIDLIST pidlHistory;
|
|
if (SUCCEEDED(SHGetHistoryPIDL(&pidlHistory)))
|
|
{
|
|
for (USHORT us = 1; us <= VIEWPIDL_ORDER_MAX; ++us)
|
|
{
|
|
LPITEMIDLIST pidlView;
|
|
if (SUCCEEDED(CreateSpecialViewPidl(us, &pidlView)))
|
|
{
|
|
LPITEMIDLIST pidlTemp = ILCombine(pidlHistory, pidlView);
|
|
if (pidlTemp)
|
|
{
|
|
SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
ILFree(pidlView);
|
|
}
|
|
}
|
|
ILFree(pidlHistory);
|
|
SHChangeNotifyHandleEvents();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
// On a per user basis.
|
|
// chrisfra 6/11/97. _DeleteItems of a Time Interval deletes the entire interval.
|
|
// ClearHistory should probably work the same. Pros of _DeleteEntries is on non-profile,
|
|
// multi-user machine, other user's history is preserved. Cons is that on profile based
|
|
// machine, empty intervals are created.
|
|
HRESULT CHistFolder::ClearHistory()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int i;
|
|
|
|
hr = _ValidateIntervalCache();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (i = 0; i < _cbIntervals; i++)
|
|
{
|
|
_DeleteInterval(&_pIntervalCache[i]);
|
|
}
|
|
}
|
|
#ifndef UNIX
|
|
_ViewType_NotifyUpdateAll();
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
|
|
// ftModified is in "User Perceived", ie local time
|
|
// stuffed into FILETIME as if it were UNC. ftExpires is in normal UNC time.
|
|
HRESULT CHistFolder::WriteHistory(LPCTSTR pszPrefixedUrl,
|
|
FILETIME ftExpires, FILETIME ftModified,
|
|
LPITEMIDLIST * ppidlSelect)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = _ValidateIntervalCache();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _WriteHistory(pszPrefixedUrl, ftExpires, ftModified, TRUE, ppidlSelect);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Makes best efforts attempt to copy old style history items into new containers
|
|
HRESULT CHistFolder::_CopyEntries(LPCTSTR pszHistPrefix)
|
|
{
|
|
HANDLE hEnum = NULL;
|
|
HRESULT hr;
|
|
BOOL fNotCopied = FALSE;
|
|
LPINTERNET_CACHE_ENTRY_INFO pceiWorking;
|
|
DWORD dwBuffSize;
|
|
LPTSTR pszSearchPattern = NULL;
|
|
TCHAR szHistSearchPattern[65]; // search pattern for history items
|
|
|
|
|
|
StrCpyN(szHistSearchPattern, pszHistPrefix, ARRAYSIZE(szHistSearchPattern));
|
|
|
|
// We can't pass in the whole search pattern that we want,
|
|
// because FindFirstUrlCacheEntry is busted. It will only look at the
|
|
// prefix if there is a cache container for that prefix. So, we can
|
|
// pass in "Visited: " and enumerate all the history items in the cache,
|
|
// but then we need to pull out only the ones with the correct username.
|
|
|
|
// StrCpy(szHistSearchPattern, szUserName);
|
|
|
|
pszSearchPattern = szHistSearchPattern;
|
|
|
|
pceiWorking = (LPINTERNET_CACHE_ENTRY_INFO)LocalAlloc(LPTR, MAX_URLCACHE_ENTRY);
|
|
if (NULL == pceiWorking)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
hr = _ValidateIntervalCache();
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
while (SUCCEEDED(hr))
|
|
{
|
|
dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
if (!hEnum)
|
|
{
|
|
hEnum = FindFirstUrlCacheEntry(pszSearchPattern, pceiWorking, &dwBuffSize);
|
|
if (!hEnum)
|
|
{
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
else if (!FindNextUrlCacheEntry(hEnum, pceiWorking, &dwBuffSize))
|
|
{
|
|
// chrisfra 4/3/97 should we distinquish eod vs hard errors?
|
|
// old code for cachevu doesn't (see above in enum code)
|
|
hr = S_OK;
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
((pceiWorking->CacheEntryType & URLHISTORY_CACHE_ENTRY) == URLHISTORY_CACHE_ENTRY) &&
|
|
_FilterPrefix(pceiWorking, (LPTSTR) pszHistPrefix))
|
|
{
|
|
hr = _WriteHistory(pceiWorking->lpszSourceUrlName,
|
|
pceiWorking->ExpireTime,
|
|
pceiWorking->LastModifiedTime,
|
|
FALSE,
|
|
NULL);
|
|
if (S_FALSE == hr) fNotCopied = TRUE;
|
|
}
|
|
}
|
|
exitPoint:
|
|
if (pceiWorking)
|
|
{
|
|
LocalFree(pceiWorking);
|
|
pceiWorking = NULL;
|
|
}
|
|
|
|
if (hEnum)
|
|
{
|
|
FindCloseUrlCache(hEnum);
|
|
}
|
|
return SUCCEEDED(hr) ? (fNotCopied ? S_FALSE : S_OK) : hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_GetUserName(LPTSTR pszUserName, DWORD cchUserName)
|
|
{
|
|
HRESULT hr = _EnsureHistStg();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _pUrlHistStg->GetUserName(pszUserName, cchUserName);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Makes best efforts attempt to delete old history items in container on a per
|
|
// user basis. if we get rid of per user - can just empty whole container
|
|
HRESULT CHistFolder::_DeleteEntries(LPCTSTR pszHistPrefix, PFNDELETECALLBACK pfnDeleteFilter, void * pDelData)
|
|
{
|
|
HANDLE hEnum = NULL;
|
|
HRESULT hr = S_OK;
|
|
BOOL fNotDeleted = FALSE;
|
|
LPINTERNET_CACHE_ENTRY_INFO pceiWorking;
|
|
DWORD dwBuffSize;
|
|
LPTSTR pszSearchPattern = NULL;
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1]; // username of person logged on
|
|
DWORD dwUserNameLen = INTERNET_MAX_USER_NAME_LENGTH + 1; // len of this buffer
|
|
TCHAR szHistSearchPattern[PREFIX_SIZE+1]; // search pattern for history items
|
|
LPITEMIDLIST pidlNotify;
|
|
|
|
StrCpyN(szHistSearchPattern, pszHistPrefix, ARRAYSIZE(szHistSearchPattern));
|
|
if (FAILED(_GetUserName(szUserName, dwUserNameLen)))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
// We can't pass in the whole search pattern that we want,
|
|
// because FindFirstUrlCacheEntry is busted. It will only look at the
|
|
// prefix if there is a cache container for that prefix. So, we can
|
|
// pass in "Visited: " and enumerate all the history items in the cache,
|
|
// but then we need to pull out only the ones with the correct username.
|
|
|
|
// StrCpy(szHistSearchPattern, szUserName);
|
|
|
|
pszSearchPattern = szHistSearchPattern;
|
|
|
|
pceiWorking = (LPINTERNET_CACHE_ENTRY_INFO)LocalAlloc(LPTR, MAX_URLCACHE_ENTRY);
|
|
if (NULL == pceiWorking)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
|
|
while (SUCCEEDED(hr))
|
|
{
|
|
dwBuffSize = MAX_URLCACHE_ENTRY;
|
|
if (!hEnum)
|
|
{
|
|
hEnum = FindFirstUrlCacheEntry(pszSearchPattern, pceiWorking, &dwBuffSize);
|
|
if (!hEnum)
|
|
{
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
else if (!FindNextUrlCacheEntry(hEnum, pceiWorking, &dwBuffSize))
|
|
{
|
|
// chrisfra 4/3/97 should we distinquish eod vs hard errors?
|
|
// old code for cachevu doesn't (see above in enum code)
|
|
hr = S_OK;
|
|
goto exitPoint;
|
|
}
|
|
|
|
pidlNotify = NULL;
|
|
if (SUCCEEDED(hr) &&
|
|
((pceiWorking->CacheEntryType & URLHISTORY_CACHE_ENTRY) == URLHISTORY_CACHE_ENTRY) &&
|
|
_FilterUserName(pceiWorking, pszHistPrefix, szUserName) &&
|
|
(NULL == pfnDeleteFilter || pfnDeleteFilter(pceiWorking, pDelData, &pidlNotify)))
|
|
{
|
|
//if (!DeleteUrlCacheEntryA(pceiWorking->lpszSourceUrlName))
|
|
if (FAILED(_DeleteUrlFromBucket(pceiWorking->lpszSourceUrlName)))
|
|
{
|
|
fNotDeleted = TRUE;
|
|
}
|
|
else if (pidlNotify)
|
|
{
|
|
SHChangeNotify(SHCNE_DELETE, SHCNF_IDLIST, pidlNotify, NULL);
|
|
}
|
|
}
|
|
ILFree(pidlNotify);
|
|
}
|
|
exitPoint:
|
|
if (pceiWorking)
|
|
{
|
|
LocalFree(pceiWorking);
|
|
pceiWorking = NULL;
|
|
}
|
|
|
|
if (hEnum)
|
|
{
|
|
FindCloseUrlCache(hEnum);
|
|
}
|
|
return SUCCEEDED(hr) ? (fNotDeleted ? S_FALSE : S_OK) : hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_DeleteInterval(HSFINTERVAL *pInterval)
|
|
{
|
|
UINT err = S_OK;
|
|
TCHAR szInterval[INTERVAL_SIZE+1];
|
|
CHAR szAnsiInterval[INTERVAL_SIZE+1];
|
|
|
|
_KeyForInterval(pInterval, szInterval, ARRAYSIZE(szInterval));
|
|
|
|
SHTCharToAnsi(szInterval, szAnsiInterval, ARRAYSIZE(szAnsiInterval));
|
|
if (!DeleteUrlCacheContainerA(szAnsiInterval, 0))
|
|
{
|
|
err = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
_NotifyInterval(pInterval, SHCNE_RMDIR);
|
|
}
|
|
return S_OK == err ? S_OK : HRESULT_FROM_WIN32(err);
|
|
}
|
|
|
|
// Returns S_OK if no intervals we're deleted, S_FALSE if at least
|
|
// one interval was deleted.
|
|
HRESULT CHistFolder::_CleanUpHistory(FILETIME ftLimit, FILETIME ftTommorrow)
|
|
{
|
|
HRESULT hr;
|
|
BOOL fChangedRegistry = FALSE;
|
|
int i;
|
|
|
|
// _CleanUpHistory does two things:
|
|
//
|
|
// If we have any stale weeks destroy them and flag the change
|
|
//
|
|
// If we have any days that should be in cache but not in dailies
|
|
// copy them to the relevant week then destroy those days
|
|
// and flag the change
|
|
|
|
hr = _LoadIntervalCache();
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
for (i = 0; i < _cbIntervals; i++)
|
|
{
|
|
// Delete old intervals or ones which start at a day in the future
|
|
// (due to fooling with the clock)
|
|
if (CompareFileTime(&_pIntervalCache[i].ftEnd, &ftLimit) < 0 ||
|
|
CompareFileTime(&_pIntervalCache[i].ftStart, &ftTommorrow) >= 0)
|
|
{
|
|
fChangedRegistry = TRUE;
|
|
hr = _DeleteInterval(&_pIntervalCache[i]);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
}
|
|
else if (1 == _DaysInInterval(&_pIntervalCache[i]))
|
|
{
|
|
HSFINTERVAL *pWeek;
|
|
|
|
// NOTE: at this point we have guaranteed, we've built weeks
|
|
// for all days outside of current week
|
|
if (S_OK == _GetInterval(&_pIntervalCache[i].ftStart, TRUE, &pWeek))
|
|
{
|
|
fChangedRegistry = TRUE;
|
|
hr = _CopyEntries(_pIntervalCache[i].szPrefix);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
_NotifyInterval(pWeek, SHCNE_UPDATEDIR);
|
|
|
|
hr = _DeleteInterval(&_pIntervalCache[i]);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
}
|
|
|
|
exitPoint:
|
|
if (S_OK == hr && fChangedRegistry) hr = S_FALSE;
|
|
return hr;
|
|
}
|
|
|
|
typedef struct _HSFDELETEDATA
|
|
{
|
|
UINT cidl;
|
|
LPCITEMIDLIST *ppidl;
|
|
LPCITEMIDLIST pidlParent;
|
|
} HSFDELETEDATA,*LPHSFDELETEDATA;
|
|
|
|
// delete if matches any host on list
|
|
BOOL fDeleteInHostList(LPINTERNET_CACHE_ENTRY_INFO pceiWorking, void * pDelData, LPITEMIDLIST *ppidlNotify)
|
|
{
|
|
LPHSFDELETEDATA phsfd = (LPHSFDELETEDATA)pDelData;
|
|
TCHAR szHost[INTERNET_MAX_HOST_NAME_LENGTH+1];
|
|
TCHAR szLocalHost[INTERNET_MAX_HOST_NAME_LENGTH+1];
|
|
|
|
UINT i;
|
|
|
|
_GetLocalHost(szLocalHost, SIZECHARS(szLocalHost));
|
|
_GetURLHost(pceiWorking, szHost, INTERNET_MAX_HOST_NAME_LENGTH, szLocalHost);
|
|
for (i = 0; i < phsfd->cidl; i++)
|
|
{
|
|
if (!ualstrcmpi(szHost, _GetURLTitle((LPBASEPIDL)(phsfd->ppidl[i]))))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Will attempt to hunt down all occurrances of this url in any of the
|
|
// various history buckets...
|
|
// This is a utility function for _ViewType_DeleteItems -- it may
|
|
// be used in other contexts providing these preconditions
|
|
// are kept in mind:
|
|
//
|
|
// *The URL passed in should be prefixed ONLY with the username portion
|
|
// such that this function can prepend prefixes to these urls
|
|
// *WARNING: This function ASSUMES that _ValidateIntervalCache
|
|
// has been called recently!!!! DANGER DANGER!
|
|
//
|
|
// RETURNS: S_OK if at least one entry was found and deleted
|
|
//
|
|
HRESULT CHistFolder::_DeleteUrlHistoryGlobal(LPCTSTR pszUrl) {
|
|
HRESULT hr = E_FAIL;
|
|
if (pszUrl) {
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
if (pUrlHistStg) {
|
|
LPCTSTR pszStrippedUrl = _StripHistoryUrlToUrl(pszUrl);
|
|
if (pszStrippedUrl)
|
|
{
|
|
UINT cchwTempUrl = lstrlen(pszStrippedUrl) + 1;
|
|
LPWSTR pwszTempUrl = ((LPWSTR)LocalAlloc(LPTR, cchwTempUrl * sizeof(WCHAR)));
|
|
if (pwszTempUrl)
|
|
{
|
|
SHTCharToUnicode(pszStrippedUrl, pwszTempUrl, cchwTempUrl);
|
|
hr = pUrlHistStg->DeleteUrl(pwszTempUrl, URLFLAG_DONT_DELETE_SUBSCRIBED);
|
|
for (int i = 0; i < _cbIntervals; ++i) {
|
|
// should this length be constant? (bucket sizes shouldn't vary)
|
|
UINT cchTempUrl = (PREFIX_SIZE +
|
|
lstrlen(pszUrl) + 1);
|
|
LPTSTR pszTempUrl = ((LPTSTR)LocalAlloc(LPTR, cchTempUrl * sizeof(TCHAR)));
|
|
if (pszTempUrl) {
|
|
// StrCpy null terminates
|
|
StrCpyN(pszTempUrl, _pIntervalCache[i].szPrefix, cchTempUrl);
|
|
StrCpyN(pszTempUrl + PREFIX_SIZE, pszUrl, cchTempUrl - PREFIX_SIZE);
|
|
if (DeleteUrlCacheEntry(pszTempUrl))
|
|
hr = S_OK;
|
|
|
|
LocalFree(pszTempUrl);
|
|
pszTempUrl = NULL;
|
|
}
|
|
else {
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
LocalFree(pwszTempUrl);
|
|
pwszTempUrl = NULL;
|
|
}
|
|
else {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
pUrlHistStg->Release();
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
return hr;
|
|
}
|
|
|
|
// WARNING: assumes ppidl
|
|
HRESULT CHistFolder::_ViewBySite_DeleteItems(LPCITEMIDLIST *ppidl, UINT cidl)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1];
|
|
if (FAILED(_GetUserName(szUserName, ARRAYSIZE(szUserName))))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
|
|
if (pUrlHistStg)
|
|
{
|
|
IEnumSTATURL *penum;
|
|
if (SUCCEEDED(pUrlHistStg->EnumUrls(&penum)) &&
|
|
penum) {
|
|
|
|
for (UINT i = 0; i < cidl; ++i)
|
|
{
|
|
LPCUTSTR pszHostName = _GetURLTitle((LPBASEPIDL)ppidl[i]);
|
|
UINT uUserNameLen = lstrlen(szUserName);
|
|
UINT uBuffLen = (USHORT)((HOSTPREFIXLEN + uUserNameLen +
|
|
ualstrlen(pszHostName) + 2)); // insert '@' and '\0'
|
|
LPTSTR pszUrl =
|
|
((LPTSTR)LocalAlloc(LPTR, (uBuffLen) * sizeof(TCHAR)));
|
|
if (pszUrl) {
|
|
// get rid of ":Host: " prefixed entires in the cache
|
|
// Generates "username@:Host: hostname" -- wnsprintf null terminates
|
|
wnsprintf(pszUrl, uBuffLen, TEXT("%s@%s%s"), szUserName,
|
|
c_szHostPrefix, pszHostName);
|
|
hr = _DeleteUrlHistoryGlobal(pszUrl);
|
|
|
|
// enumerate over all urls in history
|
|
|
|
ULONG cFetched;
|
|
// don't retrieve TITLE information (too much overhead)
|
|
penum->SetFilter(NULL, STATURL_QUERYFLAG_NOTITLE);
|
|
STATURL statUrl;
|
|
statUrl.cbSize = sizeof(STATURL);
|
|
while(SUCCEEDED(penum->Next(1, &statUrl, &cFetched)) && cFetched) {
|
|
if (statUrl.pwcsUrl) {
|
|
// these next few lines painfully constructs a string
|
|
// that is of the form "username@url"
|
|
LPTSTR pszStatUrlUrl;
|
|
UINT uStatUrlUrlLen = lstrlenW(statUrl.pwcsUrl);
|
|
pszStatUrlUrl = statUrl.pwcsUrl;
|
|
TCHAR szHost[INTERNET_MAX_HOST_NAME_LENGTH + 1];
|
|
_GetURLHostFromUrl_NoStrip(pszStatUrlUrl, szHost, INTERNET_MAX_HOST_NAME_LENGTH + 1, _GetLocalHost());
|
|
|
|
if (!ualstrcmpi(szHost, pszHostName)) {
|
|
LPTSTR pszDelUrl; // url to be deleted
|
|
UINT uUrlLen = uUserNameLen + 1 + uStatUrlUrlLen; // +1 for '@'
|
|
pszDelUrl = ((LPTSTR)LocalAlloc(LPTR, (uUrlLen + 1) * sizeof(TCHAR)));
|
|
if (pszDelUrl) {
|
|
wnsprintf(pszDelUrl, uUrlLen + 1, TEXT("%s@%s"), szUserName, pszStatUrlUrl);
|
|
// finally, delete all all occurrances of that URL in all history buckets
|
|
hr = _DeleteUrlHistoryGlobal(pszDelUrl);
|
|
|
|
//
|
|
// Is is really safe to delete *during* an enumeration like this, or should
|
|
// we cache all of the URLS and delete at the end? I'd rather do it this
|
|
// way if possible -- anyhoo, no docs say its bad to do -- 'course there are no docs ;)
|
|
// Also, there is an example of code later that deletes during an enumeration
|
|
// and seems to work...
|
|
LocalFree(pszDelUrl);
|
|
pszDelUrl = NULL;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
OleFree(statUrl.pwcsUrl);
|
|
}
|
|
}
|
|
penum->Reset();
|
|
LocalFree(pszUrl);
|
|
pszUrl = NULL;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
LPITEMIDLIST pidlTemp = ILCombine(_pidl, ppidl[i]);
|
|
if (pidlTemp) {
|
|
SHChangeNotify(SHCNE_RMDIR, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (hr == E_OUTOFMEMORY)
|
|
break;
|
|
} // for
|
|
penum->Release();
|
|
} // if penum
|
|
else
|
|
hr = E_FAIL;
|
|
pUrlHistStg->Release();
|
|
} // if purlHistStg
|
|
else
|
|
hr = E_FAIL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// This guy will delete an URL from one history (MSHIST-type) bucket
|
|
// and then try to find it in other (MSHIST-type) buckets.
|
|
// If it can't be found, then the URL will be removed from the main
|
|
// history (Visited-type) bucket.
|
|
// NOTE: Only the url will be deleted and not any of its "frame-children"
|
|
// This is probably not the a great thing...
|
|
// ASSUMES that _ValidateIntervalCache has been called recently
|
|
HRESULT CHistFolder::_DeleteUrlFromBucket(LPCTSTR pszPrefixedUrl) {
|
|
HRESULT hr = E_FAIL;
|
|
if (DeleteUrlCacheEntry(pszPrefixedUrl)) {
|
|
// check if we need to delete this url from the main Visited container, too
|
|
// we make sure that url exists in at least one other bucket
|
|
LPCTSTR pszUrl = _StripHistoryUrlToUrl(pszPrefixedUrl);
|
|
if (pszUrl)
|
|
{
|
|
DWORD dwError = _SearchFlatCacheForUrl(pszUrl, NULL, NULL);
|
|
if (dwError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
if (pUrlHistStg)
|
|
{
|
|
pUrlHistStg->DeleteUrl(pszUrl, 0);
|
|
pUrlHistStg->Release();
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Tries to delete as many as possible, and returns E_FAIL if the last one could not
|
|
// be deleted.
|
|
// <RATIONALIZATION>not usually called with more than one pidl</RATIONALIZATION>
|
|
// ASSUMES that _ValidateIntervalCache has been called recently
|
|
HRESULT CHistFolder::_ViewType_DeleteItems(LPCITEMIDLIST *ppidl, UINT cidl)
|
|
{
|
|
ASSERT(_uViewType);
|
|
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (ppidl) {
|
|
switch(_uViewType) {
|
|
case VIEWPIDL_ORDER_SITE:
|
|
if (_uViewDepth == 0) {
|
|
hr = _ViewBySite_DeleteItems(ppidl, cidl);
|
|
break;
|
|
}
|
|
ASSERT(_uViewDepth == 1);
|
|
// FALLTHROUGH INTENTIONAL!!
|
|
case VIEWPIDL_SEARCH:
|
|
case VIEWPIDL_ORDER_FREQ: {
|
|
for (UINT i = 0; i < cidl; ++i) {
|
|
LPCTSTR pszPrefixedUrl = HPidlToSourceUrl(ppidl[i]);
|
|
if (pszPrefixedUrl) {
|
|
if (SUCCEEDED((hr =
|
|
_DeleteUrlHistoryGlobal(_StripContainerUrlUrl(pszPrefixedUrl)))))
|
|
{
|
|
LPITEMIDLIST pidlTemp = ILCombine(_pidl, ppidl[i]);
|
|
if (pidlTemp) {
|
|
SHChangeNotify(SHCNE_DELETE, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
}
|
|
case VIEWPIDL_ORDER_TODAY: {
|
|
// find the entry in the cache and delete it:
|
|
for (UINT i = 0; i < cidl; ++i)
|
|
{
|
|
if (_IsValid_HEIPIDL(ppidl[i]))
|
|
{
|
|
hr = _DeleteUrlFromBucket(HPidlToSourceUrl(ppidl[i]));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlTemp = ILCombine(_pidl, ppidl[i]);
|
|
if (pidlTemp)
|
|
{
|
|
SHChangeNotify(SHCNE_DELETE, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
hr = E_NOTIMPL;
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CHistFolder::_DeleteItems(LPCITEMIDLIST *ppidl, UINT cidl)
|
|
{
|
|
UINT i;
|
|
HSFDELETEDATA hsfDeleteData = {cidl, ppidl, _pidl};
|
|
HSFINTERVAL *pDelInterval;
|
|
FILETIME ftStart;
|
|
FILETIME ftEnd;
|
|
LPCUTSTR pszIntervalName;
|
|
|
|
HRESULT hr = _ValidateIntervalCache();
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
if (_uViewType)
|
|
{
|
|
hr = _ViewType_DeleteItems(ppidl, cidl);
|
|
goto exitPoint; // when in rome...
|
|
}
|
|
|
|
switch(_foldertype)
|
|
{
|
|
case FOLDER_TYPE_Hist:
|
|
for (i = 0; i < cidl; i++)
|
|
{
|
|
pszIntervalName = _GetURLTitle((LPBASEPIDL)ppidl[i]);
|
|
|
|
hr = _ValueToInterval(pszIntervalName, &ftStart, &ftEnd);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
if (S_OK == _GetInterval(&ftStart, FALSE, &pDelInterval))
|
|
{
|
|
hr = _DeleteInterval(pDelInterval);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
break;
|
|
case FOLDER_TYPE_HistInterval:
|
|
// last id of of _pidl is name of interval, which implies start and end
|
|
pszIntervalName = _GetURLTitle((LPBASEPIDL)ILFindLastID(_pidl));
|
|
hr = _ValueToInterval(pszIntervalName, &ftStart, &ftEnd);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
if (S_OK == _GetInterval(&ftStart, FALSE, &pDelInterval))
|
|
{
|
|
// It's important to delete the host: <HOSTNAME> url's first so that
|
|
// an interleaved _NotityWrite() will not leave us inserting a pidl
|
|
// but the the host: directory. it is a conscious performance tradeoff
|
|
// we're making here to not MUTEX this operation (rare) with _NotifyWrite
|
|
for (i = 0; i < cidl; i++)
|
|
{
|
|
LPCTSTR pszHost;
|
|
LPITEMIDLIST pidlTemp;
|
|
TCHAR szNewPrefixedUrl[INTERNET_MAX_URL_LENGTH+1];
|
|
TCHAR szUrlMinusContainer[INTERNET_MAX_URL_LENGTH+1];
|
|
|
|
ua_GetURLTitle( &pszHost, (LPBASEPIDL)ppidl[i] );
|
|
DWORD cbHost = lstrlen(pszHost);
|
|
|
|
// Compose the prefixed URL for the host cache entry, then
|
|
// use it to delete host entry
|
|
hr = _GetUserName(szUrlMinusContainer, ARRAYSIZE(szUrlMinusContainer));
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
DWORD cbUserName = lstrlen(szUrlMinusContainer);
|
|
|
|
if ((cbHost + cbUserName + 1)*sizeof(TCHAR) + HOSTPREFIXLEN > INTERNET_MAX_URL_LENGTH)
|
|
{
|
|
hr = E_FAIL;
|
|
goto exitPoint;
|
|
}
|
|
StrCatBuff(szUrlMinusContainer, TEXT("@"), ARRAYSIZE(szUrlMinusContainer));
|
|
StrCatBuff(szUrlMinusContainer, c_szHostPrefix, ARRAYSIZE(szUrlMinusContainer));
|
|
StrCatBuff(szUrlMinusContainer, pszHost, ARRAYSIZE(szUrlMinusContainer));
|
|
hr = _PrefixUrl(szUrlMinusContainer,
|
|
&ftStart,
|
|
szNewPrefixedUrl,
|
|
ARRAYSIZE(szNewPrefixedUrl));
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
if (!DeleteUrlCacheEntry(szNewPrefixedUrl))
|
|
{
|
|
hr = E_FAIL;
|
|
goto exitPoint;
|
|
}
|
|
pidlTemp = _HostPidl(pszHost, pDelInterval);
|
|
if (pidlTemp == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exitPoint;
|
|
}
|
|
SHChangeNotify(SHCNE_RMDIR, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
hr = _DeleteEntries(_pszCachePrefix , fDeleteInHostList, &hsfDeleteData);
|
|
}
|
|
break;
|
|
case FOLDER_TYPE_HistDomain:
|
|
for (i = 0; i < cidl; ++i)
|
|
{
|
|
if (_IsValid_HEIPIDL(ppidl[i]))
|
|
{
|
|
hr = _DeleteUrlFromBucket(HPidlToSourceUrl(ppidl[i]));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlTemp = ILCombine(_pidl, ppidl[i]);
|
|
if (pidlTemp)
|
|
{
|
|
SHChangeNotify(SHCNE_DELETE, SHCNF_IDLIST, pidlTemp, NULL);
|
|
ILFree(pidlTemp);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
}
|
|
exitPoint:
|
|
|
|
if (SUCCEEDED(hr))
|
|
SHChangeNotifyHandleEvents();
|
|
|
|
return hr;
|
|
}
|
|
|
|
IUrlHistoryPriv *CHistFolder::_GetHistStg()
|
|
{
|
|
_EnsureHistStg();
|
|
if (_pUrlHistStg)
|
|
{
|
|
_pUrlHistStg->AddRef();
|
|
}
|
|
return _pUrlHistStg;
|
|
}
|
|
|
|
HRESULT CHistFolder::_EnsureHistStg()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_pUrlHistStg == NULL)
|
|
{
|
|
hr = CoCreateInstance(CLSID_CUrlHistory, NULL, CLSCTX_INPROC_SERVER, IID_IUrlHistoryPriv, (void **)&_pUrlHistStg);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_ValidateIntervalCache()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SYSTEMTIME stNow;
|
|
SYSTEMTIME stThen;
|
|
FILETIME ftNow;
|
|
FILETIME ftTommorrow;
|
|
FILETIME ftMonday;
|
|
FILETIME ftDayOfWeek;
|
|
FILETIME ftLimit;
|
|
BOOL fChangedRegistry = FALSE;
|
|
DWORD dwWaitResult = WAIT_TIMEOUT;
|
|
HSFINTERVAL *pWeirdWeek;
|
|
HSFINTERVAL *pPrevDay;
|
|
long compareResult;
|
|
BOOL fCleanupVisitedDB = FALSE;
|
|
int i;
|
|
int daysToKeep;
|
|
|
|
// Check for reentrancy
|
|
if (_fValidatingCache) return S_OK;
|
|
|
|
_fValidatingCache = TRUE;
|
|
|
|
// IE6 RAID 2031
|
|
// Is this mutex necessary?
|
|
// In IE4 days, this mutex was named _!MSFTHISTORY!_, the same as that in wininet.
|
|
// As a consequence, sometimes you got into one-minute timeouts that caused the entire
|
|
// browser to hang. (Since one thread could be cleaning up the history while another thread is
|
|
// trying to access the cache for non-history purposes.)
|
|
|
|
// I've changed the name of the mutex to prevent shdocvw from locking wininet, but we need
|
|
// to understand exactly what purpose this mutex serves, and if none, remove it.
|
|
|
|
if (g_hMutexHistory == NULL)
|
|
{
|
|
ENTERCRITICAL;
|
|
|
|
if (g_hMutexHistory == NULL)
|
|
{
|
|
//
|
|
// Use the "A" version for W95 compatability.
|
|
//
|
|
g_hMutexHistory = OpenMutexA(SYNCHRONIZE, FALSE, "_!SHMSFTHISTORY!_");
|
|
if (g_hMutexHistory == NULL && (GetLastError() == ERROR_FILE_NOT_FOUND
|
|
|| GetLastError() == ERROR_INVALID_NAME))
|
|
{
|
|
SECURITY_ATTRIBUTES* psa = SHGetAllAccessSA();
|
|
if (psa)
|
|
{
|
|
g_hMutexHistory = CreateMutexA(psa, FALSE, "_!SHMSFTHISTORY!_");
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// Note that if multiple processes are trying to clean up the history, we're still going to
|
|
// hang the other processes for a minute. Oops.
|
|
|
|
if (g_hMutexHistory)
|
|
dwWaitResult = WaitForSingleObject(g_hMutexHistory, FAILSAFE_TIMEOUT);
|
|
|
|
if ((dwWaitResult!=WAIT_OBJECT_0) && (dwWaitResult!=WAIT_ABANDONED))
|
|
{
|
|
ASSERT(FALSE);
|
|
goto exitPoint;
|
|
}
|
|
|
|
hr = _LoadIntervalCache();
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
// All history is maintained using "User Perceived Time", which is the
|
|
// local time when navigate was made.
|
|
GetLocalTime(&stNow);
|
|
SystemTimeToFileTime(&stNow, &ftNow);
|
|
_FileTimeDeltaDays(&ftNow, &ftNow, 0);
|
|
_FileTimeDeltaDays(&ftNow, &ftTommorrow, 1);
|
|
|
|
hr = _EnsureHistStg();
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
|
|
// Compute ftLimit as first instant of first day to keep in history
|
|
// _FileTimeDeltaDays truncates to first FILETIME incr of day before computing
|
|
// earlier/later, day.
|
|
daysToKeep = (int)_pUrlHistStg->GetDaysToKeep();
|
|
if (daysToKeep < 0) daysToKeep = 0;
|
|
_FileTimeDeltaDays(&ftNow, &ftLimit, 1-daysToKeep);
|
|
|
|
FileTimeToSystemTime(&ftNow, &stThen);
|
|
// We take monday as day 0 of week, and adjust it for file time
|
|
// tics per day (100ns per tick
|
|
_FileTimeDeltaDays(&ftNow, &ftMonday, stThen.wDayOfWeek ? 1-stThen.wDayOfWeek: -6);
|
|
|
|
// Delete old version intervals so prefix matching in wininet isn't hosed
|
|
|
|
for (i = 0; i < _cbIntervals; i++)
|
|
{
|
|
if (_pIntervalCache[i].usVers < OUR_VERS)
|
|
{
|
|
fChangedRegistry = TRUE;
|
|
hr = _DeleteInterval(&_pIntervalCache[i]);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
}
|
|
}
|
|
|
|
// If someone set their clock forward and then back, we could have
|
|
// a week that shouldn't be there. delete it. they will lose that week
|
|
// of history, c'est la guerre! quel domage!
|
|
if (S_OK == _GetInterval(&ftMonday, TRUE, &pWeirdWeek))
|
|
{
|
|
hr = _DeleteInterval(pWeirdWeek);
|
|
fCleanupVisitedDB = TRUE;
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
fChangedRegistry = TRUE;
|
|
}
|
|
|
|
// Create weeks as needed to house days that are within "days to keep" limit
|
|
// but are not in the same week at today
|
|
for (i = 0; i < _cbIntervals; i++)
|
|
{
|
|
FILETIME ftThisDay = _pIntervalCache[i].ftStart;
|
|
if (_pIntervalCache[i].usVers >= OUR_VERS &&
|
|
1 == _DaysInInterval(&_pIntervalCache[i]) &&
|
|
CompareFileTime(&ftThisDay, &ftLimit) >= 0 &&
|
|
CompareFileTime(&ftThisDay, &ftMonday) < 0)
|
|
{
|
|
if (S_OK != _GetInterval(&ftThisDay, TRUE, NULL))
|
|
{
|
|
int j;
|
|
BOOL fProcessed = FALSE;
|
|
FILETIME ftThisMonday;
|
|
FILETIME ftNextMonday;
|
|
|
|
FileTimeToSystemTime(&ftThisDay, &stThen);
|
|
// We take monday as day 0 of week, and adjust it for file time
|
|
// tics per day (100ns per tick
|
|
_FileTimeDeltaDays(&ftThisDay, &ftThisMonday, stThen.wDayOfWeek ? 1-stThen.wDayOfWeek: -6);
|
|
_FileTimeDeltaDays(&ftThisMonday, &ftNextMonday, 7);
|
|
|
|
// Make sure we haven't already done this week
|
|
for (j = 0; j < i; j++)
|
|
{
|
|
if (_pIntervalCache[j].usVers >= OUR_VERS &&
|
|
CompareFileTime(&_pIntervalCache[j].ftStart, &ftLimit) >= 0 &&
|
|
_InInterval(&ftThisMonday,
|
|
&ftNextMonday,
|
|
&_pIntervalCache[j].ftStart))
|
|
{
|
|
fProcessed = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!fProcessed)
|
|
{
|
|
hr = _CreateInterval(&ftThisMonday, 7);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
fChangedRegistry = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Guarantee today is created and old TODAY is renamed to Day of Week
|
|
ftDayOfWeek = ftMonday;
|
|
pPrevDay = NULL;
|
|
while ((compareResult = CompareFileTime(&ftDayOfWeek, &ftNow)) <= 0)
|
|
{
|
|
HSFINTERVAL *pFound;
|
|
|
|
if (S_OK != _GetInterval(&ftDayOfWeek, FALSE, &pFound))
|
|
{
|
|
if (0 == compareResult)
|
|
{
|
|
if (pPrevDay) // old today's name changes
|
|
{
|
|
_NotifyInterval(pPrevDay, SHCNE_RENAMEFOLDER);
|
|
}
|
|
hr = _CreateInterval(&ftDayOfWeek, 1);
|
|
if (FAILED(hr))
|
|
goto exitPoint;
|
|
fChangedRegistry = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPrevDay = pFound;
|
|
}
|
|
_FileTimeDeltaDays(&ftDayOfWeek, &ftDayOfWeek, 1);
|
|
}
|
|
|
|
// On the first time through, we do not migrate history, wininet
|
|
// changed cache file format so users going to 4.0B2 from 3.0 or B1
|
|
// will lose their history anyway
|
|
|
|
// _CleanUpHistory does two things:
|
|
//
|
|
// If we have any stale weeks destroy them and flag the change
|
|
//
|
|
// If we have any days that should be in cache but not in dailies
|
|
// copy them to the relevant week then destroy those days
|
|
// and flag the change
|
|
|
|
hr = _CleanUpHistory(ftLimit, ftTommorrow);
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
hr = S_OK;
|
|
fChangedRegistry = TRUE;
|
|
fCleanupVisitedDB = TRUE;
|
|
}
|
|
|
|
if (fChangedRegistry)
|
|
hr = _LoadIntervalCache();
|
|
|
|
exitPoint:
|
|
if ((dwWaitResult == WAIT_OBJECT_0)
|
|
|| (dwWaitResult == WAIT_ABANDONED))
|
|
ReleaseMutex(g_hMutexHistory);
|
|
|
|
if (fCleanupVisitedDB)
|
|
{
|
|
if (SUCCEEDED(_EnsureHistStg()))
|
|
{
|
|
HRESULT hrLocal = _pUrlHistStg->CleanupHistory();
|
|
ASSERT(SUCCEEDED(hrLocal));
|
|
}
|
|
}
|
|
_fValidatingCache = FALSE;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_CopyTSTRField(LPTSTR *ppszField, LPCTSTR pszValue)
|
|
{
|
|
if (*ppszField)
|
|
{
|
|
LocalFree(*ppszField);
|
|
*ppszField = NULL;
|
|
}
|
|
if (pszValue)
|
|
{
|
|
int cchField = lstrlen(pszValue) + 1;
|
|
*ppszField = (LPTSTR)LocalAlloc(LPTR, cchField * sizeof(TCHAR));
|
|
if (*ppszField)
|
|
{
|
|
StrCpyN(*ppszField, pszValue, cchField);
|
|
}
|
|
else
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// IHistSFPrivate methods...
|
|
//
|
|
HRESULT CHistFolder::SetCachePrefix(LPCTSTR pszCachePrefix)
|
|
{
|
|
return _CopyTSTRField(&_pszCachePrefix, pszCachePrefix);
|
|
}
|
|
|
|
HRESULT CHistFolder::SetDomain(LPCTSTR pszDomain)
|
|
{
|
|
return _CopyTSTRField(&_pszDomain, pszDomain);
|
|
}
|
|
|
|
|
|
//
|
|
// IShellFolder
|
|
//
|
|
HRESULT CHistFolder::ParseDisplayName(HWND hwnd, LPBC pbc,
|
|
LPOLESTR pszDisplayName, ULONG *pchEaten,
|
|
LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
|
|
{
|
|
*ppidl = NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT CHistFolder::EnumObjects(HWND hwnd, DWORD grfFlags,
|
|
IEnumIDList **ppenumIDList)
|
|
{
|
|
return CHistFolderEnum_CreateInstance(grfFlags, this, ppenumIDList);
|
|
}
|
|
|
|
HRESULT CHistFolder::_ViewPidl_BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
switch(((LPVIEWPIDL)pidl)->usViewType)
|
|
{
|
|
case VIEWPIDL_SEARCH:
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
case VIEWPIDL_ORDER_SITE:
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
|
|
CHistFolder *phsf = new CHistFolder(FOLDER_TYPE_HistDomain);
|
|
if (phsf)
|
|
{
|
|
// initialize?
|
|
phsf->_uViewType = ((LPVIEWPIDL)pidl)->usViewType;
|
|
|
|
LPITEMIDLIST pidlLeft = ILCloneFirst(pidl);
|
|
if (pidlLeft)
|
|
{
|
|
hr = S_OK;
|
|
if (((LPVIEWPIDL)pidl)->usViewType == VIEWPIDL_SEARCH)
|
|
{
|
|
// find this search in the global database
|
|
phsf->_pcsCurrentSearch =
|
|
_CurrentSearches::s_FindSearch(((LPSEARCHVIEWPIDL)pidl)->ftSearchKey);
|
|
|
|
// search not found -- do not proceed
|
|
if (!phsf->_pcsCurrentSearch)
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (phsf->_pidl)
|
|
ILFree(phsf->_pidl);
|
|
phsf->_pidl = ILCombine(_pidl, pidlLeft);
|
|
|
|
LPCITEMIDLIST pidlNext = _ILNext(pidl);
|
|
if (pidlNext->mkid.cb)
|
|
{
|
|
CHistFolder *phsf2;
|
|
hr = phsf->BindToObject(pidlNext, pbc, riid, (void **)&phsf2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
phsf->Release();
|
|
phsf = phsf2;
|
|
}
|
|
else
|
|
{
|
|
phsf->Release();
|
|
phsf = NULL;
|
|
break;
|
|
}
|
|
}
|
|
hr = phsf->QueryInterface(riid, ppv);
|
|
}
|
|
|
|
ILFree(pidlLeft);
|
|
}
|
|
ASSERT(phsf);
|
|
phsf->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_ViewType_BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
switch (_uViewType)
|
|
{
|
|
case VIEWPIDL_ORDER_SITE:
|
|
if (_uViewDepth++ < 1)
|
|
{
|
|
LPITEMIDLIST pidlNext = _ILNext(pidl);
|
|
if (!(ILIsEmpty(pidlNext)))
|
|
{
|
|
hr = BindToObject(pidlNext, pbc, riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
*ppv = (void *)this;
|
|
LPITEMIDLIST pidlOld = _pidl;
|
|
if (pidlOld)
|
|
{
|
|
_pidl = ILCombine(_pidl, pidl);
|
|
ILFree(pidlOld);
|
|
}
|
|
else
|
|
{
|
|
_pidl = ILClone(pidl);
|
|
}
|
|
AddRef();
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
case VIEWPIDL_SEARCH:
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
BOOL fRealignedPidl;
|
|
HRESULT hr = AlignPidl(&pidl, &fRealignedPidl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (IS_VALID_VIEWPIDL(pidl))
|
|
{
|
|
hr = _ViewPidl_BindToObject(pidl, pbc, riid, ppv);
|
|
}
|
|
else if (_uViewType)
|
|
{
|
|
hr = _ViewType_BindToObject(pidl, pbc, riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
FOLDER_TYPE ftNew = _foldertype;
|
|
LPCITEMIDLIST pidlNext = pidl;
|
|
|
|
while (pidlNext->mkid.cb && SUCCEEDED(hr))
|
|
{
|
|
LPHIDPIDL phid = (LPHIDPIDL)pidlNext;
|
|
switch (ftNew)
|
|
{
|
|
case FOLDER_TYPE_Hist:
|
|
if (phid->usSign != IDIPIDL_SIGN && phid->usSign != IDTPIDL_SIGN)
|
|
hr = E_FAIL;
|
|
else
|
|
ftNew = FOLDER_TYPE_HistInterval;
|
|
break;
|
|
|
|
case FOLDER_TYPE_HistDomain:
|
|
if (phid->usSign != HEIPIDL_SIGN)
|
|
hr = E_FAIL;
|
|
break;
|
|
|
|
case FOLDER_TYPE_HistInterval:
|
|
if (phid->usSign != IDDPIDL_SIGN)
|
|
hr = E_FAIL;
|
|
else
|
|
ftNew = FOLDER_TYPE_HistDomain;
|
|
break;
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
pidlNext = _ILNext(pidlNext);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CHistFolder *phsf = new CHistFolder(ftNew);
|
|
if (phsf)
|
|
{
|
|
// If we're binding to a Domain from an Interval, pidl will not contain the
|
|
// interval, so we've got to do a SetCachePrefix.
|
|
hr = phsf->SetCachePrefix(_pszCachePrefix);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlNew;
|
|
hr = SHILCombine(_pidl, pidl, &pidlNew);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = phsf->Initialize(pidlNew);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = phsf->QueryInterface(riid, ppv);
|
|
}
|
|
ILFree(pidlNew);
|
|
}
|
|
}
|
|
phsf->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fRealignedPidl)
|
|
FreeRealignedPidl(pidl);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// A Successor to the IsLeaf
|
|
BOOL CHistFolder::_IsLeaf()
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
switch(_uViewType) {
|
|
case 0:
|
|
fRet = IsLeaf(_foldertype);
|
|
break;
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
case VIEWPIDL_SEARCH:
|
|
fRet = TRUE;
|
|
break;
|
|
case VIEWPIDL_ORDER_SITE:
|
|
fRet = (_uViewDepth == 1);
|
|
break;
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
// coroutine for CompaireIDs -- makes recursive call
|
|
int CHistFolder::_View_ContinueCompare(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
int iRet = 0;
|
|
if ( (pidl1 = _ILNext(pidl1)) && (pidl2 = _ILNext(pidl2)) )
|
|
{
|
|
BOOL fEmpty1 = ILIsEmpty(pidl1);
|
|
BOOL fEmpty2 = ILIsEmpty(pidl2);
|
|
if (fEmpty1 || fEmpty2)
|
|
{
|
|
if (fEmpty1 && fEmpty2)
|
|
iRet = 0;
|
|
else
|
|
iRet = (fEmpty1 ? -1 : 1);
|
|
}
|
|
else
|
|
{
|
|
IShellFolder *psf;
|
|
if (SUCCEEDED(BindToObject(pidl1, NULL, IID_PPV_ARG(IShellFolder, &psf))))
|
|
{
|
|
iRet = psf->CompareIDs(0, pidl1, pidl2);
|
|
psf->Release();
|
|
}
|
|
}
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
int _CompareTitles(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
int iRet = 0;
|
|
LPCTSTR pszTitle1;
|
|
LPCTSTR pszTitle2;
|
|
LPCTSTR pszUrl1 = _StripHistoryUrlToUrl(HPidlToSourceUrl(pidl1));
|
|
LPCTSTR pszUrl2 = _StripHistoryUrlToUrl(HPidlToSourceUrl(pidl2));
|
|
|
|
ua_GetURLTitle( &pszTitle1, (LPBASEPIDL)pidl1 );
|
|
ua_GetURLTitle( &pszTitle2, (LPBASEPIDL)pidl2 );
|
|
|
|
// CompareIDs has to check for equality, also -- two URLs are only equal when
|
|
// they have the same URL (not title)
|
|
int iUrlCmp;
|
|
if (!(iUrlCmp = StrCmpI(pszUrl1, pszUrl2)))
|
|
iRet = 0;
|
|
else
|
|
{
|
|
iRet = StrCmpI( (pszTitle1 ? pszTitle1 : pszUrl1),
|
|
(pszTitle2 ? pszTitle2 : pszUrl2) );
|
|
|
|
// this says: if two docs have the same Title, but different URL
|
|
// we then sort by url -- the last thing we want to do
|
|
// is return that they're equal!! Ay Caramba!
|
|
if (iRet == 0)
|
|
iRet = iUrlCmp;
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
|
|
// unalligned verison
|
|
|
|
#if defined(UNIX) || !defined(_X86_)
|
|
|
|
UINT ULCompareFileTime(UNALIGNED const FILETIME *pft1, UNALIGNED const FILETIME *pft2)
|
|
{
|
|
FILETIME tmpFT1, tmpFT2;
|
|
CopyMemory(&tmpFT1, pft1, sizeof(tmpFT1));
|
|
CopyMemory(&tmpFT2, pft2, sizeof(tmpFT2));
|
|
return CompareFileTime( &tmpFT1, &tmpFT2 );
|
|
}
|
|
|
|
#else
|
|
|
|
#define ULCompareFileTime(pft1, pft2) CompareFileTime(pft1, pft2)
|
|
|
|
#endif
|
|
|
|
|
|
HRESULT CHistFolder::_ViewType_CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
ASSERT(_uViewType);
|
|
|
|
int iRet = -1;
|
|
|
|
if (pidl1 && pidl2)
|
|
{
|
|
switch (_uViewType) {
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
ASSERT(_IsValid_HEIPIDL(pidl1) && _IsValid_HEIPIDL(pidl2));
|
|
// need to strip because freq pidls are "Visited: " and
|
|
// all others come from our special bucket
|
|
if (!_CompareHCURLs(pidl1, pidl2))
|
|
iRet = 0;
|
|
else
|
|
iRet = ((((LPHEIPIDL)pidl2)->llPriority < ((LPHEIPIDL)pidl1)->llPriority) ? -1 : +1);
|
|
break;
|
|
case VIEWPIDL_SEARCH:
|
|
iRet = _CompareTitles(pidl1, pidl2);
|
|
break;
|
|
case VIEWPIDL_ORDER_TODAY: // view by order visited today
|
|
{
|
|
int iNameDiff;
|
|
ASSERT(_IsValid_HEIPIDL(pidl1) && _IsValid_HEIPIDL(pidl2));
|
|
// must do this comparison because CompareIDs is not only called for Sorting
|
|
// but to see if some pidls are equal
|
|
|
|
if ((iNameDiff = _CompareHCURLs(pidl1, pidl2)) == 0)
|
|
iRet = 0;
|
|
else
|
|
{
|
|
iRet = ULCompareFileTime(&(((LPHEIPIDL)pidl2)->ftModified), &(((LPHEIPIDL)pidl1)->ftModified));
|
|
// if the file times are equal, they're still not the same url -- so
|
|
// they have to be ordered on url
|
|
if (iRet == 0)
|
|
iRet = iNameDiff;
|
|
}
|
|
break;
|
|
}
|
|
case VIEWPIDL_ORDER_SITE:
|
|
if (_uViewDepth == 0)
|
|
{
|
|
TCHAR szName1[MAX_PATH], szName2[MAX_PATH];
|
|
|
|
_GetURLDispName((LPBASEPIDL)pidl1, szName1, ARRAYSIZE(szName1));
|
|
_GetURLDispName((LPBASEPIDL)pidl2, szName2, ARRAYSIZE(szName2));
|
|
|
|
iRet = StrCmpI(szName1, szName2);
|
|
}
|
|
else if (_uViewDepth == 1) {
|
|
iRet = _CompareTitles(pidl1, pidl2);
|
|
}
|
|
break;
|
|
}
|
|
if (iRet == 0)
|
|
iRet = _View_ContinueCompare(pidl1, pidl2);
|
|
}
|
|
else {
|
|
iRet = -1;
|
|
}
|
|
|
|
return ResultFromShort((SHORT)iRet);
|
|
}
|
|
|
|
HRESULT CHistFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
BOOL fRealigned1;
|
|
HRESULT hr = AlignPidl(&pidl1, &fRealigned1);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL fRealigned2;
|
|
hr = AlignPidl(&pidl2, &fRealigned2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _CompareAlignedIDs(lParam, pidl1, pidl2);
|
|
|
|
if (fRealigned2)
|
|
FreeRealignedPidl(pidl2);
|
|
}
|
|
|
|
if (fRealigned1)
|
|
FreeRealignedPidl(pidl1);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_CompareAlignedIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
int iRet = 0;
|
|
USHORT usSign;
|
|
FOLDER_TYPE FolderType = _foldertype;
|
|
LPHEIPIDL phei1 = NULL;
|
|
LPHEIPIDL phei2 = NULL;
|
|
|
|
if (NULL == pidl1 || NULL == pidl2)
|
|
return E_INVALIDARG;
|
|
|
|
if (_uViewType)
|
|
{
|
|
return _ViewType_CompareIDs(lParam, pidl1, pidl2);
|
|
}
|
|
|
|
if (IS_VALID_VIEWPIDL(pidl1) && IS_VALID_VIEWPIDL(pidl2))
|
|
{
|
|
if ((((LPVIEWPIDL)pidl1)->usViewType == ((LPVIEWPIDL)pidl2)->usViewType) &&
|
|
(((LPVIEWPIDL)pidl1)->usExtra == ((LPVIEWPIDL)pidl2)->usExtra))
|
|
{
|
|
iRet = _View_ContinueCompare(pidl1, pidl2);
|
|
}
|
|
else
|
|
{
|
|
iRet = ((((LPVIEWPIDL)pidl1)->usViewType < ((LPVIEWPIDL)pidl2)->usViewType) ? -1 : 1);
|
|
}
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (!IsLeaf(_foldertype))
|
|
{
|
|
// We try to avoid unneccessary BindToObjs to compare partial paths
|
|
usSign = FOLDER_TYPE_Hist == FolderType ? IDIPIDL_SIGN : IDDPIDL_SIGN;
|
|
while (TRUE)
|
|
{
|
|
LPBASEPIDL pceip1 = (LPBASEPIDL) pidl1;
|
|
LPBASEPIDL pceip2 = (LPBASEPIDL) pidl2;
|
|
|
|
if (pidl1->mkid.cb == 0 || pidl2->mkid.cb == 0)
|
|
{
|
|
iRet = pidl1->mkid.cb == pidl2->mkid.cb ? 0 : 1;
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (!_IsValid_IDPIDL(pidl1) || !_IsValid_IDPIDL(pidl2))
|
|
return E_FAIL;
|
|
|
|
if (!EQUIV_IDSIGN(pceip1->usSign,usSign) || !EQUIV_IDSIGN(pceip2->usSign,usSign))
|
|
return E_FAIL;
|
|
|
|
if (_foldertype == FOLDER_TYPE_HistInterval)
|
|
{
|
|
TCHAR szName1[MAX_PATH], szName2[MAX_PATH];
|
|
|
|
_GetURLDispName((LPBASEPIDL)pidl1, szName1, ARRAYSIZE(szName1));
|
|
_GetURLDispName((LPBASEPIDL)pidl2, szName2, ARRAYSIZE(szName2));
|
|
|
|
iRet = StrCmpI(szName1, szName2);
|
|
goto exitPoint;
|
|
}
|
|
else
|
|
{
|
|
iRet = ualstrcmpi(_GetURLTitle((LPBASEPIDL)pidl1), _GetURLTitle((LPBASEPIDL)pidl2));
|
|
if (iRet != 0)
|
|
goto exitPoint;
|
|
}
|
|
|
|
if (pceip1->usSign != pceip2->usSign)
|
|
{
|
|
iRet = -1;
|
|
goto exitPoint;
|
|
}
|
|
|
|
pidl1 = _ILNext(pidl1);
|
|
pidl2 = _ILNext(pidl2);
|
|
if (IDIPIDL_SIGN == usSign)
|
|
{
|
|
usSign = IDDPIDL_SIGN;
|
|
}
|
|
}
|
|
}
|
|
|
|
// At this point, both pidls have resolved to leaf (history or cache)
|
|
|
|
phei1 = _IsValid_HEIPIDL(pidl1);
|
|
phei2 = _IsValid_HEIPIDL(pidl2);
|
|
if (!phei1 || !phei2)
|
|
return E_FAIL;
|
|
|
|
switch (lParam & SHCIDS_COLUMNMASK)
|
|
{
|
|
case ICOLH_URL_TITLE:
|
|
{
|
|
TCHAR szStr1[MAX_PATH], szStr2[MAX_PATH];
|
|
_GetHistURLDispName(phei1, szStr1, ARRAYSIZE(szStr1));
|
|
_GetHistURLDispName(phei2, szStr2, ARRAYSIZE(szStr2));
|
|
|
|
iRet = StrCmpI(szStr1, szStr2);
|
|
}
|
|
break;
|
|
|
|
case ICOLH_URL_NAME:
|
|
iRet = _CompareHFolderPidl(pidl1, pidl2);
|
|
break;
|
|
|
|
case ICOLH_URL_LASTVISITED:
|
|
iRet = ULCompareFileTime(&((LPHEIPIDL)pidl2)->ftModified, &((LPHEIPIDL)pidl1)->ftModified);
|
|
break;
|
|
|
|
default:
|
|
// The high bit on means to compare absolutely, ie: even if only filetimes
|
|
// are different, we rule file pidls to be different
|
|
|
|
if (lParam & SHCIDS_ALLFIELDS)
|
|
{
|
|
iRet = CompareIDs(ICOLH_URL_NAME, pidl1, pidl2);
|
|
if (iRet == 0)
|
|
{
|
|
iRet = CompareIDs(ICOLH_URL_TITLE, pidl1, pidl2);
|
|
if (iRet == 0)
|
|
{
|
|
iRet = CompareIDs(ICOLH_URL_LASTVISITED, pidl1, pidl2);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iRet = -1;
|
|
}
|
|
break;
|
|
}
|
|
exitPoint:
|
|
|
|
return ResultFromShort((SHORT)iRet);
|
|
}
|
|
|
|
|
|
HRESULT CHistFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (riid == IID_IShellView)
|
|
{
|
|
ASSERT(!_uViewType);
|
|
hr = HistFolderView_CreateInstance(this, ppv);
|
|
}
|
|
else if (riid == IID_IContextMenu)
|
|
{
|
|
// this creates the "Arrange Icons" cascased menu in the background of folder view
|
|
if (IsLeaf(_foldertype))
|
|
{
|
|
CFolderArrangeMenu *p = new CFolderArrangeMenu(MENU_HISTORY);
|
|
if (p)
|
|
{
|
|
hr = p->QueryInterface(riid, ppv);
|
|
p->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else if (riid == IID_IShellDetails)
|
|
{
|
|
CDetailsOfFolder *p = new CDetailsOfFolder(hwnd, this);
|
|
if (p)
|
|
{
|
|
hr = p->QueryInterface(riid, ppv);
|
|
p->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::_ViewType_GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *prgfInOut)
|
|
{
|
|
ASSERT(_uViewType);
|
|
|
|
if (!prgfInOut || !apidl)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr = S_OK;
|
|
int cGoodPidls = 0;
|
|
|
|
if (*prgfInOut & SFGAO_VALIDATE)
|
|
{
|
|
for (UINT u = 0; SUCCEEDED(hr) && (u < cidl); ++u)
|
|
{
|
|
switch(_uViewType)
|
|
{
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
_EnsureHistStg();
|
|
if (_IsValid_HEIPIDL(apidl[u]) &&
|
|
SUCCEEDED(_pUrlHistStg->QueryUrl(_StripHistoryUrlToUrl(HPidlToSourceUrl(apidl[u])),
|
|
STATURL_QUERYFLAG_NOURL, NULL)))
|
|
{
|
|
++cGoodPidls;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
break;
|
|
|
|
case VIEWPIDL_SEARCH:
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
// this is a temporary fix to get the behaviour of the namespace
|
|
// control correct -- the long-term fix involves cacheing a
|
|
// generated list of these items and validating that list
|
|
break;
|
|
|
|
case VIEWPIDL_ORDER_SITE:
|
|
{
|
|
ASSERT(_uViewDepth == 1);
|
|
_ValidateIntervalCache();
|
|
LPCWSTR psz = _StripHistoryUrlToUrl(HPidlToSourceUrl(apidl[u]));
|
|
if (psz && _SearchFlatCacheForUrl(psz, NULL, NULL) == ERROR_SUCCESS)
|
|
{
|
|
++cGoodPidls;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (_IsLeaf())
|
|
*prgfInOut = SFGAO_CANCOPY | SFGAO_HASPROPSHEET;
|
|
else
|
|
*prgfInOut = SFGAO_FOLDER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Right now, we will allow TIF Drag in Browser Only, even though
|
|
// it will not be Zone Checked at the Drop.
|
|
//#define BROWSERONLY_NOTIFDRAG
|
|
|
|
HRESULT CHistFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST * apidl, ULONG * prgfInOut)
|
|
{
|
|
ULONG rgfInOut;
|
|
FOLDER_TYPE FolderType = _foldertype;
|
|
|
|
// Make sure each pidl in the array is dword aligned.
|
|
|
|
BOOL fRealigned;
|
|
HRESULT hr = AlignPidlArray(apidl, cidl, &apidl, &fRealigned);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// For view types, we'll map FolderType to do the right thing...
|
|
if (_uViewType)
|
|
{
|
|
hr = _ViewType_GetAttributesOf(cidl, apidl, prgfInOut);
|
|
}
|
|
else
|
|
{
|
|
switch (FolderType)
|
|
{
|
|
case FOLDER_TYPE_Hist:
|
|
rgfInOut = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
|
|
break;
|
|
|
|
case FOLDER_TYPE_HistInterval:
|
|
rgfInOut = SFGAO_FOLDER;
|
|
break;
|
|
|
|
case FOLDER_TYPE_HistDomain:
|
|
{
|
|
UINT cGoodPidls;
|
|
|
|
if (SFGAO_VALIDATE & *prgfInOut)
|
|
{
|
|
cGoodPidls = 0;
|
|
if (SUCCEEDED(_EnsureHistStg()))
|
|
{
|
|
for (UINT i = 0; i < cidl; i++)
|
|
{
|
|
// NOTE: QueryUrlA checks for NULL URL and returns E_INVALIDARG
|
|
if (!_IsValid_HEIPIDL(apidl[i]) ||
|
|
FAILED(_pUrlHistStg->QueryUrl(_StripHistoryUrlToUrl(HPidlToSourceUrl(apidl[i])),
|
|
STATURL_QUERYFLAG_NOURL, NULL)))
|
|
{
|
|
break;
|
|
}
|
|
cGoodPidls++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
cGoodPidls = cidl;
|
|
|
|
if (cidl == cGoodPidls)
|
|
{
|
|
rgfInOut = SFGAO_CANCOPY | SFGAO_HASPROPSHEET;
|
|
break;
|
|
}
|
|
// FALL THROUGH INTENDED!
|
|
}
|
|
|
|
default:
|
|
rgfInOut = 0;
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
// all items can be deleted
|
|
if (SUCCEEDED(hr))
|
|
rgfInOut |= SFGAO_CANDELETE;
|
|
*prgfInOut = rgfInOut;
|
|
}
|
|
|
|
if (fRealigned)
|
|
FreeRealignedPidlArray(apidl, cidl);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST * apidl,
|
|
REFIID riid, UINT * prgfInOut, void **ppv)
|
|
{
|
|
*ppv = NULL; // null the out param
|
|
|
|
// Make sure all pidls in the array are dword aligned.
|
|
|
|
BOOL fRealigned;
|
|
HRESULT hr = AlignPidlArray(apidl, cidl, &apidl, &fRealigned);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if ((riid == IID_IShellLinkA ||
|
|
riid == IID_IShellLinkW ||
|
|
riid == IID_IExtractIconA ||
|
|
riid == IID_IExtractIconW) &&
|
|
_IsLeaf())
|
|
{
|
|
LPCTSTR pszURL = HPidlToSourceUrl(apidl[0]);
|
|
|
|
pszURL = _StripHistoryUrlToUrl(pszURL);
|
|
|
|
hr = _GetShortcut(pszURL, riid, ppv);
|
|
}
|
|
else if ((riid == IID_IContextMenu) ||
|
|
(riid == IID_IDataObject) ||
|
|
(riid == IID_IExtractIconA) ||
|
|
(riid == IID_IExtractIconW) ||
|
|
(riid == IID_IQueryInfo))
|
|
{
|
|
hr = CHistItem_CreateInstance(this, hwnd, cidl, apidl, riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
if (fRealigned)
|
|
FreeRealignedPidlArray(apidl, cidl);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
|
|
{
|
|
if (pSort)
|
|
{
|
|
if (_uViewType == 0 && _foldertype == FOLDER_TYPE_HistDomain)
|
|
*pSort = ICOLH_URL_TITLE;
|
|
else
|
|
*pSort = 0;
|
|
}
|
|
|
|
if (pDisplay)
|
|
{
|
|
if (_uViewType == 0 && _foldertype == FOLDER_TYPE_HistDomain)
|
|
*pDisplay = ICOLH_URL_TITLE;
|
|
else
|
|
*pDisplay = 0;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
LPCTSTR _GetUrlForPidl(LPCITEMIDLIST pidl)
|
|
{
|
|
LPCTSTR pszUrl = _StripHistoryUrlToUrl(HPidlToSourceUrl(pidl));
|
|
|
|
return pszUrl ? pszUrl : TEXT("");
|
|
}
|
|
|
|
HRESULT CHistFolder::_GetInfoTip(LPCITEMIDLIST pidl, DWORD dwFlags, WCHAR **ppwszTip)
|
|
{
|
|
HRESULT hr;
|
|
TCHAR szTip[MAX_URL_STRING + 100], szPart2[MAX_URL_STRING];
|
|
|
|
szTip[0] = szPart2[0] = 0;
|
|
|
|
FOLDER_TYPE FolderType = _foldertype;
|
|
|
|
// For special views, map FolderType to do the right thing
|
|
if (_uViewType)
|
|
{
|
|
switch(_uViewType) {
|
|
case VIEWPIDL_SEARCH:
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
FolderType = FOLDER_TYPE_HistDomain;
|
|
break;
|
|
case VIEWPIDL_ORDER_SITE:
|
|
if (_uViewDepth == 0)
|
|
FolderType = FOLDER_TYPE_HistInterval;
|
|
else
|
|
FolderType = FOLDER_TYPE_HistDomain;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (FolderType)
|
|
{
|
|
case FOLDER_TYPE_HistDomain:
|
|
{
|
|
_GetHistURLDispName((LPHEIPIDL)pidl, szTip, ARRAYSIZE(szTip));
|
|
DWORD cchPart2 = ARRAYSIZE(szPart2);
|
|
PrepareURLForDisplayUTF8(_GetUrlForPidl(pidl), szPart2, &cchPart2, TRUE);
|
|
}
|
|
break;
|
|
|
|
|
|
case FOLDER_TYPE_Hist:
|
|
{
|
|
FILETIME ftStart, ftEnd;
|
|
LPCTSTR pszIntervalName;
|
|
|
|
ua_GetURLTitle(&pszIntervalName, (LPBASEPIDL)pidl);
|
|
|
|
if (SUCCEEDED(_ValueToInterval(pszIntervalName, &ftStart, &ftEnd)))
|
|
{
|
|
GetTooltipForTimeInterval(&ftStart, &ftEnd, szTip, ARRAYSIZE(szTip));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FOLDER_TYPE_HistInterval:
|
|
{
|
|
TCHAR szFmt[64];
|
|
|
|
MLLoadString(IDS_SITETOOLTIP, szFmt, ARRAYSIZE(szFmt));
|
|
wnsprintf(szTip, ARRAYSIZE(szTip), szFmt, _GetURLTitle((LPBASEPIDL)pidl));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (szTip[0])
|
|
{
|
|
// Only combine the 2 parts if the second part exists, and if
|
|
// the 2 parts are not equal.
|
|
if (szPart2[0] && StrCmpI(szTip, szPart2) != 0)
|
|
{
|
|
StrCatBuff(szTip, TEXT("\r\n"), ARRAYSIZE(szTip));
|
|
StrCatBuff(szTip, szPart2, ARRAYSIZE(szTip));
|
|
}
|
|
hr = SHStrDup(szTip, ppwszTip);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
*ppwszTip = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// _GetFriendlyUrlDispName -- compute the "friendly name" of an URL
|
|
//
|
|
// in: A UTF8 encoded URL. For example, ftp://ftp.nsca.uiuc.edu/foo.bar
|
|
//
|
|
// out: A "friendly name" for the URL with the path stripped if necessary
|
|
// (ie ftp://ftp.ncsa.uiuc.edu ==> ftp.ncsa.uiuc.edu
|
|
// and ftp://www.foo.bar/foo.bar ==> foo -or- foo.bar depeneding on
|
|
// whether file xtnsn hiding is on or off
|
|
//
|
|
// NOTE: pszUrl and pszOut may be the same buffer -- this is allowed
|
|
//
|
|
HRESULT _GetFriendlyUrlDispName(LPCTSTR pszUrl, LPTSTR pszOut, DWORD cchBuf)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
PrepareURLForDisplayUTF8(pszUrl, pszOut, &cchBuf, TRUE);
|
|
|
|
TCHAR szUrlPath[MAX_PATH];
|
|
TCHAR szUrlHost[MAX_PATH];
|
|
|
|
// Set up InternetCrackUrl parameter block
|
|
SHURL_COMPONENTSW urlcomponents = { 0 };
|
|
urlcomponents.dwStructSize = sizeof(URL_COMPONENTS);
|
|
urlcomponents.lpszUrlPath = szUrlPath;
|
|
urlcomponents.dwUrlPathLength = ARRAYSIZE(szUrlPath);
|
|
urlcomponents.lpszHostName = szUrlHost;
|
|
urlcomponents.dwHostNameLength = ARRAYSIZE(szUrlHost);
|
|
|
|
if (UrlCrackW(pszOut, cchBuf, ICU_DECODE, &urlcomponents))
|
|
{
|
|
SHELLSTATE ss;
|
|
SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE);
|
|
|
|
// eliminate trailing slash
|
|
if ((urlcomponents.dwUrlPathLength > 0) &&
|
|
(urlcomponents.lpszUrlPath[urlcomponents.dwUrlPathLength - 1] == TEXT('/')))
|
|
{
|
|
urlcomponents.lpszUrlPath[urlcomponents.dwUrlPathLength - 1] = TEXT('\0');
|
|
--urlcomponents.dwUrlPathLength;
|
|
}
|
|
|
|
if (urlcomponents.dwUrlPathLength > 0)
|
|
{
|
|
// LPCTSTR _FindURLFileName(LPCTSTR) --> const_cast is OK
|
|
LPTSTR pszFileName = const_cast<LPTSTR>(_FindURLFileName(urlcomponents.lpszUrlPath));
|
|
|
|
if (!ss.fShowExtensions)
|
|
{
|
|
PathRemoveExtension(pszFileName);
|
|
}
|
|
StrCpyN(pszOut, pszFileName, cchBuf);
|
|
}
|
|
else
|
|
{
|
|
StrCpyN(pszOut, urlcomponents.lpszHostName, cchBuf);
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
void CHistFolder::_GetHistURLDispName(LPHEIPIDL phei, LPTSTR pszStr, UINT cchStr)
|
|
{
|
|
*pszStr = 0;
|
|
|
|
if ((phei->usFlags & HISTPIDL_VALIDINFO) && phei->usTitle)
|
|
{
|
|
StrCpyN(pszStr, (LPTSTR)((BYTE*)phei + phei->usTitle), cchStr);
|
|
}
|
|
else if (SUCCEEDED(_EnsureHistStg()))
|
|
{
|
|
LPCTSTR pszUrl = _StripHistoryUrlToUrl(HPidlToSourceUrl((LPCITEMIDLIST)phei));
|
|
if (pszUrl)
|
|
{
|
|
STATURL suThis;
|
|
if (SUCCEEDED(_pUrlHistStg->QueryUrl(pszUrl, STATURL_QUERYFLAG_NOURL, &suThis)) && suThis.pwcsTitle)
|
|
{
|
|
// sometimes the URL is stored in the title
|
|
// avoid using those titles.
|
|
if (_TitleIsGood(suThis.pwcsTitle))
|
|
SHUnicodeToTChar(suThis.pwcsTitle, pszStr, cchStr);
|
|
|
|
OleFree(suThis.pwcsTitle);
|
|
}
|
|
|
|
// if we havent got anything yet
|
|
if (!*pszStr)
|
|
{
|
|
if (FAILED(_GetFriendlyUrlDispName(pszUrl, pszStr, cchStr)))
|
|
{
|
|
// last resort: display the whole URL
|
|
StrCpyN(pszStr, pszUrl, cchStr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
HRESULT CHistFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, STRRET *lpName)
|
|
{
|
|
TCHAR szTemp[MAX_URL_STRING];
|
|
|
|
szTemp[0] = 0;
|
|
|
|
// Make sure the pidl is dword aligned.
|
|
|
|
BOOL fRealigned;
|
|
|
|
if (SUCCEEDED(AlignPidl(&pidl, &fRealigned)))
|
|
{
|
|
if (IS_VALID_VIEWPIDL(pidl))
|
|
{
|
|
UINT idRsrc;
|
|
switch(((LPVIEWPIDL)pidl)->usViewType) {
|
|
case VIEWPIDL_ORDER_SITE: idRsrc = IDS_HISTVIEW_SITE; break;
|
|
case VIEWPIDL_ORDER_TODAY: idRsrc = IDS_HISTVIEW_TODAY; break;
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
default:
|
|
idRsrc = IDS_HISTVIEW_FREQUENCY; break;
|
|
}
|
|
|
|
MLLoadString(idRsrc, szTemp, ARRAYSIZE(szTemp));
|
|
}
|
|
else
|
|
{
|
|
if (_uViewType == VIEWPIDL_ORDER_SITE &&
|
|
_uViewDepth == 0)
|
|
{
|
|
_GetURLDispName((LPBASEPIDL)pidl, szTemp, ARRAYSIZE(szTemp));
|
|
}
|
|
else if (_IsLeaf())
|
|
{
|
|
LPCTSTR pszTitle;
|
|
BOOL fDoUnescape;
|
|
|
|
ua_GetURLTitle(&pszTitle, (LPBASEPIDL)pidl);
|
|
// _GetURLTitle could return the real title or just an URL.
|
|
// We use _URLTitleIsURL to make sure we don't unescape any titles.
|
|
|
|
if (pszTitle && *pszTitle)
|
|
{
|
|
StrCpyN(szTemp, pszTitle, ARRAYSIZE(szTemp));
|
|
fDoUnescape = _URLTitleIsURL((LPBASEPIDL)pidl);
|
|
}
|
|
else
|
|
{
|
|
LPCTSTR pszUrl = _StripHistoryUrlToUrl(HPidlToSourceUrl(pidl));
|
|
if (pszUrl)
|
|
StrCpyN(szTemp, pszUrl, ARRAYSIZE(szTemp));
|
|
fDoUnescape = TRUE;
|
|
}
|
|
|
|
if (fDoUnescape)
|
|
{
|
|
// at this point, szTemp contains part of an URL
|
|
// we will crack (smoke) the URL
|
|
LPCTSTR pszUrl = HPidlToSourceUrl(pidl);
|
|
|
|
// Is this pidl a history entry?
|
|
if (((LPBASEPIDL)pidl)->usSign == (USHORT)HEIPIDL_SIGN)
|
|
{
|
|
pszUrl = _StripHistoryUrlToUrl(pszUrl);
|
|
}
|
|
|
|
if (pszUrl)
|
|
{
|
|
if (FAILED(_GetFriendlyUrlDispName(pszUrl, szTemp, ARRAYSIZE(szTemp))))
|
|
{
|
|
StrCpyN(szTemp, pszUrl, ARRAYSIZE(szTemp));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// for the history, we'll use the title if we have one, otherwise we'll use
|
|
// the url filename.
|
|
switch (_foldertype)
|
|
{
|
|
case FOLDER_TYPE_HistDomain:
|
|
_GetHistURLDispName((LPHEIPIDL)pidl, szTemp, ARRAYSIZE(szTemp));
|
|
break;
|
|
|
|
case FOLDER_TYPE_Hist:
|
|
{
|
|
FILETIME ftStart, ftEnd;
|
|
|
|
_ValueToInterval(_GetURLTitle((LPBASEPIDL)pidl), &ftStart, &ftEnd);
|
|
GetDisplayNameForTimeInterval(&ftStart, &ftEnd, szTemp, ARRAYSIZE(szTemp));
|
|
}
|
|
break;
|
|
|
|
case FOLDER_TYPE_HistInterval:
|
|
_GetURLDispName((LPBASEPIDL)pidl, szTemp, ARRAYSIZE(szTemp));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fRealigned)
|
|
FreeRealignedPidl(pidl);
|
|
}
|
|
|
|
return StringToStrRet(szTemp, lpName);
|
|
}
|
|
|
|
HRESULT CHistFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl,
|
|
LPCOLESTR pszName, DWORD uFlags, LPITEMIDLIST *ppidlOut)
|
|
{
|
|
if (ppidlOut)
|
|
*ppidlOut = NULL; // null the out param
|
|
return E_FAIL;
|
|
}
|
|
|
|
//////////////////////////////////
|
|
//
|
|
// IShellIcon Methods...
|
|
//
|
|
HRESULT CHistFolder::GetIconOf(LPCITEMIDLIST pidl, UINT flags, LPINT lpIconIndex)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// IPersist
|
|
HRESULT CHistFolder::GetClassID(CLSID *pclsid)
|
|
{
|
|
*pclsid = CLSID_HistFolder;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CHistFolder::Initialize(LPCITEMIDLIST pidlInit)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ILFree(_pidl);
|
|
|
|
if ((FOLDER_TYPE_Hist == _foldertype) && !IsCSIDLFolder(CSIDL_HISTORY, pidlInit))
|
|
hr = E_FAIL;
|
|
else
|
|
{
|
|
hr = SHILClone(pidlInit, &_pidl);
|
|
if (SUCCEEDED(hr))
|
|
hr = _ExtractInfoFromPidl();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////
|
|
//
|
|
// IPersistFolder2 Methods...
|
|
//
|
|
HRESULT CHistFolder::GetCurFolder(LPITEMIDLIST *ppidl)
|
|
{
|
|
if (_pidl)
|
|
return SHILClone(_pidl, ppidl);
|
|
|
|
*ppidl = NULL;
|
|
return S_FALSE; // success but empty
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
// IShellFolderViewType Methods
|
|
//
|
|
// but first, the enumerator class...
|
|
class CHistViewTypeEnum : public IEnumIDList
|
|
{
|
|
friend class CHistFolder;
|
|
public:
|
|
// IUnknown Methods
|
|
STDMETHODIMP QueryInterface(REFIID,void **);
|
|
STDMETHODIMP_(ULONG) AddRef(void);
|
|
STDMETHODIMP_(ULONG) Release(void);
|
|
|
|
// IEnumIDList Methods
|
|
STDMETHODIMP Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched);
|
|
STDMETHODIMP Skip(ULONG celt) { _uCurViewType += celt; return S_OK; }
|
|
STDMETHODIMP Reset() { _uCurViewType = 1; return S_OK; }
|
|
STDMETHODIMP Clone(IEnumIDList **ppenum);
|
|
|
|
private:
|
|
~CHistViewTypeEnum() {}
|
|
CHistViewTypeEnum() : _cRef(1), _uCurViewType(1) {}
|
|
|
|
LONG _cRef;
|
|
UINT _uCurViewType;
|
|
};
|
|
|
|
STDMETHODIMP CHistViewTypeEnum::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CHistViewTypeEnum, IEnumIDList), // IID_IEnumIDList
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
ULONG CHistViewTypeEnum::AddRef(void)
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG CHistViewTypeEnum::Release(void)
|
|
{
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
HRESULT CHistViewTypeEnum::Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (rgelt && (pceltFetched || 1 == celt))
|
|
{
|
|
ULONG i = 0;
|
|
|
|
while (i < celt)
|
|
{
|
|
if (_uCurViewType <= VIEWPIDL_ORDER_MAX)
|
|
{
|
|
hr = CreateSpecialViewPidl(_uCurViewType, &(rgelt[i]));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
++i;
|
|
++_uCurViewType;
|
|
}
|
|
else
|
|
{
|
|
while (i)
|
|
ILFree(rgelt[--i]);
|
|
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = i;
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CHistViewTypeEnum::Clone(IEnumIDList **ppenum)
|
|
{
|
|
CHistViewTypeEnum* phvte = new CHistViewTypeEnum();
|
|
if (phvte)
|
|
{
|
|
phvte->_uCurViewType = _uCurViewType;
|
|
*ppenum = phvte;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// Continuing with the CHistFolder::IShellFolderViewType
|
|
STDMETHODIMP CHistFolder::EnumViews(ULONG grfFlags, IEnumIDList **ppenum)
|
|
{
|
|
*ppenum = new CHistViewTypeEnum();
|
|
return *ppenum ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
STDMETHODIMP CHistFolder::GetDefaultViewName(DWORD uFlags, LPWSTR *ppwszName)
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
|
|
MLLoadString(IDS_HISTVIEW_DEFAULT, szName, ARRAYSIZE(szName));
|
|
return SHStrDup(szName, ppwszName);
|
|
}
|
|
|
|
// Remember that these *MUST* be in order so that
|
|
// the array can be accessed by VIEWPIDL type
|
|
const DWORD CHistFolder::_rdwFlagsTable[] = {
|
|
SFVTFLAG_NOTIFY_CREATE, // Date
|
|
SFVTFLAG_NOTIFY_CREATE, // site
|
|
0, // freq
|
|
SFVTFLAG_NOTIFY_CREATE | SFVTFLAG_NOTIFY_RESORT // today
|
|
};
|
|
|
|
STDMETHODIMP CHistFolder::GetViewTypeProperties(LPCITEMIDLIST pidl, DWORD *pdwFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
UINT uFlagTableIndex = 0;
|
|
|
|
if ((pidl != NULL) && !ILIsEmpty(pidl)) // default view
|
|
{
|
|
// Make sure the pidl is dword aligned.
|
|
|
|
BOOL fRealigned;
|
|
hr = AlignPidl(&pidl, &fRealigned);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (IS_VALID_VIEWPIDL(pidl))
|
|
{
|
|
uFlagTableIndex = ((LPVIEWPIDL)pidl)->usViewType;
|
|
ASSERT(uFlagTableIndex <= VIEWPIDL_ORDER_MAX);
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
if (fRealigned)
|
|
FreeRealignedPidl(pidl);
|
|
}
|
|
}
|
|
|
|
*pdwFlags = _rdwFlagsTable[uFlagTableIndex];
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CHistFolder::TranslateViewPidl(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlView,
|
|
LPITEMIDLIST *ppidlOut)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (pidl && IS_VALID_VIEWPIDL(pidlView))
|
|
{
|
|
if (!IS_VALID_VIEWPIDL(pidl))
|
|
{
|
|
hr = ConvertStandardHistPidlToSpecialViewPidl(pidl,
|
|
((LPVIEWPIDL)pidlView)->usViewType,
|
|
ppidlOut);
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOTIMPL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// IShellFolderSearchable Methods
|
|
//
|
|
// For more information about how this search stuff works,
|
|
// please see the comments for _CurrentSearches above
|
|
STDMETHODIMP CHistFolder::FindString(LPCWSTR pwszTarget, LPDWORD pdwFlags,
|
|
IUnknown *punkOnAsyncSearch,
|
|
LPITEMIDLIST *ppidlOut)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
if (ppidlOut)
|
|
{
|
|
*ppidlOut = NULL;
|
|
if (pwszTarget)
|
|
{
|
|
LPITEMIDLIST pidlView;
|
|
|
|
SYSTEMTIME systime;
|
|
FILETIME ftNow;
|
|
GetLocalTime(&systime);
|
|
SystemTimeToFileTime(&systime, &ftNow);
|
|
|
|
hr = CreateSpecialViewPidl(VIEWPIDL_SEARCH, &pidlView, sizeof(SEARCHVIEWPIDL) - sizeof(VIEWPIDL));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
((LPSEARCHVIEWPIDL)pidlView)->ftSearchKey = ftNow;
|
|
|
|
IShellFolderSearchableCallback *psfscOnAsyncSearch = NULL;
|
|
if (punkOnAsyncSearch)
|
|
punkOnAsyncSearch->QueryInterface(IID_PPV_ARG(IShellFolderSearchableCallback, &psfscOnAsyncSearch));
|
|
|
|
// Insert this search into the global database
|
|
// This constructor will AddRef psfscOnAsyncSearch
|
|
_CurrentSearches *pcsNew = new _CurrentSearches(ftNow, pwszTarget, psfscOnAsyncSearch);
|
|
|
|
if (pcsNew)
|
|
{
|
|
if (psfscOnAsyncSearch)
|
|
psfscOnAsyncSearch->Release(); // _CurrentSearches now holds the ref
|
|
|
|
// This will AddRef pcsNew 'cause its going in the list
|
|
_CurrentSearches::s_NewSearch(pcsNew);
|
|
pcsNew->Release();
|
|
*ppidlOut = pidlView;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
ILFree(pidlView);
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CHistFolder::CancelAsyncSearch(LPCITEMIDLIST pidlSearch, LPDWORD pdwFlags)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (IS_VALID_VIEWPIDL(pidlSearch) &&
|
|
(((LPVIEWPIDL)pidlSearch)->usViewType == VIEWPIDL_SEARCH))
|
|
{
|
|
hr = S_FALSE;
|
|
_CurrentSearches *pcs = _CurrentSearches::s_FindSearch(((LPSEARCHVIEWPIDL)pidlSearch)->ftSearchKey);
|
|
if (pcs) {
|
|
pcs->_fKillSwitch = TRUE;
|
|
hr = S_OK;
|
|
pcs->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CHistFolder::InvalidateSearch(LPCITEMIDLIST pidlSearch, LPDWORD pdwFlags)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
if (IS_VALID_VIEWPIDL(pidlSearch) &&
|
|
(((LPVIEWPIDL)pidlSearch)->usViewType == VIEWPIDL_SEARCH))
|
|
{
|
|
hr = S_FALSE;
|
|
_CurrentSearches *pcs = _CurrentSearches::s_FindSearch(((LPSEARCHVIEWPIDL)pidlSearch)->ftSearchKey);
|
|
if (pcs) {
|
|
_CurrentSearches::s_RemoveSearch(pcs);
|
|
pcs->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
|
|
DWORD CHistFolder::_GetHitCount(LPCTSTR pszUrl)
|
|
{
|
|
DWORD dwHitCount = 0;
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
|
|
if (pUrlHistStg)
|
|
{
|
|
PROPVARIANT vProp = {0};
|
|
if (SUCCEEDED(pUrlHistStg->GetProperty(pszUrl, PID_INTSITE_VISITCOUNT, &vProp)) &&
|
|
(vProp.vt == VT_UI4))
|
|
{
|
|
dwHitCount = vProp.lVal;
|
|
}
|
|
pUrlHistStg->Release();
|
|
}
|
|
return dwHitCount;
|
|
}
|
|
|
|
// pidl should be freed by caller
|
|
// URL must have some sort of cache container prefix
|
|
LPHEIPIDL CHistFolder::_CreateHCacheFolderPidlFromUrl(BOOL fOleMalloc, LPCTSTR pszPrefixedUrl)
|
|
{
|
|
LPHEIPIDL pheiRet;
|
|
HRESULT hrLocal = E_FAIL;
|
|
STATURL suThis;
|
|
LPCTSTR pszStrippedUrl = _StripHistoryUrlToUrl(pszPrefixedUrl);
|
|
IUrlHistoryPriv *pUrlHistStg = _GetHistStg();
|
|
if (pUrlHistStg)
|
|
{
|
|
hrLocal = pUrlHistStg->QueryUrl(pszStrippedUrl, STATURL_QUERYFLAG_NOURL, &suThis);
|
|
pUrlHistStg->Release();
|
|
}
|
|
|
|
FILETIME ftLastVisit = { 0 };
|
|
DWORD dwNumHits = 0;
|
|
|
|
if (FAILED(hrLocal)) { // maybe the cache knows...
|
|
BYTE ab[MAX_URLCACHE_ENTRY];
|
|
LPINTERNET_CACHE_ENTRY_INFO pcei = (LPINTERNET_CACHE_ENTRY_INFO)(&ab);
|
|
DWORD dwSize = MAX_URLCACHE_ENTRY;
|
|
if (GetUrlCacheEntryInfo(_StripHistoryUrlToUrl(pszPrefixedUrl), pcei, &dwSize)) {
|
|
ftLastVisit = pcei->LastAccessTime;
|
|
dwNumHits = pcei->dwHitRate;
|
|
}
|
|
}
|
|
|
|
pheiRet = _CreateHCacheFolderPidl(fOleMalloc, pszPrefixedUrl,
|
|
SUCCEEDED(hrLocal) ? suThis.ftLastVisited : ftLastVisit,
|
|
SUCCEEDED(hrLocal) ? &suThis : NULL, 0,
|
|
SUCCEEDED(hrLocal) ? _GetHitCount(pszStrippedUrl) : dwNumHits);
|
|
if (SUCCEEDED(hrLocal) && suThis.pwcsTitle)
|
|
OleFree(suThis.pwcsTitle);
|
|
return pheiRet;
|
|
}
|
|
|
|
|
|
UINT _CountPidlParts(LPCITEMIDLIST pidl) {
|
|
LPCITEMIDLIST pidlTemp = pidl;
|
|
UINT uParts = 0;
|
|
|
|
if (pidl)
|
|
{
|
|
for (uParts = 0; pidlTemp->mkid.cb; pidlTemp = _ILNext(pidlTemp))
|
|
++uParts;
|
|
}
|
|
return uParts;
|
|
}
|
|
|
|
// you must dealloc (LocalFree) the ppidl returned
|
|
LPITEMIDLIST* _SplitPidl(LPCITEMIDLIST pidl, UINT& uSizeInOut) {
|
|
LPCITEMIDLIST pidlTemp = pidl;
|
|
LPITEMIDLIST* ppidlList =
|
|
reinterpret_cast<LPITEMIDLIST *>(LocalAlloc(LPTR,
|
|
sizeof(LPITEMIDLIST) * uSizeInOut));
|
|
if (pidlTemp && ppidlList) {
|
|
UINT uCount;
|
|
for (uCount = 0; ( (uCount < uSizeInOut) && (pidlTemp->mkid.cb) );
|
|
++uCount, pidlTemp = _ILNext(pidlTemp))
|
|
ppidlList[uCount] = const_cast<LPITEMIDLIST>(pidlTemp);
|
|
}
|
|
return ppidlList;
|
|
}
|
|
|
|
LPITEMIDLIST* _SplitPidlEasy(LPCITEMIDLIST pidl, UINT& uSizeOut) {
|
|
uSizeOut = _CountPidlParts(pidl);
|
|
return _SplitPidl(pidl, uSizeOut);
|
|
}
|
|
|
|
// caller LocalFree's *ppidlOut
|
|
// returned pidl should be combined with the history folder location
|
|
HRESULT _ConvertStdPidlToViewPidl_OrderSite(LPCITEMIDLIST pidlSecondLast,
|
|
LPCITEMIDLIST pidlLast,
|
|
LPITEMIDLIST *ppidlOut) {
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// painfully construct the final pidl by concatenating the little
|
|
// peices [special_viewpidl, iddpidl, heipidl]
|
|
if ( _IsValid_IDPIDL(pidlSecondLast) &&
|
|
EQUIV_IDSIGN(IDDPIDL_SIGN,
|
|
(reinterpret_cast<LPBASEPIDL>
|
|
(const_cast<LPITEMIDLIST>(pidlSecondLast)))->usSign) &&
|
|
(_IsValid_HEIPIDL(pidlLast)) )
|
|
{
|
|
LPITEMIDLIST pidlViewTemp = NULL;
|
|
hr = CreateSpecialViewPidl(VIEWPIDL_ORDER_SITE, &pidlViewTemp);
|
|
if (SUCCEEDED(hr) && pidlViewTemp)
|
|
{
|
|
hr = SHILCombine(pidlViewTemp, pidlSecondLast, ppidlOut);
|
|
ILFree(pidlViewTemp);
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
return hr;
|
|
}
|
|
|
|
// caller LocalFree's *ppidlOut
|
|
// returned pidl should be combined with the history folder location
|
|
HRESULT _ConvertStdPidlToViewPidl_OrderToday(LPITEMIDLIST pidlLast,
|
|
LPITEMIDLIST *ppidlOut,
|
|
USHORT usViewType = VIEWPIDL_ORDER_TODAY)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// painfully construct the final pidl by concatenating the little
|
|
// peices [special_viewpidl, heipidl]
|
|
if (_IsValid_HEIPIDL(pidlLast))
|
|
{
|
|
LPHEIPIDL phei = reinterpret_cast<LPHEIPIDL>(pidlLast);
|
|
LPITEMIDLIST pidlViewTemp = NULL;
|
|
hr = CreateSpecialViewPidl(usViewType, &pidlViewTemp);
|
|
if (SUCCEEDED(hr) && pidlViewTemp)
|
|
{
|
|
hr = SHILCombine(pidlViewTemp, reinterpret_cast<LPITEMIDLIST>(phei), ppidlOut);
|
|
ILFree(pidlViewTemp);
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
return hr;
|
|
}
|
|
|
|
// remember to ILFree pidl
|
|
HRESULT ConvertStandardHistPidlToSpecialViewPidl(LPCITEMIDLIST pidlStandardHist,
|
|
USHORT usViewType,
|
|
LPITEMIDLIST *ppidlOut) {
|
|
if (!pidlStandardHist || !ppidlOut)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
HRESULT hr = E_FAIL;
|
|
|
|
UINT uPidlCount;
|
|
LPITEMIDLIST *ppidlSplit = _SplitPidlEasy(pidlStandardHist, uPidlCount);
|
|
/* Standard Hist Pidl should be in this form:
|
|
* [IDIPIDL, IDDPIDL, HEIPIDL]
|
|
* ex: [Today, foo.com, http://foo.com/bar.html]
|
|
*/
|
|
if (ppidlSplit)
|
|
{
|
|
if (uPidlCount >= 3)
|
|
{
|
|
LPITEMIDLIST pidlTemp = NULL;
|
|
switch(usViewType)
|
|
{
|
|
case VIEWPIDL_ORDER_FREQ:
|
|
case VIEWPIDL_ORDER_TODAY:
|
|
hr = _ConvertStdPidlToViewPidl_OrderToday(ppidlSplit[uPidlCount - 1],
|
|
&pidlTemp, usViewType);
|
|
break;
|
|
case VIEWPIDL_ORDER_SITE:
|
|
hr = _ConvertStdPidlToViewPidl_OrderSite(ppidlSplit[uPidlCount - 2],
|
|
ppidlSplit[uPidlCount - 1],
|
|
&pidlTemp);
|
|
break;
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
}
|
|
if (SUCCEEDED(hr) && pidlTemp)
|
|
{
|
|
*ppidlOut = pidlTemp;
|
|
hr = (*ppidlOut ? S_OK : E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else {
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
LocalFree(ppidlSplit);
|
|
ppidlSplit = NULL;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// START OF JCORDELL CODE
|
|
|
|
#ifdef DEBUG
|
|
BOOL ValidBeginningOfDay( const SYSTEMTIME *pTime )
|
|
{
|
|
return pTime->wHour == 0 && pTime->wMinute == 0 && pTime->wSecond == 0 && pTime->wMilliseconds == 0;
|
|
}
|
|
|
|
BOOL ValidBeginningOfDay( const FILETIME *pTime )
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
|
|
FileTimeToSystemTime( pTime, &sysTime );
|
|
return ValidBeginningOfDay( &sysTime);
|
|
}
|
|
#endif
|
|
|
|
void _CommonTimeFormatProcessing(const FILETIME *pStartTime, const FILETIME *pEndTime,
|
|
int *pdays_delta,
|
|
int *pdays_delta_from_today,
|
|
TCHAR *szStartDateBuffer,
|
|
DWORD dwStartDateBuffer,
|
|
SYSTEMTIME *pSysStartTime,
|
|
SYSTEMTIME *pSysEndTime,
|
|
LCID lcidUI)
|
|
{
|
|
SYSTEMTIME sysStartTime, sysEndTime, sysLocalTime;
|
|
FILETIME fileLocalTime;
|
|
|
|
// ASSERTS
|
|
ASSERT(ValidBeginningOfDay( pStartTime ));
|
|
ASSERT(ValidBeginningOfDay( pEndTime ));
|
|
|
|
// Get times in SYSTEMTIME format
|
|
FileTimeToSystemTime( pStartTime, &sysStartTime );
|
|
FileTimeToSystemTime( pEndTime, &sysEndTime );
|
|
|
|
// Get string date of start time
|
|
GetDateFormat(lcidUI, DATE_SHORTDATE, &sysStartTime, NULL, szStartDateBuffer, dwStartDateBuffer);
|
|
|
|
// Get FILETIME of the first instant of today
|
|
GetLocalTime( &sysLocalTime );
|
|
sysLocalTime.wHour = sysLocalTime.wMinute = sysLocalTime.wSecond = sysLocalTime.wMilliseconds = 0;
|
|
SystemTimeToFileTime( &sysLocalTime, &fileLocalTime );
|
|
|
|
*pdays_delta = DAYS_DIFF(pEndTime, pStartTime);
|
|
*pdays_delta_from_today = DAYS_DIFF(&fileLocalTime, pStartTime);
|
|
*pSysEndTime = sysEndTime;
|
|
*pSysStartTime = sysStartTime;
|
|
}
|
|
|
|
// this wrapper allows the FormatMessage wrapper to make use of FormatMessageLite, which
|
|
// does not require a code page for correct operation on Win9x. The original FormatMessage calls
|
|
// used the FORMAT_MESSAGE_MAX_WIDTH_MASK (which is not relevant to our strings), and used an array
|
|
// of arguments. Now we make the call compatible with FormatMessageLite.
|
|
|
|
DWORD FormatMessageLiteWrapperW(LPCWSTR lpSource, LPWSTR lpBuffer, DWORD cchBuffer, ...)
|
|
{
|
|
va_list arguments;
|
|
va_start(arguments, cchBuffer);
|
|
WCHAR* pszTemp;
|
|
DWORD dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING, lpSource, 0, 0, (LPWSTR)&pszTemp, 0, &arguments);
|
|
if (dwRet)
|
|
{
|
|
StringCchCopy(lpBuffer, cchBuffer, pszTemp);
|
|
LocalFree(pszTemp);
|
|
pszTemp = NULL;
|
|
}
|
|
else
|
|
{
|
|
*lpBuffer = L'\0';
|
|
}
|
|
va_end(arguments);
|
|
return dwRet;
|
|
}
|
|
|
|
BOOL GetTooltipForTimeInterval( const FILETIME *pStartTime, const FILETIME *pEndTime,
|
|
TCHAR *pszBuffer, int cchBuffer)
|
|
{
|
|
SYSTEMTIME sysStartTime, sysEndTime;
|
|
int days_delta; // number of days between start and end time
|
|
int days_delta_from_today; // number of days between today and start time
|
|
TCHAR szStartDateBuffer[64];
|
|
TCHAR szDayBuffer[64];
|
|
TCHAR szEndDateBuffer[64];
|
|
TCHAR *args[2];
|
|
TCHAR szFmt[64];
|
|
int idFormat;
|
|
LANGID lidUI;
|
|
LCID lcidUI;
|
|
|
|
lidUI = MLGetUILanguage();
|
|
lcidUI = MAKELCID(lidUI, SORT_DEFAULT);
|
|
|
|
_CommonTimeFormatProcessing(pStartTime,
|
|
pEndTime,
|
|
&days_delta,
|
|
&days_delta_from_today,
|
|
szStartDateBuffer,
|
|
ARRAYSIZE(szStartDateBuffer),
|
|
&sysStartTime,
|
|
&sysEndTime,
|
|
lcidUI);
|
|
if ( days_delta == 1 ) {
|
|
args[0] = &szDayBuffer[0];
|
|
idFormat = IDS_DAYTOOLTIP;
|
|
|
|
// day sized bucket
|
|
if ( days_delta_from_today == 0 ) {
|
|
// today
|
|
szDayBuffer[0] = 0;
|
|
idFormat = IDS_TODAYTOOLTIP;
|
|
}
|
|
else if ( days_delta_from_today > 0 && days_delta_from_today < 7 )
|
|
{
|
|
// within the last week, put day of week
|
|
GetDateFormat(lcidUI, 0, &sysStartTime, TEXT("dddd"), szDayBuffer, ARRAYSIZE(szDayBuffer));
|
|
}
|
|
else {
|
|
// just a plain day bucket
|
|
StrCpyN( szDayBuffer, szStartDateBuffer, ARRAYSIZE(szDayBuffer) );
|
|
}
|
|
}
|
|
else if ( days_delta == 7 && sysStartTime.wDayOfWeek == 1 ) {
|
|
// week-size bucket starting on a Monday
|
|
args[0] = &szStartDateBuffer[0];
|
|
|
|
// make is point to the first string for safety sake. This will be ignored by wsprintf
|
|
args[1] = args[0];
|
|
idFormat = IDS_WEEKTOOLTIP;
|
|
}
|
|
else {
|
|
// non-standard bucket (not exactly a week and not exactly a day)
|
|
|
|
args[0] = &szStartDateBuffer[0];
|
|
args[1] = &szEndDateBuffer[0];
|
|
idFormat = IDS_MISCTOOLTIP;
|
|
|
|
GetDateFormat(lcidUI, DATE_SHORTDATE, &sysEndTime, NULL, szEndDateBuffer, ARRAYSIZE(szEndDateBuffer) );
|
|
}
|
|
|
|
MLLoadString(idFormat, szFmt, ARRAYSIZE(szFmt));
|
|
|
|
// NOTE, if the second parameter is not needed by the szFMt, then it will be ignored by wnsprintf
|
|
if (idFormat == IDS_DAYTOOLTIP)
|
|
wnsprintf(pszBuffer, cchBuffer, szFmt, args[0]);
|
|
else
|
|
FormatMessageLiteWrapperW(szFmt, pszBuffer, cchBuffer, args[0], args[1]);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL GetDisplayNameForTimeInterval( const FILETIME *pStartTime, const FILETIME *pEndTime,
|
|
LPTSTR pszBuffer, int cchBuffer)
|
|
{
|
|
SYSTEMTIME sysStartTime, sysEndTime;
|
|
int days_delta; // number of days between start and end time
|
|
int days_delta_from_today; // number of days between today and start time
|
|
TCHAR szStartDateBuffer[64];
|
|
LANGID lidUI;
|
|
LCID lcidUI;
|
|
|
|
lidUI = MLGetUILanguage();
|
|
lcidUI = MAKELCID(lidUI, SORT_DEFAULT);
|
|
|
|
_CommonTimeFormatProcessing(pStartTime,
|
|
pEndTime,
|
|
&days_delta,
|
|
&days_delta_from_today,
|
|
szStartDateBuffer,
|
|
ARRAYSIZE(szStartDateBuffer),
|
|
&sysStartTime,
|
|
&sysEndTime,
|
|
lcidUI);
|
|
if ( days_delta == 1 ) {
|
|
// day sized bucket
|
|
if ( days_delta_from_today == 0 ) {
|
|
// today
|
|
MLLoadString(IDS_TODAY, pszBuffer, cchBuffer);
|
|
}
|
|
else if ( days_delta_from_today > 0 && days_delta_from_today < 7 )
|
|
{
|
|
// within the last week, put day of week
|
|
int nResult = GetDateFormat(lcidUI, 0, &sysStartTime, TEXT("dddd"), pszBuffer, cchBuffer);
|
|
|
|
|
|
ASSERT(nResult);
|
|
}
|
|
else {
|
|
// just a plain day bucket
|
|
StrCpyN( pszBuffer, szStartDateBuffer, cchBuffer );
|
|
}
|
|
}
|
|
else if ( days_delta == 7 && sysStartTime.wDayOfWeek == 1 ) {
|
|
// week-size bucket starting on a Monday
|
|
TCHAR szFmt[64];
|
|
|
|
int nWeeksAgo = days_delta_from_today / 7;
|
|
|
|
if (nWeeksAgo == 1) {
|
|
// print "Last Week"
|
|
MLLoadString(IDS_LASTWEEK, pszBuffer, cchBuffer);
|
|
}
|
|
else {
|
|
// print "n Weeks Ago"
|
|
MLLoadString(IDS_WEEKSAGO, szFmt, ARRAYSIZE(szFmt));
|
|
wnsprintf(pszBuffer, cchBuffer, szFmt, nWeeksAgo);
|
|
}
|
|
}
|
|
else {
|
|
// non-standard bucket (not exactly a week and not exactly a day)
|
|
TCHAR szFmt[64];
|
|
TCHAR szEndDateBuffer[64];
|
|
TCHAR *args[2];
|
|
|
|
args[0] = &szStartDateBuffer[0];
|
|
args[1] = &szEndDateBuffer[0];
|
|
|
|
|
|
GetDateFormat(lcidUI, DATE_SHORTDATE, &sysEndTime, NULL, szEndDateBuffer, ARRAYSIZE(szEndDateBuffer) );
|
|
|
|
MLLoadString(IDS_FROMTO, szFmt, ARRAYSIZE(szFmt));
|
|
FormatMessageLiteWrapperW(szFmt, pszBuffer, cchBuffer, args[0], args[1]);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// END OF JCORDELL CODE
|
|
|
|
// if !fOleMalloc, use LocalAlloc for speed // ok to pass in NULL for lpStatURL
|
|
LPHEIPIDL _CreateHCacheFolderPidl(BOOL fOleMalloc, LPCTSTR pszUrl, FILETIME ftModified, LPSTATURL lpStatURL,
|
|
__int64 llPriority/* = 0*/, DWORD dwNumHits/* = 0*/) // used in freqnecy view
|
|
{
|
|
USHORT usUrlSize = (USHORT)((lstrlen(pszUrl) + 1) * sizeof(TCHAR));
|
|
DWORD dwSize = sizeof(HEIPIDL) + usUrlSize;
|
|
USHORT usTitleSize = 0;
|
|
BOOL fUseTitle = (lpStatURL && lpStatURL->pwcsTitle && _TitleIsGood(lpStatURL->pwcsTitle));
|
|
if (fUseTitle)
|
|
usTitleSize = (USHORT)((lstrlen(lpStatURL->pwcsTitle) + 1) * sizeof(WCHAR));
|
|
|
|
dwSize += usTitleSize;
|
|
|
|
LPHEIPIDL pheip = (LPHEIPIDL)_CreateBaseFolderPidl(fOleMalloc, dwSize, HEIPIDL_SIGN);
|
|
|
|
if (pheip)
|
|
{
|
|
pheip->usUrl = sizeof(HEIPIDL);
|
|
pheip->usFlags = lpStatURL ? HISTPIDL_VALIDINFO : 0;
|
|
pheip->usTitle = fUseTitle ? pheip->usUrl+usUrlSize :0;
|
|
pheip->ftModified = ftModified;
|
|
pheip->llPriority = llPriority;
|
|
pheip->dwNumHits = dwNumHits;
|
|
if (lpStatURL)
|
|
{
|
|
pheip->ftLastVisited = lpStatURL->ftLastVisited;
|
|
if (fUseTitle)
|
|
StrCpyN((LPTSTR)(((BYTE*)pheip)+pheip->usTitle), lpStatURL->pwcsTitle, usTitleSize / sizeof(TCHAR));
|
|
}
|
|
else {
|
|
//mm98: not so sure about the semantics on this one -- but this call
|
|
// with lpstaturl NULL (called from _NotifyWrite<--_WriteHistory<--WriteHistory<--CUrlHistory::_WriteToHistory
|
|
// makes for an uninitialised "Last Visited Member" which wreaks havoc
|
|
// when we want to order URLs by last visited
|
|
pheip->ftLastVisited = ftModified;
|
|
}
|
|
StrCpyN((LPTSTR)(((BYTE*)pheip)+pheip->usUrl), pszUrl, usUrlSize / sizeof(TCHAR));
|
|
}
|
|
return pheip;
|
|
}
|
|
|
|
// if !fOleMalloc, use LocalAlloc for speed
|
|
LPBASEPIDL _CreateIdCacheFolderPidl(BOOL fOleMalloc, USHORT usSign, LPCTSTR szId)
|
|
{
|
|
DWORD cch = lstrlen(szId) + 1;
|
|
DWORD dwSize = cch * sizeof(TCHAR);
|
|
dwSize += sizeof(BASEPIDL);
|
|
LPBASEPIDL pceip = _CreateBaseFolderPidl(fOleMalloc, dwSize, usSign);
|
|
if (pceip)
|
|
{
|
|
// dst <- src
|
|
// since pcei is ID type sign, _GetURLTitle points into correct place in pcei
|
|
StrCpyN((LPTSTR)_GetURLTitle(pceip), szId, cch);
|
|
}
|
|
return pceip;
|
|
}
|
|
|
|
// if !fOleAlloc, use LocalAlloc for speed
|
|
LPBASEPIDL _CreateBaseFolderPidl(BOOL fOleAlloc, DWORD cbSize, USHORT usSign)
|
|
{
|
|
LPBASEPIDL pcei;
|
|
DWORD cbTotalSize;
|
|
|
|
// Note: the buffer size returned by wininet includes INTERNET_CACHE_ENTRY_INFO
|
|
cbTotalSize = sizeof(BASEPIDL) + cbSize;
|
|
|
|
if (fOleAlloc)
|
|
{
|
|
pcei = (LPBASEPIDL)OleAlloc(cbTotalSize);
|
|
if (pcei != NULL)
|
|
{
|
|
ZeroMemory(pcei, cbTotalSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pcei = (LPBASEPIDL) LocalAlloc(GPTR, cbTotalSize);
|
|
// LocalAlloc zero inits
|
|
}
|
|
if (pcei)
|
|
{
|
|
pcei->cb = (USHORT)(cbTotalSize - sizeof(USHORT));
|
|
pcei->usSign = usSign;
|
|
}
|
|
return pcei;
|
|
}
|
|
|
|
// returns a pidl (viewpidl)
|
|
// You must free the pidl with ILFree
|
|
|
|
// cbExtra - count of how much to allocate at the end of the pidl
|
|
// ppbExtra - pointer to buffer at end of pidl that is cbExtra big
|
|
HRESULT CreateSpecialViewPidl(USHORT usViewType, LPITEMIDLIST* ppidlOut, UINT cbExtra /* = 0*/, LPBYTE *ppbExtra /* = NULL*/)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (ppidlOut) {
|
|
*ppidlOut = NULL;
|
|
|
|
ASSERT((usViewType > 0) &&
|
|
((usViewType <= VIEWPIDL_ORDER_MAX) ||
|
|
(usViewType == VIEWPIDL_SEARCH)));
|
|
|
|
// Tack another ITEMIDLIST on the end to be the empty "null terminating" pidl
|
|
USHORT cbSize = sizeof(VIEWPIDL) + cbExtra + sizeof(ITEMIDLIST);
|
|
// use the shell's allocator because folks will want to free it with ILFree
|
|
VIEWPIDL *viewpidl = ((VIEWPIDL *)SHAlloc(cbSize));
|
|
if (viewpidl)
|
|
{
|
|
// this should also make the "next" pidl empty
|
|
ZeroMemory(viewpidl, cbSize);
|
|
viewpidl->cb = (USHORT)(sizeof(VIEWPIDL) + cbExtra);
|
|
viewpidl->usSign = VIEWPIDL_SIGN;
|
|
viewpidl->usViewType = usViewType;
|
|
viewpidl->usExtra = 0; // currently unused
|
|
|
|
if (ppbExtra)
|
|
*ppbExtra = ((LPBYTE)viewpidl) + sizeof(VIEWPIDL);
|
|
|
|
*ppidlOut = (LPITEMIDLIST)viewpidl;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
|
|
return hr;
|
|
}
|
|
|