1989 lines
53 KiB
C++
1989 lines
53 KiB
C++
|
|
/* File: userprop.cpp
|
|
|
|
Description: Provides implementations for quota user property page.
|
|
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
06/25/98 Replaced AddUserPropSheet with AddUserDialog. BrianAu
|
|
Now that we're getting user info from the DS
|
|
object picker, the prop sheet idea doesn't work
|
|
so well. A std dialog is better.
|
|
*/
|
|
|
|
#include "pch.h" // PCH
|
|
#pragma hdrstop
|
|
|
|
#include <lm.h>
|
|
#include "undo.h"
|
|
#include "userprop.h"
|
|
#include "userbat.h"
|
|
#include "uihelp.h"
|
|
#include "progress.h"
|
|
#include "uiutils.h"
|
|
|
|
|
|
// Context help IDs.
|
|
|
|
#pragma data_seg(".text", "CODE")
|
|
const static DWORD rgUserPropSheetHelpIDs[] =
|
|
{
|
|
IDC_ICON_USER, DWORD(-1),
|
|
IDC_STATIC2, DWORD(-1),
|
|
IDC_TXT_USERNAME, IDH_TXT_USERNAME,
|
|
IDC_TXT_SPACEUSED, IDH_TXT_SPACEUSED,
|
|
IDC_TXT_SPACEREMAINING, IDH_TXT_SPACEREMAINING,
|
|
IDC_LBL_SPACEUSED, DWORD(-1),
|
|
IDC_LBL_SPACEREMAINING, DWORD(-1),
|
|
IDC_ICON_USERSTATUS, IDH_ICON_USERSTATUS,
|
|
IDC_RBN_USER_NOLIMIT, IDH_RBN_USER_NOLIMIT,
|
|
IDC_RBN_USER_LIMIT, IDH_RBN_USER_LIMIT,
|
|
IDC_TXT_WARN_LEVEL, DWORD(-1),
|
|
IDC_EDIT_USER_LIMIT, IDH_EDIT_USER_LIMIT,
|
|
IDC_EDIT_USER_THRESHOLD, IDH_EDIT_USER_THRESHOLD,
|
|
IDC_CMB_USER_LIMIT, IDH_CMB_USER_LIMIT,
|
|
IDC_CMB_USER_THRESHOLD, IDH_CMB_USER_THRESHOLD,
|
|
0,0
|
|
};
|
|
|
|
#pragma data_seg()
|
|
|
|
|
|
|
|
// Messages for querying property page for icon images.
|
|
|
|
#define DQM_QUERY_STATUS_ICON (WM_USER + 1)
|
|
#define DQM_QUERY_USER_ICON (WM_USER + 2)
|
|
#define DQM_ENABLE_APPLY_BUTTON (WM_USER + 3)
|
|
|
|
|
|
/* Function: UserPropSheet::UserPropSheet
|
|
|
|
Description: Constructor for a user property sheet object.
|
|
Initializes the members that hold user quota data.
|
|
|
|
Arguments: None.
|
|
|
|
Returns: Nothing.
|
|
|
|
Exceptions: OutOfMemory.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
UserPropSheet::UserPropSheet(
|
|
PDISKQUOTA_CONTROL pQuotaControl,
|
|
const CVolumeID& idVolume,
|
|
HWND hWndParent,
|
|
LVSelection& LVSel,
|
|
UndoList& UndoList
|
|
) : m_cVolumeMaxBytes(0),
|
|
m_pQuotaControl(pQuotaControl),
|
|
m_UndoList(UndoList),
|
|
m_LVSelection(LVSel),
|
|
m_hWndParent(hWndParent),
|
|
m_bIsDirty(FALSE),
|
|
m_bHomogeneousSelection(TRUE), // Assume selection is homogeneous.
|
|
m_pxbQuotaLimit(NULL),
|
|
m_pxbQuotaThreshold(NULL),
|
|
m_idVolume(idVolume),
|
|
m_strPageTitle(g_hInstDll, IDS_TITLE_GENERAL),
|
|
m_idCtlNextFocus(-1)
|
|
{
|
|
DBGASSERT((NULL != m_pQuotaControl));
|
|
DBGASSERT((NULL != m_hWndParent));
|
|
DBGTRACE((DM_UPROP, DL_HIGH, TEXT("UserPropSheet::UserPropSheet")));
|
|
|
|
m_llQuotaUsed = 0;
|
|
m_llQuotaLimit = 0;
|
|
m_llQuotaThreshold = 0;
|
|
|
|
DBGASSERT((0 == iICON_USER_SINGLE));
|
|
DBGASSERT((1 == iICON_USER_MULTIPLE));
|
|
m_hIconUser[0] = LoadIcon(g_hInstDll, MAKEINTRESOURCE(IDI_SINGLE_USER));
|
|
m_hIconUser[1] = LoadIcon(g_hInstDll, MAKEINTRESOURCE(IDI_MULTI_USER));
|
|
|
|
DBGASSERT((0 == iICON_STATUS_OK));
|
|
DBGASSERT((1 == iICON_STATUS_OVER_THRESHOLD));
|
|
DBGASSERT((2 == iICON_STATUS_OVER_LIMIT));
|
|
m_hIconStatus[0] = LoadIcon(g_hInstDll, MAKEINTRESOURCE(IDI_OKBUBBLE));
|
|
m_hIconStatus[1] = LoadIcon(NULL, IDI_WARNING);
|
|
m_hIconStatus[2] = LoadIcon(g_hInstDll, MAKEINTRESOURCE(IDI_WARNERR));
|
|
}
|
|
|
|
|
|
|
|
UserPropSheet::~UserPropSheet(
|
|
VOID
|
|
)
|
|
{
|
|
DBGTRACE((DM_UPROP, DL_HIGH, TEXT("UserPropSheet::~UserPropSheet")));
|
|
INT i = 0;
|
|
|
|
if (NULL != m_pQuotaControl)
|
|
m_pQuotaControl->Release();
|
|
|
|
if (NULL != m_pxbQuotaLimit)
|
|
delete m_pxbQuotaLimit;
|
|
if (NULL != m_pxbQuotaThreshold)
|
|
delete m_pxbQuotaThreshold;
|
|
}
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::Run
|
|
|
|
Description: Creates and runs the property sheet dialog.
|
|
This is the only method a client needs to call once the object
|
|
is created.
|
|
|
|
Arguments: None.
|
|
|
|
Returns:
|
|
NO_ERROR
|
|
E_FAIL - Couldn't create property sheet.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
HRESULT
|
|
UserPropSheet::Run(
|
|
VOID
|
|
)
|
|
{
|
|
HRESULT hResult = NO_ERROR; // Assume success.
|
|
|
|
PROPSHEETHEADER psh;
|
|
PROPSHEETPAGE psp;
|
|
|
|
ZeroMemory(&psh, sizeof(psh));
|
|
ZeroMemory(&psp, sizeof(psp));
|
|
|
|
|
|
// Define page.
|
|
|
|
psp.dwSize = sizeof(PROPSHEETPAGE);
|
|
psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE;
|
|
psp.hInstance = g_hInstDll;
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE_USERQUOTA);
|
|
psp.pszTitle = (LPCTSTR)m_strPageTitle;
|
|
psp.pfnDlgProc = (DLGPROC)DlgProc;
|
|
psp.lParam = (LPARAM)this;
|
|
psp.pcRefParent = (UINT *)& g_cRefThisDll;
|
|
|
|
|
|
// Define sheet.
|
|
|
|
psh.dwSize = sizeof(PROPSHEETHEADER);
|
|
psh.dwFlags = PSH_PROPSHEETPAGE;
|
|
psh.hwndParent = m_hWndParent;
|
|
psh.hInstance = g_hInstDll;
|
|
psh.pszIcon = NULL;
|
|
psh.pszCaption = NULL;
|
|
psh.nPages = 1;
|
|
psh.nStartPage = 0;
|
|
psh.ppsp = (LPCPROPSHEETPAGE)&psp;
|
|
|
|
if (0 <= PropertySheet(&psh))
|
|
hResult = E_FAIL;
|
|
|
|
return hResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::DlgProc
|
|
|
|
Description: Static method called by windows to process messages for the
|
|
property page dialog. Since it's static, we have to save the "this"
|
|
pointer in the window's USERDATA.
|
|
|
|
Arguments: Standard WndProc-type arguments.
|
|
|
|
Returns: Standard WndProc-type return values.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR APIENTRY
|
|
UserPropSheet::DlgProc(
|
|
HWND hDlg,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
INT_PTR bResult = FALSE;
|
|
|
|
|
|
// Retrieve the "this" pointer from the dialog's userdata.
|
|
// It was placed there in OnInitDialog().
|
|
|
|
UserPropSheet *pThis = (UserPropSheet *)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
try
|
|
{
|
|
switch(message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("DlgProc: WM_INITDIALOG")));
|
|
bResult = OnInitDialog(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("DlgProc: WM_NOTIFY")));
|
|
bResult = pThis->OnNotify(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("DlgProc: WM_COMMAND")));
|
|
bResult = pThis->OnCommand(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("DlgProc: WM_HELP")));
|
|
bResult = pThis->OnHelp(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
bResult = pThis->OnContextMenu((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("DlgProc: WM_DESTROY")));
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
case WM_ENDSESSION:
|
|
DestroyWindow(hDlg);
|
|
break;
|
|
|
|
case DQM_ENABLE_APPLY_BUTTON:
|
|
pThis->m_bIsDirty = TRUE;
|
|
bResult = PropSheet_Changed(GetParent(hDlg), hDlg);
|
|
break;
|
|
|
|
|
|
// These two icon query messages are for automated testing
|
|
// of the UI.
|
|
|
|
case DQM_QUERY_USER_ICON:
|
|
bResult = pThis->QueryUserIcon(hDlg);
|
|
break;
|
|
|
|
case DQM_QUERY_STATUS_ICON:
|
|
bResult = pThis->QueryUserStatusIcon(hDlg);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch(CAllocException& e)
|
|
{
|
|
DiskQuotaMsgBox(GetDesktopWindow(),
|
|
IDS_OUTOFMEMORY,
|
|
IDS_TITLE_DISK_QUOTA,
|
|
MB_ICONERROR | MB_OK);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnInitDialog
|
|
|
|
Description: Handler for WM_INITDIALOG. Retrieves the "this" pointer from
|
|
the PROPSHEETPAGE structure (pointed to by lParam) and saves it in
|
|
the window's USERDATA.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - Handle of control to receive focus if we return FALSE.
|
|
|
|
lParam - Pointer to PROPSHEETPAGE structure for the property page.
|
|
|
|
Returns:
|
|
TRUE = Tells windows to assign focus to the control in wParam.
|
|
|
|
Exceptions: OutOfMemory.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnInitDialog(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
HRESULT hResult = NO_ERROR;
|
|
|
|
PROPSHEETPAGE *pPage = (PROPSHEETPAGE *)lParam;
|
|
UserPropSheet *pThis = (UserPropSheet *)pPage->lParam;
|
|
DWORD dwSectorsPerCluster = 0;
|
|
DWORD dwBytesPerSector = 0;
|
|
DWORD dwFreeClusters = 0;
|
|
DWORD dwTotalClusters = 0;
|
|
|
|
DBGASSERT((NULL != pThis));
|
|
|
|
|
|
// Save "this" in the window's userdata.
|
|
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (INT_PTR)pThis);
|
|
|
|
|
|
// Read quota info from NTFS.
|
|
// For single selection, we cache the selected user's info.
|
|
// For multi selection, we cache the defaults for the volume.
|
|
// If adding a new user (count == 0), we also use the defaults for the
|
|
// volume.
|
|
|
|
pThis->RefreshCachedQuotaInfo();
|
|
|
|
|
|
// Calculate the volume's size.
|
|
// We'll use this to limit user threshold and quota limit entries.
|
|
|
|
if (GetDiskFreeSpace(pThis->m_idVolume.ForParsing(),
|
|
&dwSectorsPerCluster,
|
|
&dwBytesPerSector,
|
|
&dwFreeClusters,
|
|
&dwTotalClusters))
|
|
{
|
|
pThis->m_cVolumeMaxBytes = (LONGLONG)dwSectorsPerCluster *
|
|
(LONGLONG)dwBytesPerSector *
|
|
(LONGLONG)dwTotalClusters;
|
|
}
|
|
|
|
pThis->m_pxbQuotaLimit = new XBytes(hDlg,
|
|
IDC_EDIT_USER_LIMIT,
|
|
IDC_CMB_USER_LIMIT,
|
|
pThis->m_llQuotaLimit);
|
|
pThis->m_pxbQuotaThreshold = new XBytes(hDlg,
|
|
IDC_EDIT_USER_THRESHOLD,
|
|
IDC_CMB_USER_THRESHOLD,
|
|
pThis->m_llQuotaThreshold);
|
|
|
|
pThis->InitializeControls(hDlg);
|
|
|
|
return TRUE; // Set focus to default control.
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::RefreshCachedQuotaInfo
|
|
|
|
Description: Reads the quota limit, threshold and used values from the
|
|
property sheet's user object. If multiple users are selected,
|
|
only the first one is read.
|
|
|
|
Arguments: None.
|
|
|
|
Returns: Result of read operation.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
HRESULT
|
|
UserPropSheet::RefreshCachedQuotaInfo(
|
|
VOID
|
|
)
|
|
{
|
|
HRESULT hResult = NO_ERROR;
|
|
PDISKQUOTA_USER pUser = NULL;
|
|
INT cSelectedUsers = m_LVSelection.Count();
|
|
|
|
m_LVSelection.Retrieve(0, &pUser);
|
|
|
|
|
|
// Read quota threshold. Multi-user selections use the volume's default.
|
|
|
|
if (1 == cSelectedUsers)
|
|
{
|
|
hResult = pUser->GetQuotaThreshold(&m_llQuotaThreshold);
|
|
}
|
|
else
|
|
{
|
|
hResult = m_pQuotaControl->GetDefaultQuotaThreshold(&m_llQuotaThreshold);
|
|
}
|
|
if (FAILED(hResult))
|
|
goto refresh_quota_info_failed;
|
|
|
|
|
|
// Read quota limit. Multi-user selections use the volume's default.
|
|
|
|
if (1 == cSelectedUsers)
|
|
{
|
|
hResult = pUser->GetQuotaLimit(&m_llQuotaLimit);
|
|
}
|
|
else
|
|
{
|
|
hResult = m_pQuotaControl->GetDefaultQuotaLimit(&m_llQuotaLimit);
|
|
}
|
|
if (FAILED(hResult))
|
|
goto refresh_quota_info_failed;
|
|
|
|
|
|
|
|
// Read quota used.
|
|
|
|
if (1 == cSelectedUsers)
|
|
{
|
|
hResult = pUser->GetQuotaUsed(&m_llQuotaUsed);
|
|
}
|
|
else
|
|
{
|
|
m_llQuotaUsed = 0;
|
|
}
|
|
|
|
refresh_quota_info_failed:
|
|
return hResult;
|
|
}
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnCommand
|
|
|
|
Description: Handler for WM_COMMAND.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - ID of selected control and notification code.
|
|
|
|
lParam - HWND of selected control.
|
|
|
|
Returns:
|
|
TRUE = Message wasn't handled.
|
|
FALSE = Message was handled.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnCommand(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DWORD dwCtlId = LOWORD(wParam);
|
|
HWND hWndCtl = (HWND)lParam;
|
|
DWORD dwNotifyCode = HIWORD(wParam);
|
|
INT_PTR bResult = FALSE;
|
|
|
|
switch(dwCtlId)
|
|
{
|
|
case IDC_TXT_USERNAME:
|
|
if (EN_SETFOCUS == dwNotifyCode && IDC_EDIT_USER_THRESHOLD == m_idCtlNextFocus)
|
|
{
|
|
|
|
// Focus is being set as a result of an invalid entry
|
|
// in the warning level field. Force input focus to the
|
|
// field and select the entire contents. User can then just
|
|
// enter a new value.
|
|
|
|
SetFocus(GetDlgItem(hDlg, IDC_EDIT_USER_THRESHOLD));
|
|
SendDlgItemMessage(hDlg, IDC_EDIT_USER_THRESHOLD, EM_SETSEL, 0, -1);
|
|
m_idCtlNextFocus = -1;
|
|
}
|
|
break;
|
|
|
|
case IDC_RBN_USER_NOLIMIT:
|
|
if (m_pxbQuotaThreshold->IsEnabled())
|
|
{
|
|
|
|
// This is simple. Just set both the limit and threshold controls
|
|
// to "no limit".
|
|
|
|
m_pxbQuotaThreshold->SetBytes(NOLIMIT);
|
|
m_pxbQuotaLimit->SetBytes(NOLIMIT);
|
|
m_bIsDirty = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDC_RBN_USER_LIMIT:
|
|
{
|
|
LONGLONG llValue;
|
|
|
|
|
|
// This handler needs some logic. We have to handle several
|
|
// scenarios/rules with this one.
|
|
// 1. Single vs. Multiple selection.
|
|
// 2. Single selection for Administrator account.
|
|
// 3. Multi selection homogeneous/heterogenous with respect to
|
|
// quota limit and threshold values.
|
|
// 4. Can't display "No Limit" in edit controls when they're active.
|
|
// 5. Use volume defaults for new user and hetergenous multi-select.
|
|
|
|
if (!m_pxbQuotaThreshold->IsEnabled())
|
|
{
|
|
enum use_types { USE_CACHED, USE_VOLDEF, USE_NOLIMIT };
|
|
|
|
INT iUseAsValue = USE_CACHED;
|
|
INT cSelected = m_LVSelection.Count();
|
|
|
|
///
|
|
// First set the quota limit controls.
|
|
///
|
|
if (0 == cSelected) // Adding new user...
|
|
{
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
else if (1 == cSelected) // One user selected...
|
|
{
|
|
PDISKQUOTA_USER pUser = NULL;
|
|
m_LVSelection.Retrieve(0, &pUser);
|
|
if (UserIsAdministrator(pUser))
|
|
{
|
|
|
|
// If user is administrator, the limit is always "No Limit".
|
|
// This will disable the "Limit" controls and prevent
|
|
// user from setting a limit on this account.
|
|
|
|
iUseAsValue = USE_NOLIMIT;
|
|
}
|
|
else if (NOLIMIT == m_llQuotaLimit)
|
|
{
|
|
|
|
// Account isn't Administrator AND the limit is NOLIMIT.
|
|
// Use the volume's default "new user" limit value.
|
|
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
}
|
|
else if (!m_bHomogeneousSelection || NOLIMIT == m_llQuotaLimit) // Multiple user.
|
|
{
|
|
|
|
// Multiple non-homogeneous users get the volume's default limit.
|
|
// Multiple homogeneous users get their current cached setting unless
|
|
// the cached setting is NOLIMIT; in which case, they get the
|
|
// volume's defaults.
|
|
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
|
|
|
|
// Set the proper quota limit value in the edit/combo box control.
|
|
|
|
llValue = 0;
|
|
switch(iUseAsValue)
|
|
{
|
|
case USE_VOLDEF:
|
|
m_pQuotaControl->GetDefaultQuotaLimit(&llValue);
|
|
|
|
// If default is NOLIMIT, display 0 MB. We can't display an
|
|
// "editable" No Limit in the edit control. Only numbers.
|
|
|
|
if (NOLIMIT == llValue)
|
|
llValue = 0;
|
|
break;
|
|
|
|
case USE_NOLIMIT:
|
|
llValue = NOLIMIT;
|
|
break;
|
|
|
|
case USE_CACHED:
|
|
llValue = m_llQuotaLimit;
|
|
break;
|
|
}
|
|
|
|
m_pxbQuotaLimit->SetBytes(llValue);
|
|
|
|
|
|
///
|
|
// Now the threshold controls...
|
|
///
|
|
llValue = 0;
|
|
iUseAsValue = USE_CACHED;
|
|
if (0 == cSelected)
|
|
{
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
else if (1 == cSelected)
|
|
{
|
|
if (NOLIMIT == m_llQuotaThreshold)
|
|
{
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
}
|
|
else if (!m_bHomogeneousSelection || NOLIMIT == m_llQuotaThreshold)
|
|
{
|
|
iUseAsValue = USE_VOLDEF;
|
|
}
|
|
|
|
|
|
// Set the proper quota threshold value in the edit/combo box control.
|
|
|
|
switch(iUseAsValue)
|
|
{
|
|
case USE_VOLDEF:
|
|
m_pQuotaControl->GetDefaultQuotaThreshold(&llValue);
|
|
|
|
// If default is NOLIMIT, display 0 MB. We can't display an
|
|
// "editable" No Limit in the edit control. Only numbers.
|
|
|
|
if (NOLIMIT == llValue)
|
|
llValue = 0;
|
|
break;
|
|
|
|
case USE_NOLIMIT:
|
|
llValue = NOLIMIT;
|
|
break;
|
|
|
|
case USE_CACHED:
|
|
llValue = m_llQuotaThreshold;
|
|
break;
|
|
}
|
|
|
|
m_pxbQuotaThreshold->SetBytes(llValue);
|
|
|
|
m_bIsDirty = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IDC_EDIT_USER_LIMIT:
|
|
case IDC_EDIT_USER_THRESHOLD:
|
|
switch(dwNotifyCode)
|
|
{
|
|
case EN_UPDATE:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnCommand, EN_CHANGE")));
|
|
bResult = OnEditNotifyUpdate(hDlg, wParam, lParam);
|
|
m_bIsDirty = TRUE;
|
|
break;
|
|
|
|
case EN_KILLFOCUS:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnCommand, EN_KILLFOCUS")));
|
|
bResult = OnEditNotifyKillFocus(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IDC_CMB_USER_LIMIT:
|
|
case IDC_CMB_USER_THRESHOLD:
|
|
switch(dwNotifyCode)
|
|
{
|
|
case CBN_SELCHANGE:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnCommand, CBN_CHANGE")));
|
|
bResult = OnComboNotifySelChange(hDlg, wParam, lParam);
|
|
m_bIsDirty = TRUE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bResult = TRUE; // Didn't handle message.
|
|
break;
|
|
}
|
|
|
|
|
|
if (m_bIsDirty)
|
|
PropSheet_Changed(GetParent(hDlg), hDlg);
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnNotify
|
|
|
|
Description: Handler for WM_NOTIFY.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - ID of selected control and notification code.
|
|
|
|
lParam - HWND of selected control.
|
|
|
|
Returns:
|
|
TRUE = Message wasn't handled.
|
|
FALSE = Message was handled.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnNotify(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
INT_PTR bResult = FALSE;
|
|
|
|
switch(((NMHDR *)lParam)->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnNotify, PSN_SETACTIVE")));
|
|
bResult = OnSheetNotifySetActive(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnNotify, PSN_APPLY")));
|
|
bResult = OnSheetNotifyApply(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnNotify, PSN_KILLACTIVE")));
|
|
bResult = OnSheetNotifyKillActive(hDlg, wParam, lParam);
|
|
break;
|
|
|
|
case PSN_RESET:
|
|
DBGPRINT((DM_WND, DL_MID, TEXT("OnNotify, PSN_RESET")));
|
|
|
|
// Fall through.
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnSheetNotifySetActive
|
|
|
|
Description: Handler for WM_NOTIFY - PSN_SETACTIVE.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - ID of control.
|
|
|
|
lParam - Address of NMHDR structure.
|
|
|
|
Returns:
|
|
FALSE = Accept activation.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnSheetNotifySetActive(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, 0);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnSheetNotifyApply
|
|
|
|
Description: Handler for WM_NOTIFY - PSN_APPLY.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - ID of control.
|
|
|
|
lParam - Address of NMHDR structure.
|
|
|
|
Returns:
|
|
TRUE = PSN return value set using SetWindowLong.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnSheetNotifyApply(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
HRESULT hResult = NO_ERROR;
|
|
LONG dwPSNReturn = PSNRET_NOERROR;
|
|
|
|
|
|
// Only apply settings if the "Apply" button is enabled indicating
|
|
// that something has been changed. No need to apply unchanged
|
|
// settings when the OK button is pressed.
|
|
|
|
if (m_bIsDirty)
|
|
{
|
|
if (PSNRET_NOERROR == dwPSNReturn)
|
|
{
|
|
|
|
// We need to do this because if you activate the apply button
|
|
// with Alt-A we receive PSN_APPLY before EN_KILLFOCUS.
|
|
|
|
m_pxbQuotaThreshold->OnEditKillFocus((LPARAM)GetDlgItem(hDlg, IDC_EDIT_USER_THRESHOLD));
|
|
m_pxbQuotaLimit->OnEditKillFocus((LPARAM)GetDlgItem(hDlg, IDC_EDIT_USER_LIMIT));
|
|
|
|
|
|
// Ensure warning threshold is not above limit.
|
|
|
|
INT64 iThreshold = m_pxbQuotaThreshold->GetBytes();
|
|
INT64 iLimit = m_pxbQuotaLimit->GetBytes();
|
|
|
|
if (NOLIMIT != iLimit && iThreshold > iLimit)
|
|
{
|
|
TCHAR szLimit[40], szThreshold[40];
|
|
XBytes::FormatByteCountForDisplay(iLimit, szLimit, ARRAYSIZE(szLimit));
|
|
XBytes::FormatByteCountForDisplay(iThreshold, szThreshold, ARRAYSIZE(szThreshold));
|
|
|
|
CString s(g_hInstDll, IDS_FMT_ERR_WARNOVERLIMIT, szThreshold, szLimit, szLimit);
|
|
switch(DiskQuotaMsgBox(hDlg, s, IDS_TITLE_DISK_QUOTA, MB_ICONWARNING | MB_YESNO))
|
|
{
|
|
case IDYES:
|
|
m_pxbQuotaThreshold->SetBytes(iLimit);
|
|
break;
|
|
|
|
case IDNO:
|
|
|
|
// This m_idCtlNextFocus hack stuff is here because I can't get
|
|
// the @#$%! prop sheet to return focus to the threshold control.
|
|
// The only way I've been able to get this to happen is to
|
|
// cache this ID value then on the EN_SETFOCUS generated when
|
|
// the page is activated, set focus to the control.
|
|
// Gross but it works without too much hassle. [brianau]
|
|
|
|
m_idCtlNextFocus = IDC_EDIT_USER_THRESHOLD;
|
|
dwPSNReturn = PSNRET_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (PSNRET_NOERROR == dwPSNReturn)
|
|
{
|
|
hResult = ApplySettings(hDlg);
|
|
if (FAILED(hResult))
|
|
{
|
|
INT idMsg = IDS_UNKNOWN_ERROR;
|
|
UINT uFlags = MB_OK;
|
|
switch(hResult)
|
|
{
|
|
case E_FAIL:
|
|
idMsg = IDS_WRITE_ERROR;
|
|
uFlags |= MB_ICONERROR;
|
|
break;
|
|
|
|
default:
|
|
switch(HRESULT_CODE(hResult))
|
|
{
|
|
|
|
// case ERROR_USER_EXISTS:
|
|
// idMsg = IDS_NOADD_EXISTING_USER;
|
|
// uFlags |= MB_ICONWARNING;
|
|
// break;
|
|
|
|
// BUGBUG: Still valid? [brianau - 5/27/98]
|
|
|
|
case ERROR_NO_SUCH_USER:
|
|
idMsg = IDS_NOADD_UNKNOWN_USER;
|
|
uFlags |= MB_ICONWARNING;
|
|
break;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
idMsg = IDS_NO_WRITE_ACCESS;
|
|
uFlags |= MB_ICONWARNING;
|
|
break;
|
|
|
|
default:
|
|
uFlags |= MB_ICONERROR;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
DiskQuotaMsgBox(GetDesktopWindow(),
|
|
idMsg,
|
|
IDS_TITLE_DISK_QUOTA,
|
|
uFlags);
|
|
|
|
dwPSNReturn = PSNRET_INVALID;
|
|
}
|
|
else
|
|
{
|
|
m_bIsDirty = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, dwPSNReturn);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnSheetNotifyKillActive
|
|
|
|
Description: Handler for WM_NOTIFY - PSN_KILLACTIVE.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
wParam - ID of control.
|
|
|
|
lParam - Address of NMHDR structure.
|
|
|
|
Returns:
|
|
TRUE = Invalid data entered. Don't kill page.
|
|
FALSE = All data is valid. Ok to kill page.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnSheetNotifyKillActive(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bAllDataIsValid = TRUE;
|
|
|
|
|
|
// No sheet-level validation performed at this time.
|
|
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, !bAllDataIsValid);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnHelp
|
|
|
|
Description: Handler for WM_HELP. Displays context sensitive help.
|
|
|
|
Arguments:
|
|
lParam - Pointer to a HELPINFO structure.
|
|
|
|
Returns: TRUE;
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/17/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnHelp(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, STR_DSKQUOUI_HELPFILE,
|
|
HELP_WM_HELP, (DWORD_PTR)(LPTSTR) rgUserPropSheetHelpIDs);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnContextMenu(
|
|
HWND hwndItem,
|
|
int xPos,
|
|
int yPos
|
|
)
|
|
{
|
|
int idCtl = GetDlgCtrlID(hwndItem);
|
|
WinHelp(hwndItem,
|
|
UseWindowsHelp(idCtl) ? NULL : STR_DSKQUOUI_HELPFILE,
|
|
HELP_CONTEXTMENU,
|
|
(DWORD_PTR)((LPTSTR)rgUserPropSheetHelpIDs));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropPage::OnEditNotifyUpdate
|
|
|
|
Description: Handler for WM_COMMAND, EN_UPDATE.
|
|
Called whenever a character is entered in an edit control.
|
|
|
|
Arguments:
|
|
|
|
Returns: FALSE;
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
09/03/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnEditNotifyUpdate(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
XBytes *pxb = NULL;
|
|
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_EDIT_USER_LIMIT:
|
|
pxb = m_pxbQuotaLimit;
|
|
break;
|
|
|
|
case IDC_EDIT_USER_THRESHOLD:
|
|
pxb = m_pxbQuotaThreshold;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (NULL != pxb)
|
|
pxb->OnEditNotifyUpdate(lParam);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::OnEditNotifyKillFocus
|
|
|
|
Description: Handler for WM_COMMAND, EN_KILLFOCUS.
|
|
Called whenever focus leaves an edit control.
|
|
Validates the value in the edit control and adjusts it if necessary.
|
|
|
|
Arguments:
|
|
|
|
Returns: FALSE;
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/17/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnEditNotifyKillFocus(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
XBytes *pxb = NULL;
|
|
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_EDIT_USER_LIMIT:
|
|
pxb = m_pxbQuotaLimit;
|
|
break;
|
|
|
|
case IDC_EDIT_USER_THRESHOLD:
|
|
pxb = m_pxbQuotaThreshold;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (NULL != pxb)
|
|
pxb->OnEditKillFocus(lParam);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropPage::OnComboNotifySelChange
|
|
|
|
Description: Handler for WM_COMMAND, CBN_SELCHANGE.
|
|
Called whenever the user selects the combo box.
|
|
|
|
Arguments: Std DlgProc args.
|
|
|
|
Returns: FALSE;
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
09/03/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT_PTR
|
|
UserPropSheet::OnComboNotifySelChange(
|
|
HWND hDlg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
XBytes *pxb = NULL;
|
|
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_CMB_USER_LIMIT:
|
|
pxb = m_pxbQuotaLimit;
|
|
break;
|
|
|
|
case IDC_CMB_USER_THRESHOLD:
|
|
pxb = m_pxbQuotaThreshold;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (NULL != pxb)
|
|
pxb->OnComboNotifySelChange(lParam);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::ApplySettings
|
|
|
|
Description: Applies the current settings to the user's quota information
|
|
if they have not changed from the original settings.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
Returns:
|
|
NO_ERROR - Success.
|
|
E_INVALIDARG - One of the settings was invalid.
|
|
ERROR_ACCESS_DENIED (hr) - No WRITE access to quota device.
|
|
E_FAIL - Any other error.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
01/24/98 Added bUndo argument. BrianAu
|
|
*/
|
|
|
|
HRESULT
|
|
UserPropSheet::ApplySettings(
|
|
HWND hDlg,
|
|
bool bUndo // Default == true.
|
|
)
|
|
{
|
|
HRESULT hResult = NO_ERROR;
|
|
BOOL bTranslated = FALSE;
|
|
com_autoptr<DISKQUOTA_USER> ptrUser;
|
|
UINT cUsers = m_LVSelection.Count();
|
|
UINT i = 0;
|
|
LONGLONG llThreshold;
|
|
LONGLONG llLimit;
|
|
CAutoSetRedraw autoredraw(m_hWndParent);
|
|
|
|
if (bUndo)
|
|
m_UndoList.Clear(); // Clear current undo list.
|
|
|
|
|
|
// Determine what threshold and limit to apply.
|
|
|
|
if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RBN_USER_NOLIMIT))
|
|
{
|
|
llThreshold = NOLIMIT;
|
|
llLimit = NOLIMIT;
|
|
}
|
|
else
|
|
{
|
|
llThreshold = m_pxbQuotaThreshold->GetBytes();
|
|
llLimit = m_pxbQuotaLimit->GetBytes();
|
|
}
|
|
|
|
if (cUsers > 1)
|
|
{
|
|
|
|
// Create batch object and do batch update for multiple users.
|
|
|
|
com_autoptr<DISKQUOTA_USER_BATCH> ptrBatch;
|
|
|
|
hResult = m_pQuotaControl->CreateUserBatch(ptrBatch.getaddr());
|
|
if (SUCCEEDED(hResult))
|
|
{
|
|
for (i = 0; i < cUsers; i++)
|
|
{
|
|
m_LVSelection.Retrieve(i, ptrUser.getaddr());
|
|
if (bUndo)
|
|
{
|
|
|
|
// Add an entry to the undo list.
|
|
|
|
LONGLONG LimitUndo;
|
|
LONGLONG ThresholdUndo;
|
|
ptrUser->GetQuotaThreshold(&ThresholdUndo);
|
|
ptrUser->GetQuotaLimit(&LimitUndo);
|
|
|
|
// Use a local autoptr to ensure proper release of
|
|
// iface in case adding to the undo list throws an exception.
|
|
// On success, disown the real ptr so that the object
|
|
// stays with the undo list.
|
|
|
|
com_autoptr<DISKQUOTA_USER> ptrQuotaUser(ptrUser);
|
|
ptrUser->AddRef();
|
|
m_UndoList.Add(new UndoModify(ptrUser, ThresholdUndo, LimitUndo));
|
|
ptrQuotaUser.disown();
|
|
}
|
|
|
|
ptrUser->SetQuotaThreshold(llThreshold, FALSE);
|
|
|
|
if (UserIsAdministrator(ptrUser) && NOLIMIT != llLimit)
|
|
{
|
|
|
|
// User is the Administrator account AND
|
|
// We're trying to set the limit to something other than NOLIMIT.
|
|
// Can't set a limit on the administrator account.
|
|
|
|
DiskQuotaMsgBox(GetDesktopWindow(),
|
|
IDS_CANT_SET_ADMIN_LIMIT,
|
|
IDS_TITLE_DISK_QUOTA,
|
|
MB_ICONWARNING | MB_OK);
|
|
}
|
|
else
|
|
{
|
|
|
|
// OK to set quota limit.
|
|
|
|
ptrUser->SetQuotaLimit(llLimit, FALSE);
|
|
}
|
|
|
|
ptrBatch->Add(ptrUser);
|
|
}
|
|
|
|
hResult = ptrBatch->FlushToDisk();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// Do single user update or add new user.
|
|
|
|
m_LVSelection.Retrieve(0, ptrUser.getaddr());
|
|
DBGASSERT((NULL != ptrUser.get()));
|
|
|
|
if (bUndo)
|
|
{
|
|
|
|
// Add an entry to the undo list.
|
|
|
|
LONGLONG LimitUndo;
|
|
LONGLONG ThresholdUndo;
|
|
ptrUser->GetQuotaThreshold(&ThresholdUndo);
|
|
ptrUser->GetQuotaLimit(&LimitUndo);
|
|
|
|
// Use local autoptr to ensure proper release of iface ptr if
|
|
// an exception is thrown. Disown real ptr on success.
|
|
|
|
com_autoptr<DISKQUOTA_USER> ptrQuotaUser(ptrUser);
|
|
ptrUser->AddRef();
|
|
m_UndoList.Add(new UndoModify(ptrUser, ThresholdUndo, LimitUndo));
|
|
ptrQuotaUser.disown();
|
|
}
|
|
|
|
if (llThreshold != m_llQuotaThreshold)
|
|
{
|
|
hResult = ptrUser->SetQuotaThreshold(llThreshold, TRUE);
|
|
|
|
if (FAILED(hResult))
|
|
goto apply_failed;
|
|
|
|
m_llQuotaThreshold = llThreshold;
|
|
}
|
|
|
|
if (llLimit != m_llQuotaLimit)
|
|
{
|
|
hResult = ptrUser->SetQuotaLimit(llLimit, TRUE);
|
|
if (FAILED(hResult))
|
|
goto apply_failed;
|
|
|
|
m_llQuotaLimit = llLimit;
|
|
}
|
|
|
|
|
|
// Update the user's status icon and %used to reflect the new settings.
|
|
|
|
UpdateUserStatusIcon(hDlg,
|
|
m_llQuotaUsed,
|
|
m_llQuotaThreshold,
|
|
m_llQuotaLimit);
|
|
|
|
UpdateSpaceUsed(hDlg,
|
|
m_llQuotaUsed,
|
|
m_llQuotaLimit,
|
|
1);
|
|
}
|
|
|
|
|
|
// Update the listview item(s) so the user sees a visual response to
|
|
// pressing the "Apply" button.
|
|
|
|
autoredraw.Set(false);
|
|
for (i = 0; i < cUsers; i++)
|
|
{
|
|
INT iItem = 0;
|
|
m_LVSelection.Retrieve(i, &iItem);
|
|
ListView_Update(m_hWndParent, iItem);
|
|
}
|
|
autoredraw.Set(true);
|
|
InvalidateRect(m_hWndParent, NULL, FALSE);
|
|
|
|
apply_failed:
|
|
|
|
return hResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::InitializeControls
|
|
|
|
Description: Initializes the page controls based on the user's
|
|
quota settings.
|
|
|
|
Arguments:
|
|
hDlg - Dialog window handle.
|
|
|
|
Returns:
|
|
NO_ERROR - Always returns NO_ERROR.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
HRESULT
|
|
UserPropSheet::InitializeControls(
|
|
HWND hDlg
|
|
)
|
|
{
|
|
PDISKQUOTA_USER pUser = NULL;
|
|
UINT cUsers = m_LVSelection.Count();
|
|
|
|
if (1 == cUsers)
|
|
{
|
|
|
|
// Initialize controls for a single user.
|
|
|
|
m_LVSelection.Retrieve(0, &pUser);
|
|
|
|
|
|
// Configure the Limit/NoLimit radio buttons.
|
|
// Must examine the current threshold rather than the limit because of the
|
|
// special-case for the Administrator account. That account can have a
|
|
// threshold value but quota limit must always be "No Limit".
|
|
|
|
CheckDlgButton(hDlg, IDC_RBN_USER_LIMIT, NOLIMIT != m_llQuotaThreshold);
|
|
CheckDlgButton(hDlg, IDC_RBN_USER_NOLIMIT, NOLIMIT == m_llQuotaThreshold);
|
|
if (UserIsAdministrator(pUser))
|
|
{
|
|
|
|
// Override initialization of Quota Limit control with "No Limit".
|
|
|
|
m_pxbQuotaLimit->SetBytes(NOLIMIT);
|
|
}
|
|
|
|
|
|
// Note that the XBytes controls have already been set for single-user.
|
|
// See OnInitDialog().
|
|
|
|
|
|
|
|
// Configure the remaining dialog controls.
|
|
|
|
UpdateUserName(hDlg, pUser);
|
|
UpdateSpaceUsed(hDlg, m_llQuotaUsed, m_llQuotaLimit, cUsers);
|
|
UpdateUserStatusIcon(hDlg,
|
|
m_llQuotaUsed,
|
|
m_llQuotaThreshold,
|
|
m_llQuotaLimit);
|
|
}
|
|
else
|
|
{
|
|
|
|
// Initialize controls for multiple users.
|
|
|
|
LONGLONG llLimit = 0;
|
|
LONGLONG llLastLimit = 0;
|
|
LONGLONG llThreshold = 0;
|
|
LONGLONG llLastThreshold = 0;
|
|
LONGLONG llUsed = 0;
|
|
LONGLONG llTotalUsed = 0;
|
|
|
|
|
|
// Add up the total usage by all users.
|
|
|
|
for (UINT i = 0; i < cUsers; i++)
|
|
{
|
|
m_LVSelection.Retrieve(i, &pUser);
|
|
pUser->GetQuotaLimit(&llLimit);
|
|
pUser->GetQuotaThreshold(&llThreshold);
|
|
pUser->GetQuotaUsed(&llUsed);
|
|
|
|
llTotalUsed += llUsed;
|
|
if (m_bHomogeneousSelection)
|
|
{
|
|
|
|
// Determine if at least one user has a different
|
|
// threshold or limit. If all are the same, we can display
|
|
// the values in the edit controls. Otherwise, we default
|
|
// to "No Limit". Radio buttons don't provide an
|
|
// indeterminate state like checkboxes.
|
|
|
|
if (i > 0 &&
|
|
(llLimit != llLastLimit ||
|
|
llThreshold != llLastThreshold))
|
|
{
|
|
m_bHomogeneousSelection = FALSE;
|
|
}
|
|
else
|
|
{
|
|
llLastLimit = llLimit;
|
|
llLastThreshold = llThreshold;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// If all selected objects have the same limit and threshold,
|
|
// set the cached data to represent multiple-selection.
|
|
// If any one is different, we stick with the volume's default
|
|
// values set in RefreshCachedQuotaInfo().
|
|
|
|
if (m_bHomogeneousSelection)
|
|
{
|
|
m_llQuotaThreshold = llLastThreshold;
|
|
m_llQuotaLimit = llLastLimit;
|
|
}
|
|
else
|
|
{
|
|
|
|
// Since not all selected users have the same limit/thresold,
|
|
// the number we're displaying will be a change for at least
|
|
// one user. Activate the "Apply" button.
|
|
|
|
|
|
PostMessage(hDlg, DQM_ENABLE_APPLY_BUTTON, 0, 0);
|
|
}
|
|
|
|
m_pxbQuotaThreshold->SetBytes(m_llQuotaThreshold);
|
|
m_pxbQuotaLimit->SetBytes(m_llQuotaLimit);
|
|
|
|
|
|
// Configure the Limit/NoLimit radio buttons.
|
|
|
|
CheckDlgButton(hDlg,
|
|
IDC_RBN_USER_NOLIMIT,
|
|
NOLIMIT == m_llQuotaThreshold);
|
|
CheckDlgButton(hDlg,
|
|
IDC_RBN_USER_LIMIT,
|
|
NOLIMIT != m_llQuotaThreshold);
|
|
|
|
UpdateUserName(hDlg, cUsers);
|
|
UpdateSpaceUsed(hDlg, llTotalUsed, NOLIMIT, cUsers);
|
|
|
|
// Don't display any user status icon for multi-users.
|
|
|
|
}
|
|
|
|
|
|
|
|
// If "No Limit" radio button is checked, set limit and threshold controls
|
|
// to the "No Limit" state (disabled and displaying "No Limit" text).
|
|
// This may override any setting we made above.
|
|
|
|
if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RBN_USER_NOLIMIT))
|
|
{
|
|
m_pxbQuotaThreshold->SetBytes(NOLIMIT);
|
|
m_pxbQuotaLimit->SetBytes(NOLIMIT);
|
|
}
|
|
|
|
|
|
// Set user icon.
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_ICON_USER),
|
|
STM_SETICON,
|
|
(WPARAM)m_hIconUser[1 == cUsers ? iICON_USER_SINGLE :
|
|
iICON_USER_MULTIPLE],
|
|
0);
|
|
|
|
|
|
// Force the property sheet to disable the "Apply" button.
|
|
// The way I have set up the "Apply" enabling logic through OnCommand(),
|
|
// merely initializing the edit controls on the page causes the Apply
|
|
// button to become enabled. Since the user hasn't changed anything
|
|
// yet, it should be disabled.
|
|
|
|
m_bIsDirty = FALSE;
|
|
PropSheet_UnChanged(GetParent(hDlg), hDlg);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::QueryUserStatusIcon
|
|
|
|
|
|
Description: This function is provided for automated testing of the UI.
|
|
It is used by test scripts to determine which user status icon is
|
|
currently displayed.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
|
|
Returns: -1 = No icon displayed.
|
|
0 = "Everything OK" icon.
|
|
1 = Threshold exceded icon.
|
|
2 = Limit exceded icon.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT
|
|
UserPropSheet::QueryUserStatusIcon(
|
|
HWND hDlg
|
|
) const
|
|
{
|
|
HICON hicon = (HICON)SendMessage(GetDlgItem(hDlg, IDC_ICON_USERSTATUS),
|
|
STM_GETICON,
|
|
0, 0);
|
|
|
|
for (UINT i = 0; i < cSTATUS_ICONS; i++)
|
|
{
|
|
if (hicon == m_hIconStatus[i])
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::QueryUserIcon
|
|
|
|
|
|
Description: This function is provided for automated testing of the UI.
|
|
It is used by test scripts to determine which user status icon is
|
|
currently displayed.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
|
|
Returns: -1 = No icon displayed.
|
|
0 = Single-user icon.
|
|
1 = Multi-user icon.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
INT
|
|
UserPropSheet::QueryUserIcon(
|
|
HWND hDlg
|
|
) const
|
|
{
|
|
HICON hicon = (HICON)SendMessage(GetDlgItem(hDlg, IDC_ICON_USER),
|
|
STM_GETICON,
|
|
0, 0);
|
|
|
|
for (UINT i = 0; i < cUSER_ICONS; i++)
|
|
{
|
|
if (hicon == m_hIconUser[i])
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::UpdateUserStatusIcon
|
|
|
|
Description: Updates the quota status icon in the dialog box. This icon
|
|
must match the icon displayed in the listview for the selected user.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
iUsed - Quota bytes charged to user.
|
|
|
|
iThreshold - Quota warning threshold (bytes).
|
|
|
|
iLimit - User's quota limit.
|
|
|
|
Returns: Nothing.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
VOID
|
|
UserPropSheet::UpdateUserStatusIcon(
|
|
HWND hDlg,
|
|
LONGLONG iUsed,
|
|
LONGLONG iThreshold,
|
|
LONGLONG iLimit
|
|
)
|
|
{
|
|
|
|
// Set the user status icon if user is exceding the
|
|
// quota threshold or the limit. This is the same icon that is
|
|
// displayed in the listview status column. This logic must
|
|
// mirror that used in DetailsView::GetDispInfo_Image().
|
|
|
|
INT iIcon = iICON_STATUS_OK;
|
|
if (NOLIMIT != iLimit && iUsed > iLimit)
|
|
{
|
|
iIcon = iICON_STATUS_OVER_LIMIT;
|
|
}
|
|
else if (NOLIMIT != iThreshold && iUsed > iThreshold)
|
|
{
|
|
iIcon = iICON_STATUS_OVER_THRESHOLD;
|
|
}
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_ICON_USERSTATUS),
|
|
STM_SETICON,
|
|
(WPARAM)m_hIconStatus[iIcon],
|
|
0);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::UpdateUserName
|
|
|
|
Description: Updates the Domain\Name text with the user's domain name
|
|
and account name strings. This method is called for a single-user
|
|
selection.
|
|
|
|
Also sets the property sheet title text.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
pUser - Address of user's IDiskQuotaUser interface.
|
|
|
|
Returns: Nothing.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
08/05/97 Added code to set prop sheet title text. BrianAu
|
|
*/
|
|
|
|
VOID
|
|
UserPropSheet::UpdateUserName(
|
|
HWND hDlg,
|
|
PDISKQUOTA_USER pUser
|
|
)
|
|
{
|
|
DBGASSERT((NULL != pUser));
|
|
|
|
// Display the user name, or some status text
|
|
// if the name hasn't been resolved.
|
|
|
|
CString strLogonName;
|
|
DWORD dwAccountStatus = 0;
|
|
|
|
pUser->GetAccountStatus(&dwAccountStatus);
|
|
|
|
if (DISKQUOTA_USER_ACCOUNT_RESOLVED == dwAccountStatus)
|
|
{
|
|
|
|
// User account name has been resolved. Display it.
|
|
|
|
TCHAR szLogonName[MAX_USERNAME];
|
|
TCHAR szDisplayName[MAX_FULL_USERNAME];
|
|
|
|
pUser->GetName(NULL, 0,
|
|
szLogonName, ARRAYSIZE(szLogonName),
|
|
szDisplayName, ARRAYSIZE(szDisplayName));
|
|
|
|
if (TEXT('\0') != szLogonName[0])
|
|
{
|
|
if (TEXT('\0') != szDisplayName[0])
|
|
{
|
|
strLogonName.Format(g_hInstDll,
|
|
IDS_FMT_DISPLAY_LOGON,
|
|
szDisplayName,
|
|
szLogonName);
|
|
}
|
|
else
|
|
{
|
|
strLogonName = szLogonName;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// User account name has not been resolved or cannot
|
|
// be resolved for some reason. Display appropriate
|
|
// status text. This is the same text displayed in the
|
|
// listview when the user's name has not been resolved.
|
|
|
|
INT idText = IDS_USER_ACCOUNT_UNKNOWN;
|
|
|
|
switch(dwAccountStatus)
|
|
{
|
|
case DISKQUOTA_USER_ACCOUNT_UNAVAILABLE:
|
|
idText = IDS_USER_ACCOUNT_UNAVAILABLE;
|
|
break;
|
|
|
|
case DISKQUOTA_USER_ACCOUNT_DELETED:
|
|
idText = IDS_USER_ACCOUNT_DELETED;
|
|
break;
|
|
|
|
case DISKQUOTA_USER_ACCOUNT_INVALID:
|
|
idText = IDS_USER_ACCOUNT_INVALID;
|
|
break;
|
|
|
|
case DISKQUOTA_USER_ACCOUNT_UNRESOLVED:
|
|
idText = IDS_USER_ACCOUNT_UNRESOLVED;
|
|
break;
|
|
|
|
case DISKQUOTA_USER_ACCOUNT_UNKNOWN:
|
|
default:
|
|
break;
|
|
}
|
|
strLogonName.Format(g_hInstDll, idText);
|
|
}
|
|
SetDlgItemText(hDlg, IDC_TXT_USERNAME, strLogonName);
|
|
|
|
|
|
// Format and draw the prop sheet title string.
|
|
|
|
CString strSheetTitle(g_hInstDll,
|
|
IDS_TITLE_EDIT_USER,
|
|
(LPCTSTR)strLogonName);
|
|
|
|
PropSheet_SetTitle(GetParent(hDlg), 0, (LPCTSTR)strSheetTitle);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::UpdateUserName
|
|
|
|
Description: Replaces the user Domain\Name text with a message showing
|
|
how many users are selected. This is used for multi-user selections
|
|
where no single user name is applicable.
|
|
|
|
Also sets the property sheet title text.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
cUsers - Number of users represented in the property dialog.
|
|
|
|
Returns: Nothing.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
08/05/97 Added code to set prop sheet title text. BrianAu
|
|
*/
|
|
|
|
VOID
|
|
UserPropSheet::UpdateUserName(
|
|
HWND hDlg,
|
|
INT cUsers
|
|
)
|
|
{
|
|
|
|
// Hide name edit control. Can't display names for all users.
|
|
// Display "Multiple Quota Users." instead.
|
|
|
|
CString strText(g_hInstDll, IDS_TITLE_MULTIUSER, cUsers);
|
|
SetDlgItemText(hDlg, IDC_TXT_USERNAME, strText);
|
|
|
|
|
|
// Set the title of the property sheet.
|
|
|
|
CString strSheetTitle(g_hInstDll, IDS_TITLE_EDIT_MULTIUSER);
|
|
PropSheet_SetTitle(GetParent(hDlg), 0, (LPCTSTR)strSheetTitle);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function: UserPropSheet::UpdateSpaceUsed
|
|
|
|
Description: Updates the "space used" and "remaining" fields on the user
|
|
property sheet.
|
|
|
|
Arguments:
|
|
hDlg - Dialog handle.
|
|
|
|
iUsed - Quota bytes charged to user(s).
|
|
|
|
iLimit - User's quota limit.
|
|
|
|
cUsers - Number of users represented in the property dialog.
|
|
|
|
Returns: Nothing.
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- ----------- ----------
|
|
08/15/96 Initial creation. BrianAu
|
|
*/
|
|
|
|
VOID
|
|
UserPropSheet::UpdateSpaceUsed(
|
|
HWND hDlg,
|
|
LONGLONG iUsed,
|
|
LONGLONG iLimit,
|
|
INT cUsers
|
|
)
|
|
{
|
|
TCHAR szText[80];
|
|
|
|
|
|
// Display - Used: 999XB (99%)
|
|
|
|
XBytes::FormatByteCountForDisplay(iUsed,
|
|
szText, ARRAYSIZE(szText));
|
|
CString strText(szText);
|
|
if (1 == cUsers)
|
|
{
|
|
|
|
// Only single-user page gets (99%) appended.
|
|
// Pct quota is meaningless for multiple users.
|
|
|
|
if (0 != iLimit && NOLIMIT != iLimit)
|
|
{
|
|
UINT iPct = (INT)((iUsed * 100) / iLimit);
|
|
|
|
strText.Format(g_hInstDll,
|
|
IDS_QUOTA_USED_SINGLEUSER,
|
|
szText,
|
|
iPct);
|
|
}
|
|
}
|
|
|
|
SetDlgItemText(hDlg,
|
|
IDC_TXT_SPACEUSED,
|
|
strText);
|
|
|
|
|
|
|
|
// Display - Remaining: 999XB
|
|
|
|
strText = szText;
|
|
if (NOLIMIT != iLimit)
|
|
{
|
|
LONGLONG iAmount = 0;
|
|
|
|
if (iUsed <= iLimit)
|
|
iAmount = iLimit - iUsed;
|
|
|
|
XBytes::FormatByteCountForDisplay(iAmount,
|
|
strText.GetBuffer(80), 80);
|
|
strText.ReleaseBuffer();
|
|
}
|
|
else
|
|
{
|
|
|
|
// Display "N/A" if limit is NOLIMIT.
|
|
|
|
strText.Format(g_hInstDll, IDS_NOT_APPLICABLE);
|
|
}
|
|
|
|
SetDlgItemText(hDlg,
|
|
IDC_TXT_SPACEREMAINING,
|
|
strText);
|
|
}
|
|
|
|
|