1556 lines
51 KiB
C++
1556 lines
51 KiB
C++
//
|
|
// CleanupWiz.cpp
|
|
//
|
|
#include "CleanupWiz.h"
|
|
#include "resource.h"
|
|
#include "priv.h"
|
|
#include "dblnul.h"
|
|
|
|
#include <windowsx.h> // for SetWindowFont
|
|
#include <varutil.h>
|
|
#include <commctrl.h>
|
|
#include <shlwapi.h>
|
|
#include <shguidp.h>
|
|
#include <ieguidp.h>
|
|
|
|
|
|
// UEM stuff: including this source file is the
|
|
// recommended way of using it in your project
|
|
// (see comments in the file itself for the reason)
|
|
#include "..\inc\uassist.cpp"
|
|
|
|
#define MAX_GUID_STRING_LEN 39
|
|
|
|
////////////////////////////////////////////
|
|
//
|
|
// Globals, constants, externs etc...
|
|
//
|
|
////////////////////////////////////////////
|
|
|
|
extern HINSTANCE g_hInst;
|
|
STDMETHODIMP GetItemCLSID(IShellFolder2 *psf, LPCITEMIDLIST pidlLast, CLSID *pclsid);
|
|
|
|
//
|
|
// number of items to grow dsa by
|
|
//
|
|
const int c_GROWBYSIZE = 4;
|
|
|
|
//
|
|
// number of pages in the wizard
|
|
//
|
|
const int c_NUM_PAGES = 3;
|
|
|
|
//
|
|
// dialog prompt text length
|
|
//
|
|
const int c_MAX_PROMPT_TEXT = 1024;
|
|
const int c_MAX_HEADER_LEN = 64;
|
|
const int c_MAX_DATE_LEN = 40;
|
|
|
|
//
|
|
// file modified more than 60 days back is candidate for cleanup
|
|
// this value can be overriden by policy
|
|
//
|
|
const int c_NUMDAYSTODECAY = 60;
|
|
|
|
//
|
|
// Needed for hiding regitems
|
|
//
|
|
#define DEFINE_SCID(name, fmtid, pid) const SHCOLUMNID name = { fmtid, pid }
|
|
DEFINE_SCID(SCID_DESCRIPTIONID, PSGUID_SHELLDETAILS, PID_DESCRIPTIONID);
|
|
|
|
//
|
|
// pointer to member function typedef
|
|
//
|
|
typedef INT_PTR (STDMETHODCALLTYPE CCleanupWiz::* PCFC_DlgProcFn)(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
//
|
|
// struct for helping us manage our dialog procs
|
|
//
|
|
typedef struct
|
|
{
|
|
CCleanupWiz * pcfc;
|
|
PCFC_DlgProcFn pfnDlgProc;
|
|
} DLGPROCINFO, *PDLGPROCINFO;
|
|
|
|
//
|
|
// enum for columns
|
|
//
|
|
typedef enum eColIndex
|
|
{
|
|
FC_COL_SHORTCUT,
|
|
FC_COL_DATE
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// iDays can be negative or positive, indicating time in the past or future
|
|
//
|
|
//
|
|
#define FTsPerDayOver1000 (10000*60*60*24) // we've got (1000 x 10,000) 100ns intervals per second
|
|
|
|
STDAPI_(void) GetFileTimeNDaysFromGivenTime(const FILETIME *pftGiven, FILETIME * pftReturn, int iDays)
|
|
{
|
|
__int64 i64 = *((__int64 *) pftGiven);
|
|
i64 += Int32x32To64(iDays*1000,FTsPerDayOver1000);
|
|
|
|
*pftReturn = *((FILETIME *) &i64);
|
|
}
|
|
|
|
STDAPI_(void) GetFileTimeNDaysFromCurrentTime(FILETIME *pf, int iDays)
|
|
{
|
|
SYSTEMTIME st;
|
|
FILETIME ftNow;
|
|
|
|
GetLocalTime(&st);
|
|
SystemTimeToFileTime(&st, &ftNow);
|
|
|
|
GetFileTimeNDaysFromGivenTime(&ftNow, pf, iDays);
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
//
|
|
//
|
|
// The CCleanupWiz class implementation
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////
|
|
|
|
CCleanupWiz::CCleanupWiz(): _psf(NULL),
|
|
_hdsaItems(NULL),
|
|
_hTitleFont(NULL),
|
|
_iDeltaDays(0),
|
|
_dwCleanMode(CLEANUP_MODE_NORMAL)
|
|
{
|
|
INITCOMMONCONTROLSEX icce;
|
|
icce.dwSize = sizeof(icce);
|
|
icce.dwICC = ICC_LISTVIEW_CLASSES;
|
|
_bInited = InitCommonControlsEx(&icce);
|
|
|
|
// get the desktop folder
|
|
_bInited = _bInited && SUCCEEDED(SHGetDesktopFolder(&_psf));
|
|
};
|
|
|
|
CCleanupWiz::~CCleanupWiz()
|
|
{
|
|
_CleanUpDSA();
|
|
if (_psf)
|
|
{
|
|
_psf->Release();
|
|
_psf = NULL;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Runs the folder cleaning operation on the desktop folder.
|
|
//
|
|
//
|
|
// bCleanAll
|
|
//
|
|
// TRUE: show all the items in the desktop, this is done
|
|
// only when the user runs the wizard from the right click
|
|
// menu or display applet. in this case we don't need to show the
|
|
// notification balloon tip.
|
|
//
|
|
// FALSE: show only those items which are candidates for cleanup.
|
|
// this is done when we run the wizard through explorer (every 60 days,
|
|
// we check if it's time on login and every 24 hours thereafter)
|
|
// so we need to show the balloon tip and proceeed only if the user
|
|
// asks us to.
|
|
//
|
|
|
|
STDMETHODIMP CCleanupWiz::Run(DWORD dwCleanMode, HWND hwndParent)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// early out
|
|
if (!_bInited)
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
_dwCleanMode = dwCleanMode;
|
|
|
|
if (CLEANUP_MODE_SILENT == _dwCleanMode)
|
|
{
|
|
hr = _RunSilent();
|
|
}
|
|
else
|
|
{
|
|
_iDeltaDays = GetNumDaysBetweenCleanup();
|
|
|
|
if (_iDeltaDays < 0)
|
|
{
|
|
_iDeltaDays = c_NUMDAYSTODECAY; //initial default value
|
|
}
|
|
|
|
LoadString(g_hInst, IDS_ARCHIVEFOLDER, _szFolderName, MAX_PATH);
|
|
|
|
// init the common control classes we need
|
|
hr = _LoadDesktopContents();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = S_OK;
|
|
|
|
UINT cItems = DSA_GetItemCount(_hdsaItems);
|
|
if (CLEANUP_MODE_NORMAL == dwCleanMode)
|
|
{
|
|
if (cItems > 0) // if there are items, we want to notify and proceed only if the user wants us to.
|
|
{
|
|
hr = _ShowBalloonNotification();
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
_cItemsOnDesktop = cItems;
|
|
hr = _InitializeAndLaunchWizard(hwndParent);
|
|
}
|
|
|
|
_LogUsage(); // set registry values to indicate the last run time
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Creates the property pages for the wizard and launches the wizard
|
|
//
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_InitializeAndLaunchWizard(HWND hwndParent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DLGPROCINFO adpi[c_NUM_PAGES];
|
|
|
|
HPROPSHEETPAGE ahpsp[c_NUM_PAGES];
|
|
PROPSHEETPAGE psp = {0};
|
|
|
|
|
|
if (!_hTitleFont)
|
|
{
|
|
NONCLIENTMETRICS ncm = {0};
|
|
ncm.cbSize = sizeof(ncm);
|
|
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
|
|
LOGFONT TitleLogFont = ncm.lfMessageFont;
|
|
TitleLogFont.lfWeight = FW_BOLD;
|
|
TCHAR szFont[128];
|
|
LoadString(g_hInst, IDS_TITLELOGFONT, szFont, ARRAYSIZE(szFont));
|
|
lstrcpy(TitleLogFont.lfFaceName, szFont);
|
|
|
|
HDC hdc = GetDC(NULL);
|
|
INT FontSize = 12;
|
|
TitleLogFont.lfHeight = 0 - GetDeviceCaps(hdc, LOGPIXELSY) * FontSize / 72;
|
|
_hTitleFont = CreateFontIndirect(&TitleLogFont);
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
//
|
|
// Intro Page
|
|
//
|
|
adpi[0].pcfc = this;
|
|
adpi[0].pfnDlgProc = &CCleanupWiz::_IntroPageDlgProc;
|
|
psp.dwSize = sizeof(psp);
|
|
psp.dwFlags = PSP_DEFAULT|PSP_HIDEHEADER;
|
|
psp.hInstance = g_hInst;
|
|
psp.lParam = (LPARAM) &adpi[0];
|
|
psp.pfnDlgProc = s_StubDlgProc;
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_INTRO);
|
|
ahpsp[0] = CreatePropertySheetPage(&psp);
|
|
|
|
//
|
|
// Choose files page
|
|
//
|
|
adpi[1].pcfc = this;
|
|
adpi[1].pfnDlgProc = &CCleanupWiz::_ChooseFilesPageDlgProc;
|
|
psp.hInstance = g_hInst;
|
|
psp.dwFlags = PSP_DEFAULT|PSP_USEHEADERTITLE| PSP_USEHEADERSUBTITLE;
|
|
psp.lParam = (LPARAM) &adpi[1];
|
|
psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_CHOOSEFILES);
|
|
psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_CHOOSEFILES_INFO);
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_CHOOSEFILES);
|
|
psp.pfnDlgProc = s_StubDlgProc;
|
|
ahpsp[1] = CreatePropertySheetPage(&psp);
|
|
|
|
//
|
|
// Completion Page
|
|
//
|
|
adpi[2].pcfc = this;
|
|
adpi[2].pfnDlgProc = &CCleanupWiz::_FinishPageDlgProc;
|
|
psp.dwFlags = PSP_DEFAULT|PSP_HIDEHEADER;
|
|
psp.hInstance = g_hInst;
|
|
psp.lParam = (LPARAM) &adpi[2];
|
|
psp.pfnDlgProc = s_StubDlgProc;
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_FINISH);
|
|
ahpsp[2] = CreatePropertySheetPage(&psp);
|
|
|
|
//
|
|
// The wizard property sheet
|
|
//
|
|
PROPSHEETHEADER psh = {0};
|
|
|
|
psh.dwSize = sizeof(psh);
|
|
psh.hInstance = g_hInst;
|
|
psh.hwndParent = hwndParent;
|
|
psh.phpage = ahpsp;
|
|
psh.dwFlags = PSH_WIZARD97|PSH_WATERMARK|PSH_HEADER;
|
|
psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK);
|
|
psh.pszbmHeader = MAKEINTRESOURCE(IDB_LOGO);
|
|
psh.nStartPage = _cItemsOnDesktop ? 0 : c_NUM_PAGES - 1; // if there are no pages on desktop, start on final page
|
|
psh.nPages = c_NUM_PAGES;
|
|
|
|
PropertySheet(&psh);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Pops up a balloon notification tip which asks the user
|
|
// if he wants to clean up the desktop.
|
|
//
|
|
// returns S_OK if user wants us to cleanup.
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_ShowBalloonNotification()
|
|
{
|
|
IUserNotification *pun;
|
|
HRESULT hr = CoCreateInstance(CLSID_UserNotification, NULL, CLSCTX_ALL,
|
|
IID_PPV_ARG(IUserNotification, &pun));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szTitle[64], szMsg[256]; // we leave enough room for localization bloat
|
|
|
|
LoadString(g_hInst, IDS_NOTIFICATION_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
LoadString(g_hInst, IDS_NOTIFICATION_TEXT, szMsg, ARRAYSIZE(szMsg));
|
|
|
|
pun->SetIconInfo(LoadIcon(g_hInst, MAKEINTRESOURCE(IDI_WIZ_ICON)), szTitle);
|
|
pun->SetBalloonInfo(szTitle, szMsg, NIIF_WARNING);
|
|
|
|
// try once, for 20 seconds
|
|
pun->SetBalloonRetry(20 * 1000, -1, 1);
|
|
|
|
// returns S_OK if user wants to continue, ERROR_CANCELLED if timedout
|
|
// or canncelled otherwise.
|
|
hr = pun->Show(NULL, 0); // we don't support iquerycontinue, we will just wait
|
|
|
|
pun->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Gets the list of items on the desktop that should be cleaned
|
|
//
|
|
// if dwCleanMode == CLEANUP_MODE_NORMAL, it only loads items which have not been used recently
|
|
// if dwCleanMode == CLEANUP_MODE_ALL, it loads all items on the desktop, marking those which have not been used recently
|
|
//
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_LoadDesktopContents()
|
|
{
|
|
ASSERT(_psf);
|
|
|
|
IEnumIDList * ppenum;
|
|
|
|
DWORD grfFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
|
|
HRESULT hr = _psf->EnumObjects(NULL, grfFlags, &ppenum);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_CleanUpDSA();
|
|
_hdsaItems = DSA_Create(sizeof(FOLDERITEMDATA), c_GROWBYSIZE);
|
|
|
|
if (_hdsaItems)
|
|
{
|
|
ULONG celtFetched;
|
|
FOLDERITEMDATA fid = {0};
|
|
|
|
hr = S_OK;
|
|
while(SUCCEEDED(hr) && (S_OK == ppenum->Next(1,&fid.pidl, &celtFetched)))
|
|
{
|
|
if (_IsSupportedType(fid.pidl)) // only support links and regitems
|
|
{
|
|
// note, the call to _IsCandidateForRemoval also obtains the last
|
|
// used timestamp for the item
|
|
BOOL bShouldRemove = ((CLEANUP_MODE_SILENT == _dwCleanMode) ||
|
|
(_IsCandidateForRemoval(fid.pidl, &fid.ftLastUsed)));
|
|
if ( (CLEANUP_MODE_ALL == _dwCleanMode) || bShouldRemove)
|
|
{
|
|
SHFILEINFO sfi = {0};
|
|
if (SHGetFileInfo((LPCTSTR) fid.pidl,
|
|
0,
|
|
&sfi,
|
|
sizeof(sfi),
|
|
SHGFI_PIDL | SHGFI_DISPLAYNAME | SHGFI_ICON | SHGFI_SMALLICON ))
|
|
{
|
|
if (Str_SetPtr(&(fid.pszName), sfi.szDisplayName))
|
|
{
|
|
fid.hIcon = sfi.hIcon;
|
|
fid.bSelected = bShouldRemove;
|
|
if (-1 != DSA_AppendItem(_hdsaItems, &fid))
|
|
{
|
|
// All is well, the item has succesfully been added
|
|
// to the dsa, we zero out the fields so as not to
|
|
// free those resources now, they will be freed when the
|
|
// dsa is destroyed.
|
|
ZeroMemory(&fid, sizeof(fid));
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Common cleanup path for various failure cases above,
|
|
// we did not add this item to the dsa, so cleanup now.
|
|
_CleanUpDSAItem(&fid);
|
|
}
|
|
//
|
|
// If we did not load any items into the dsa, we return S_FALSE
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = DSA_GetItemCount(_hdsaItems) > 0 ? S_OK : S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we failed to allocate memory for the DSA
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
ppenum->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Gets the list of items on the desktop that should be cleaned
|
|
//
|
|
// if dwCleanMode == CLEANUP_MODE_SILENT, it loads all items on all desktops, marking them all
|
|
//
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_LoadMergedDesktopContents()
|
|
{
|
|
ASSERT(_psf);
|
|
|
|
IEnumIDList * ppenum;
|
|
|
|
DWORD grfFlags = _dwCleanMode == CLEANUP_MODE_SILENT ? SHCONTF_FOLDERS | SHCONTF_NONFOLDERS: SHCONTF_NONFOLDERS;
|
|
HRESULT hr = _psf->EnumObjects(NULL, grfFlags, &ppenum);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_CleanUpDSA();
|
|
_hdsaItems = DSA_Create(sizeof(FOLDERITEMDATA), c_GROWBYSIZE);
|
|
|
|
if (_hdsaItems)
|
|
{
|
|
ULONG celtFetched;
|
|
FOLDERITEMDATA fid = {0};
|
|
|
|
hr = S_OK;
|
|
while(SUCCEEDED(hr) && (S_OK == ppenum->Next(1,&fid.pidl, &celtFetched)))
|
|
{
|
|
if (_IsSupportedType(fid.pidl)) // only support links and regitems
|
|
{
|
|
// note, the call to _IsCandidateForRemoval also obtains the last
|
|
// used timestamp for the item
|
|
BOOL bShouldRemove = ((CLEANUP_MODE_SILENT == _dwCleanMode) ||
|
|
(_IsCandidateForRemoval(fid.pidl, &fid.ftLastUsed)));
|
|
if ( (CLEANUP_MODE_ALL == _dwCleanMode) || bShouldRemove)
|
|
{
|
|
SHFILEINFO sfi = {0};
|
|
if (SHGetFileInfo((LPCTSTR) fid.pidl,
|
|
0,
|
|
&sfi,
|
|
sizeof(sfi),
|
|
SHGFI_PIDL | SHGFI_DISPLAYNAME | SHGFI_ICON | SHGFI_SMALLICON ))
|
|
{
|
|
if (Str_SetPtr(&(fid.pszName), sfi.szDisplayName))
|
|
{
|
|
fid.hIcon = sfi.hIcon;
|
|
fid.bSelected = bShouldRemove;
|
|
if (-1 != DSA_AppendItem(_hdsaItems, &fid))
|
|
{
|
|
// All is well, the item has succesfully been added
|
|
// to the dsa, we zero out the fields so as not to
|
|
// free those resources now, they will be freed when the
|
|
// dsa is destroyed.
|
|
ZeroMemory(&fid, sizeof(fid));
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Common cleanup path for various failure cases above,
|
|
// we did not add this item to the dsa, so cleanup now.
|
|
_CleanUpDSAItem(&fid);
|
|
}
|
|
//
|
|
// If we did not load any items into the dsa, we return S_FALSE
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = DSA_GetItemCount(_hdsaItems) > 0 ? S_OK : S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we failed to allocate memory for the DSA
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
ppenum->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Expects the given pidl to be a link or regitem. Determines if it is a candidate for removal based
|
|
// on when was the last time it was used.
|
|
//
|
|
STDMETHODIMP_(BOOL) CCleanupWiz::_IsCandidateForRemoval(LPCITEMIDLIST pidl, FILETIME * pftLastUsed)
|
|
{
|
|
BOOL bRet = FALSE; // be conservative, if we do not know anything about the
|
|
// object we will not volunteer to remove it
|
|
int cHit = 0;
|
|
TCHAR szName[MAX_PATH];
|
|
|
|
ASSERT(_psf);
|
|
|
|
//
|
|
// we store UEM usage info for the regitems and links on the desktop
|
|
//
|
|
if (SUCCEEDED(DisplayNameOf(_psf,
|
|
pidl,
|
|
SHGDN_INFOLDER | SHGDN_FORPARSING,
|
|
szName,
|
|
ARRAYSIZE(szName))))
|
|
{
|
|
if (SUCCEEDED(_GetUEMInfo(-1, (LPARAM) szName, &cHit, pftLastUsed)))
|
|
{
|
|
FILETIME ft;
|
|
GetFileTimeNDaysFromCurrentTime(&ft, -_iDeltaDays);
|
|
|
|
#ifdef DEBUG
|
|
SYSTEMTIME st;
|
|
FileTimeToSystemTime(&ft, &st);
|
|
#endif
|
|
|
|
bRet = (CompareFileTime(pftLastUsed, &ft) < 0);
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//
|
|
// Copied from shell\shell32\deskfldr.cpp : CDesktopViewCallBack::ShouldShow
|
|
// If you modify this, modify that as well
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_ShouldShow(IShellFolder* psf, LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlItem)
|
|
{
|
|
HRESULT hr = S_OK; //Assume that this item should be shown!
|
|
|
|
#if 0
|
|
//
|
|
// we know this is the real desktop
|
|
// leaving this code here to maintain parallel with deskfldr.cpp
|
|
//
|
|
if (!_fCheckedIfRealDesktop) //Have we done this check before?
|
|
{
|
|
_fRealDesktop = IsDesktopBrowser(_punkSite);
|
|
_fCheckedIfRealDesktop = TRUE; //Remember this fact!
|
|
}
|
|
|
|
if (!_fRealDesktop)
|
|
return S_OK; //Not a real desktop! So, let's show everything!
|
|
#endif
|
|
|
|
IShellFolder2 *psf2;
|
|
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
|
|
{
|
|
// Get the GUID in the pidl, which requires IShellFolder2.
|
|
CLSID guidItem;
|
|
if (SUCCEEDED(GetItemCLSID(psf2, pidlItem, &guidItem)))
|
|
{
|
|
SHELLSTATE ss = {0};
|
|
SHGetSetSettings(&ss, SSF_STARTPANELON, FALSE); //See if the StartPanel is on!
|
|
|
|
TCHAR szRegPath[MAX_PATH];
|
|
//Get the proper registry path based on if StartPanel is ON/OFF
|
|
wsprintf(szRegPath, REGSTR_PATH_HIDDEN_DESKTOP_ICONS, (ss.fStartPanelOn ? REGSTR_VALUE_STARTPANEL : REGSTR_VALUE_CLASSICMENU));
|
|
|
|
//Convert the guid to a string
|
|
TCHAR szGuidValue[MAX_GUID_STRING_LEN];
|
|
|
|
SHStringFromGUID(guidItem, szGuidValue, ARRAYSIZE(szGuidValue));
|
|
|
|
//See if this item is turned off in the registry.
|
|
if (SHRegGetBoolUSValue(szRegPath, szGuidValue, FALSE, /* default */FALSE))
|
|
hr = S_FALSE; //They want to hide it; So, return S_FALSE.
|
|
|
|
if (SHRestricted(REST_NOMYCOMPUTERICON) && IsEqualCLSID(CLSID_MyComputer, guidItem))
|
|
hr = S_FALSE;
|
|
|
|
}
|
|
psf2->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Normal, All: We only support removing regitems and links from the desktop
|
|
// Silent: We support moving everything except the clean up shortcut folders and the recycle bin
|
|
//
|
|
STDMETHODIMP_(BOOL) CCleanupWiz::_IsSupportedType(LPCITEMIDLIST pidl)
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
|
|
// if not in silent mode, must be a link or regitem
|
|
eFILETYPE eType = _GetItemType(pidl);
|
|
if (CLEANUP_MODE_SILENT == _dwCleanMode ||
|
|
FC_TYPE_LINK == eType || FC_TYPE_REGITEM == eType)
|
|
{
|
|
// can't be the recycle bin
|
|
IShellFolder* psf;
|
|
if (SUCCEEDED(SHGetDesktopFolder(&psf)))
|
|
{
|
|
IShellFolder2 *psf2;
|
|
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
|
|
{
|
|
CLSID guidItem;
|
|
if (SUCCEEDED(GetItemCLSID(psf2, pidl, &guidItem)) &&
|
|
!IsEqualCLSID(CLSID_MyComputer, guidItem) &&
|
|
!IsEqualCLSID(CLSID_MyDocuments, guidItem) &&
|
|
!IsEqualCLSID(CLSID_NetworkPlaces, guidItem) &&
|
|
!IsEqualCLSID(CLSID_RecycleBin, guidItem))
|
|
{
|
|
// can't be the folder we're storing things in
|
|
TCHAR szName[MAX_PATH];
|
|
if (SUCCEEDED(DisplayNameOf(_psf,
|
|
pidl,
|
|
SHGDN_INFOLDER | SHGDN_FORPARSING,
|
|
szName,
|
|
ARRAYSIZE(szName))))
|
|
{
|
|
if (0 != lstrcmp(szName, _szFolderName))
|
|
{
|
|
fRetVal = (S_OK == _ShouldShow(psf, NULL, pidl));
|
|
}
|
|
}
|
|
}
|
|
psf2->Release();
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
//
|
|
// Returns the type of the pidl.
|
|
// We are only interested in Links and Regitems, so we return FC_TYPE_OTHER for
|
|
// all other items.
|
|
//
|
|
STDMETHODIMP_(eFILETYPE) CCleanupWiz::_GetItemType(LPCITEMIDLIST pidl)
|
|
{
|
|
eFILETYPE eftVal = FC_TYPE_OTHER;
|
|
TCHAR szName[MAX_PATH];
|
|
IShellLink *psl;
|
|
|
|
ASSERT(_psf);
|
|
|
|
if (SUCCEEDED( _psf->GetUIObjectOf(NULL,
|
|
1,
|
|
&pidl,
|
|
IID_PPV_ARG_NULL(IShellLink, &psl))))
|
|
{
|
|
eftVal = FC_TYPE_LINK;
|
|
psl->Release();
|
|
}
|
|
else if (SUCCEEDED(DisplayNameOf(_psf,
|
|
pidl,
|
|
SHGDN_INFOLDER | SHGDN_FORPARSING,
|
|
szName,
|
|
ARRAYSIZE(szName))))
|
|
{
|
|
if(_IsRegItemName(szName))
|
|
{
|
|
|
|
eftVal = FC_TYPE_REGITEM;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Maybe this item is a kind of .{GUID} object we created to restore
|
|
// regitems. In that case we want to actually restore the regitem
|
|
// at this point by marking it as unhidden.
|
|
//
|
|
|
|
LPTSTR pszExt = PathFindExtension(szName);
|
|
if (TEXT('.') == *pszExt // it is a file extension
|
|
&& lstrlen(++pszExt) == (GUIDSTR_MAX - 1) // AND the extension is of the right length
|
|
// note: GUIDSTR_MAX includes the terminating NULL
|
|
// while lstrlen does not, hence the expression
|
|
&& TEXT('{') == *pszExt) // AND looks like it is a guid...
|
|
{
|
|
// we most prob have a bonafide guid string
|
|
// pszExt now points to the beginning of the GUID string
|
|
TCHAR szGUIDName[ARRAYSIZE(TEXT("::")) + GUIDSTR_MAX];
|
|
|
|
// put it in the regitem SHGDN_FORPARSING name format, which is like
|
|
//
|
|
// "::{16B280C6-EE70-11D1-9066-00C04FD9189D}"
|
|
//
|
|
wnsprintf(szGUIDName, ARRAYSIZE(szGUIDName), TEXT("::%s"), pszExt );
|
|
|
|
LPITEMIDLIST pidlGUID;
|
|
DWORD dwAttrib = SFGAO_NONENUMERATED;
|
|
|
|
//
|
|
// get the pidl of the regitem, if this call succeeds, it means we do have
|
|
// a corresponding regitem in the desktop's namespace
|
|
//
|
|
if (SUCCEEDED(_psf->ParseDisplayName(NULL,
|
|
NULL,
|
|
szGUIDName,
|
|
NULL,
|
|
&pidlGUID,
|
|
&dwAttrib)))
|
|
{
|
|
//
|
|
// check if the regitem is marked as hidden
|
|
//
|
|
if (dwAttrib & SFGAO_NONENUMERATED)
|
|
{
|
|
//
|
|
// One last check before we enable the regitem:
|
|
// Does the regitem have the same display name as the .CLSID file.
|
|
// In case the user has restored this .CLSID file and renamed it we will
|
|
// not attempt to restore the regitem as it may confuse the user.
|
|
//
|
|
TCHAR szNameRegItem[MAX_PATH];
|
|
|
|
if (SUCCEEDED((DisplayNameOf(_psf,
|
|
pidl,
|
|
SHGDN_NORMAL,
|
|
szName,
|
|
ARRAYSIZE(szName)))) &&
|
|
SUCCEEDED((DisplayNameOf(_psf,
|
|
pidlGUID,
|
|
SHGDN_NORMAL,
|
|
szNameRegItem,
|
|
ARRAYSIZE(szNameRegItem)))) &&
|
|
lstrcmp(szName, szNameRegItem) == 0)
|
|
{
|
|
if (SUCCEEDED(_HideRegPidl(pidlGUID, FALSE)))
|
|
{
|
|
// delete the file corresponding to the regitem
|
|
if (SUCCEEDED(DisplayNameOf(_psf,
|
|
pidl,
|
|
SHGDN_NORMAL | SHGDN_FORPARSING,
|
|
szName,
|
|
ARRAYSIZE(szName))))
|
|
{
|
|
DeleteFile(szName); // too bad if we fail, we will just
|
|
// have two identical icons on the desktop
|
|
}
|
|
|
|
//
|
|
// Log the current time as the last used time of the regitem.
|
|
// We just re-enabled this regitem but we do not have the
|
|
// usage info for the corresponding .{CLSID} which the user had
|
|
// been using so far. So we will be conservative and say that
|
|
// it was used right now, so that it does not become a candidate
|
|
// for removal soon. As this is a regitem that the user restored
|
|
// after the wizard removed it, so it is a fair assumption that
|
|
// the user has used it after restoring it and is not a candidate
|
|
// for cleanup right now.
|
|
//
|
|
UEMFireEvent(&UEMIID_SHELL, UEME_RUNPATH, UEMF_XEVENT, -1, (LPARAM)szGUIDName);
|
|
}
|
|
}
|
|
}
|
|
ILFree(pidlGUID);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return eftVal;
|
|
}
|
|
|
|
|
|
//
|
|
// Determines if a filename is that of a regitem
|
|
//
|
|
// a regitem's SHGDN_INFOLDER | SHGDN_FORPARSING name is always "::{someguid}"
|
|
//
|
|
// CDefview::_LogDesktopLinksAndRegitems() uses the same test to determine
|
|
// if a given pidl is a regitem. This case can lead to false positives if
|
|
// you have other items on the desktop which have infoder parsing names
|
|
// beginning with "::{", but as ':' is not presently allowed in filenames
|
|
// it should not be a problem.
|
|
//
|
|
STDMETHODIMP_(BOOL) CCleanupWiz::_IsRegItemName(LPTSTR pszName)
|
|
{
|
|
return (pszName[0] == TEXT(':') && pszName[1] == TEXT(':') && pszName[2] == TEXT('{'));
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL) CCleanupWiz::_CreateFakeRegItem(LPCTSTR pszDestPath, LPCTSTR pszName, LPCTSTR pszGUID)
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
|
|
TCHAR szLinkName[MAX_PATH];
|
|
lstrcpyn(szLinkName, pszDestPath, ARRAYSIZE(szLinkName));
|
|
PathAppend(szLinkName, pszName);
|
|
StrCatBuff(szLinkName, TEXT("."), ARRAYSIZE(szLinkName));
|
|
StrCatBuff(szLinkName, pszGUID, ARRAYSIZE(szLinkName));
|
|
|
|
//
|
|
// We use the CREATE_ALWAYS flag so that if the file already exists
|
|
// in the Unused Desktop Files folder, we will go ahead and hide the
|
|
// regitem.
|
|
//
|
|
HANDLE hFile = CreateFile(szLinkName, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
// we created/opened the shortcut, now hide the regitem and close
|
|
// the shortcut file
|
|
fRetVal = TRUE;
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
//
|
|
// Given path to an exe, returns the UEM hit count and last used date for it
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_GetUEMInfo(WPARAM wParam, LPARAM lParam, int * pcHit, FILETIME * pftLastUsed)
|
|
{
|
|
UEMINFO uei;
|
|
uei.cbSize = sizeof(uei);
|
|
uei.dwMask = UEIM_HIT | UEIM_FILETIME;
|
|
|
|
|
|
HRESULT hr = UEMQueryEvent(&UEMIID_SHELL, UEME_RUNPATH, wParam, lParam, &uei);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pcHit = uei.cHit;
|
|
*pftLastUsed = uei.ftExecute;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(BOOL) CCleanupWiz::_ShouldProcess()
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
if (_dwCleanMode == CLEANUP_MODE_SILENT)
|
|
{
|
|
fRetVal = TRUE;
|
|
}
|
|
else
|
|
{
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
if (pfid->bSelected)
|
|
{
|
|
fRetVal = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
//
|
|
// Process the list of items. At this point _hdsaItems only contains the
|
|
// items that the user wants to delete
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_ProcessItems()
|
|
{
|
|
TCHAR szFolderLocation[MAX_PATH]; // desktop folder
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_ShouldProcess())
|
|
{
|
|
LPITEMIDLIST pidlCommonDesktop = NULL;
|
|
|
|
ASSERT(_psf);
|
|
// use the archive folder on the desktop
|
|
if (CLEANUP_MODE_SILENT != _dwCleanMode)
|
|
{
|
|
hr = DisplayNameOf(_psf, NULL, SHGDN_FORPARSING, szFolderLocation, ARRAYSIZE(szFolderLocation));
|
|
}
|
|
else // use the archive folder in Program Files
|
|
{
|
|
hr = SHGetFolderLocation(NULL, CSIDL_PROGRAM_FILES , NULL, 0, &pidlCommonDesktop);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = DisplayNameOf(_psf, pidlCommonDesktop, SHGDN_FORPARSING, szFolderLocation, ARRAYSIZE(szFolderLocation));
|
|
}
|
|
}
|
|
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERTMSG(*_szFolderName, "Desktop Cleaner: Archive Folder Name not present");
|
|
|
|
// create the full path of the archive folder
|
|
TCHAR szFolderPath[MAX_PATH];
|
|
lstrcpyn(szFolderPath, szFolderLocation, ARRAYSIZE(szFolderPath));
|
|
PathAppend(szFolderPath, _szFolderName);
|
|
|
|
//
|
|
// We have to make sure that this folder exists, as otherwise, if we try to move
|
|
// a single shortcut using SHFileOperation, that file will be renamed to the target
|
|
// name instead of being put in a folder with that name.
|
|
//
|
|
SECURITY_ATTRIBUTES sa;
|
|
sa.nLength = sizeof (sa);
|
|
sa.lpSecurityDescriptor = NULL; // we get the default attributes for this process
|
|
sa.bInheritHandle = FALSE;
|
|
|
|
int iRetVal = SHCreateDirectoryEx(NULL, szFolderPath, &sa);
|
|
if (ERROR_SUCCESS == iRetVal || ERROR_FILE_EXISTS == iRetVal || ERROR_ALREADY_EXISTS == iRetVal)
|
|
{
|
|
DblNulTermList dnSourceFiles;
|
|
TCHAR szFileName[MAX_PATH + 1]; // to pad an extra null char for SHFileOpStruct
|
|
|
|
//
|
|
//
|
|
// now we can start on the files we need to move
|
|
//
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
|
|
if ((pfid->bSelected || _dwCleanMode == CLEANUP_MODE_SILENT) &&
|
|
SUCCEEDED(DisplayNameOf(_psf,pfid->pidl,
|
|
SHGDN_FORPARSING,
|
|
szFileName,
|
|
ARRAYSIZE(szFileName) - 1)))
|
|
{
|
|
if (_IsRegItemName(szFileName))
|
|
{
|
|
// if its a regitem, we create a "Item Name.{GUID}" file
|
|
// and mark the regitem as hidden.
|
|
//
|
|
if (_CreateFakeRegItem(szFolderPath, pfid->pszName, szFileName+2))
|
|
{
|
|
_HideRegPidl(pfid->pidl, TRUE);
|
|
}
|
|
}
|
|
else // not a regitem, will move it
|
|
{
|
|
dnSourceFiles.AddString(szFileName);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (dnSourceFiles.Count() > 0)
|
|
{
|
|
DblNulTermList dnTargetFolder;
|
|
dnTargetFolder.AddString(szFolderPath);
|
|
|
|
SHFILEOPSTRUCT sfo;
|
|
sfo.hwnd = NULL;
|
|
sfo.wFunc = FO_MOVE;
|
|
sfo.pFrom = (LPCTSTR) dnSourceFiles;
|
|
sfo.pTo = (LPCTSTR) dnTargetFolder;
|
|
sfo.fFlags = FOF_NORECURSION | FOF_NOCONFIRMMKDIR | FOF_ALLOWUNDO ;
|
|
hr = SHFileOperation(&sfo);
|
|
}
|
|
|
|
SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, (LPCVOID) szFolderPath, 0);
|
|
SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, (LPCVOID) szFolderLocation, 0);
|
|
|
|
}
|
|
else
|
|
{
|
|
// we failed to create the Unused Desktop Files folder
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
//
|
|
// DialogProcs
|
|
//
|
|
// TODO: test for accessibilty issues
|
|
//
|
|
////////////////////////////////////////////////////////
|
|
|
|
INT_PTR STDMETHODCALLTYPE CCleanupWiz::_IntroPageDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
INT_PTR ipRet = FALSE;
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT_TITLE_WELCOME);
|
|
SetWindowFont(hWnd, _hTitleFont, TRUE);
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY :
|
|
{
|
|
LPNMHDR lpnm = (LPNMHDR) lParam;
|
|
|
|
switch (lpnm->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ipRet;
|
|
}
|
|
|
|
INT_PTR STDMETHODCALLTYPE CCleanupWiz::_ChooseFilesPageDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
INT_PTR ipRet = FALSE;
|
|
HWND hwLV = NULL;
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
_InitChoosePage(hDlg);
|
|
ipRet = TRUE;
|
|
break;
|
|
|
|
case WM_NOTIFY :
|
|
LPNMHDR lpnm = (LPNMHDR) lParam;
|
|
switch (lpnm->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT | PSWIZB_BACK);
|
|
hwLV = GetDlgItem(hDlg, IDC_LV_PROMPT);
|
|
_SetCheckedState(hwLV);
|
|
break;
|
|
|
|
case PSN_WIZNEXT:
|
|
// remember the items the user selected
|
|
hwLV = GetDlgItem(hDlg, IDC_LV_PROMPT);
|
|
_MarkSelectedItems(hwLV);
|
|
break;
|
|
|
|
case PSN_WIZBACK:
|
|
// remember the items the user selected
|
|
hwLV = GetDlgItem(hDlg, IDC_LV_PROMPT);
|
|
_MarkSelectedItems(hwLV);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return ipRet;
|
|
}
|
|
|
|
|
|
INT_PTR STDMETHODCALLTYPE CCleanupWiz::_FinishPageDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
INT_PTR ipRet = FALSE;
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
_InitFinishPage(hDlg);
|
|
ipRet = TRUE;
|
|
break;
|
|
|
|
case WM_NOTIFY :
|
|
{
|
|
LPNMHDR lpnm = (LPNMHDR) lParam;
|
|
|
|
switch (lpnm->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PropSheet_SetWizButtons(GetParent(hDlg), _cItemsOnDesktop ? PSWIZB_BACK | PSWIZB_FINISH : PSWIZB_FINISH);
|
|
// selection can change so need to do this everytime you come to this page
|
|
_RefreshFinishPage(hDlg);
|
|
break;
|
|
|
|
case PSN_WIZFINISH:
|
|
// process the items now
|
|
_ProcessItems();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ipRet;
|
|
}
|
|
|
|
//
|
|
// stub dialog proc which redirects calls to the right dialog procs
|
|
//
|
|
INT_PTR CALLBACK CCleanupWiz::s_StubDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PDLGPROCINFO pInfo = (PDLGPROCINFO) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
if (WM_INITDIALOG == wMsg)
|
|
{
|
|
pInfo = (PDLGPROCINFO) ((LPPROPSHEETPAGE) lParam) -> lParam;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM) pInfo);
|
|
}
|
|
|
|
if (pInfo)
|
|
{
|
|
CCleanupWiz * pThis = pInfo->pcfc;
|
|
PCFC_DlgProcFn pfn = pInfo->pfnDlgProc;
|
|
|
|
return (pThis->*pfn)(hDlg, wMsg, wParam, lParam);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CCleanupWiz::_InitListBox(HWND hWndListView)
|
|
{
|
|
ListView_SetExtendedListViewStyle(hWndListView, LVS_EX_SUBITEMIMAGES);
|
|
//
|
|
// add the columns
|
|
//
|
|
LVCOLUMN lvcDate;
|
|
TCHAR szDateHeader[c_MAX_HEADER_LEN];
|
|
|
|
lvcDate.mask = LVCF_SUBITEM | LVCF_WIDTH | LVCF_TEXT ;
|
|
lvcDate.iSubItem = FC_COL_SHORTCUT;
|
|
lvcDate.cx = 200;
|
|
LoadString(g_hInst, IDS_HEADER_ITEM, szDateHeader, ARRAYSIZE(szDateHeader));
|
|
lvcDate.pszText = szDateHeader;
|
|
ListView_InsertColumn(hWndListView, FC_COL_SHORTCUT, &lvcDate);
|
|
|
|
lvcDate.mask = LVCF_SUBITEM | LVCF_FMT | LVCF_WIDTH | LVCF_TEXT ;
|
|
lvcDate.iSubItem = FC_COL_DATE;
|
|
lvcDate.fmt = LVCFMT_LEFT;
|
|
lvcDate.cx = 1;
|
|
LoadString(g_hInst, IDS_HEADER_DATE, szDateHeader, ARRAYSIZE(szDateHeader));
|
|
lvcDate.pszText = szDateHeader;
|
|
ListView_InsertColumn(hWndListView, FC_COL_DATE, &lvcDate);
|
|
ListView_SetColumnWidth(hWndListView, FC_COL_DATE, LVSCW_AUTOSIZE_USEHEADER);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CCleanupWiz::_InitChoosePage(HWND hDlg)
|
|
{
|
|
HWND hWndListView = GetDlgItem(hDlg, IDC_LV_PROMPT);
|
|
|
|
_InitListBox(hWndListView);
|
|
|
|
//
|
|
// add the images
|
|
//
|
|
HIMAGELIST hSmall = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
ILC_MASK | ILC_COLOR32 , c_GROWBYSIZE, c_GROWBYSIZE);
|
|
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
ImageList_AddIcon(hSmall, pfid->hIcon);
|
|
}
|
|
ListView_SetImageList(hWndListView, hSmall, LVSIL_SMALL);
|
|
|
|
//
|
|
// set the checkboxes style
|
|
//
|
|
ListView_SetExtendedListViewStyleEx(hWndListView, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
|
|
|
|
_PopulateListView(hWndListView);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CCleanupWiz::_InitFinishPage(HWND hDlg)
|
|
{
|
|
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT_TITLE_WELCOME);
|
|
|
|
SetWindowFont(hWnd, _hTitleFont, TRUE);
|
|
|
|
HIMAGELIST hSmall = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
ILC_MASK | ILC_COLOR32, c_GROWBYSIZE, c_GROWBYSIZE);
|
|
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
ImageList_AddIcon(hSmall, pfid->hIcon);
|
|
}
|
|
|
|
ListView_SetImageList(GetDlgItem(hDlg, IDC_LV_INFORM), hSmall, LVSIL_SMALL);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CCleanupWiz::_RefreshFinishPage(HWND hDlg)
|
|
{
|
|
HWND hWndListView = GetDlgItem(hDlg, IDC_LV_INFORM);
|
|
ListView_DeleteAllItems(hWndListView);
|
|
|
|
int cMovedItems = _PopulateListViewFinish(hWndListView);
|
|
|
|
// set the informative text to reflect how many items were moved
|
|
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT_INFORM);
|
|
TCHAR szDisplayText[c_MAX_PROMPT_TEXT];
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDC_LV_INFORM), BOOLIFY(cMovedItems));
|
|
ShowWindow(GetDlgItem(hDlg, IDC_TEXT_SHORTCUTS), BOOLIFY(cMovedItems));
|
|
ShowWindow(GetDlgItem(hDlg, IDC_TEXT_CHANGE), BOOLIFY(cMovedItems));
|
|
|
|
if ( 0 == cMovedItems)
|
|
{
|
|
LoadString(g_hInst, _cItemsOnDesktop ? IDS_INFORM_NONE : IDS_INFORM_NONEFOUND, szDisplayText, ARRAYSIZE(szDisplayText));
|
|
}
|
|
else if (1 == cMovedItems)
|
|
{
|
|
LoadString(g_hInst, IDS_INFORM_SINGLE, szDisplayText, ARRAYSIZE(szDisplayText));
|
|
}
|
|
else
|
|
{
|
|
TCHAR szRawText[c_MAX_PROMPT_TEXT];
|
|
LoadString(g_hInst, IDS_INFORM, szRawText, ARRAYSIZE(szRawText));
|
|
wnsprintf(szDisplayText, ARRAYSIZE(szDisplayText), szRawText, cMovedItems);
|
|
}
|
|
SetWindowText(hWnd, szDisplayText);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(int) CCleanupWiz::_PopulateListView(HWND hWndListView)
|
|
{
|
|
LVITEM lvi = {0};
|
|
int cRet = 0;
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
|
|
lvi.mask = LVIF_TEXT | LVIF_IMAGE;
|
|
lvi.pszText = pfid->pszName;
|
|
lvi.iImage = i;
|
|
lvi.iItem = i;
|
|
lvi.iSubItem = FC_COL_SHORTCUT;
|
|
ListView_InsertItem(hWndListView, &lvi);
|
|
cRet++;
|
|
|
|
// set the last used date
|
|
TCHAR szDate[c_MAX_DATE_LEN];
|
|
if (SUCCEEDED(_GetDateFromFileTime(pfid->ftLastUsed, szDate, ARRAYSIZE(szDate))))
|
|
{
|
|
ListView_SetItemText(hWndListView, i, FC_COL_DATE, szDate);
|
|
}
|
|
}
|
|
return cRet;
|
|
}
|
|
|
|
STDMETHODIMP_(int) CCleanupWiz::_PopulateListViewFinish(HWND hWndListView)
|
|
{
|
|
LVITEM lvi = {0};
|
|
lvi.mask = LVIF_TEXT | LVIF_IMAGE ;
|
|
int cRet = 0;
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
|
|
//
|
|
// it's the Finish Page, we only show the items we were asked to move
|
|
//
|
|
if (pfid->bSelected)
|
|
{
|
|
lvi.pszText = pfid->pszName;
|
|
lvi.iImage = i;
|
|
lvi.iItem = i;
|
|
ListView_InsertItem(hWndListView, &lvi);
|
|
cRet++;
|
|
}
|
|
|
|
}
|
|
return cRet;
|
|
}
|
|
|
|
//
|
|
// Converts a given FILETIME date into s displayable string
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_GetDateFromFileTime(FILETIME ftLastUsed, LPTSTR pszDate, int cch )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if (0 == ftLastUsed.dwHighDateTime && 0 == ftLastUsed.dwLowDateTime)
|
|
{
|
|
if (0 == LoadString(g_hInst, IDS_NEVER, pszDate, cch))
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwFlags = FDTF_SHORTDATE;
|
|
if (0 == SHFormatDateTime(&ftLastUsed, &dwFlags, pszDate, cch))
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Marks listview items as checked or unchecked
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_SetCheckedState(HWND hWndListView)
|
|
{
|
|
int cItems = DSA_GetItemCount(_hdsaItems);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, i);
|
|
ListView_SetCheckState(hWndListView, i, pfid->bSelected);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// Reverse of above, updates our list based on user selection.
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_MarkSelectedItems(HWND hWndListView)
|
|
{
|
|
int cItems = ListView_GetItemCount(hWndListView);
|
|
for (int iLV = 0; iLV < cItems; iLV++)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems, iLV);
|
|
pfid->bSelected = ListView_GetCheckState(hWndListView, iLV);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// These methods clean up _hdsaItems and free the allocated memory
|
|
//
|
|
STDMETHODIMP_(void) CCleanupWiz::_CleanUpDSA()
|
|
{
|
|
if (_hdsaItems != NULL)
|
|
{
|
|
for (int i = DSA_GetItemCount(_hdsaItems)-1; i >= 0; i--)
|
|
{
|
|
FOLDERITEMDATA * pfid = (FOLDERITEMDATA *) DSA_GetItemPtr(_hdsaItems,i);
|
|
_CleanUpDSAItem(pfid);
|
|
}
|
|
DSA_Destroy(_hdsaItems);
|
|
_hdsaItems = NULL;
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CCleanupWiz::_CleanUpDSAItem(FOLDERITEMDATA * pfid)
|
|
{
|
|
|
|
if (pfid->pidl)
|
|
{
|
|
ILFree(pfid->pidl);
|
|
}
|
|
|
|
if (pfid->pszName)
|
|
{
|
|
Str_SetPtr(&(pfid->pszName), NULL);
|
|
}
|
|
|
|
if (pfid->hIcon)
|
|
{
|
|
DestroyIcon(pfid->hIcon);
|
|
}
|
|
|
|
ZeroMemory(pfid, sizeof(*pfid));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////
|
|
//
|
|
// Hide regitems
|
|
//
|
|
//////////////////////
|
|
|
|
|
|
//
|
|
// Helper routines used below.
|
|
// Cloned from shell32/util.cpp
|
|
//
|
|
STDMETHODIMP GetItemCLSID(IShellFolder2 *psf, LPCITEMIDLIST pidlLast, CLSID *pclsid)
|
|
{
|
|
VARIANT var;
|
|
HRESULT hr = psf->GetDetailsEx(pidlLast, &SCID_DESCRIPTIONID, &var);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SHDESCRIPTIONID did;
|
|
hr = VariantToBuffer(&var, (void *)&did, sizeof(did));
|
|
if (SUCCEEDED(hr))
|
|
*pclsid = did.clsid;
|
|
|
|
VariantClear(&var);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Given a regitem, it sets the SFGAO_NONENUMERATED bit on it so that
|
|
// that it no longer shows up in the folder.
|
|
//
|
|
// Since we are primarily only interested in cleaning up desktop clutter,
|
|
// that means we don't have to worry about all possible kinds of regitems.
|
|
// Our main target is apps like Outlook which create regitems instead of
|
|
// .lnk shortcuts. So our code does not have to be as complex as the
|
|
// regfldr.cpp version for deleting regitems, which has to account for
|
|
// everything, from legacy regitems to delegate folders.
|
|
//
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_HideRegPidl(LPCITEMIDLIST pidlr, BOOL fHide)
|
|
{
|
|
IShellFolder2 *psf2;
|
|
HRESULT hr = _psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CLSID clsid;
|
|
hr = GetItemCLSID(psf2, pidlr, &clsid);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _HideRegItem(&clsid, fHide, NULL);
|
|
}
|
|
psf2->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CCleanupWiz::_HideRegItem(CLSID* pclsid, BOOL fHide, BOOL* pfWasVisible)
|
|
{
|
|
HKEY hkey;
|
|
|
|
if (pfWasVisible)
|
|
{
|
|
*pfWasVisible = FALSE;
|
|
}
|
|
|
|
HRESULT hr = SHRegGetCLSIDKey(*pclsid, TEXT("ShellFolder"), FALSE, TRUE, &hkey);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
DWORD dwAttr, dwErr;
|
|
DWORD dwType = 0;
|
|
DWORD cbSize = sizeof(dwAttr);
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("Attributes"), NULL, &dwType, (BYTE *) &dwAttr, &cbSize))
|
|
{
|
|
if (pfWasVisible)
|
|
{
|
|
*pfWasVisible = !(dwAttr & SFGAO_NONENUMERATED);
|
|
}
|
|
fHide ? dwAttr |= SFGAO_NONENUMERATED : dwAttr &= ~SFGAO_NONENUMERATED;
|
|
}
|
|
else
|
|
{
|
|
// attributes do not exist, so we will try creating them
|
|
fHide ? dwAttr = SFGAO_NONENUMERATED : dwAttr = 0;
|
|
}
|
|
dwErr = RegSetValueEx(hkey, TEXT("Attributes"), NULL, dwType, (BYTE *) &dwAttr, cbSize);
|
|
hr = HRESULT_FROM_WIN32(dwErr);
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Method writes out the last used time in the registry and the
|
|
// number of days it was checkin for
|
|
//
|
|
STDMETHODIMP CCleanupWiz::_LogUsage()
|
|
{
|
|
FILETIME ft;
|
|
SYSTEMTIME st;
|
|
|
|
GetLocalTime(&st);
|
|
|
|
SystemTimeToFileTime(&st, &ft);
|
|
|
|
//
|
|
// we ignore if any of these calls fail, as we cannot really do anything
|
|
// in that case. the next time we run, we will run maybe sooner that expected.
|
|
//
|
|
SHRegSetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_TIME,
|
|
REG_BINARY, &ft, sizeof(ft),
|
|
SHREGSET_FORCE_HKCU);
|
|
|
|
SHRegSetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_DELTA_DAYS,
|
|
REG_DWORD,(DWORD *) &_iDeltaDays, sizeof(_iDeltaDays),
|
|
SHREGSET_FORCE_HKCU);
|
|
|
|
//
|
|
// TODO: also write out to log file here
|
|
//
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// returns the current value from the policy key or the user settings
|
|
//
|
|
STDMETHODIMP_(int) CCleanupWiz::GetNumDaysBetweenCleanup()
|
|
{
|
|
DWORD dwData;
|
|
DWORD dwType;
|
|
DWORD cch = sizeof (DWORD);
|
|
|
|
int iDays = -1; // if the value does not exist
|
|
|
|
//
|
|
// ISSUE-2000/12/01-AIDANL Removed REGSTR_POLICY_CLEANUP, don't think we need both, but want to
|
|
// leave this note in case issues come up later.
|
|
//
|
|
if (ERROR_SUCCESS == (SHRegGetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_DELTA_DAYS,
|
|
&dwType, &dwData, &cch,FALSE, NULL, 0)))
|
|
{
|
|
iDays = dwData;
|
|
}
|
|
|
|
return iDays;
|
|
}
|
|
|
|
// helper functions
|
|
STDAPI_(BOOL) IsUserAGuest()
|
|
{
|
|
return SHTestTokenMembership(NULL, DOMAIN_ALIAS_RID_GUESTS);
|
|
}
|