288 lines
11 KiB
C++
288 lines
11 KiB
C++
//=============================================================================*
|
|
// COPYRIGHT© 2001 Microsoft Corporation and Executive Software International, Inc.
|
|
//=============================================================================*
|
|
// File: VolList.h
|
|
//=============================================================================*
|
|
|
|
#ifndef _VOLLIST_H
|
|
#define _VOLLIST_H
|
|
|
|
#include "stdafx.h"
|
|
#include "diskdisp.h"
|
|
#include "dfrgcmn.h"
|
|
#include "fssubs.h"
|
|
#include "VolCom.h"
|
|
#include "FraggedFileList.h"
|
|
|
|
// from the c++ library
|
|
#include "vString.hpp"
|
|
#include "vPtrArray.hpp"
|
|
|
|
// the number of chars in the volume name to compare
|
|
// to determine a match
|
|
// this handles the trailing backslash problem
|
|
#if _WIN32_WINNT>=0x0500
|
|
#define ESI_VOLUME_NAME_LENGTH 48
|
|
#else
|
|
#define ESI_VOLUME_NAME_LENGTH 6
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------*
|
|
// Constants used by the CVolume class
|
|
//-------------------------------------------------------------------*
|
|
/*
|
|
// for the EngineState()
|
|
#define ENGINE_STATE_NULL 0 // Means it hasn't begun running yet.
|
|
#define ENGINE_STATE_IDLE 1 // Means it is instantiated, but not running
|
|
#define ENGINE_STATE_RUNNING 2 // Means it is running
|
|
|
|
// for the DefragMode()
|
|
#define NONE 0
|
|
#define ANALYZE 1
|
|
#define DEFRAG 2
|
|
|
|
// for DefragState()
|
|
#define DEFRAG_STATE_NONE 0 // set when the engine starts, always set thereafter
|
|
#define DEFRAG_STATE_USER_STOPPED 1 // set when user stops anal or defrag
|
|
#define DEFRAG_STATE_ANALYZING 2 // set during analyze phase only
|
|
#define DEFRAG_STATE_ANALYZED 3 // set when volume is analyzed and graphic data is available
|
|
#define DEFRAG_STATE_REANALYZING 4 // set during reanalyze phase only
|
|
#define DEFRAG_STATE_DEFRAGMENTING 5 // set when defragging is going on
|
|
#define DEFRAG_STATE_DEFRAGMENTED 6 // set when defragging is complete
|
|
*/
|
|
|
|
#define ESI_VOLLIST_ERR_MUST_RESTART 0x20009000
|
|
#define ESI_VOLLIST_ERR_FAT12 0x20009001
|
|
#define ESI_VOLLIST_ERR_NON_ADMIN 0x20009002
|
|
#define ESI_VOLLIST_ERR_NON_WRITE_DISK 0x20009004
|
|
#define ESI_VOLLIST_ERR_ENGINE_ERROR 0x20009008
|
|
|
|
// number of usable freespace bytes that is always ok to defrag with
|
|
static const ULONG UsableFreeSpaceByteMin = 1073741824;
|
|
|
|
|
|
//-------------------------------------------------------------------*
|
|
// Class that represents a single volume
|
|
//-------------------------------------------------------------------*
|
|
class CDfrgCtl;
|
|
class CVolume{
|
|
public:
|
|
friend class CVolList;
|
|
CVolume(PTCHAR pVolumeName, CVolList* pVolList, CDfrgCtl* pDfrgCtl);
|
|
virtual ~CVolume();
|
|
TCHAR Drive(void) {return m_Drive;}
|
|
void Drive(TCHAR drive) {m_Drive = drive;}
|
|
PTCHAR VolumeName(void) {return m_VolumeName;}
|
|
PTCHAR VolumeNameTag(void) {return m_VolumeNameTag;}
|
|
PTCHAR VolumeLabel(void) {return m_VolumeLabel;}
|
|
PTCHAR FileSystem(void) {return m_FileSystem;}
|
|
PTCHAR sCapacity(void) {return m_sCapacity;}
|
|
ULONGLONG Capacity(void) {return m_Capacity;}
|
|
PTCHAR sFreeSpace(void) {return m_sFreeSpace;}
|
|
ULONGLONG FreeSpace(void) {return m_FreeSpace;}
|
|
PTCHAR DisplayLabel(void) {return m_DisplayLabel;}
|
|
PTCHAR sFreeSpacePercent(void) {return m_sPercentFreeSpace;}
|
|
UINT FreeSpacePercent(void) {return m_PercentFreeSpace;}
|
|
UINT DefragMode(void) {return m_DefragMode;}
|
|
void DefragMode(UINT defragMode) {m_DefragMode = defragMode;}
|
|
UINT PercentDone(void) {return m_PercentDone;}
|
|
void PercentDone(UINT percentDone, PTCHAR fileName);
|
|
PTCHAR cPercentDone(void) {return m_cPercentDone;}
|
|
UINT EngineState(void) {return m_EngineState;}
|
|
void EngineState(UINT engineState) {m_EngineState = engineState;}
|
|
UINT DefragState(void) {return m_DefragState;}
|
|
void DefragState(UINT defragState);
|
|
PTCHAR sDefragState(void) {return m_sDefragState;}
|
|
BOOL IsReportOKToDisplay(void);
|
|
void GetVolumeMountPointList(void);
|
|
UINT MountPointCount(void) {return m_MountPointCount;}
|
|
PTCHAR MountPoint(UINT mountPointIndex);
|
|
BOOL Locked(void) {return m_Locked;}
|
|
void Locked(BOOL locked) {m_Locked = locked;}
|
|
BOOL Changed(void) {return m_Changed;}
|
|
void Changed(BOOL isChanged) {m_Changed = isChanged;}
|
|
BOOL FileSystemChanged(void) {return m_FileSystemChanged;}
|
|
BOOL New(void) {return m_New;}
|
|
void New(BOOL isNew) {m_New = isNew;}
|
|
BOOL Deleted(void) {return m_Deleted;}
|
|
BOOL Paused(void) {return m_Paused;}
|
|
void Paused(BOOL paused);
|
|
BOOL PausedBySnapshot(void) {return m_PausedBySnapshot;}
|
|
void PausedBySnapshot(BOOL paused);
|
|
BOOL StoppedByUser(void) {return m_StoppedByUser;}
|
|
void StoppedByUser(BOOL stoppedByUser);
|
|
BOOL Restart(void) {return m_Restart;};
|
|
void Restart(BOOL restartState) {m_Restart = restartState;}
|
|
BOOL RemovableVolume(void) {return m_RemovableVolume;};
|
|
void RemovableVolume(BOOL removableVolume) {m_RemovableVolume = removableVolume;}
|
|
BOOL Refresh(void);
|
|
void Reset(void);
|
|
void ShowReport(void);
|
|
void StopEngine(void);
|
|
void AbortEngine(BOOL bOCXIsDead=FALSE);
|
|
void PauseEngine(void);
|
|
BOOL ContinueEngine(void);
|
|
BOOL Analyze(void);
|
|
BOOL Defragment(void);
|
|
BOOL PostMessageLocal(IN HWND hWnd, IN UINT Msg, IN WPARAM wParam, IN LPARAM lParam);
|
|
BOOL WasFutilityChecked(void) {return m_WasFutilityChecked;}
|
|
void WasFutilityChecked(BOOL wasFutilityChecked) {m_WasFutilityChecked = wasFutilityChecked;}
|
|
BOOL IsDefragFutile(DWORD *dwFreeSpaceErrorLevel);
|
|
BOOL WarnFutility(void);
|
|
BOOL NoGraphicsMemory(void) {return m_bNoGraphicsMemory;}
|
|
void NoGraphicsMemory(BOOL noGraphicsMemory) {m_bNoGraphicsMemory = noGraphicsMemory;}
|
|
//acs//
|
|
UINT Pass(void) {return m_Pass;}
|
|
void Pass(UINT Pass);
|
|
PTCHAR cPass(void) {return m_cPass;}
|
|
TCHAR m_fileName[100];
|
|
|
|
|
|
private:
|
|
void Deleted(BOOL isDeleted) {m_Deleted = isDeleted;}
|
|
void FileSystemChanged(BOOL isChanged) {m_FileSystemChanged = isChanged;}
|
|
BOOL CheckFileSystem(PTCHAR volumeLabel, PTCHAR fileSystem);
|
|
BOOL GetDriveLetter(void);
|
|
void FormatDisplayString(void);
|
|
void SetStatusString(void);
|
|
BOOL GetVolumeSizes(void);
|
|
|
|
private:
|
|
TCHAR m_Drive;
|
|
TCHAR m_VolumeName[50]; // a GUID or UNC "\\?\Volume{0c89e9d1-0523-11d2-935b-000000000000}\" or "\\.\x:"
|
|
TCHAR m_VolumeNameTag[50]; // can be used to concat onto file names, etc.
|
|
TCHAR m_FileSystem[20];
|
|
TCHAR m_VolumeLabel[100];
|
|
TCHAR m_DisplayLabel[MAX_PATH]; // drive letter + volume label or 1st Mount Point
|
|
ULONGLONG m_Capacity;
|
|
TCHAR m_sCapacity[30]; // string version
|
|
ULONGLONG m_FreeSpace;
|
|
TCHAR m_sFreeSpace[30]; // string version
|
|
UINT m_PercentFreeSpace;
|
|
TCHAR m_sPercentFreeSpace[30]; // string version
|
|
UINT m_DefragState; // specific phase of defrag
|
|
TCHAR m_sDefragState[100]; // string version specific phase of defrag
|
|
UINT m_DefragMode; // ANALYZE or DEFRAG
|
|
UINT m_EngineState; // STOPPED, IDLE OR RUNNING
|
|
UINT m_PercentDone; // 0 to 100 percent done
|
|
TCHAR m_cPercentDone[10]; // 0 to 100 percent done
|
|
VString m_MountPointList[MAX_MOUNT_POINTS]; // up to five mount points
|
|
UINT m_MountPointCount;
|
|
BOOL m_RemovableVolume;
|
|
BOOL m_Changed;
|
|
BOOL m_FileSystemChanged;
|
|
BOOL m_New;
|
|
BOOL m_Deleted;
|
|
BOOL m_Locked;
|
|
BOOL m_Paused;
|
|
BOOL m_PausedBySnapshot;
|
|
BOOL m_StoppedByUser;
|
|
BOOL m_Restart;
|
|
BOOL m_WasFutilityChecked;
|
|
BOOL m_bNoGraphicsMemory; // engine can't allocate enough memory for graphics
|
|
//acs//
|
|
UINT m_Pass;
|
|
TCHAR m_cPass[10];
|
|
|
|
public:
|
|
TEXT_DATA m_TextData;
|
|
CFraggedFileList m_FraggedFileList;
|
|
|
|
DiskDisplay m_AnalyzeDisplay;
|
|
DiskDisplay m_DefragDisplay;
|
|
LPDATAOBJECT m_pdataDefragEngine;
|
|
|
|
CDfrgCtl* m_pDfrgCtl;
|
|
|
|
IDataObject* m_pIDataObject;
|
|
|
|
private:
|
|
HINSTANCE m_hDfrgRes; // handle to resource dll
|
|
|
|
//
|
|
// TLP
|
|
//
|
|
CVolList* m_pVolList;
|
|
|
|
public:
|
|
BOOL PingEngine();
|
|
const BOOL InitializeDataIo( DWORD dwRegCls = REGCLS_MULTIPLEUSE );
|
|
|
|
//
|
|
// Generate a random guid for communication purposes.
|
|
//
|
|
BOOL InitVolumeID();
|
|
|
|
//
|
|
// Accessor
|
|
//
|
|
CLSID GetVolumeID()
|
|
{
|
|
return( m_VolumeID );
|
|
}
|
|
|
|
//
|
|
// Accessor
|
|
//
|
|
void SetVolumeID( CLSID VolumeID )
|
|
{
|
|
m_VolumeID = VolumeID;
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// Contains the clsid used to start communications.
|
|
//
|
|
CLSID m_VolumeID;
|
|
|
|
//
|
|
// Contains the object registration token.
|
|
//
|
|
DWORD m_dwRegister;
|
|
|
|
//
|
|
// Contains the factory registered.
|
|
//
|
|
IClassFactory* m_pFactory;
|
|
};
|
|
|
|
//-------------------------------------------------------------------*
|
|
// Class that represents the list of volumes on the computer
|
|
//-------------------------------------------------------------------*
|
|
class CVolList
|
|
{
|
|
private:
|
|
VPtrArray m_VolumeList; // array of pointers to CVolume objects
|
|
int m_CurrentVolume;
|
|
BOOL m_Locked;
|
|
BOOL m_Redraw; // set this to TRUE to tell the OCX to redraw
|
|
|
|
public:
|
|
CVolList( CDfrgCtl* pDfrgCtl );
|
|
~CVolList();
|
|
BOOL Refresh(void);
|
|
BOOL Locked(void) {return m_Locked;}
|
|
void Locked(BOOL locked) {m_Locked = locked;}
|
|
BOOL Redraw(void) {return m_Redraw;}
|
|
void Redraw(BOOL redraw) {m_Redraw = redraw;}
|
|
BOOL DefragInProcess(void);
|
|
UINT GetVolumeCount(void) {return m_VolumeList.Size();}
|
|
UINT GetVolumeIndex(CVolume *pVolume); // gets the array index for a given CVolume object
|
|
CVolume * SetCurrentVolume(CVolume *pVolume); // sets current based on CVolume pointer
|
|
CVolume * SetCurrentVolume(TCHAR driveLetter); // drive letter version
|
|
CVolume * SetCurrentVolume(PTCHAR volumeName); // volume name version
|
|
CVolume * GetCurrentVolume(void);
|
|
|
|
// the GetVolumeAt functions do not change the current Volume
|
|
CVolume * GetVolumeAt(UINT i);
|
|
CVolume * GetVolumeAt(TCHAR driveLetter);
|
|
CVolume * GetVolumeAt(PTCHAR volumeName);
|
|
CVolume * GetVolumeRunning(void);
|
|
UINT GetRefreshInterval(void);
|
|
|
|
protected:
|
|
CDfrgCtl* m_pDfrgCtl;
|
|
};
|
|
|
|
#endif
|