able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/wins/srvlatpp.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2077 lines
53 KiB
C++
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
srvlatpp.cpp
Brings up the property page for the server node
FILE HISTORY:
*/
#include "stdafx.h"
#include "winssnap.h"
#include "shlobj.h"
#include "srvlatpp.h"
#include "server.h"
#include "service.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define MAX_HOURS 23
#define MAX_MINUTES 59
#define MAX_SECONDS 59
/////////////////////////////////////////////////////////////////////////////
// CServerPropGeneral property page
IMPLEMENT_DYNCREATE(CServerPropGeneral, CPropertyPageBase)
CServerPropGeneral::CServerPropGeneral() : CPropertyPageBase(CServerPropGeneral::IDD)
{
//{{AFX_DATA_INIT(CServerPropGeneral)
m_fBackupDB = FALSE;
m_fEnableAutoRefresh = FALSE;
m_strBackupPath = _T("");
m_nRefreshHours = 0;
m_nRefreshMinutes = 0;
m_nRefreshSeconds = 0;
//}}AFX_DATA_INIT
m_fUpdateConfig = FALSE;
}
CServerPropGeneral::~CServerPropGeneral()
{
}
void
CServerPropGeneral::DoDataExchange(CDataExchange* pDX)
{
CPropertyPageBase::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CServerPropGeneral)
DDX_Control(pDX, IDC_EDIT_REFRESH_MINUTES2, m_editRefreshMn);
DDX_Control(pDX, IDC_EDIT_REFRESH_HOURS2, m_editRefreshHr);
DDX_Control(pDX, IDC_EDIT_REFRESH_SECONDS2, m_editRefreshSc);
DDX_Control(pDX, IDC_SPIN_REFRESH_SECONDS2, m_spinRefreshSc);
DDX_Control(pDX, IDC_SPIN_REFRESH_MINUTES2, m_spinRefreshmn);
DDX_Control(pDX, IDC_SPIN_REFRESH_HOURS2, m_spinRefreshHr);
DDX_Control(pDX, IDC_EDIT_BACKUPPATH, m_editBackupPath);
DDX_Control(pDX, IDC_CHECK_BACKUPDB, m_check_BackupOnTermination);
DDX_Control(pDX, IDC_CHECK_ENABLE_AUTOREFRESH, m_check_EnableAutoRefresh);
DDX_Control(pDX, IDC_BUTTON_BROWSE, m_button_Browse);
DDX_Check(pDX, IDC_CHECK_BACKUPDB, m_fBackupDB);
DDX_Check(pDX, IDC_CHECK_ENABLE_AUTOREFRESH, m_fEnableAutoRefresh);
DDX_Text(pDX, IDC_EDIT_BACKUPPATH, m_strBackupPath);
DDX_Text(pDX, IDC_EDIT_REFRESH_HOURS2, m_nRefreshHours);
DDV_MinMaxInt(pDX, m_nRefreshHours, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_REFRESH_MINUTES2, m_nRefreshMinutes);
DDV_MinMaxInt(pDX, m_nRefreshMinutes, 0, MAX_MINUTES);
DDX_Text(pDX, IDC_EDIT_REFRESH_SECONDS2, m_nRefreshSeconds);
DDV_MinMaxInt(pDX, m_nRefreshSeconds, 0, MAX_SECONDS);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CServerPropGeneral, CPropertyPageBase)
//{{AFX_MSG_MAP(CServerPropGeneral)
ON_BN_CLICKED(IDC_BUTTON_BROWSE, OnButtonBrowse)
ON_BN_CLICKED(IDC_CHECK_ENABLE_AUTOREFRESH, OnCheckEnableAutorefresh)
ON_EN_CHANGE(IDC_EDIT_BACKUPPATH, OnChangeEditBackuppath)
ON_EN_CHANGE(IDC_EDIT_REFRESH_HOURS2, OnChangeRefresh)
ON_EN_CHANGE(IDC_EDIT_REFRESH_MINUTES2, OnChangeRefresh)
ON_EN_CHANGE(IDC_EDIT_REFRESH_SECONDS2, OnChangeRefresh)
ON_BN_CLICKED(IDC_CHECK_BACKUPDB, OnChangeCheckBackupdb)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CServerPropGeneral message handlers
BOOL
CServerPropGeneral::OnApply()
{
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return FALSE;
}
else
{
m_fUpdateConfig = FALSE;
return CPropertyPageBase::OnApply();
}
}
void
CServerPropGeneral::OnOK()
{
HRESULT hr = UpdateServerConfiguration();
if (SUCCEEDED(hr))
{
CPropertyPageBase::OnOK();
}
}
BOOL
CServerPropGeneral::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
GetConfig();
m_fBackupDB = m_pConfig->m_fBackupOnTermination;
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
SetRefreshData();
if (pServer->m_dwFlags & FLAG_AUTO_REFRESH)
{
m_fEnableAutoRefresh = TRUE;
m_check_EnableAutoRefresh.SetCheck(1);
}
else
{
m_fEnableAutoRefresh = FALSE;
m_check_EnableAutoRefresh.SetCheck(0);
// diable the controls
m_spinRefreshHr.EnableWindow(FALSE);
m_spinRefreshmn.EnableWindow(FALSE);
m_spinRefreshSc.EnableWindow(FALSE);
m_editRefreshHr.EnableWindow(FALSE);
m_editRefreshMn.EnableWindow(FALSE);
m_editRefreshSc.EnableWindow(FALSE);
}
m_spinRefreshHr.SetRange(0, 23);
m_spinRefreshmn.SetRange(0, 59);
m_spinRefreshSc.SetRange(0, 59);
// browse only available on local machine
m_button_Browse.EnableWindow(IsLocalConnection());
m_check_BackupOnTermination.SetCheck(m_pConfig->m_fBackupOnTermination);
m_editBackupPath.SetWindowText(m_pConfig->m_strBackupPath);
// load the correct icon
for (int i = 0; i < ICON_IDX_MAX; i++)
{
if (g_uIconMap[i][1] == m_uImage)
{
HICON hIcon = LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(g_uIconMap[i][0]));
if (hIcon)
((CStatic *) GetDlgItem(IDC_STATIC_ICON))->SetIcon(hIcon);
break;
}
}
m_fUpdateConfig = FALSE;
SetDirty(FALSE);
return TRUE;
}
void CServerPropGeneral::OnChangeEditBackuppath()
{
m_fUpdateConfig = TRUE;
SetDirty(TRUE);
}
void CServerPropGeneral::OnChangeRefresh()
{
SetDirty(TRUE);
}
void CServerPropGeneral::OnChangeCheckBackupdb()
{
m_fUpdateConfig = TRUE;
SetDirty(TRUE);
}
/*---------------------------------------------------------------------------
CServerPropGeneral::IsLocalConnection()
Checks if the local machine is being monitored
---------------------------------------------------------------------------*/
BOOL
CServerPropGeneral::IsLocalConnection()
{
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
return pServer->IsLocalConnection();
}
void
CServerPropGeneral::OnButtonBrowse()
{
TCHAR szBuffer[MAX_PATH];
LPITEMIDLIST pidlPrograms = NULL; //CSIDL_DRIVES
SHGetSpecialFolderLocation(m_hWnd, CSIDL_DRIVES, &pidlPrograms);
BROWSEINFO browseInfo;
browseInfo.hwndOwner = m_hWnd;
browseInfo.pidlRoot = pidlPrograms;
browseInfo.pszDisplayName = szBuffer;
CString strSel;
strSel.LoadString(IDS_SELECT_FOLDER);
browseInfo.lpszTitle = strSel;
browseInfo.ulFlags = BIF_NEWDIALOGSTYLE | BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS ;
browseInfo.lpfn = NULL;
browseInfo.lParam = 0;
LPITEMIDLIST pidlBrowse = SHBrowseForFolder(&browseInfo);
if (pidlBrowse)
{
SHGetPathFromIDList(pidlBrowse, szBuffer);
CString strBackupPath(szBuffer);
// check if it's a network drive, if yes, don't allow.
/* int nPos = strBackupPath.Find(_T("\\"));
if (nPos != -1)
{
CString strDrive = strBackupPath.Left(nPos);
UINT uType = GetDriveType(strDrive);
if(uType == DRIVE_REMOTE)
{
// tell the user that the files ccanot be backed up the location chosen
CString strBackup;
AfxFormatString1(strBackup, IDS_BACKUP_LOCATION, strBackupPath);
AfxMessageBox(strBackup, MB_OK | MB_ICONINFORMATION);
return;
}
}
*/
if (!strBackupPath.IsEmpty())
m_editBackupPath.SetWindowText(strBackupPath);
}
}
/*---------------------------------------------------------------------------
CServerPropGeneral::UpdateServerConfiguration()
Updates the variables in the Server Handler
---------------------------------------------------------------------------*/
HRESULT
CServerPropGeneral::UpdateServerConfiguration()
{
UpdateData();
// Reflect the changes in the server's CConfiguration object
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
// update config displays any necessary error dialogs
if (!UpdateConfig())
return E_FAIL;
DWORD err = ERROR_SUCCESS;
// now write to server
if (m_fUpdateConfig)
{
err = m_pConfig->Store();
if (err != ERROR_SUCCESS)
{
// something bad happened
WinsMessageBox(err);
}
else
{
// success update our local copy
pServer->SetConfig(*m_pConfig);
}
}
return HRESULT_FROM_WIN32(err);
}
/*---------------------------------------------------------------------------
CServerPropGeneral::UpdateConfig()
Updates the Config object in the server handler
---------------------------------------------------------------------------*/
BOOL
CServerPropGeneral::UpdateConfig()
{
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
CString strTemp;
m_editBackupPath.GetWindowText(strTemp);
// backup path needs to be non-null when backup on termination is set
if (m_fBackupDB && strTemp.IsEmpty())
{
AfxMessageBox(IDS_SPECIFY_DEFAULT_BACKUP_PATH);
return FALSE;
}
if (m_fUpdateConfig)
{
m_pConfig->m_strBackupPath = strTemp;
m_pConfig->m_fBackupOnTermination = m_fBackupDB;
}
pServer->m_dwRefreshInterval = CalculateRefrInt();
if (m_fEnableAutoRefresh)
{
pServer->m_dwFlags |= FLAG_AUTO_REFRESH;
}
else
{
pServer->m_dwFlags &= ~FLAG_AUTO_REFRESH;
}
// since these settins are stored in the console file, mark it as dirty
SPITFSNode spRootNode;
spNode->GetParent(&spRootNode);
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
return TRUE;
}
/*---------------------------------------------------------------------------
CServerPropGeneral::CalculateRefrInt()
Rteurns the refresh interval in seconds
---------------------------------------------------------------------------*/
int
CServerPropGeneral::CalculateRefrInt()
{
UpdateData();
CString strValue;
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
int nHour = m_spinRefreshHr.GetPos();
int nMinute = m_spinRefreshmn.GetPos();
int nSecond = m_spinRefreshSc.GetPos();
int nRenewInterval = nHour * SEC_PER_HOUR +
nMinute * SEC_PER_MINUTE +
nSecond;
pServer->m_dwRefreshInterval = nRenewInterval;
pServer->m_dlgStats.ReInitRefresherThread();
return nRenewInterval;
}
/*---------------------------------------------------------------------------
CServerPropGeneral::ToString(int nNumber)
Returns string value of an integer
---------------------------------------------------------------------------*/
CString
CServerPropGeneral::ToString(int nNumber)
{
TCHAR szStr[20];
_itot(nNumber, szStr, 10);
CString str(szStr);
return str;
}
/*---------------------------------------------------------------------------
CServerPropGeneral::SetRefreshData()
Sets the variables' dtata for the refresh group.
---------------------------------------------------------------------------*/
void
CServerPropGeneral::SetRefreshData()
{
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
DWORD dwInterval = pServer->m_dwRefreshInterval;
m_spinRefreshmn.SetRange(0, MAX_MINUTES);
m_spinRefreshSc.SetRange(0, MAX_SECONDS);
m_spinRefreshHr.SetRange(0, UD_MAXVAL);
int nHours, nMinutes, nSeconds;
nHours = dwInterval / SEC_PER_HOUR;
dwInterval -= nHours * SEC_PER_HOUR;
nMinutes = dwInterval / SEC_PER_MINUTE;
dwInterval -= nMinutes * SEC_PER_MINUTE;
nSeconds = dwInterval ;
// convert them to strings
CString strHr = ToString(nHours);
CString strMn = ToString(nMinutes);
CString strSc = ToString(nSeconds);
m_spinRefreshHr.SetPos(nHours);
m_spinRefreshmn.SetPos(nMinutes);
m_spinRefreshSc.SetPos(nSeconds);
}
/*---------------------------------------------------------------------------
CServerPropGeneral::GetConfig()
Gets the Configuration object from the server
---------------------------------------------------------------------------*/
HRESULT
CServerPropGeneral::GetConfig()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
return hr;
}
void CServerPropGeneral::OnCheckEnableAutorefresh()
{
SetDirty(TRUE);
UpdateData();
if (m_check_EnableAutoRefresh.GetCheck() == 1)
{
m_fEnableAutoRefresh = TRUE;
m_spinRefreshHr.EnableWindow(TRUE);
m_spinRefreshmn.EnableWindow(TRUE);
m_spinRefreshSc.EnableWindow(TRUE);
m_editRefreshHr.EnableWindow(TRUE);
m_editRefreshMn.EnableWindow(TRUE);
m_editRefreshSc.EnableWindow(TRUE);
}
else
{
m_fEnableAutoRefresh = FALSE;
m_spinRefreshHr.EnableWindow(FALSE);
m_spinRefreshmn.EnableWindow(FALSE);
m_spinRefreshSc.EnableWindow(FALSE);
m_editRefreshHr.EnableWindow(FALSE);
m_editRefreshMn.EnableWindow(FALSE);
m_editRefreshSc.EnableWindow(FALSE);
}
// mark the snap-in as dirty, so as to prompt the user
// mark the snap-in as dirty
SPITFSNode spNode ;
spNode = GetHolder()->GetNode();
SPITFSNodeMgr spNodeManager;
SPITFSNode spRootNode;
spNode->GetNodeMgr(&spNodeManager);
spNodeManager->GetRootNode(&spRootNode);
// mark the data as dirty so that we'll ask the user to save.
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
}
/////////////////////////////////////////////////////////////////////////////
// CServerPropDBRecord property page
IMPLEMENT_DYNCREATE(CServerPropDBRecord, CPropertyPageBase)
CServerPropDBRecord::CServerPropDBRecord() : CPropertyPageBase(CServerPropDBRecord::IDD)
{
//{{AFX_DATA_INIT(CServerPropDBRecord)
m_nExtintDay = 0;
m_nExtIntHour = 0;
m_nExtIntMinute = 0;
m_nExtTmDay = 0;
m_nExtTmHour = 0;
m_nExtTmMinute = 0;
m_nRenewDay = 0;
m_nrenewMinute = 0;
m_nRenewMinute = 0;
m_nVerifyDay = 0;
m_nVerifyHour = 0;
m_nVerifyMinute = 0;
//}}AFX_DATA_INIT
}
CServerPropDBRecord::~CServerPropDBRecord()
{
}
void CServerPropDBRecord::DoDataExchange(CDataExchange* pDX)
{
CPropertyPageBase::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CServerPropDBRecord)
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_MINUTE, m_editExtIntMinute);
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_MINUTE, m_spinVerifyMinute);
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_HOUR, m_spinVerifyHour);
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_DAY, m_spinVerifyDay);
DDX_Control(pDX, IDC_SPIN_RENEW_INT_MINUTE, m_spinRefrIntMinute);
DDX_Control(pDX, IDC_SPIN_RENEW_INT_HOUR, m_spinRefrIntHour);
DDX_Control(pDX, IDC_SPIN_RENEW_INT_DAY, m_spinRefrIntDay);
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_MINUTE, m_spinExtTmMinute);
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_HOUR, m_spinExtTmHour);
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_DAY, m_spinExtTmDay);
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_MINUTE, m_spinExtIntMinute);
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_HOUR, m_spinExtIntHour);
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_DAY, m_spinExtIntDay);
DDX_Control(pDX, IDC_EDIT_VERIFY_MINUTE, m_editVerifyMinute);
DDX_Control(pDX, IDC_EDIT_VERIFY_HOUR, m_editVerifyHour);
DDX_Control(pDX, IDC_EDIT_VERIFY_DAY, m_editVerifyDay);
DDX_Control(pDX, IDC_EDIT_RENEW_MINUTE, m_editRefrIntMinute);
DDX_Control(pDX, IDC_EDIT_RENEW_HOUR, m_editRefrIntHour);
DDX_Control(pDX, IDC_EDIT_RENEW_DAY, m_editRefrIntDay);
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_HOUR, m_editExtTmHour);
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, m_editExtTmMinute);
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_DAY, m_editExtTmDay);
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_HOUR, m_editExtIntHour);
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_DAY, m_editExtIntDay);
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_DAY, m_nExtintDay);
DDV_MinMaxInt(pDX, m_nExtintDay, 0, 365);
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_HOUR, m_nExtIntHour);
DDV_MinMaxInt(pDX, m_nExtIntHour, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_MINUTE, m_nExtIntMinute);
DDV_MinMaxInt(pDX, m_nExtIntMinute, 0, MAX_MINUTES);
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_DAY, m_nExtTmDay);
DDV_MinMaxInt(pDX, m_nExtTmDay, 0, 365);
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_HOUR, m_nExtTmHour);
DDV_MinMaxInt(pDX, m_nExtTmHour, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, m_nExtTmMinute);
DDV_MinMaxInt(pDX, m_nExtTmMinute, 0, MAX_MINUTES);
DDX_Text(pDX, IDC_EDIT_RENEW_DAY, m_nRenewDay);
DDV_MinMaxInt(pDX, m_nRenewDay, 0, 365);
DDX_Text(pDX, IDC_EDIT_RENEW_HOUR, m_nrenewMinute);
DDV_MinMaxInt(pDX, m_nrenewMinute, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_RENEW_MINUTE, m_nRenewMinute);
DDV_MinMaxInt(pDX, m_nRenewMinute, 0, MAX_MINUTES);
DDX_Text(pDX, IDC_EDIT_VERIFY_DAY, m_nVerifyDay);
DDV_MinMaxInt(pDX, m_nVerifyDay, 0, 365);
DDX_Text(pDX, IDC_EDIT_VERIFY_HOUR, m_nVerifyHour);
DDV_MinMaxInt(pDX, m_nVerifyHour, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_VERIFY_MINUTE, m_nVerifyMinute);
DDV_MinMaxInt(pDX, m_nVerifyMinute, 0, MAX_MINUTES);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CServerPropDBRecord, CPropertyPageBase)
//{{AFX_MSG_MAP(CServerPropDBRecord)
ON_BN_CLICKED(IDC_BUTTON_SET_DEFAULT, OnButtonSetDefault)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_DAY, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_HOUR, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_MINUTE, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_DAY, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_HOUR, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_RENEW_DAY, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_RENEW_HOUR, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_RENEW_MINUTE, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_VERIFY_DAY, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_VERIFY_HOUR, OnChangeEditExtinctIntHour)
ON_EN_CHANGE(IDC_EDIT_VERIFY_MINUTE, OnChangeEditExtinctIntHour)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CServerPropDBRecord message handlers
BOOL
CServerPropDBRecord::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
// get the interval stuff from the server and display in the spinner controlss
HRESULT hr = GetConfig();
DWORD m_dwRefreshInterval = m_pConfig->m_dwRefreshInterval;
m_spinRefrIntHour.SetRange(0, MAX_HOURS);
m_spinRefrIntMinute.SetRange(0, MAX_MINUTES);
m_spinRefrIntDay.SetRange(0, UD_MAXVAL);
int nDays = 0, nHours = 0, nMinutes = 0;
nDays = m_dwRefreshInterval /86400;// SEC_PER_DAY;
m_dwRefreshInterval -= (nDays * SEC_PER_DAY);
if (m_dwRefreshInterval)
{
nHours = m_dwRefreshInterval / SEC_PER_HOUR;
m_dwRefreshInterval -= (nHours * SEC_PER_HOUR);
if(m_dwRefreshInterval)
{
nMinutes = m_dwRefreshInterval / SEC_PER_MINUTE;
m_dwRefreshInterval -= (nMinutes * SEC_PER_MINUTE);
}
}
m_spinRefrIntDay.SetPos(nDays);
m_spinRefrIntHour.SetPos(nHours);
m_spinRefrIntMinute.SetPos(nMinutes);
SetVerifyData();
SetExtTimeData();
SetExtIntData();
SetDirty(FALSE);
return TRUE;
}
BOOL
CServerPropDBRecord::OnApply()
{
if (!CheckValues())
{
return FALSE;
}
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return FALSE;
}
else
{
return CPropertyPageBase::OnApply();
}
}
void
CServerPropDBRecord::OnOK()
{
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return;
}
else
{
CPropertyPageBase::OnOK();
}
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::CalculateRenewInt()
Returns the Renew interval in seconds
---------------------------------------------------------------------------*/
DWORD
CServerPropDBRecord::CalculateRenewInt()
{
UpdateData();
int nDay = m_spinRefrIntDay.GetPos();
int nHour = m_spinRefrIntHour.GetPos();
int nMinute = m_spinRefrIntMinute.GetPos();
int nRenewInterval = nDay * SEC_PER_DAY +
nHour * SEC_PER_HOUR +
nMinute * SEC_PER_MINUTE;
return nRenewInterval;
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::CalculateExtInt()
Returns the Extinction interval in seconds
---------------------------------------------------------------------------*/
DWORD
CServerPropDBRecord::CalculateExtInt()
{
UpdateData();
int nDay = m_spinExtIntDay.GetPos();
int nHour = m_spinExtIntHour.GetPos();
int nMinute = m_spinExtIntMinute.GetPos();
int nExtInterval = nDay * SEC_PER_DAY +
nHour * SEC_PER_HOUR +
nMinute * SEC_PER_MINUTE;
return nExtInterval;
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::CalculateExtTm()
Returns the Extinction timeout interval in seconds
---------------------------------------------------------------------------*/
DWORD
CServerPropDBRecord::CalculateExtTm()
{
UpdateData();
int nDay = m_spinExtTmDay.GetPos();
int nHour = m_spinExtTmHour.GetPos();
int nMinute = m_spinExtTmMinute.GetPos();
int nExtTm = nDay * SEC_PER_DAY +
nHour * SEC_PER_HOUR +
nMinute * SEC_PER_MINUTE;
return nExtTm;
}
/*----------------------------------------------------------------------------
CServerPropDBRecord::CalculateVerifyInt()
Returns the Verify interval in seconds
---------------------------------------------------------------------------*/
DWORD
CServerPropDBRecord::CalculateVerifyInt()
{
UpdateData();
int nDay = m_spinVerifyDay.GetPos();
int nHour = m_spinVerifyHour.GetPos();
int nMinute = m_spinVerifyMinute.GetPos();
int nVerifyInt = nDay * SEC_PER_DAY +
nHour * SEC_PER_HOUR +
nMinute * SEC_PER_MINUTE;
return nVerifyInt;
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::UpdateServerConfiguration()
Updates the server handler variables
---------------------------------------------------------------------------*/
HRESULT
CServerPropDBRecord::UpdateServerConfiguration()
{
UpdateData();
// Reflect the changes in the server's CConfiguration object
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
m_pConfig->m_dwRefreshInterval = CalculateRenewInt();
m_pConfig->m_dwTombstoneInterval = CalculateExtInt();
m_pConfig->m_dwTombstoneTimeout = CalculateExtTm();
m_pConfig->m_dwVerifyInterval = CalculateVerifyInt();
// now write to server
DWORD err = m_pConfig->Store();
if (err != ERROR_SUCCESS)
{
// something bad happened
WinsMessageBox(err);
}
else
{
// success update our local copy
pServer->SetConfig(*m_pConfig);
}
return HRESULT_FROM_WIN32(err);
}
void
CServerPropDBRecord::OnButtonSetDefault()
{
SetDefaultRenewInt();
SetDefaultExtInt();
SetDefaultExtTm();
SetDefaultVerifyInt();
}
//
// note, these defaults come from winscnf.c in the wins server code.
// if that code changes, these function will need to change as well.
//
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetDefaultRenewInt()
Sets the defalut values for the Renew interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetDefaultRenewInt()
{
int nValue = WINSCNF_DEF_REFRESH_INTERVAL;
int nDays = 0, nHours = 0, nMinutes = 0;
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
m_spinRefrIntDay.SetPos(nDays);
m_spinRefrIntHour.SetPos(nHours);
m_spinRefrIntMinute.SetPos(nMinutes);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetDefaultExtInt()
Sets the defalut values for the Extinction interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetDefaultExtInt()
{
int nValue = WINSCNF_MAKE_TOMB_INTVL_M(WINSCNF_DEF_REFRESH_INTERVAL, 0);
int nDays = 0, nHours = 0, nMinutes = 0;
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
m_spinExtIntDay.SetPos(nDays);
m_spinExtIntHour.SetPos(nHours);
m_spinExtIntMinute.SetPos(nMinutes);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetDefaultExtTm()
Sets the defalut values for the Extinction timeout interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetDefaultExtTm()
{
int nValue = WINSCNF_DEF_REFRESH_INTERVAL;
int nDays = 0, nHours = 0, nMinutes = 0;
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
m_spinExtTmDay.SetPos(nDays);
m_spinExtTmHour.SetPos(nHours);
m_spinExtTmMinute.SetPos(nMinutes);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetDefaultExtTm()
Sets the defalut values for the verify interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetDefaultVerifyInt()
{
int nValue = WINSCNF_MAKE_VERIFY_INTVL_M(WINSCNF_MAKE_TOMB_INTVL_M(WINSCNF_DEF_REFRESH_INTERVAL, 0));
int nDays = 0, nHours = 0, nMinutes = 0;
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
m_spinVerifyDay.SetPos(nDays);
m_spinVerifyHour.SetPos(nHours);
m_spinVerifyMinute.SetPos(nMinutes);
}
void
CServerPropDBRecord::CalcDaysHoursMinutes(int nValue, int & nDays, int & nHours, int & nMinutes)
{
nDays = 0;
nHours = 0;
nMinutes = 0;
nDays = nValue / SEC_PER_DAY; // 86400;
nValue -= (nDays * SEC_PER_DAY);
if (nValue)
{
nHours = nValue / SEC_PER_HOUR;
nValue -= (nHours * SEC_PER_HOUR);
if (nValue)
{
nMinutes = nValue / SEC_PER_MINUTE;
nValue -= (nMinutes * SEC_PER_MINUTE);
}
}
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::GetConfig()
Updates the configuration object from the server handler
---------------------------------------------------------------------------*/
HRESULT
CServerPropDBRecord::GetConfig()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
return hr;
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetVerifyData()
Sets the controls' data for verify interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetVerifyData()
{
DWORD dwInterval = m_pConfig->m_dwVerifyInterval;
m_spinVerifyHour.SetRange(0, MAX_HOURS);
m_spinVerifyMinute.SetRange(0, MAX_MINUTES);
m_spinVerifyDay.SetRange(0, UD_MAXVAL);
int nDays =0, nHours =0, nMinutes =0;
if(dwInterval)
{
nDays = dwInterval / SEC_PER_DAY;
dwInterval -= nDays * SEC_PER_DAY;
if(dwInterval)
{
nHours = dwInterval / SEC_PER_HOUR;
dwInterval -= nHours * SEC_PER_HOUR;
if(dwInterval)
{
nMinutes = dwInterval / SEC_PER_MINUTE;
dwInterval -= nMinutes * SEC_PER_MINUTE;
}
}
}
m_spinVerifyDay.SetPos(nDays);
m_spinVerifyHour.SetPos(nHours);
m_spinVerifyMinute.SetPos(nMinutes);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetExtTimeData()
Sets the controls' data for extinction timeout interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetExtTimeData()
{
DWORD dwInterval = m_pConfig->m_dwTombstoneTimeout;
m_spinExtTmHour.SetRange(0, MAX_HOURS);
m_spinExtTmMinute.SetRange(0, MAX_MINUTES);
m_spinExtTmDay.SetRange(0, UD_MAXVAL);
int nHours = 0, nMinutes =0, nDays =0;
if(dwInterval)
{
nDays = dwInterval / SEC_PER_DAY;
dwInterval -= nDays * SEC_PER_DAY;
if(dwInterval)
{
nHours = dwInterval / SEC_PER_HOUR;
dwInterval -= nHours * SEC_PER_HOUR;
if(dwInterval)
{
nMinutes = dwInterval / SEC_PER_MINUTE;
dwInterval -= nMinutes * SEC_PER_MINUTE;
}
}
}
m_spinExtTmDay.SetPos(nDays);
m_spinExtTmHour.SetPos(nHours);
m_spinExtTmMinute.SetPos(nMinutes);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::SetExtData()
Sets the controls' data for extinction interval
---------------------------------------------------------------------------*/
void
CServerPropDBRecord::SetExtIntData()
{
DWORD dwInterval = m_pConfig->m_dwTombstoneInterval;
m_spinExtIntHour.SetRange(0, MAX_HOURS);
m_spinExtIntMinute.SetRange(0, MAX_MINUTES);
m_spinExtIntDay.SetRange(0, UD_MAXVAL);
int nHours =0, nMinutes =0, nDays =0;
if(dwInterval)
{
nDays = dwInterval / SEC_PER_DAY;
dwInterval -= nDays * SEC_PER_DAY;
if(dwInterval)
{
nHours = dwInterval / SEC_PER_HOUR;
dwInterval -= nHours * SEC_PER_HOUR;
if(dwInterval)
{
nMinutes = dwInterval / SEC_PER_MINUTE;
dwInterval -= nMinutes * SEC_PER_MINUTE;
}
}
}
m_spinExtIntDay.SetPos(nDays);
m_spinExtIntHour.SetPos(nHours);
m_spinExtIntMinute.SetPos(nMinutes);
}
void CServerPropDBRecord::OnChangeEditExtinctIntHour()
{
SetDirty(TRUE);
}
/*---------------------------------------------------------------------------
CServerPropDBRecord::CheckValues()
checks if the values are valid
NOTE: All of these checks mimic what the server does since we write
directly to the registry and don't go through an API. If these
every change, the error messages will need to be updated as well.
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
CServerPropDBRecord::CheckValues()
{
BOOL fValid = TRUE;
UpdateData();
do
{
DWORD dwRenew = CalculateRenewInt();
if (dwRenew < WINSCNF_MIN_REFRESH_INTERVAL)
{
AfxMessageBox(IDS_ERR_RENEW_INTERVAL);
fValid = FALSE;
break;
}
DWORD dwExtTm = CalculateExtTm();
if (dwExtTm < WINSCNF_MIN_TOMBSTONE_TIMEOUT)
{
// minimum value
AfxMessageBox(IDS_ERR_EXTINCTION_TIMEOUT_MIN);
fValid = FALSE;
break;
}
if (dwExtTm < dwRenew)
{
// bad... must be at least this value
AfxMessageBox(IDS_ERR_EXTINCTION_TIMEOUT);
fValid = FALSE;
break;
}
DWORD dwExtInt = CalculateExtInt();
//--ft:07/10/00--
// replaced WINSCNF_MAKE_TOMB_INTVL_M macro with its expansion..
// otherwise, the compiler with CLEAN64_BIT=1 reports an error
// since max(any_dword, 0) is always true - and the compiler is dumb enough
// to signal this as an error..
//
//if (dwExtInt < WINSCNF_MAKE_TOMB_INTVL_M(dwRenew, 0))
if (dwExtInt < min(dwRenew, FOUR_DAYS))
{
// bad... must be at least that value
AfxMessageBox(IDS_ERR_EXTINCTION_INTERVAL);
fValid = FALSE;
break;
}
DWORD dwVerifyInt = CalculateVerifyInt();
if (dwVerifyInt < WINSCNF_MAKE_VERIFY_INTVL_M(dwExtInt))
{
// bad... must be at least this value
if (WINSCNF_MAKE_VERIFY_INTVL_M(dwExtInt) == TWENTY_FOUR_DAYS)
{
AfxMessageBox(IDS_ERR_VERIFY_INTERVAL_24_DAYS);
}
else
{
CString strTemp;
strTemp.Format(IDS_ERR_VERIFY_INTERVAL_CALC, TOMB_MULTIPLIER_FOR_VERIFY);
AfxMessageBox(strTemp);
}
fValid = FALSE;
break;
}
}
while (FALSE);
return fValid;
}
/////////////////////////////////////////////////////////////////////////////
// CServerPropDBVerification property page
IMPLEMENT_DYNCREATE(CServerPropDBVerification, CPropertyPageBase)
CServerPropDBVerification::CServerPropDBVerification() : CPropertyPageBase(CServerPropDBVerification::IDD)
{
//{{AFX_DATA_INIT(CServerPropDBVerification)
m_fCCPeriodic = FALSE;
m_nCCCheckRandom = -1;
m_nCCHour = 0;
m_nCCMinute = 0;
m_nCCSecond = 0;
m_nCCMaxChecked = 0;
m_nCCTimeInterval = 0;
//}}AFX_DATA_INIT
}
CServerPropDBVerification::~CServerPropDBVerification()
{
}
void CServerPropDBVerification::DoDataExchange(CDataExchange* pDX)
{
CPropertyPageBase::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CServerPropDBVerification)
DDX_Control(pDX, IDC_EDIT_CC_START_SECOND, m_editCCSecond);
DDX_Control(pDX, IDC_EDIT_CC_START_MINUTE, m_editCCMinute);
DDX_Control(pDX, IDC_EDIT_CC_START_HOUR, m_editCCHour);
DDX_Control(pDX, IDC_SPIN_CC_START_MINUTE, m_spinCCMinute);
DDX_Control(pDX, IDC_EDIT_CC_INTERVAL, m_editCCInterval);
DDX_Control(pDX, IDC_EDIT_CC_MAX_CHECKED, m_editCCMaxChecked);
DDX_Control(pDX, IDC_RADIO_CHECK_OWNER, m_radioCheckOwner);
DDX_Control(pDX, IDC_CHECK_PERIODIC_CC, m_checkEnableCC);
DDX_Control(pDX, IDC_SPIN_CC_START_SECOND, m_spinCCSecond);
DDX_Control(pDX, IDC_SPIN_CC_START_HOUR, m_spinCCHour);
DDX_Check(pDX, IDC_CHECK_PERIODIC_CC, m_fCCPeriodic);
DDX_Radio(pDX, IDC_RADIO_CHECK_OWNER, m_nCCCheckRandom);
DDX_Text(pDX, IDC_EDIT_CC_START_HOUR, m_nCCHour);
DDV_MinMaxInt(pDX, m_nCCHour, 0, MAX_HOURS);
DDX_Text(pDX, IDC_EDIT_CC_START_MINUTE, m_nCCMinute);
DDV_MinMaxInt(pDX, m_nCCMinute, 0, MAX_MINUTES);
DDX_Text(pDX, IDC_EDIT_CC_START_SECOND, m_nCCSecond);
DDV_MinMaxInt(pDX, m_nCCSecond, 0, MAX_SECONDS);
DDX_Text(pDX, IDC_EDIT_CC_MAX_CHECKED, m_nCCMaxChecked);
DDV_MinMaxUInt(pDX, m_nCCMaxChecked, WINSCNF_CC_MIN_RECS_AAT, 4294967295);
DDX_Text(pDX, IDC_EDIT_CC_INTERVAL, m_nCCTimeInterval);
DDV_MinMaxUInt(pDX, m_nCCTimeInterval, WINSCNF_CC_MIN_INTERVAL/(60*60), 24);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CServerPropDBVerification, CPropertyPageBase)
//{{AFX_MSG_MAP(CServerPropDBVerification)
ON_BN_CLICKED(IDC_CHECK_PERIODIC_CC, OnCheckPeriodicCc)
ON_EN_CHANGE(IDC_EDIT_CC_INTERVAL, OnChangeEditCcInterval)
ON_EN_CHANGE(IDC_EDIT_CC_MAX_CHECKED, OnChangeEditCcMaxChecked)
ON_EN_CHANGE(IDC_EDIT_CC_START_HOUR, OnChangeEditCcStartHour)
ON_EN_CHANGE(IDC_EDIT_CC_START_MINUTE, OnChangeEditCcStartMinute)
ON_EN_CHANGE(IDC_EDIT_CC_START_SECOND, OnChangeEditCcStartSecond)
ON_BN_CLICKED(IDC_RADIO_CHECK_OWNER, OnRadioCheckOwner)
ON_BN_CLICKED(IDC_RADIO_CHECK_RANDOM, OnRadioCheckRandom)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CServerPropDBVerification message handlers
BOOL
CServerPropDBVerification::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
// get the interval stuff from the server and display in the spinner controlss
HRESULT hr = GetConfig();
m_spinCCHour.SetRange(0, MAX_HOURS);
m_spinCCMinute.SetRange(0, MAX_MINUTES);
m_spinCCSecond.SetRange(0, MAX_SECONDS);
SetCCInfo();
UpdateCCControls();
SetDirty(FALSE);
return TRUE;
}
BOOL
CServerPropDBVerification::OnApply()
{
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return FALSE;
}
else
{
return CPropertyPageBase::OnApply();
}
}
void
CServerPropDBVerification::OnOK()
{
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return;
}
else
{
CPropertyPageBase::OnOK();
}
}
void CServerPropDBVerification::OnCheckPeriodicCc()
{
UpdateCCControls();
SetDirty(TRUE);
}
void CServerPropDBVerification::OnChangeEditCcInterval()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnChangeEditCcMaxChecked()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnChangeEditCcStartHour()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnChangeEditCcStartMinute()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnChangeEditCcStartSecond()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnRadioCheckOwner()
{
SetDirty(TRUE);
}
void CServerPropDBVerification::OnRadioCheckRandom()
{
SetDirty(TRUE);
}
/*---------------------------------------------------------------------------
CServerPropDBVerification::UpdateServerConfiguration()
Updates the server handler variables
---------------------------------------------------------------------------*/
HRESULT
CServerPropDBVerification::UpdateServerConfiguration()
{
UpdateData();
// Reflect the changes in the server's CConfiguration object
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
// consistency check
m_pConfig->m_fPeriodicConsistencyCheck = m_fCCPeriodic;
m_pConfig->m_fCCUseRplPnrs = m_nCCCheckRandom;
m_pConfig->m_dwMaxRecsAtATime = m_nCCMaxChecked;
// convert to seconds
m_pConfig->m_dwCCTimeInterval = m_nCCTimeInterval * (60*60);
// start time
CTime curTime = CTime::GetCurrentTime();
int nYear = curTime.GetYear();
int nMonth = curTime.GetMonth();
int nDay = curTime.GetDay();
CTime tempTime(nYear, nMonth, nDay, m_nCCHour, m_nCCMinute, m_nCCSecond);
m_pConfig->m_itmCCStartTime = tempTime;
// now write to server
DWORD err = m_pConfig->Store();
if (err != ERROR_SUCCESS)
{
// something bad happened
WinsMessageBox(err);
}
else
{
// success update our local copy
pServer->SetConfig(*m_pConfig);
}
return HRESULT_FROM_WIN32(err);
}
/*---------------------------------------------------------------------------
CServerPropDBVerification::GetConfig()
Updates the configuration object from the server handler
---------------------------------------------------------------------------*/
HRESULT
CServerPropDBVerification::GetConfig()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
return hr;
}
/*---------------------------------------------------------------------------
CServerPropDBVerification::UpdateCCControls()
Enables/disables depending on checkbox
Author: EricDav
---------------------------------------------------------------------------*/
void
CServerPropDBVerification::UpdateCCControls()
{
UpdateData();
BOOL fEnable = FALSE;
if (m_fCCPeriodic)
{
fEnable = TRUE;
}
m_spinCCHour.EnableWindow(fEnable);
m_spinCCMinute.EnableWindow(fEnable);
m_spinCCSecond.EnableWindow(fEnable);
m_editCCHour.EnableWindow(fEnable);
m_editCCMinute.EnableWindow(fEnable);
m_editCCSecond.EnableWindow(fEnable);
m_editCCMaxChecked.EnableWindow(fEnable);
m_editCCInterval.EnableWindow(fEnable);
m_radioCheckOwner.EnableWindow(fEnable);
GetDlgItem(IDC_RADIO_CHECK_RANDOM)->EnableWindow(fEnable);
// TODO: static text
}
/*---------------------------------------------------------------------------
CServerPropDBVerification::SetCCInfo()
Sets the interval values for Consistency checking
Author: EricDav
---------------------------------------------------------------------------*/
void
CServerPropDBVerification::SetCCInfo()
{
CString strTemp;
CButton * pRadio;
m_checkEnableCC.SetCheck(m_pConfig->m_fPeriodicConsistencyCheck);
if (m_pConfig->m_fCCUseRplPnrs)
{
pRadio = (CButton *) GetDlgItem(IDC_RADIO_CHECK_RANDOM);
}
else
{
pRadio = (CButton *) GetDlgItem(IDC_RADIO_CHECK_OWNER);
}
pRadio->SetCheck(TRUE);
strTemp.Format(_T("%lu"), m_pConfig->m_dwMaxRecsAtATime);
m_editCCMaxChecked.SetWindowText(strTemp);
// convert the TimeInterval into hours from seconds
int nTimeTemp = m_pConfig->m_dwCCTimeInterval / (60 * 60);
strTemp.Format(_T("%lu"), nTimeTemp);
m_editCCInterval.SetWindowText(strTemp);
m_spinCCHour.SetPos(m_pConfig->m_itmCCStartTime.GetHour());
m_spinCCMinute.SetPos(m_pConfig->m_itmCCStartTime.GetMinute());
m_spinCCSecond.SetPos(m_pConfig->m_itmCCStartTime.GetSecond());
}
/////////////////////////////////////////////////////////////////////////////
// CServerPropAdvanced property page
IMPLEMENT_DYNCREATE(CServerPropAdvanced, CPropertyPageBase)
CServerPropAdvanced::CServerPropAdvanced() : CPropertyPageBase(CServerPropAdvanced::IDD)
{
//{{AFX_DATA_INIT(CServerPropAdvanced)
m_fLogEvents = FALSE;
m_strStartVersion = _T("");
m_fLanNames = FALSE;
m_fBurstHandling = FALSE;
m_nQueSelection = -1;
m_strDbPath = _T("");
//}}AFX_DATA_INIT
m_fRestart = FALSE;
}
CServerPropAdvanced::~CServerPropAdvanced()
{
}
void CServerPropAdvanced::DoDataExchange(CDataExchange* pDX)
{
CPropertyPageBase::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CServerPropAdvanced)
DDX_Control(pDX, IDC_BUTTON_BROWSE_DATABASE, m_buttonBrowse);
DDX_Control(pDX, IDC_EDIT_DATABASE_PATH, m_editDbPath);
DDX_Control(pDX, IDC_CHECK_BURST_HANDLING, m_checkBurstHandling);
DDX_Control(pDX, IDC_CHECK_LANNAMES, m_checkLanNames);
DDX_Control(pDX, IDC_EDIT_START_VERSION, m_editVersionCount);
DDX_Control(pDX, IDC_CHECK_LOGEVENTS, m_checkLogDetailedEvents);
DDX_Check(pDX, IDC_CHECK_LOGEVENTS, m_fLogEvents);
DDX_Text(pDX, IDC_EDIT_START_VERSION, m_strStartVersion);
DDV_MaxChars(pDX, m_strStartVersion, 16);
DDX_Check(pDX, IDC_CHECK_LANNAMES, m_fLanNames);
DDX_Check(pDX, IDC_CHECK_BURST_HANDLING, m_fBurstHandling);
DDX_Radio(pDX, IDC_RADIO_LOW, m_nQueSelection);
DDX_Text(pDX, IDC_EDIT_DATABASE_PATH, m_strDbPath);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CServerPropAdvanced, CPropertyPageBase)
//{{AFX_MSG_MAP(CServerPropAdvanced)
ON_BN_CLICKED(IDC_CHECK_LANNAMES, OnCheckLannames)
ON_BN_CLICKED(IDC_CHECK_BURST_HANDLING, OnCheckBurstHandling)
ON_BN_CLICKED(IDC_RADIO_CUSTOM, OnRadioCustom)
ON_BN_CLICKED(IDC_RADIO_HIGH, OnRadioHigh)
ON_BN_CLICKED(IDC_RADIO_LOW, OnRadioLow)
ON_BN_CLICKED(IDC_RADIO_MEDIUM, OnRadioMedium)
ON_EN_CHANGE(IDC_EDIT_CUSTOM_VALUE, OnChangeEditCustomValue)
ON_BN_CLICKED(IDC_BUTTON_BROWSE_DATABASE, OnButtonBrowseDatabase)
ON_BN_CLICKED(IDC_CHECK_LOGEVENTS, MarkDirty)
ON_EN_CHANGE(IDC_EDIT_START_VERSION, MarkDirty)
ON_EN_CHANGE(IDC_EDIT_DATABASE_PATH, OnChangeEditDatabasePath)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CServerPropAdvanced message handlers
BOOL
CServerPropAdvanced::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
GetConfig();
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
m_fLogEvents = m_pConfig->m_fLogDetailedEvents;
if (m_fLogEvents)
{
m_checkLogDetailedEvents.SetCheck(1);
}
else
{
m_checkLogDetailedEvents.SetCheck(0);
}
if (pServer->m_dwFlags & FLAG_LANMAN_COMPATIBLE)
{
m_fLanNames = TRUE;
m_checkLanNames.SetCheck(TRUE);
}
else
{
m_fLanNames = FALSE;
m_checkLanNames.SetCheck(FALSE);
}
LONG lLowWord = m_pConfig->m_dwVersCountStart_LowWord;
LONG lHighWord = m_pConfig->m_dwVersCountStart_HighWord;
CString strVersion = GetVersionInfo(lLowWord, lHighWord);
m_editVersionCount.SetWindowText(strVersion);
// burst que stuff
m_checkBurstHandling.SetCheck(m_pConfig->m_fBurstHandling);
((CEdit *) GetDlgItem(IDC_EDIT_CUSTOM_VALUE))->LimitText(5);
SetQueSize();
UpdateBurstHandling();
// db path stuff
// browse only available on local machine
// get the server
m_buttonBrowse.ShowWindow(FALSE); // we may add this back in later
m_buttonBrowse.EnableWindow(pServer->IsLocalConnection());
m_editDbPath.EnableWindow(pServer->IsLocalConnection());
m_editDbPath.SetWindowText(m_pConfig->m_strDbPath);
SetDirty(FALSE);
m_fRestart = FALSE;
return TRUE;
}
void
CServerPropAdvanced::OnOK()
{
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return;
}
else
{
CPropertyPageBase::OnOK();
}
}
BOOL
CServerPropAdvanced::OnApply()
{
BOOL fRestartNow = FALSE;
UpdateData();
// validate the value for Hex
for (int i=0; i < m_strStartVersion.GetLength(); i++)
{
if (!(((m_strStartVersion[i] >= _T('0') ) &&
(m_strStartVersion[i] <= _T('9') )) ||
((m_strStartVersion[i] >= _T('A') ) &&
(m_strStartVersion[i] <= _T('F') )) ||
((m_strStartVersion[i] >= _T('a') ) &&
(m_strStartVersion[i] <= _T('f') ))
))
{
::WinsMessageBox(IDS_ERR_VERSION_NUMBER);
m_editVersionCount.SetFocus();
m_editVersionCount.SetSel(0,-1);
return FALSE;
}
}
DWORD dwSize = GetQueSize();
if (dwSize < WINS_QUEUE_HWM_MIN ||
dwSize > WINS_QUEUE_HWM_MAX)
{
CString strMin, strMax, strDisplay;
strMin.Format(_T("%d"), WINS_QUEUE_HWM_MIN);
strMax.Format(_T("%d"), WINS_QUEUE_HWM_MAX);
AfxFormatString2(strDisplay, IDS_ERR_BURST_QUE_SIZE, strMin, strMax);
AfxMessageBox(strDisplay);
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->SetFocus();
return FALSE;
}
// warn the user
if (m_fRestart)
{
int nRet = AfxMessageBox(IDS_DATABASE_PATH_CHANGE, MB_YESNOCANCEL);
if (nRet == IDCANCEL)
{
return FALSE;
}
else
if (nRet == IDYES)
{
fRestartNow = TRUE;
}
}
HRESULT hr = UpdateServerConfiguration();
if (FAILED(hr))
{
return FALSE;
}
if (fRestartNow)
{
CString strServiceName;
strServiceName.LoadString(IDS_SERVICE_NAME);
// get the server
SPITFSNode spNode;
CWinsServerHandler *pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
DWORD dwError = TFSStopServiceEx(m_pConfig->GetOwner(), _T("WINS"), _T("WINS Service"), strServiceName);
if (dwError)
{
WinsMessageBox(dwError);
}
else
{
dwError = TFSStartServiceEx(m_pConfig->GetOwner(), _T("WINS"), _T("WINS Service"), strServiceName);
if (dwError)
{
WinsMessageBox(dwError);
}
}
pServer->ConnectToWinsServer(spNode);
}
m_fRestart = FALSE;
return CPropertyPageBase::OnApply();
}
/*---------------------------------------------------------------------------
CServerPropAdvanced::GetConfig()
Updates the configuration object from the server handler
---------------------------------------------------------------------------*/
HRESULT
CServerPropAdvanced::GetConfig()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
return hr;
}
/*---------------------------------------------------------------------------
CServerPropAdvanced::UpdateServerConfiguration()
Updates the variables in the server handler
---------------------------------------------------------------------------*/
HRESULT
CServerPropAdvanced::UpdateServerConfiguration()
{
UpdateData();
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// get the server
SPITFSNode spNode;
CWinsServerHandler * pServer;
spNode = GetHolder()->GetNode();
pServer = GETHANDLER(CWinsServerHandler, spNode);
// update our settings
m_pConfig->m_fLogDetailedEvents = m_fLogEvents;
if (m_fLanNames)
{
pServer->m_dwFlags |= FLAG_LANMAN_COMPATIBLE;
}
else
{
pServer->m_dwFlags &= (~FLAG_LANMAN_COMPATIBLE);
}
// version stuff
LONG lLowWord, lHighWord;
FillVersionInfo(lLowWord, lHighWord);
m_pConfig->m_dwVersCountStart_HighWord = lHighWord;
m_pConfig->m_dwVersCountStart_LowWord = lLowWord;
// burst handling
m_pConfig->m_fBurstHandling = m_fBurstHandling;
m_pConfig->m_dwBurstQueSize = GetQueSize();
// db path
if (m_fRestart)
{
m_pConfig->m_strDbPath = m_strDbPath;
}
// now write to server
DWORD err = m_pConfig->Store();
if (err != ERROR_SUCCESS)
{
// something bad happened
WinsMessageBox(err);
}
else
{
// success update our local copy
pServer->SetConfig(*m_pConfig);
}
return HRESULT_FROM_WIN32(err);
}
/*---------------------------------------------------------------------------
CServerPropAdvanced::FillVersionInfo(LONG &lLowValue, LONG &lHighValue)
fills the version info in the related controls
---------------------------------------------------------------------------*/
void
CServerPropAdvanced::FillVersionInfo(LONG &lLowValue, LONG &lHighValue)
{
CString str ;
m_editVersionCount.GetWindowText(str);
int j = str.GetLength();
if ( j > 16 || !j )
{
//
// Invalid string
//
return;
}
TCHAR sz[] = _T("0000000000000000");
TCHAR *pch;
::_tcscpy(sz + 16 - j, (LPCTSTR)str);
pch = sz + 8;
::_stscanf(pch, _T("%08lX"),&lLowValue);
*pch = '\0';
::_stscanf(sz, _T("%08lX"),&lHighValue);
return;
}
CString
CServerPropAdvanced::GetVersionInfo(LONG lLowWord, LONG lHighWord)
{
CString strVersionCount;
TCHAR sz[20];
TCHAR *pch = sz;
::wsprintf(sz, _T("%08lX%08lX"), lHighWord, lLowWord);
// Kill leading zero's
while (*pch == '0')
{
++pch;
}
// At least one digit...
if (*pch == '\0')
{
--pch;
}
strVersionCount = pch;
return strVersionCount;
}
void CServerPropAdvanced::OnCheckLannames()
{
SetDirty(TRUE);
// mark the snap-in as dirty
SPITFSNode spNode ;
spNode = GetHolder()->GetNode();
SPITFSNodeMgr spNodeManager;
SPITFSNode spRootNode;
spNode->GetNodeMgr(&spNodeManager);
spNodeManager->GetRootNode(&spRootNode);
// mark the data as dirty so that we'll ask the user to save.
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
}
void CServerPropAdvanced::MarkDirty()
{
SetDirty(TRUE);
}
void CServerPropAdvanced::OnCheckBurstHandling()
{
SetDirty(TRUE);
UpdateBurstHandling();
}
void CServerPropAdvanced::OnRadioCustom()
{
SetDirty(TRUE);
EnableCustomEntry();
}
void CServerPropAdvanced::OnRadioHigh()
{
SetDirty(TRUE);
EnableCustomEntry();
}
void CServerPropAdvanced::OnRadioLow()
{
SetDirty(TRUE);
EnableCustomEntry();
}
void CServerPropAdvanced::OnRadioMedium()
{
SetDirty(TRUE);
EnableCustomEntry();
}
void CServerPropAdvanced::OnChangeEditCustomValue()
{
SetDirty(TRUE);
}
void CServerPropAdvanced::OnButtonBrowseDatabase()
{
// TODO: browse for a path
}
void CServerPropAdvanced::OnChangeEditDatabasePath()
{
SetDirty(TRUE);
m_fRestart = TRUE;
}
void CServerPropAdvanced::UpdateBurstHandling()
{
if (IsWindow(m_checkBurstHandling.GetSafeHwnd()))
{
EnableQueSelection(m_checkBurstHandling.GetCheck());
}
}
void CServerPropAdvanced::EnableQueSelection(BOOL bEnable)
{
GetDlgItem(IDC_RADIO_LOW)->EnableWindow(bEnable);
GetDlgItem(IDC_RADIO_MEDIUM)->EnableWindow(bEnable);
GetDlgItem(IDC_RADIO_HIGH)->EnableWindow(bEnable);
GetDlgItem(IDC_RADIO_CUSTOM)->EnableWindow(bEnable);
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->EnableWindow(bEnable);
EnableCustomEntry();
}
void CServerPropAdvanced::EnableCustomEntry()
{
BOOL bEnable = ((CButton *)GetDlgItem(IDC_RADIO_CUSTOM))->GetCheck() &&
m_checkBurstHandling.GetSafeHwnd() &&
m_checkBurstHandling.GetCheck();
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->EnableWindow(bEnable);
}
void CServerPropAdvanced::SetQueSize()
{
UINT uControlID = IDC_RADIO_CUSTOM;
switch (m_pConfig->m_dwBurstQueSize)
{
case BURST_QUE_SIZE_LOW:
uControlID = IDC_RADIO_LOW;
m_nQueSelection = 0;
break;
case BURST_QUE_SIZE_MEDIUM:
uControlID = IDC_RADIO_MEDIUM;
m_nQueSelection = 1;
break;
case BURST_QUE_SIZE_HIGH:
uControlID = IDC_RADIO_HIGH;
m_nQueSelection = 2;
break;
default:
{
TCHAR szBuf[10];
_itot(m_pConfig->m_dwBurstQueSize, szBuf, 10);
m_nQueSelection = 3;
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->SetWindowText(szBuf);
}
break;
}
((CButton *) GetDlgItem(uControlID))->SetCheck(TRUE);
}
DWORD CServerPropAdvanced::GetQueSize()
{
DWORD dwSize = 0;
UpdateData();
if (IsDlgButtonChecked(IDC_RADIO_LOW))
{
dwSize = BURST_QUE_SIZE_LOW;
}
else
if (IsDlgButtonChecked(IDC_RADIO_MEDIUM))
{
dwSize = BURST_QUE_SIZE_MEDIUM;
}
else
if (IsDlgButtonChecked(IDC_RADIO_HIGH))
{
dwSize = BURST_QUE_SIZE_HIGH;
}
else
{
// must be custom
CString strText;
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->GetWindowText(strText);
dwSize = (DWORD) _ttoi(strText);
}
return dwSize;
}
/////////////////////////////////////////////////////////////////////////////
//
// CServerProperties holder
//
/////////////////////////////////////////////////////////////////////////////
CServerProperties::CServerProperties
(
ITFSNode * pNode,
IComponentData * pComponentData,
ITFSComponentData * pTFSCompData,
LPCTSTR pszSheetName
) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
{
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
AddPageToList((CPropertyPageBase*) &m_pageGeneral);
AddPageToList((CPropertyPageBase*) &m_pageDBRecord);
AddPageToList((CPropertyPageBase*) &m_pageDBVerification);
AddPageToList((CPropertyPageBase*) &m_pageAdvanced);
Assert(pTFSCompData != NULL);
m_spTFSCompData.Set(pTFSCompData);
}
CServerProperties::~CServerProperties()
{
RemovePageFromList((CPropertyPageBase*) &m_pageGeneral, FALSE);
RemovePageFromList((CPropertyPageBase*) &m_pageDBRecord, FALSE);
RemovePageFromList((CPropertyPageBase*) &m_pageDBVerification, FALSE);
RemovePageFromList((CPropertyPageBase*) &m_pageAdvanced, FALSE);
}
Reference in a new issue View git blame Copy permalink