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.
1783 lines
65 KiB
1783 lines
65 KiB
/*
|
|
**------------------------------------------------------------------------------
|
|
** Module: Disk Cleanup Applet
|
|
** File: dmgrinfo.c
|
|
**
|
|
** Purpose: Defines the CleanupMgrInfo class for the property tab
|
|
** Notes:
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**
|
|
** Copyright (c)1997 Microsoft Corporation, All Rights Reserved
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** Project include files
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
#include "common.h"
|
|
#include <limits.h>
|
|
#include <emptyvc.h>
|
|
#include "dmgrinfo.h"
|
|
#include "dmgrdlg.h"
|
|
#include "diskutil.h"
|
|
#include "resource.h"
|
|
#include "msprintf.h"
|
|
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** Local variables
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
HINSTANCE CleanupMgrInfo::hInstance = NULL;
|
|
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** Function prototypes
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
INT_PTR CALLBACK
|
|
ScanAbortDlgProc(
|
|
HWND hDlg,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
void
|
|
ScanAbortThread(
|
|
CleanupMgrInfo *pcmi
|
|
);
|
|
|
|
INT_PTR CALLBACK
|
|
PurgeAbortDlgProc(
|
|
HWND hDlg,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
void
|
|
PurgeAbortThread(
|
|
CleanupMgrInfo *pcmi
|
|
);
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** Function definitions
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
|
|
|
|
void
|
|
CleanupMgrInfo::Register(
|
|
HINSTANCE hInstance
|
|
)
|
|
{
|
|
CleanupMgrInfo::hInstance = hInstance;
|
|
}
|
|
|
|
void
|
|
CleanupMgrInfo::Unregister(
|
|
void
|
|
)
|
|
{
|
|
CleanupMgrInfo::hInstance= NULL;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** GetCleanupMgrInfoPointer
|
|
**
|
|
** Purpose:
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
CleanupMgrInfo * GetCleanupMgrInfoPointer(
|
|
HWND hDlg
|
|
)
|
|
{
|
|
//
|
|
//Get the DriveInfo
|
|
//
|
|
CleanupMgrInfo * pcmi = (CleanupMgrInfo *)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
return pcmi;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo method definitions
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInit::init
|
|
**
|
|
** Purpose: sets to default values
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
void
|
|
CleanupMgrInfo::init(void)
|
|
{
|
|
dre = Drive_INV;
|
|
szVolName[0] = 0;
|
|
vtVolume = vtINVALID;
|
|
dwUIFlags = 0;
|
|
bPurgeFiles = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::destroy
|
|
**
|
|
** Purpose: releases any dynamic memory
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
void
|
|
CleanupMgrInfo::destroy(void)
|
|
{
|
|
//
|
|
//Set values back to defaults
|
|
//
|
|
init();
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::CleanupMgrInfo
|
|
**
|
|
** Purpose: Default constructor
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
CleanupMgrInfo::CleanupMgrInfo (void)
|
|
{
|
|
init();
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::CleanupMgrInfo
|
|
**
|
|
** Purpose: Constructor
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
CleanupMgrInfo::CleanupMgrInfo(
|
|
LPTSTR lpDrive,
|
|
DWORD dwFlags,
|
|
ULONG ulProfile
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
init();
|
|
|
|
hr = CoInitialize(NULL);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (create(lpDrive, dwFlags))
|
|
{
|
|
dwReturnCode = RETURN_SUCCESS;
|
|
dwUIFlags = dwFlags;
|
|
ulSAGEProfile = ulProfile;
|
|
bAbortScan = FALSE;
|
|
bAbortPurge = FALSE;
|
|
|
|
volumeCacheCallBack = NULL;
|
|
pIEmptyVolumeCacheCallBack = NULL;
|
|
volumeCacheCallBack = new CVolumeCacheCallBack();
|
|
|
|
if (volumeCacheCallBack)
|
|
{
|
|
hr = volumeCacheCallBack->QueryInterface(IID_IEmptyVolumeCacheCallBack,
|
|
(LPVOID*)&pIEmptyVolumeCacheCallBack);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (hr != NOERROR)
|
|
{
|
|
MiDebugMsg((hr, "CleanupMgrInfo::CleanupMgrInfo failed with error "));
|
|
}
|
|
|
|
//
|
|
//Initialize all of the cleanup clients
|
|
//
|
|
if (initializeClients() && !(dwUIFlags & FLAG_TUNEUP) && !(dwUIFlags & FLAG_SAGESET))
|
|
{
|
|
//
|
|
//Have all of the cleanup clients calculate the ammount of disk
|
|
//space that they can free up.
|
|
//
|
|
getSpaceUsedByClients();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::~CleanupMgrInfo
|
|
**
|
|
** Purpose: Destructor
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
CleanupMgrInfo::~CleanupMgrInfo (void)
|
|
{
|
|
if (isValid())
|
|
{
|
|
//
|
|
//Cleanup the Volume Cache Clients
|
|
//
|
|
deactivateClients();
|
|
|
|
if (volumeCacheCallBack != NULL)
|
|
{
|
|
volumeCacheCallBack->Release();
|
|
}
|
|
|
|
CoUninitialize();
|
|
|
|
destroy();
|
|
}
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::create
|
|
**
|
|
** Purpose: Gets Drive info from drive letter
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
BOOL
|
|
CleanupMgrInfo::create(
|
|
LPTSTR lpDrive,
|
|
DWORD Flags
|
|
)
|
|
{
|
|
|
|
//
|
|
//Note: Make sure the assigns to zero stay current
|
|
// otherwise we might get garbage stats if
|
|
// we fail because of lack of free space
|
|
//
|
|
DWORD cSectorsPerCluster;
|
|
DWORD cBytesPerSector;
|
|
DWORD cBytesPerCluster;
|
|
DWORD cFreeClusters;
|
|
DWORD cUsedClusters;
|
|
DWORD cTotalClusters;
|
|
ULARGE_INTEGER cbFree;
|
|
ULARGE_INTEGER cbUsed;
|
|
ULARGE_INTEGER cbTotal;
|
|
#ifdef NEC_98
|
|
drenum drive;
|
|
hardware hw_type;
|
|
#endif
|
|
|
|
cbFree.QuadPart = 0;
|
|
cbUsed.QuadPart = 0;
|
|
|
|
//
|
|
//Cleanup up any old stuff
|
|
//
|
|
destroy();
|
|
|
|
//
|
|
//Check parameters
|
|
//
|
|
if (lpDrive == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Is it a valid drive path
|
|
//
|
|
if (!fIsValidDriveString(lpDrive))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Get drive from path
|
|
//
|
|
if (!GetDriveFromString(lpDrive, dre))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!SUCCEEDED(StringCchCopy(szRoot, ARRAYSIZE(szRoot), lpDrive)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Step 2. Get general info from drive
|
|
//
|
|
|
|
//
|
|
//Get volume name
|
|
//
|
|
if (!GetVolumeInformation (szRoot, // Root name
|
|
szVolName, // Volume Name
|
|
ARRAYSIZE(szVolName), // Size
|
|
NULL, // Volume serial number
|
|
NULL, // Max path length
|
|
NULL, // flags
|
|
szFileSystem, sizeof(szFileSystem))) // file system name
|
|
{
|
|
//Error - failed to get volume name
|
|
goto lblERROR;
|
|
}
|
|
|
|
//
|
|
//Get the Driver Icon
|
|
//
|
|
if (Flags & FLAG_SAGESET)
|
|
hDriveIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(ICON_CLEANMGR));
|
|
else
|
|
hDriveIcon = GetDriveIcon(dre, FALSE);
|
|
|
|
//
|
|
//Get Hardware type
|
|
//
|
|
if (!GetHardwareType(dre, hwHardware))
|
|
{
|
|
//Error - failed to get hardware
|
|
goto lblERROR;
|
|
}
|
|
|
|
|
|
#ifdef NEC_98
|
|
drive = Drive_A;
|
|
GetHardwareType (Drive_A, hw_type);
|
|
|
|
if (hw_type != hwFixed)
|
|
{
|
|
drive = Drive_B;
|
|
GetHardwareType (Drive_B, hw_type);
|
|
|
|
if (hw_type != hwFixed)
|
|
drive = Drive_C;
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
//Get disk statistics
|
|
//
|
|
if (!GetDiskFreeSpace (szRoot,
|
|
&cSectorsPerCluster,
|
|
&cBytesPerSector,
|
|
&cFreeClusters,
|
|
&cTotalClusters))
|
|
{
|
|
//Error - couldn't get drive stats
|
|
goto lblERROR;
|
|
}
|
|
|
|
//
|
|
//Calculate secondary statistics
|
|
//
|
|
cBytesPerCluster = cBytesPerSector * cSectorsPerCluster;
|
|
if (cTotalClusters >= cFreeClusters)
|
|
cUsedClusters = cTotalClusters - cFreeClusters;
|
|
else
|
|
cUsedClusters = 0L;
|
|
|
|
cbFree.QuadPart = UInt32x32To64(cFreeClusters, cBytesPerCluster);
|
|
cbUsed.QuadPart = UInt32x32To64(cUsedClusters, cBytesPerCluster);
|
|
cbTotal.QuadPart = cbFree.QuadPart + cbUsed.QuadPart;
|
|
|
|
//
|
|
//Get the current low disk space ratio
|
|
//
|
|
cbLowSpaceThreshold = GetFreeSpaceRatio(dre, cbTotal);
|
|
|
|
//
|
|
//Should we also load the agressive cleaners? We only do this if we
|
|
//are below are critical threshold of disk space left.
|
|
//
|
|
if (cbLowSpaceThreshold.QuadPart >= cbFree.QuadPart)
|
|
{
|
|
MiDebugMsg((0, "*****We are in aggressive mode*****"));
|
|
bOutOfDiskSpace = TRUE;
|
|
}
|
|
else
|
|
bOutOfDiskSpace = FALSE;
|
|
|
|
//
|
|
// Step 3. Save stats
|
|
//
|
|
|
|
cbDriveFree = cbFree;
|
|
cbDriveUsed = cbUsed;
|
|
cbEstCleanupSpace.QuadPart = 0;
|
|
|
|
//
|
|
//Success
|
|
//
|
|
return TRUE;
|
|
|
|
lblERROR:
|
|
//
|
|
//Error
|
|
//
|
|
destroy();
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::initializeClients
|
|
**
|
|
** Purpose: Initializes all of the Volume Cache Clients
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
BOOL
|
|
CleanupMgrInfo::initializeClients(void)
|
|
{
|
|
HKEY hKeyVolCache = NULL;
|
|
DWORD iSubKey;
|
|
DWORD dwClient;
|
|
TCHAR szVolCacheClient[MAX_PATH];
|
|
TCHAR szGUID[MAX_PATH];
|
|
DWORD dwGUIDSize;
|
|
DWORD dwType;
|
|
DWORD dwState, cb, cw;
|
|
TCHAR szProfile[64];
|
|
BOOL bRet = TRUE;
|
|
BOOL bCleanup;
|
|
|
|
iNumVolumeCacheClients = 0;
|
|
pClientInfo = NULL;
|
|
|
|
MiDebugMsg((0, "CleanupMgrInfo::initializeClients entered"));
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_VOLUMECACHE, 0, KEY_READ, &hKeyVolCache) == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
//Enumerate through all of the clients to see how large we need to make the pClientInfo array
|
|
//
|
|
|
|
iSubKey = 0;
|
|
while(RegEnumKey(hKeyVolCache, iSubKey, szVolCacheClient, ARRAYSIZE(szVolCacheClient)) != ERROR_NO_MORE_ITEMS)
|
|
{
|
|
iSubKey++;
|
|
}
|
|
|
|
if ((pClientInfo = (PCLIENTINFO)LocalAlloc(LPTR, (iSubKey * sizeof(CLIENTINFO)))) == NULL)
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, TEXT("FATAL ERROR LocalAlloc() failed!"), TEXT("CLEANMGR DEBUG"), MB_OK);
|
|
#endif
|
|
RegCloseKey(hKeyVolCache);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Fill in the pClientInfo data structure and initialize all of the volume cache clients
|
|
//
|
|
iSubKey = 0;
|
|
dwClient = 0;
|
|
while(RegEnumKey(hKeyVolCache, iSubKey, szVolCacheClient, ARRAYSIZE(szVolCacheClient)) != ERROR_NO_MORE_ITEMS)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// default is we failed, so cleanup the current item....
|
|
bCleanup = TRUE;
|
|
|
|
if (RegOpenKeyEx(hKeyVolCache, szVolCacheClient, 0, MAXIMUM_ALLOWED, &(pClientInfo[dwClient].hClientKey)) == ERROR_SUCCESS)
|
|
{
|
|
hr = StringCchCopy( pClientInfo[dwClient].szRegKeyName,
|
|
ARRAYSIZE(pClientInfo[dwClient].szRegKeyName),
|
|
szVolCacheClient);
|
|
|
|
dwGUIDSize = sizeof(szGUID);
|
|
dwType = REG_SZ;
|
|
if (SUCCEEDED(hr) && RegQueryValueEx(pClientInfo[dwClient].hClientKey, NULL, NULL, &dwType, (LPBYTE)szGUID, &dwGUIDSize) == ERROR_SUCCESS)
|
|
{
|
|
WCHAR wcsFmtID[39];
|
|
|
|
#ifdef UNICODE
|
|
StringCchCopy(wcsFmtID, ARRAYSIZE(wcsFmtID), szGUID);
|
|
#else
|
|
//Convert to Unicode.
|
|
MultiByteToWideChar(CP_ACP, 0, szGUID, -1, wcsFmtID, ARRAYSIZE( wcsFmtID )) ;
|
|
#endif
|
|
|
|
//Convert to GUID.
|
|
hr = CLSIDFromString((LPOLESTR)wcsFmtID, &(pClientInfo[dwClient].clsid));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
MiDebugMsg((hr, "CLSIDFromString(%s,) returned error ", szGUID));
|
|
}
|
|
|
|
//
|
|
//Create an instance of the COM object for this cleanup client
|
|
//
|
|
pClientInfo[dwClient].pVolumeCache = NULL;
|
|
hr = CoCreateInstance(pClientInfo[dwClient].clsid,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IEmptyVolumeCache,
|
|
(void **) &(pClientInfo[dwClient].pVolumeCache));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR wcsRoot[MAX_PATH];
|
|
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients Created IID_IEmptyVolumeCache"));
|
|
//
|
|
//Set the flags to pass to the cleanup client
|
|
//
|
|
pClientInfo[dwClient].dwInitializeFlags = 0;
|
|
if (dwUIFlags & FLAG_SAGESET)
|
|
pClientInfo[dwClient].dwInitializeFlags |= EVCF_SETTINGSMODE;
|
|
if (bOutOfDiskSpace)
|
|
pClientInfo[dwClient].dwInitializeFlags |= EVCF_OUTOFDISKSPACE;
|
|
|
|
#ifdef UNICODE
|
|
StringCchCopy(wcsRoot, ARRAYSIZE(wcsRoot), szRoot);
|
|
#else
|
|
//
|
|
//Convert szRoot to UNICODE
|
|
//
|
|
MultiByteToWideChar(CP_ACP, 0, szRoot, -1, wcsRoot, ARRAYSIZE( wcsRoot ));
|
|
#endif
|
|
|
|
// Try to use version two of the interface if it is supported
|
|
IEmptyVolumeCache2 * pEVC2;
|
|
hr = pClientInfo[dwClient].pVolumeCache->QueryInterface( IID_IEmptyVolumeCache2, (void**)&pEVC2 );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// version 2 exists so that we can have a mutli-local enabled data driven cleaner. It
|
|
// allows the added Advanced Button to be set to a localized value. It tells the
|
|
// object being called which key it is being called for so that one object can support
|
|
// multiple filters.
|
|
WCHAR wcsFilterName[MAX_PATH];
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients found V2 interface"));
|
|
#ifdef UNICODE
|
|
StringCchCopy(wcsFilterName, ARRAYSIZE(wcsFilterName), szVolCacheClient);
|
|
#else
|
|
MultiByteToWideChar(CP_ACP, 0, szVolCacheClient, -1, wcsFilterName, ARRAYSIZE( wcsFilterName )) ;
|
|
#endif
|
|
|
|
hr = pEVC2->InitializeEx(pClientInfo[dwClient].hClientKey,
|
|
(LPCWSTR)wcsRoot,
|
|
(LPCWSTR)wcsFilterName,
|
|
&((LPWSTR)pClientInfo[dwClient].wcsDisplayName),
|
|
&((LPWSTR)pClientInfo[dwClient].wcsDescription),
|
|
&((LPWSTR)pClientInfo[dwClient].wcsAdvancedButtonText),
|
|
&(pClientInfo[dwClient].dwInitializeFlags));
|
|
pEVC2->Release();
|
|
}
|
|
else
|
|
{
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients using V1 interface"));
|
|
//
|
|
//Initialize the cleanup client
|
|
//
|
|
if ((pClientInfo[dwClient].wcsDescription = (LPWSTR)CoTaskMemAlloc(DESCRIPTION_LENGTH*sizeof(WCHAR))) == NULL)
|
|
return FALSE;
|
|
|
|
// We seem to have shipped this thing with a giant leak. The object is supposted to set
|
|
// pClientInfo[dwClient].wcsDescription to NULL if the registry value should be used instead
|
|
// of the buffer. However we just allocated a buffer for pClientInfo[dwClient].wcsDescription
|
|
// in the code above (this is the dumbass part). All the filters then set this pointer to
|
|
// NULL and it's bye-bye buffer. I can't simply not allocate this memory because some cleaners
|
|
// might rely on being able to use this memory and we shipped it that way.
|
|
LPWSTR wszLeakProtection = pClientInfo[dwClient].wcsDescription;
|
|
hr = pClientInfo[dwClient].pVolumeCache->Initialize(pClientInfo[dwClient].hClientKey,
|
|
(LPCWSTR)wcsRoot,
|
|
&((LPWSTR)pClientInfo[dwClient].wcsDisplayName),
|
|
&((LPWSTR)pClientInfo[dwClient].wcsDescription),
|
|
&(pClientInfo[dwClient].dwInitializeFlags));
|
|
if ( wszLeakProtection != pClientInfo[dwClient].wcsDescription )
|
|
{
|
|
// REVIEW: Use try...except around CoTaskMemFree in case some smart cleaner
|
|
// realized our mistake and deleted the memory for us?
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients prevent mem leak hack"));
|
|
CoTaskMemFree( wszLeakProtection );
|
|
}
|
|
|
|
if ( S_OK == hr )
|
|
{
|
|
// To make it easier to make a cleaner we have a default implementation of IEmptyVolumeCache
|
|
// that works entirerly using registry data. The problem is that display strings are strored
|
|
// in the registry. This is invalid for NT because NT must be multi-local localizable and
|
|
// the only way to do that is to load all display strings from a resource. As a hack, you
|
|
// can now implement IPropertyBag using an object with it's guid stored under the propertybag
|
|
// value in the registry. We will cocreate this object and query for IPropertyBag. If this
|
|
// works then we will attempt to read the localized strings from the property bag before we
|
|
// fall back on checking the registry.
|
|
TCHAR szPropBagGUID[MAX_PATH];
|
|
HRESULT hrFoo;
|
|
IPropertyBag * ppb = NULL;
|
|
VARIANT var;
|
|
|
|
VariantInit( &var );
|
|
dwGUIDSize = sizeof(szPropBagGUID);
|
|
dwType = REG_SZ;
|
|
if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, TEXT("PropertyBag"), NULL, &dwType, (LPBYTE)szPropBagGUID, &dwGUIDSize) == ERROR_SUCCESS)
|
|
{
|
|
WCHAR wcsFmtID[39];
|
|
CLSID clsid;
|
|
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients found PropBag key"));
|
|
|
|
#ifdef UNICODE
|
|
StringCchCopy(wcsFmtID, ARRAYSIZE(wcsFmtID), szPropBagGUID);
|
|
#else
|
|
MultiByteToWideChar(CP_ACP, 0, szPropBagGUID, -1, wcsFmtID, ARRAYSIZE( wcsFmtID )) ;
|
|
#endif
|
|
|
|
//Convert to GUID.
|
|
CLSIDFromString((LPOLESTR)wcsFmtID, &clsid);
|
|
|
|
//
|
|
//Create an instance of the COM object for this cleanup client
|
|
//
|
|
hrFoo = CoCreateInstance(clsid,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IPropertyBag,
|
|
(void **) &ppb);
|
|
|
|
if ( FAILED(hrFoo) )
|
|
{
|
|
MiDebugMsg((hrFoo, "CleanupMgrInfo::initializeClients failed to create PropBag"));
|
|
}
|
|
}
|
|
|
|
//
|
|
//If the client did not return the DisplayName via the Initialize
|
|
//Interface then we need to get it from the registry.
|
|
//
|
|
if ((pClientInfo[dwClient].wcsDisplayName) == NULL)
|
|
{
|
|
LPTSTR lpszDisplayName;
|
|
|
|
if ( ppb )
|
|
{
|
|
WCHAR wszSrc[MAX_PATH];
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients checking PropBag for display"));
|
|
|
|
SHTCharToUnicode(REGSTR_VAL_DISPLAY, wszSrc, MAX_PATH);
|
|
|
|
// do propertybag stuff
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = NULL;
|
|
hrFoo = ppb->Read( wszSrc, &var, NULL );
|
|
if (SUCCEEDED(hrFoo))
|
|
{
|
|
if ( var.vt == VT_BSTR )
|
|
{
|
|
DWORD dwSize = (SysStringLen(var.bstrVal)+1)*sizeof(WCHAR);
|
|
pClientInfo[dwClient].wcsDisplayName = (LPWSTR)CoTaskMemAlloc(dwSize);
|
|
StringCbCopy( pClientInfo[dwClient].wcsDisplayName,
|
|
dwSize,
|
|
var.bstrVal );
|
|
}
|
|
VariantClear( &var );
|
|
}
|
|
}
|
|
|
|
if ((pClientInfo[dwClient].wcsDisplayName) == NULL)
|
|
{
|
|
//
|
|
//First check if their is a "display" value for the client's
|
|
//name that is displayed in the list box. If not then use
|
|
//the key name itself.
|
|
//
|
|
cb = 0;
|
|
dwType = REG_SZ;
|
|
RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_DISPLAY, NULL, &dwType, (LPBYTE)NULL, &cb);
|
|
cb = max(cb, (ULONG)(lstrlen(szVolCacheClient) + 1) * sizeof (TCHAR));
|
|
if ((lpszDisplayName = (LPTSTR)LocalAlloc(LPTR, cb)) != NULL)
|
|
{
|
|
if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_DISPLAY, NULL, &dwType, (LPBYTE)lpszDisplayName, &cb) != ERROR_SUCCESS)
|
|
{
|
|
//
|
|
//Count not find "display" value so use the key name instead
|
|
//
|
|
StringCbCopy(lpszDisplayName, cb, szVolCacheClient);
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
cw = (lstrlen( lpszDisplayName ) + 1) * sizeof( WCHAR);
|
|
#else
|
|
//
|
|
//Convert this value to UNICODE
|
|
//
|
|
cw = MultiByteToWideChar(CP_ACP, 0, lpszDisplayName, -1, NULL, 0);
|
|
#endif
|
|
if ((pClientInfo[dwClient].wcsDisplayName = (LPWSTR)CoTaskMemAlloc(cw*sizeof(WCHAR))) != NULL)
|
|
{
|
|
#ifdef UNICODE
|
|
StringCchCopy(pClientInfo[dwClient].wcsDisplayName,
|
|
cw,
|
|
lpszDisplayName);
|
|
#else
|
|
MultiByteToWideChar(CP_ACP, 0, lpszDisplayName, -1, (pClientInfo[dwClient].wcsDisplayName), cw);
|
|
#endif
|
|
}
|
|
LocalFree(lpszDisplayName);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//If the client did not return the Description via the Initialize
|
|
//Interface then we need to get it from the registry.
|
|
//
|
|
if ((pClientInfo[dwClient].wcsDescription) == NULL)
|
|
{
|
|
LPTSTR lpszDescription;
|
|
|
|
|
|
if ( ppb )
|
|
{
|
|
WCHAR wszSrc[MAX_PATH];
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients checking PropBag for description"));
|
|
|
|
SHTCharToUnicode(REGSTR_VAL_DESCRIPTION, wszSrc, MAX_PATH);
|
|
|
|
// do propertybag stuff
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = NULL;
|
|
hrFoo = ppb->Read( wszSrc, &var, NULL );
|
|
if (SUCCEEDED(hrFoo))
|
|
{
|
|
if ( var.vt == VT_BSTR )
|
|
{
|
|
DWORD dwSize = (SysStringLen(var.bstrVal)+1)*sizeof(WCHAR);
|
|
pClientInfo[dwClient].wcsDescription = (LPWSTR)CoTaskMemAlloc(dwSize);
|
|
StringCbCopy(pClientInfo[dwClient].wcsDescription,
|
|
dwSize,
|
|
var.bstrVal);
|
|
}
|
|
VariantClear( &var );
|
|
}
|
|
}
|
|
|
|
if ((pClientInfo[dwClient].wcsDescription) == NULL)
|
|
{
|
|
//
|
|
//Check if their is a "description" value for the client
|
|
//
|
|
cb = 0;
|
|
dwType = REG_SZ;
|
|
RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_DESCRIPTION, NULL, &dwType, (LPBYTE)NULL, &cb);
|
|
if ((lpszDescription = (LPTSTR)LocalAlloc(LPTR, (cb + 1 ) * sizeof( TCHAR ))) != NULL)
|
|
{
|
|
if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_DESCRIPTION, NULL, &dwType, (LPBYTE)lpszDescription, &cb) == ERROR_SUCCESS)
|
|
{
|
|
#ifdef UNICODE
|
|
cw = ( lstrlen( lpszDescription ) + 1 ) * sizeof( WCHAR );
|
|
#else
|
|
//
|
|
//Convert this value to UNICODE
|
|
//
|
|
cw = MultiByteToWideChar(CP_ACP, 0, lpszDescription, -1, NULL, 0);
|
|
#endif
|
|
if ((pClientInfo[dwClient].wcsDescription = (LPWSTR)CoTaskMemAlloc(cw*sizeof(WCHAR))) != NULL)
|
|
{
|
|
#ifdef UNICODE
|
|
StringCchCopy(pClientInfo[dwClient].wcsDescription,
|
|
cw,
|
|
lpszDescription);
|
|
#else
|
|
MultiByteToWideChar(CP_ACP, 0, lpszDescription, -1, (pClientInfo[dwClient].wcsDescription), cw);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
LocalFree(lpszDescription);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//Set the Advanced Button text
|
|
//
|
|
pClientInfo[dwClient].wcsAdvancedButtonText = NULL;
|
|
|
|
if (pClientInfo[dwClient].dwInitializeFlags & EVCF_HASSETTINGS)
|
|
{
|
|
if ( ppb )
|
|
{
|
|
WCHAR wszSrc[MAX_PATH];
|
|
MiDebugMsg((hr, "CleanupMgrInfo::initializeClients checking PropBag for button text"));
|
|
|
|
SHTCharToUnicode(REGSTR_VAL_ADVANCEDBUTTONTEXT, wszSrc, MAX_PATH);
|
|
|
|
// do propertybag stuff
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = NULL;
|
|
hrFoo = ppb->Read( wszSrc, &var, NULL );
|
|
if (SUCCEEDED(hrFoo))
|
|
{
|
|
if ( var.vt == VT_BSTR )
|
|
{
|
|
DWORD dwSize = (SysStringLen(var.bstrVal)+1)*sizeof(WCHAR);
|
|
pClientInfo[dwClient].wcsAdvancedButtonText = (LPWSTR)CoTaskMemAlloc(dwSize);
|
|
StringCbCopy(pClientInfo[dwClient].wcsAdvancedButtonText,
|
|
dwSize,
|
|
var.bstrVal);
|
|
}
|
|
VariantClear( &var );
|
|
}
|
|
}
|
|
if ( pClientInfo[dwClient].wcsAdvancedButtonText == NULL )
|
|
{
|
|
LPTSTR lpszAdvancedButtonText;
|
|
TCHAR szDetails[BUTTONTEXT_LENGTH];
|
|
|
|
LoadString(g_hInstance, IDS_DETAILS, szDetails, ARRAYSIZE(szDetails));
|
|
|
|
cb = 0;
|
|
dwType = REG_SZ;
|
|
RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_ADVANCEDBUTTONTEXT, NULL, &dwType, (LPBYTE)NULL, &cb);
|
|
cb = max(cb, (UINT)(lstrlen(szDetails)+1) * sizeof(TCHAR));
|
|
if ((lpszAdvancedButtonText = (LPTSTR)LocalAlloc(LPTR, cb)) != NULL)
|
|
{
|
|
if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_ADVANCEDBUTTONTEXT, NULL, &dwType, (LPBYTE)lpszAdvancedButtonText, &cb) != ERROR_SUCCESS)
|
|
{
|
|
StringCbCopy(lpszAdvancedButtonText,
|
|
cb,
|
|
szDetails);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
cw = (lstrlen( lpszAdvancedButtonText ) + 1) * sizeof( WCHAR );
|
|
#else
|
|
//
|
|
//Convert this value to UNICODE
|
|
//
|
|
cw = MultiByteToWideChar(CP_ACP, 0, lpszAdvancedButtonText, -1, NULL, 0);
|
|
#endif
|
|
if ((pClientInfo[dwClient].wcsAdvancedButtonText = (LPWSTR)CoTaskMemAlloc(cw*sizeof(WCHAR))) != NULL)
|
|
{
|
|
#ifdef UNICODE
|
|
StringCchCopy(pClientInfo[dwClient].wcsAdvancedButtonText,
|
|
cw,
|
|
lpszAdvancedButtonText);
|
|
|
|
#else
|
|
MultiByteToWideChar(CP_ACP, 0, lpszAdvancedButtonText, -1, (pClientInfo[dwClient].wcsAdvancedButtonText), cw);
|
|
#endif
|
|
}
|
|
|
|
LocalFree(lpszAdvancedButtonText);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ppb)
|
|
{
|
|
ppb->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now we're back to stuff that both version 1 and version 2 require
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (S_OK == hr)
|
|
{
|
|
//
|
|
//Default to showing this client in the UI
|
|
//
|
|
pClientInfo[dwClient].bShow = TRUE;
|
|
|
|
//
|
|
//Get the "priority" from the registry
|
|
//
|
|
cb = sizeof(pClientInfo[dwClient].dwPriority);
|
|
dwType = REG_DWORD;
|
|
if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, REGSTR_VAL_PRIORITY, NULL, &dwType, (LPBYTE)&(pClientInfo[dwClient].dwPriority), &cb) != ERROR_SUCCESS)
|
|
pClientInfo[dwClient].dwPriority = DEFAULT_PRIORITY;
|
|
|
|
//
|
|
//Flags
|
|
//
|
|
if (dwUIFlags & FLAG_SAGERUN || dwUIFlags & FLAG_SAGESET)
|
|
{
|
|
StringCchPrintf(szProfile, ARRAYSIZE(szProfile),
|
|
TEXT("%s%04d"), SZ_STATE, ulSAGEProfile);
|
|
}
|
|
else
|
|
{
|
|
StringCchCopy(szProfile, ARRAYSIZE(szProfile), SZ_STATE);
|
|
}
|
|
|
|
dwState = 0;
|
|
cb = sizeof(dwState);
|
|
dwType = REG_DWORD;
|
|
|
|
// If we were called with the low disk flag, select every cleaner by default
|
|
if (dwUIFlags & FLAG_LOWDISK)
|
|
{
|
|
pClientInfo[iSubKey].bSelected = TRUE;
|
|
}
|
|
|
|
// Otherwise, check the registry
|
|
else if (RegQueryValueEx(pClientInfo[dwClient].hClientKey, szProfile, NULL,
|
|
&dwType, (LPBYTE)&dwState, &cb) == ERROR_SUCCESS)
|
|
{
|
|
if (dwUIFlags & FLAG_SAGERUN || dwUIFlags & FLAG_SAGESET)
|
|
{
|
|
pClientInfo[dwClient].bSelected = (dwState & STATE_SAGE_SELECTED);
|
|
}
|
|
else
|
|
{
|
|
pClientInfo[dwClient].bSelected = (dwState & STATE_SELECTED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
//No registry settings for this profile so use the cleanup clients
|
|
//default settings.
|
|
//
|
|
if (dwUIFlags & FLAG_SAGERUN || dwUIFlags & FLAG_SAGESET)
|
|
{
|
|
pClientInfo[dwClient].bSelected = (pClientInfo[dwClient].dwInitializeFlags & EVCF_ENABLEBYDEFAULT_AUTO) ? TRUE : FALSE;
|
|
}
|
|
else
|
|
{
|
|
pClientInfo[dwClient].bSelected = (pClientInfo[dwClient].dwInitializeFlags & EVCF_ENABLEBYDEFAULT) ? TRUE : FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
//Get the icon of the cleanup client
|
|
//
|
|
|
|
// first test to see if it is overridden...
|
|
TCHAR szIconPath[MAX_PATH];
|
|
cb = sizeof( szIconPath );
|
|
BOOL fOverridden = FALSE;
|
|
|
|
if ( RegQueryValueEx(pClientInfo[dwClient].hClientKey, TEXT("IconPath"), NULL,
|
|
&dwType, (LPBYTE)szIconPath, &cb) == ERROR_SUCCESS )
|
|
{
|
|
fOverridden = TRUE;
|
|
}
|
|
else
|
|
{
|
|
StringCchCopy(szIconPath, ARRAYSIZE(szIconPath), szGUID);
|
|
}
|
|
|
|
pClientInfo[dwClient].hIcon = GetClientIcon(szIconPath, fOverridden);
|
|
|
|
bCleanup = FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
//This should be S_FALSE. This means that the client has nothing to
|
|
//cleanup now so we don't even need to show it in the list.
|
|
//Therefor we will just call its Release() function and close it's
|
|
//registry key.
|
|
//
|
|
|
|
// drop through and let it cleanup below...
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MiDebugMsg((hr, "Client %d Initialize() retuned error ", dwClient));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MiDebugMsg((hr, "Client %d %s returned error ", dwClient, szGUID));
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
else
|
|
{
|
|
MessageBox(NULL, szVolCacheClient, TEXT("ERROR Opening GUID key"), MB_OK);
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef DEBUG
|
|
else
|
|
{
|
|
MessageBox(NULL, szVolCacheClient, TEXT("ERROR Opening the client key"), MB_OK);
|
|
}
|
|
#endif
|
|
|
|
if ( bCleanup )
|
|
{
|
|
deactivateSingleClient(&(pClientInfo[dwClient]));
|
|
ZeroMemory( &(pClientInfo[dwClient]), sizeof( CLIENTINFO ));
|
|
}
|
|
else
|
|
{
|
|
dwClient ++;
|
|
}
|
|
iSubKey++;
|
|
}
|
|
iNumVolumeCacheClients = dwClient;
|
|
}
|
|
#ifdef DEBUG
|
|
else
|
|
{
|
|
MessageBox(NULL, TEXT("ERROR Opening up Volume Cache key"), TEXT("CLEANMGR DEBUG"), MB_OK);
|
|
}
|
|
#endif
|
|
|
|
if( hKeyVolCache )
|
|
{
|
|
RegCloseKey(hKeyVolCache);
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::deactivateClients
|
|
**
|
|
** Purpose: Initializes all of the Volume Cache Clients
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
void
|
|
CleanupMgrInfo::deactivateClients(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<iNumVolumeCacheClients; i++)
|
|
{
|
|
deactivateSingleClient(&(pClientInfo[i]));
|
|
}
|
|
|
|
//
|
|
//Free the pClientInfo array
|
|
//
|
|
if (pClientInfo)
|
|
{
|
|
MiDebugMsg((0, "LocalFree() on ClientInfo structure"));
|
|
LocalFree( pClientInfo);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::deactivateSingleClient
|
|
**
|
|
** Purpose: Deactivate's the given client and closes its registry key
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
void
|
|
CleanupMgrInfo::deactivateSingleClient(PCLIENTINFO pSingleClientInfo)
|
|
{
|
|
DWORD dwDeactivateFlags = 0;
|
|
TCHAR szProfile[64];
|
|
|
|
if (pSingleClientInfo->pVolumeCache != NULL)
|
|
{
|
|
//
|
|
//Call the clients Deactivate function
|
|
//
|
|
pSingleClientInfo->pVolumeCache->Deactivate(&dwDeactivateFlags);
|
|
|
|
//
|
|
//Release the client
|
|
//
|
|
pSingleClientInfo->pVolumeCache->Release();
|
|
pSingleClientInfo->pVolumeCache = NULL;
|
|
}
|
|
|
|
if (pSingleClientInfo->hClientKey != 0)
|
|
{
|
|
DWORD dwState, cb, dwType, dwSelectedFlag;
|
|
|
|
if (dwUIFlags & FLAG_SAVE_STATE)
|
|
{
|
|
//
|
|
//Save the state flags
|
|
//
|
|
if (dwUIFlags & FLAG_SAGESET)
|
|
{
|
|
dwSelectedFlag = STATE_SAGE_SELECTED;
|
|
StringCchPrintf(szProfile, ARRAYSIZE(szProfile), TEXT("%s%04d"), SZ_STATE, ulSAGEProfile);
|
|
}
|
|
else
|
|
{
|
|
dwSelectedFlag = STATE_SELECTED;
|
|
StringCchCopy(szProfile, ARRAYSIZE(szProfile), SZ_STATE);
|
|
}
|
|
|
|
dwState = 0;
|
|
cb = sizeof(dwState);
|
|
dwType = REG_DWORD;
|
|
if (RegQueryValueEx(pSingleClientInfo->hClientKey, szProfile, NULL, &dwType, (LPBYTE)&dwState, &cb) == ERROR_SUCCESS)
|
|
{
|
|
if (pSingleClientInfo->bSelected)
|
|
{
|
|
dwState |= dwSelectedFlag;
|
|
}
|
|
else
|
|
{
|
|
dwState &= ~dwSelectedFlag;
|
|
}
|
|
|
|
RegSetValueEx(pSingleClientInfo->hClientKey, szProfile, 0, REG_DWORD, (LPBYTE)&dwState, sizeof(dwState));
|
|
}
|
|
}
|
|
|
|
//
|
|
//Close all of the registry keys
|
|
//
|
|
RegCloseKey(pSingleClientInfo->hClientKey);
|
|
|
|
//
|
|
//Should we remove this entry from the registry?
|
|
//
|
|
if (dwDeactivateFlags & EVCF_REMOVEFROMLIST && pSingleClientInfo->bSelected)
|
|
{
|
|
HKEY hKeyVolCache;
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_VOLUMECACHE, 0, KEY_WRITE, &hKeyVolCache) == ERROR_SUCCESS)
|
|
{
|
|
SHDeleteKey(hKeyVolCache, pSingleClientInfo->szRegKeyName);
|
|
RegCloseKey(hKeyVolCache);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
//Free the DisplayName and Description memory
|
|
//
|
|
if (pSingleClientInfo->wcsDisplayName)
|
|
CoTaskMemFree(pSingleClientInfo->wcsDisplayName);
|
|
|
|
if (pSingleClientInfo->wcsDescription)
|
|
CoTaskMemFree(pSingleClientInfo->wcsDescription);
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::getSpaceUsedByClients
|
|
**
|
|
** Purpose: Calls the IEmptyVolumeCache->GetSpaceUsed interface for each client
|
|
** to determine the total amount of cache space. This function is
|
|
** called on a secondary thread because it can take quite a long time.
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
BOOL
|
|
CleanupMgrInfo::getSpaceUsedByClients(void)
|
|
{
|
|
int i;
|
|
HRESULT hr;
|
|
BOOL bRet = TRUE;
|
|
TCHAR szDisplayName[256];
|
|
|
|
cbEstCleanupSpace.QuadPart = 0;
|
|
bAbortScan = FALSE;
|
|
|
|
hAbortScanEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
|
|
// Someone should make sure the window created in the ScanAbortThread thread is visible before
|
|
// the hAbortScanEvent event is signaled
|
|
hAbortScanThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ScanAbortThread,
|
|
(LPVOID)this, 0, &dwAbortScanThreadID);
|
|
|
|
//
|
|
//Wait until the Abort Scan window is created
|
|
//
|
|
WaitForSingleObject(hAbortScanEvent, INFINITE);
|
|
|
|
CloseHandle(hAbortScanEvent);
|
|
|
|
if (volumeCacheCallBack != NULL)
|
|
{
|
|
volumeCacheCallBack->SetCleanupMgrInfo((PVOID)this);
|
|
}
|
|
|
|
for (i=0; i<iNumVolumeCacheClients; i++)
|
|
{
|
|
//
|
|
//Update the progress UI
|
|
//
|
|
szDisplayName[0] = '\0';
|
|
|
|
#ifdef UNICODE
|
|
StringCchCopy(szDisplayName, ARRAYSIZE(szDisplayName), pClientInfo[i].wcsDisplayName);
|
|
#else
|
|
WideCharToMultiByte(CP_ACP, 0, pClientInfo[i].wcsDisplayName, -1, szDisplayName, sizeof(szDisplayName), NULL, NULL);
|
|
#endif
|
|
|
|
PostMessage(hAbortScanWnd, WMAPP_UPDATEPROGRESS, (WPARAM)i, (LPARAM)szDisplayName);
|
|
|
|
//
|
|
//Query the client for the ammount of cache disk space that it could
|
|
//possible free.
|
|
//
|
|
if (pClientInfo[i].pVolumeCache != NULL && volumeCacheCallBack != NULL)
|
|
{
|
|
volumeCacheCallBack->SetCurrentClient((PVOID)&(pClientInfo[i]));
|
|
hr = pClientInfo[i].pVolumeCache->GetSpaceUsed(&(pClientInfo[i].dwUsedSpace.QuadPart),
|
|
pIEmptyVolumeCacheCallBack);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
dwReturnCode = RETURN_CLEANER_FAILED;
|
|
MiDebugMsg((hr, "Client %d GetSpaceUsed failed with error ", i));
|
|
}
|
|
|
|
MiDebugMsg((0, "Client %d has %d disk space it can free", i,
|
|
pClientInfo[i].dwUsedSpace.QuadPart));
|
|
}
|
|
|
|
//
|
|
//See if this cleaner wants to be hidden if it has no space to free
|
|
//
|
|
if ((pClientInfo[i].dwUsedSpace.QuadPart == 0) &&
|
|
(pClientInfo[i].dwInitializeFlags & EVCF_DONTSHOWIFZERO))
|
|
{
|
|
MiDebugMsg((0, "Not showing client %d because it has no space to free", i));
|
|
pClientInfo[i].bShow = FALSE;
|
|
}
|
|
|
|
cbEstCleanupSpace.QuadPart += pClientInfo[i].dwUsedSpace.QuadPart;
|
|
|
|
//
|
|
//Did the user abort?
|
|
//
|
|
if (bAbortScan == TRUE)
|
|
{
|
|
dwReturnCode = RETURN_USER_CANCELED_SCAN;
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// the dismissal of the progress dialog is now delayed until the propsheet comes up..
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::calculateSpaceToPurge
|
|
**
|
|
** Purpose: Calculates the amount of space that is going to be purged
|
|
** by adding up all of the selected clients. It also calculates
|
|
** the progress bar divisor number. This is needed because a
|
|
** progress bar has a MAX of 0xFFFF.
|
|
**
|
|
** Mod Log: Created by Jason Cobb (6/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
void
|
|
CleanupMgrInfo::calculateSpaceToPurge(void)
|
|
{
|
|
int i;
|
|
|
|
cbSpaceToPurge.QuadPart = 0;
|
|
|
|
for (i=0; i<iNumVolumeCacheClients; i++)
|
|
{
|
|
//
|
|
//If this client is not selected or we are not showing it then don't purge it
|
|
//
|
|
if (pClientInfo[i].bShow == FALSE || pClientInfo[i].bSelected == FALSE)
|
|
continue;
|
|
|
|
cbSpaceToPurge.QuadPart += pClientInfo[i].dwUsedSpace.QuadPart;
|
|
}
|
|
|
|
cbProgressDivider.QuadPart = (cbSpaceToPurge.QuadPart / PROGRESS_DIVISOR) + 1;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** CleanupMgrInfo::purgeClients
|
|
**
|
|
** Purpose: Calls the IEmptyVolumeCache->Purge interface for each client
|
|
** to have the client cleaner object start removeing their files
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
BOOL
|
|
CleanupMgrInfo::purgeClients(void)
|
|
{
|
|
int i;
|
|
HRESULT hr;
|
|
BOOL bRet = TRUE;
|
|
TCHAR szDisplayName[256];
|
|
|
|
cbTotalPurgedSoFar.QuadPart = 0;
|
|
bAbortPurge = FALSE;
|
|
|
|
//
|
|
//Calculate the amount of space that will be purged.
|
|
//
|
|
calculateSpaceToPurge();
|
|
MiDebugMsg((0, "Total number of bytes to delete is %d", cbSpaceToPurge.LowPart));
|
|
|
|
hAbortPurgeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
|
|
// Someone should (but it hasn't broken in 3 years), make sure the window created in PurgeAbortThread is visible before
|
|
// the hAbortPurgeEvent is signaled
|
|
hAbortPurgeThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PurgeAbortThread,
|
|
(LPVOID)this, 0, &dwAbortPurgeThreadID);
|
|
|
|
//
|
|
//Wait until the Abort Purge window is created
|
|
//
|
|
WaitForSingleObject(hAbortPurgeEvent, INFINITE);
|
|
|
|
CloseHandle(hAbortPurgeEvent);
|
|
|
|
if (volumeCacheCallBack != NULL)
|
|
{
|
|
volumeCacheCallBack->SetCleanupMgrInfo((PVOID)this);
|
|
}
|
|
|
|
for (i=0; i<iNumVolumeCacheClients; i++)
|
|
{
|
|
//
|
|
//If this client is not selected or we are not showing it then don't purge it
|
|
//
|
|
if (pClientInfo[i].bShow == FALSE || pClientInfo[i].bSelected == FALSE)
|
|
continue;
|
|
|
|
#ifdef UNICODE
|
|
StringCchCopy(szDisplayName, ARRAYSIZE(szDisplayName), pClientInfo[i].wcsDisplayName);
|
|
#else
|
|
//
|
|
//Convert UNICODE display name to ANSI and then add it to the list
|
|
//
|
|
WideCharToMultiByte(CP_ACP, 0, pClientInfo[i].wcsDisplayName, -1, szDisplayName, sizeof(szDisplayName), NULL, NULL);
|
|
#endif
|
|
|
|
PostMessage(hAbortPurgeWnd, WMAPP_UPDATESTATUS, 0, (LPARAM)szDisplayName);
|
|
|
|
cbCurrentClientPurgedSoFar.QuadPart = 0;
|
|
|
|
//
|
|
//Query the client for the ammount of cache disk space that it could
|
|
//possible free.
|
|
//
|
|
if (pClientInfo[i].pVolumeCache != NULL && volumeCacheCallBack != NULL)
|
|
{
|
|
volumeCacheCallBack->SetCurrentClient((PVOID)&(pClientInfo[i]));
|
|
|
|
hr = pClientInfo[i].pVolumeCache->Purge(pClientInfo[i].dwUsedSpace.QuadPart, pIEmptyVolumeCacheCallBack);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
dwReturnCode = RETURN_CLEANER_FAILED;
|
|
MiDebugMsg((hr, "Client %d Purge failed with error ", i));
|
|
}
|
|
}
|
|
|
|
cbTotalPurgedSoFar.QuadPart += pClientInfo[i].dwUsedSpace.QuadPart;
|
|
cbCurrentClientPurgedSoFar.QuadPart = 0;
|
|
|
|
//
|
|
//Update the progress bar
|
|
//
|
|
PostMessage(hAbortPurgeWnd, WMAPP_UPDATEPROGRESS, 0, 0);
|
|
|
|
//
|
|
//Did the user abort?
|
|
//
|
|
if (bAbortPurge == TRUE)
|
|
{
|
|
dwReturnCode = RETURN_USER_CANCELED_PURGE;
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
Sleep(1000);
|
|
}
|
|
|
|
if (!bAbortPurge)
|
|
{
|
|
bAbortPurge = TRUE;
|
|
|
|
//
|
|
//Wait for Purge thread to finish
|
|
//
|
|
WaitForSingleObject(hAbortPurgeThread, INFINITE);
|
|
|
|
bAbortPurge = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** GetClientIcon
|
|
**
|
|
** Purpose: Gets the Icon for this client.
|
|
** The icon will be inferred using the standard OLE mechanism
|
|
** under HKCR\CLSID\{clsid}\DefaultIcon (with the default value
|
|
** for this being the <Module Path>, <icon index>).
|
|
** If no icon is specified the standard windows icon will be used.
|
|
** Mod Log: Created by Jason Cobb (2/97)
|
|
**------------------------------------------------------------------------------
|
|
*/
|
|
HICON
|
|
CleanupMgrInfo::GetClientIcon(
|
|
LPTSTR lpGUID,
|
|
BOOL fIconPath
|
|
)
|
|
{
|
|
HKEY hk;
|
|
HICON hIconLarge, hIconSmall;
|
|
HICON hIcon = NULL;
|
|
TCHAR szIconKey[MAX_PATH];
|
|
TCHAR szDefaultIcon[MAX_PATH];
|
|
DWORD dwType, cbBytes;
|
|
TCHAR szIconExeName[MAX_PATH];
|
|
int i, iIconIndex;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if ( fIconPath )
|
|
{
|
|
hr = StringCchCopy(szDefaultIcon, ARRAYSIZE(szDefaultIcon), lpGUID);
|
|
}
|
|
else
|
|
{
|
|
hr = StringCchPrintf(szIconKey, ARRAYSIZE(szIconKey), SZ_DEFAULTICONPATH, lpGUID);
|
|
if (SUCCEEDED(hr) && RegOpenKeyEx(HKEY_CLASSES_ROOT, szIconKey, 0, KEY_READ, &hk) == ERROR_SUCCESS)
|
|
{
|
|
dwType = REG_SZ;
|
|
cbBytes = sizeof(szDefaultIcon);
|
|
if (RegQueryValueEx(hk, NULL, NULL, &dwType, (LPBYTE)szDefaultIcon, &cbBytes) == ERROR_SUCCESS)
|
|
{
|
|
fIconPath = TRUE;
|
|
}
|
|
RegCloseKey(hk);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && fIconPath)
|
|
{
|
|
//
|
|
//Parse out the exe where the icon lives
|
|
//
|
|
for(i=0; i<lstrlen(szDefaultIcon); i++)
|
|
{
|
|
if (szDefaultIcon[i] == ',')
|
|
break;
|
|
|
|
szIconExeName[i] = szDefaultIcon[i];
|
|
}
|
|
|
|
szIconExeName[i] = '\0';
|
|
|
|
//
|
|
//Parse out the icon index
|
|
//
|
|
i++;
|
|
iIconIndex = StrToInt(&(szDefaultIcon[i]));
|
|
|
|
if (ExtractIconEx(szIconExeName, iIconIndex, (HICON FAR *)&hIconLarge, (HICON FAR *)&hIconSmall, 1))
|
|
{
|
|
if (hIconSmall)
|
|
hIcon = hIconSmall;
|
|
else
|
|
hIcon = hIconLarge;
|
|
}
|
|
}
|
|
|
|
if (hIcon == NULL)
|
|
{
|
|
if ((hIcon = LoadIcon(CleanupMgrInfo::hInstance, MAKEINTRESOURCE(ICON_GENERIC))) == NULL)
|
|
{
|
|
MiDebugMsg((0, "LoadIcon failed with error %d", GetLastError()));
|
|
}
|
|
}
|
|
|
|
return hIcon;
|
|
}
|
|
|
|
INT_PTR CALLBACK
|
|
ScanAbortDlgProc(
|
|
HWND hDlg,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
CleanupMgrInfo *pcmi;
|
|
|
|
switch(Message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetWindowLongPtr (hDlg, DWLP_USER, 0L);
|
|
|
|
//
|
|
//Get the CleanupMgrInfo
|
|
//
|
|
pcmi = (CleanupMgrInfo *)lParam;
|
|
if (pcmi == NULL)
|
|
{
|
|
//Error - passed in invalid CleanupMgrInfo info
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Save pointer to CleanupMgrInfo object
|
|
//
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
|
|
TCHAR * psz;
|
|
psz = SHFormatMessage( MSG_SCAN_ABORT_TEXT, pcmi->szVolName, pcmi->szRoot[0] );
|
|
SetDlgItemText (hDlg, IDC_ABORT_TEXT, psz);
|
|
LocalFree(psz);
|
|
|
|
//
|
|
//Set the limits on the progress bar
|
|
//
|
|
SendDlgItemMessage(hDlg, IDC_ABORT_SCAN_PROGRESS, PBM_SETRANGE,
|
|
0, MAKELPARAM(0, pcmi->iNumVolumeCacheClients));
|
|
break;
|
|
|
|
case WMAPP_UPDATEPROGRESS:
|
|
if (lParam != NULL)
|
|
SetDlgItemText(hDlg, IDC_SCAN_STATUS_TEXT, (LPTSTR)lParam);
|
|
else
|
|
SetDlgItemText(hDlg, IDC_SCAN_STATUS_TEXT, TEXT(""));
|
|
|
|
SendDlgItemMessage(hDlg, IDC_ABORT_SCAN_PROGRESS, PBM_SETPOS,
|
|
(WPARAM)wParam, 0);
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
case WM_COMMAND:
|
|
pcmi = (CleanupMgrInfo *)GetWindowLongPtr (hDlg, DWLP_USER);
|
|
if (pcmi != NULL)
|
|
pcmi->bAbortScan = TRUE;
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
PASCAL
|
|
MessagePump(
|
|
HWND hDialogWnd
|
|
)
|
|
{
|
|
MSG Msg;
|
|
BOOL fGotMessage;
|
|
|
|
if ((fGotMessage = PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)))
|
|
{
|
|
if (!IsDialogMessage(hDialogWnd, &Msg))
|
|
{
|
|
TranslateMessage(&Msg);
|
|
DispatchMessage(&Msg);
|
|
}
|
|
}
|
|
|
|
return fGotMessage;
|
|
}
|
|
|
|
|
|
void
|
|
ScanAbortThread(
|
|
CleanupMgrInfo *pcmi
|
|
)
|
|
{
|
|
if ((pcmi->hAbortScanWnd = CreateDialogParam(g_hInstance, MAKEINTRESOURCE(IDD_SCAN_ABORT),
|
|
NULL, ScanAbortDlgProc, (LPARAM)pcmi)) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Show the window (except when the /SETUP flag is specified)
|
|
if (!(pcmi->dwUIFlags & FLAG_SETUP))
|
|
ShowWindow(pcmi->hAbortScanWnd, SW_SHOW);
|
|
|
|
// Trigger the event so we can continue with the scan.
|
|
// If this is triggered from WM_INITDIALOG it can move too quickly
|
|
// and will end up sending a message to NULL instead of the scan abort window
|
|
// because the hwnd doesn't get set until CreateDialogParam returns.
|
|
SetEvent(pcmi->hAbortScanEvent);
|
|
|
|
//
|
|
//Keep spinning till the Scan is stopped
|
|
//
|
|
while (!(pcmi->bAbortScan))
|
|
{
|
|
MessagePump(pcmi->hAbortScanWnd);
|
|
}
|
|
|
|
//
|
|
//Destroy the Abort Scan dialog
|
|
//
|
|
if (pcmi->hAbortScanWnd != NULL)
|
|
{
|
|
DestroyWindow(pcmi->hAbortScanWnd);
|
|
pcmi->hAbortScanWnd = NULL;
|
|
}
|
|
}
|
|
|
|
INT_PTR CALLBACK
|
|
PurgeAbortDlgProc(
|
|
HWND hDlg,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
CleanupMgrInfo *pcmi;
|
|
DWORD dwCurrent;
|
|
|
|
switch(Message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetWindowLongPtr (hDlg, DWLP_USER, 0L);
|
|
|
|
//
|
|
//Get the CleanupMgrInfo
|
|
//
|
|
pcmi = (CleanupMgrInfo *)lParam;
|
|
if (pcmi == NULL)
|
|
{
|
|
//Error - passed in invalid CleanupMgrInfo info
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Save pointer to CleanupMgrInfo object
|
|
//
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
|
|
TCHAR * psz;
|
|
psz = SHFormatMessage( MSG_PURGE_ABORT_TEXT, pcmi->szVolName, pcmi->szRoot[0]);
|
|
SetDlgItemText (hDlg, IDC_PURGE_TEXT, psz);
|
|
LocalFree(psz);
|
|
|
|
//
|
|
//Set the limits on the progress bar
|
|
//
|
|
if (pcmi->cbProgressDivider.QuadPart != 0)
|
|
dwCurrent = (DWORD)(pcmi->cbSpaceToPurge.QuadPart / pcmi->cbProgressDivider.QuadPart);
|
|
else
|
|
dwCurrent = (DWORD)(pcmi->cbSpaceToPurge.QuadPart);
|
|
|
|
SendDlgItemMessage(hDlg, IDC_ABORT_PURGE_PROGRESS, PBM_SETRANGE,
|
|
0, MAKELPARAM(0, dwCurrent));
|
|
|
|
break;
|
|
|
|
case WMAPP_UPDATESTATUS:
|
|
if (lParam != NULL)
|
|
SetDlgItemText(hDlg, IDC_PURGE_STATUS_TEXT, (LPTSTR)lParam);
|
|
else
|
|
SetDlgItemText(hDlg, IDC_PURGE_STATUS_TEXT, TEXT(""));
|
|
break;
|
|
|
|
case WMAPP_UPDATEPROGRESS:
|
|
pcmi = (CleanupMgrInfo *)GetWindowLongPtr (hDlg, DWLP_USER);
|
|
if (pcmi != NULL)
|
|
{
|
|
if (pcmi->cbProgressDivider.QuadPart != 0)
|
|
dwCurrent = (DWORD)((pcmi->cbTotalPurgedSoFar.QuadPart +
|
|
pcmi->cbCurrentClientPurgedSoFar.QuadPart) /
|
|
pcmi->cbProgressDivider.QuadPart);
|
|
else
|
|
dwCurrent = (DWORD)(pcmi->cbTotalPurgedSoFar.QuadPart +
|
|
pcmi->cbCurrentClientPurgedSoFar.QuadPart);
|
|
|
|
SendDlgItemMessage(hDlg, IDC_ABORT_PURGE_PROGRESS, PBM_SETPOS,
|
|
(WPARAM)dwCurrent, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
case WM_COMMAND:
|
|
pcmi = (CleanupMgrInfo *)GetWindowLongPtr (hDlg, DWLP_USER);
|
|
if (pcmi != NULL)
|
|
pcmi->bAbortPurge = TRUE;
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
PurgeAbortThread(
|
|
CleanupMgrInfo *pcmi
|
|
)
|
|
{
|
|
if ((pcmi->hAbortPurgeWnd = CreateDialogParam(g_hInstance, MAKEINTRESOURCE(IDD_PURGE_ABORT),
|
|
NULL, PurgeAbortDlgProc, (LPARAM)pcmi)) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Show the window (except when the /SETUP flag is specified)
|
|
if (!(pcmi->dwUIFlags & FLAG_SETUP))
|
|
ShowWindow(pcmi->hAbortPurgeWnd, SW_SHOW);
|
|
|
|
// Make sure the HWND has been set before setting off the event
|
|
PulseEvent(pcmi->hAbortPurgeEvent);
|
|
|
|
//
|
|
//Keep spinning till the Purge is stopped
|
|
//
|
|
while (!(pcmi->bAbortPurge))
|
|
{
|
|
MessagePump(pcmi->hAbortPurgeWnd);
|
|
}
|
|
|
|
//
|
|
//Destroy the Abort Purge dialog
|
|
//
|
|
if (pcmi->hAbortPurgeWnd != NULL)
|
|
{
|
|
DestroyWindow(pcmi->hAbortPurgeWnd);
|
|
pcmi->hAbortPurgeWnd = NULL;
|
|
}
|
|
}
|
|
/*
|
|
**------------------------------------------------------------------------------
|
|
** End of File
|
|
**------------------------------------------------------------------------------
|
|
*/
|