331 lines
7.6 KiB
C++
331 lines
7.6 KiB
C++
#ifndef _INC_DSKQUOTA_UTILS_H
|
|
#define _INC_DSKQUOTA_UTILS_H
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
/* File: utils.h
|
|
|
|
Description: Header for general utilities module. It is expected that
|
|
windows.h is included before this header.
|
|
|
|
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- --------------------------------------------------- ----------
|
|
06/06/96 Initial creation. BrianAu
|
|
*/
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef _INC_DSKQUOTA_PRIVATE_H
|
|
# include "private.h"
|
|
#endif
|
|
|
|
//
|
|
// Convert a value to a "bool".
|
|
// Lower-case "boolify" is intentional to enforce relationship
|
|
// to type "bool".
|
|
//
|
|
template <class T>
|
|
inline bool boolify(const T& x)
|
|
{
|
|
return !!x;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
const T&
|
|
MAX(const T& a, const T& b)
|
|
{
|
|
return a > b ? a : b;
|
|
}
|
|
|
|
template <class T>
|
|
const T&
|
|
MIN(const T& a, const T& b)
|
|
{
|
|
return a < b ? a : b;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
void
|
|
SWAP(T& a, T& b)
|
|
{
|
|
T temp(a);
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
|
|
|
|
//
|
|
// Trivial class for ensuring window redraw is restored in the case
|
|
// of an exception.
|
|
//
|
|
class CAutoSetRedraw
|
|
{
|
|
public:
|
|
CAutoSetRedraw(HWND hwnd)
|
|
: m_hwnd(hwnd) { }
|
|
|
|
CAutoSetRedraw(HWND hwnd, bool bSet)
|
|
: m_hwnd(hwnd) { Set(bSet); }
|
|
|
|
~CAutoSetRedraw(void)
|
|
{ Set(true); }
|
|
|
|
void Set(bool bSet)
|
|
{ SendMessage(m_hwnd, WM_SETREDRAW, (WPARAM)bSet, 0); }
|
|
|
|
private:
|
|
HWND m_hwnd;
|
|
};
|
|
|
|
|
|
//
|
|
// Trivial class for ensuring window is enabled in the case
|
|
// of an exception.
|
|
//
|
|
class CAutoWndEnable
|
|
{
|
|
public:
|
|
CAutoWndEnable(HWND hwnd)
|
|
: m_hwnd(hwnd) { }
|
|
|
|
CAutoWndEnable(HWND hwnd, bool bEnable)
|
|
: m_hwnd(hwnd) { Enable(bEnable); }
|
|
|
|
~CAutoWndEnable(void)
|
|
{ Enable(true); }
|
|
|
|
void Enable(bool bEnable)
|
|
{ EnableWindow(m_hwnd, bEnable); }
|
|
|
|
private:
|
|
HWND m_hwnd;
|
|
};
|
|
|
|
|
|
//
|
|
// Ensure NT handles are exception safe.
|
|
//
|
|
class CNtHandle
|
|
{
|
|
public:
|
|
CNtHandle(HANDLE handle)
|
|
: m_handle(handle) { }
|
|
|
|
CNtHandle(void)
|
|
: m_handle(NULL) { }
|
|
|
|
~CNtHandle(void)
|
|
{ Close(); }
|
|
|
|
void Close(void)
|
|
{ if (m_handle) NtClose(m_handle); m_handle = NULL; }
|
|
|
|
operator HANDLE() const
|
|
{ return m_handle; }
|
|
|
|
HANDLE *HandlePtr(void)
|
|
{ DBGASSERT((NULL == m_handle)); return &m_handle; }
|
|
|
|
private:
|
|
HANDLE m_handle;
|
|
|
|
//
|
|
// Prevent copy.
|
|
// This class is only intended for automatic handle cleanup.
|
|
//
|
|
CNtHandle(const CNtHandle& rhs);
|
|
CNtHandle& operator = (const CNtHandle& rhs);
|
|
};
|
|
|
|
|
|
//
|
|
// Ensure Win32 handles are exception safe.
|
|
//
|
|
class CWin32Handle
|
|
{
|
|
public:
|
|
CWin32Handle(HANDLE handle)
|
|
: m_handle(handle) { }
|
|
|
|
CWin32Handle(void)
|
|
: m_handle(NULL) { }
|
|
|
|
~CWin32Handle(void)
|
|
{ Close(); }
|
|
|
|
void Close(void)
|
|
{ if (m_handle) CloseHandle(m_handle); m_handle = NULL; }
|
|
|
|
operator HANDLE() const
|
|
{ return m_handle; }
|
|
|
|
HANDLE *HandlePtr(void)
|
|
{ DBGASSERT((NULL == m_handle)); return &m_handle; }
|
|
|
|
private:
|
|
HANDLE m_handle;
|
|
|
|
//
|
|
// Prevent copy.
|
|
// This class is only intended for automatic handle cleanup.
|
|
//
|
|
CWin32Handle(const CWin32Handle& rhs);
|
|
CWin32Handle& operator = (const CWin32Handle& rhs);
|
|
};
|
|
|
|
|
|
//
|
|
// Trivial inline class to automate the cleanup of a STGMEDIUM
|
|
// structure.
|
|
//
|
|
class CStgMedium : public STGMEDIUM
|
|
{
|
|
public:
|
|
CStgMedium(void)
|
|
{ tymed = TYMED_NULL; hGlobal = NULL; pUnkForRelease = NULL; }
|
|
|
|
~CStgMedium(void)
|
|
{ ReleaseStgMedium(this); }
|
|
|
|
operator LPSTGMEDIUM(void)
|
|
{ return (LPSTGMEDIUM)this; }
|
|
|
|
operator const STGMEDIUM& (void)
|
|
{ return (STGMEDIUM &)*this; }
|
|
};
|
|
|
|
|
|
//
|
|
// On mounted volumes, the parsing name and display name are different.
|
|
// The parsing name contains a GUID which means nothing to the user.
|
|
// This class encapsulates both strings into a single class that can
|
|
// be passed as a single object to functions requiring a volume
|
|
// identifier.
|
|
//
|
|
// Here is an example of what the strings will contain:
|
|
//
|
|
// Mounted volume Non-mounted volume
|
|
//
|
|
// Display Label (C:\FOO) C:\
|
|
// Parsing \\?\Volume\{GUID} C:\
|
|
// FSPath C:\FOO C:\
|
|
//
|
|
// I've coded this using only CString object references to leverage
|
|
// the reference counting of the CString class and minimize string copying.
|
|
//
|
|
class CVolumeID
|
|
{
|
|
public:
|
|
CVolumeID(void)
|
|
: m_bMountedVol(false) { }
|
|
|
|
CVolumeID(
|
|
const CString& strForParsing,
|
|
const CString& strForDisplay,
|
|
const CString& strFSPath
|
|
) : m_bMountedVol(false)
|
|
{ SetNames(strForParsing, strForDisplay, strFSPath); }
|
|
|
|
~CVolumeID(void) { };
|
|
|
|
bool IsMountedVolume(void) const
|
|
{ return m_bMountedVol; }
|
|
|
|
void SetNames(
|
|
const CString& strForParsing,
|
|
const CString& strForDisplay,
|
|
const CString& strFSPath)
|
|
{ m_strForParsing = strForParsing;
|
|
m_strFSPath = strFSPath;
|
|
m_strForDisplay = strForDisplay;
|
|
m_bMountedVol = !!(strForParsing != strForDisplay); }
|
|
|
|
const CString& ForParsing(void) const
|
|
{ return m_strForParsing; }
|
|
|
|
void ForParsing(CString *pstr) const
|
|
{ *pstr = m_strForParsing; }
|
|
|
|
const CString& ForDisplay(void) const
|
|
{ return m_strForDisplay; }
|
|
|
|
void ForDisplay(CString *pstr) const
|
|
{ *pstr = m_strForDisplay; }
|
|
|
|
const CString& FSPath(void) const
|
|
{ return m_strFSPath; }
|
|
|
|
void FSPath(CString *pstr) const
|
|
{ *pstr = m_strFSPath; }
|
|
|
|
private:
|
|
CString m_strForParsing;
|
|
CString m_strForDisplay;
|
|
CString m_strFSPath;
|
|
bool m_bMountedVol;
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// Don't want to include dskquota.h for these.
|
|
// Including it here places the CLSIDs and IIDs in the precompiled header
|
|
// which screws up the declaration/definition of the GUIDs.
|
|
//
|
|
struct IDiskQuotaUser; // fwd decl.
|
|
#define SIDLIST FILE_GET_QUOTA_INFORMATION
|
|
#define PSIDLIST PFILE_GET_QUOTA_INFORMATION
|
|
|
|
BOOL SidToString(
|
|
PSID pSid,
|
|
LPTSTR pszSid,
|
|
LPDWORD pcchSid);
|
|
|
|
BOOL SidToString(
|
|
PSID pSid,
|
|
LPTSTR *ppszSid);
|
|
|
|
HRESULT
|
|
CreateSidList(
|
|
PSID *rgpSids,
|
|
DWORD cpSids,
|
|
PSIDLIST *ppSidList,
|
|
LPDWORD pcbSidList);
|
|
|
|
VOID MessageBoxNYI(VOID);
|
|
|
|
inline INT DiskQuotaMsgBox(HWND hWndParent,
|
|
LPCTSTR pszText,
|
|
LPCTSTR pszTitle,
|
|
UINT uType);
|
|
|
|
INT DiskQuotaMsgBox(HWND hWndParent,
|
|
UINT idMsgText,
|
|
UINT idMsgTitle,
|
|
UINT uType);
|
|
|
|
INT DiskQuotaMsgBox(HWND hWndParent,
|
|
UINT idMsgText,
|
|
LPCTSTR pszTitle,
|
|
UINT uType);
|
|
|
|
INT DiskQuotaMsgBox(HWND hWndParent,
|
|
LPCTSTR pszText,
|
|
UINT idMsgTitle,
|
|
UINT uType);
|
|
|
|
LPTSTR StringDup(LPCTSTR pszSource);
|
|
PSID SidDup(PSID pSid);
|
|
BOOL UserIsAdministrator(IDiskQuotaUser *pUser);
|
|
VOID CenterPopupWindow(HWND hwnd, HWND hwndParent = NULL);
|
|
HRESULT CallRegInstall(HINSTANCE hInstance, LPSTR szSection);
|
|
void GetDlgItemText(HWND hwnd, UINT idCtl, CString *pstrText);
|
|
|
|
|
|
|
|
#endif // _INC_DSKQUOTA_UTILS_H
|
|
|