2363 lines
58 KiB
C++
2363 lines
58 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1998 - 1999
|
|
//
|
|
// File: uiutil.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#include "preDNSsn.h"
|
|
#include <SnapBase.h>
|
|
|
|
#include "resource.h"
|
|
#include "dnsutil.h"
|
|
#include "DNSSnap.h"
|
|
|
|
#include "snapdata.h"
|
|
#include "server.h"
|
|
#include "domain.h"
|
|
#include "zone.h"
|
|
#include "serverui.h"
|
|
|
|
#include "uiutil.h"
|
|
|
|
#ifdef DEBUG_ALLOCATOR
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSNameTokenizer
|
|
|
|
CDNSNameTokenizer::CDNSNameTokenizer(PCWSTR pszDNSName)
|
|
{
|
|
ASSERT(pszDNSName != NULL);
|
|
m_szDNSName = pszDNSName;
|
|
}
|
|
|
|
CDNSNameTokenizer::~CDNSNameTokenizer()
|
|
{
|
|
|
|
}
|
|
|
|
BOOL CDNSNameTokenizer::Tokenize(const wchar_t* wcToken)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
PWSTR pszToken = new WCHAR[m_szDNSName.GetLength() + 1];
|
|
if (pszToken != NULL)
|
|
{
|
|
wcscpy(pszToken, m_szDNSName);
|
|
|
|
PWSTR pszNextToken = wcstok(pszToken, wcToken);
|
|
while (pszNextToken != NULL)
|
|
{
|
|
AddTail(pszNextToken);
|
|
pszNextToken = wcstok(NULL, wcToken);
|
|
}
|
|
delete[] pszToken;
|
|
pszToken = NULL;
|
|
}
|
|
else
|
|
{
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void CDNSNameTokenizer::RemoveMatchingFromTail(CDNSNameTokenizer& refTokenizer)
|
|
{
|
|
//
|
|
// Removes matching tokens from the tail until one of the tokenizers is empty
|
|
// or we come across mismatched tokens
|
|
//
|
|
while (GetCount() > 0 && refTokenizer.GetCount() > 0)
|
|
{
|
|
if (GetTail() == refTokenizer.GetTail())
|
|
{
|
|
RemoveTail();
|
|
refTokenizer.RemoveTail();
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDNSNameTokenizer::GetRemaining(CString& strrefRemaining, const wchar_t* wcToken)
|
|
{
|
|
//
|
|
// Copies the remaining tokens into a string delimited by the token passed in
|
|
//
|
|
strrefRemaining.Empty();
|
|
|
|
POSITION pos = GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
strrefRemaining += GetNext(pos);
|
|
if (pos != NULL)
|
|
{
|
|
strrefRemaining += wcToken;
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Global functions
|
|
|
|
BOOL LoadStringsToComboBox(HINSTANCE hInstance, CComboBox* pCombo,
|
|
UINT nStringID, UINT nMaxLen, UINT nMaxAddCount)
|
|
{
|
|
pCombo->ResetContent();
|
|
ASSERT(hInstance != NULL);
|
|
WCHAR* szBuf = (WCHAR*)malloc(sizeof(WCHAR)*nMaxLen);
|
|
if (!szBuf)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bRet = TRUE;
|
|
LPWSTR* lpszArr = 0;
|
|
do // false loop
|
|
{
|
|
if ( ::LoadString(hInstance, nStringID, szBuf, nMaxLen) == 0)
|
|
{
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*nMaxLen);
|
|
if (!lpszArr)
|
|
{
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
UINT nArrEntries;
|
|
ParseNewLineSeparatedString(szBuf,lpszArr, &nArrEntries);
|
|
|
|
if (nMaxAddCount < nArrEntries) nArrEntries = nMaxAddCount;
|
|
for (UINT k=0; k<nArrEntries; k++)
|
|
pCombo->AddString(lpszArr[k]);
|
|
} while (false);
|
|
|
|
if (szBuf)
|
|
{
|
|
free(szBuf);
|
|
szBuf = 0;
|
|
}
|
|
|
|
if (lpszArr)
|
|
{
|
|
free(lpszArr);
|
|
lpszArr = 0;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void ParseNewLineSeparatedString(LPWSTR lpsz,
|
|
LPWSTR* lpszArr,
|
|
UINT* pnArrEntries)
|
|
{
|
|
static WCHAR lpszSep[] = L"\n";
|
|
*pnArrEntries = 0;
|
|
int k = 0;
|
|
lpszArr[k] = wcstok(lpsz, lpszSep);
|
|
if (lpszArr[k] == NULL)
|
|
return;
|
|
|
|
while (TRUE)
|
|
{
|
|
WCHAR* lpszToken = wcstok(NULL, lpszSep);
|
|
if (lpszToken != NULL)
|
|
lpszArr[++k] = lpszToken;
|
|
else
|
|
break;
|
|
}
|
|
*pnArrEntries = k+1;
|
|
}
|
|
|
|
void LoadStringArrayFromResource(LPWSTR* lpszArr,
|
|
UINT* nStringIDs,
|
|
int nArrEntries,
|
|
int* pnSuccessEntries)
|
|
{
|
|
CString szTemp;
|
|
|
|
*pnSuccessEntries = 0;
|
|
for (int k = 0;k < nArrEntries; k++)
|
|
{
|
|
if (!szTemp.LoadString(nStringIDs[k]))
|
|
{
|
|
lpszArr[k] = NULL;
|
|
continue;
|
|
}
|
|
|
|
int iLength = szTemp.GetLength() + 1;
|
|
lpszArr[k] = (LPWSTR)malloc(sizeof(WCHAR)*iLength);
|
|
if (lpszArr[k] != NULL)
|
|
{
|
|
wcscpy(lpszArr[k], (LPWSTR)(LPCWSTR)szTemp);
|
|
(*pnSuccessEntries)++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void EnumerateMTNodeHelper(CMTContainerNode* pNode,
|
|
CComponentDataObject* pComponentData)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
//TRACE(_T("before CLongOperationDialog::DoModal()\n"));
|
|
HWND hWnd = NULL;
|
|
HRESULT hr = pComponentData->GetConsole()->GetMainWindow(&hWnd);
|
|
ASSERT(SUCCEEDED(hr));
|
|
CWnd* pParentWnd = CWnd::FromHandle(hWnd);
|
|
CLongOperationDialog dlg(
|
|
new CNodeEnumerationThread(pComponentData,pNode),
|
|
pParentWnd,
|
|
IDR_SEARCH_AVI);
|
|
dlg.DoModal();
|
|
//TRACE(_T("after CLongOperationDialog::DoModal()\n"));
|
|
}
|
|
|
|
void _EnableEditableControlHelper(HWND hWnd, BOOL bEnable)
|
|
{
|
|
WCHAR szBuf[256];
|
|
::GetClassName(hWnd, szBuf, 256);
|
|
if (wcscmp(szBuf, TEXT("Static")) != 0)
|
|
::EnableWindow(hWnd, bEnable);
|
|
}
|
|
|
|
void EnableDialogControls(HWND hWnd, BOOL bEnable)
|
|
{
|
|
HWND hWndCurr = ::GetWindow(hWnd, GW_CHILD);
|
|
if (hWndCurr != NULL)
|
|
{
|
|
_EnableEditableControlHelper(hWndCurr, bEnable);
|
|
hWndCurr = ::GetNextWindow(hWndCurr, GW_HWNDNEXT);
|
|
while (hWndCurr)
|
|
{
|
|
_EnableEditableControlHelper(hWndCurr, bEnable);
|
|
hWndCurr = ::GetNextWindow(hWndCurr, GW_HWNDNEXT);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL LoadFontInfoFromResource(IN UINT nFontNameID,
|
|
IN UINT nFontSizeID,
|
|
OUT LPWSTR lpFontName, IN int nFontNameMaxchar,
|
|
OUT int& nFontSize,
|
|
IN LPCWSTR lpszDefaultFont, IN int nDefaultFontSize)
|
|
{
|
|
BOOL bRes = FALSE;
|
|
if (0 == ::LoadString(_Module.GetResourceInstance(), nFontNameID,
|
|
lpFontName, nFontNameMaxchar))
|
|
{
|
|
wcscpy(lpFontName, lpszDefaultFont);
|
|
}
|
|
else
|
|
{
|
|
bRes = TRUE;
|
|
}
|
|
|
|
WCHAR szFontSize[128];
|
|
if (0 != ::LoadString(_Module.GetResourceInstance(), nFontSizeID,
|
|
szFontSize, sizeof(szFontSize)/sizeof(WCHAR)))
|
|
{
|
|
nFontSize = _wtoi(szFontSize);
|
|
if (nFontSize == 0)
|
|
nFontSize = nDefaultFontSize;
|
|
else
|
|
bRes = TRUE;
|
|
}
|
|
else
|
|
{
|
|
nFontSize = nDefaultFontSize;
|
|
}
|
|
return bRes;
|
|
}
|
|
|
|
void InitBigBoldFont(HWND hWnd, HFONT& hFont)
|
|
{
|
|
ASSERT(::IsWindow(hWnd));
|
|
|
|
NONCLIENTMETRICS ncm;
|
|
memset(&ncm, 0, sizeof(ncm));
|
|
ncm.cbSize = sizeof(ncm);
|
|
::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
|
|
|
|
LOGFONT boldLogFont = ncm.lfMessageFont;
|
|
boldLogFont.lfWeight = FW_BOLD;
|
|
|
|
int nFontSize = 0;
|
|
VERIFY(LoadFontInfoFromResource(IDS_BIG_BOLD_FONT_NAME,
|
|
IDS_BIG_BOLD_FONT_SIZE,
|
|
boldLogFont.lfFaceName, LF_FACESIZE,
|
|
nFontSize,
|
|
L"Verdana Bold", 12 // default if something goes wrong
|
|
));
|
|
|
|
HDC hdc = ::GetDC(hWnd);
|
|
|
|
if (hdc != NULL)
|
|
{
|
|
boldLogFont.lfHeight = 0 - (::GetDeviceCaps(hdc, LOGPIXELSY) * nFontSize / 72);
|
|
hFont = ::CreateFontIndirect((const LOGFONT*)(&boldLogFont));
|
|
|
|
::ReleaseDC(hWnd, hdc);
|
|
}
|
|
}
|
|
|
|
|
|
void SetBigBoldFont(HWND hWndDialog, int nControlID)
|
|
{
|
|
ASSERT(::IsWindow(hWndDialog));
|
|
ASSERT(nControlID);
|
|
|
|
static HFONT boldLogFont = 0;
|
|
if (boldLogFont == 0)
|
|
{
|
|
InitBigBoldFont(hWndDialog, boldLogFont);
|
|
}
|
|
|
|
HWND hWndControl = ::GetDlgItem(hWndDialog, nControlID);
|
|
|
|
if (hWndControl)
|
|
{
|
|
::SendMessage(hWndControl, WM_SETFONT, (WPARAM)boldLogFont, MAKELPARAM(TRUE, 0));
|
|
}
|
|
}
|
|
|
|
|
|
int GetCheckedRadioButtonHelper(HWND hDlg, int nCount, int* nRadioArr, int nRadioDefault)
|
|
{
|
|
ASSERT(::IsWindow(hDlg));
|
|
ASSERT(nCount > 0);
|
|
for (int k=0; k<nCount; k++)
|
|
{
|
|
HWND hRadio = ::GetDlgItem(hDlg, nRadioArr[k]);
|
|
ASSERT(hRadio != NULL);
|
|
if ((hRadio != NULL) && (BST_CHECKED == ::SendMessage(hRadio, BM_GETCHECK, 0, 0)))
|
|
return nRadioArr[k];
|
|
}
|
|
ASSERT(FALSE);
|
|
return nRadioDefault;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CMultiselectErrorDialog
|
|
BEGIN_MESSAGE_MAP(CMultiselectErrorDialog, CDialog)
|
|
END_MESSAGE_MAP()
|
|
|
|
HRESULT CMultiselectErrorDialog::Initialize(CNodeList* pNodeList,
|
|
DNS_STATUS* pErrorArray,
|
|
UINT nErrorCount,
|
|
PCWSTR pszTitle,
|
|
PCWSTR pszCaption,
|
|
PCWSTR pszColumnHeader)
|
|
{
|
|
ASSERT(pNodeList != NULL);
|
|
ASSERT(pErrorArray != NULL);
|
|
ASSERT(pszTitle != NULL);
|
|
ASSERT(pszCaption != NULL);
|
|
ASSERT(pszColumnHeader != NULL);
|
|
|
|
if (pNodeList == NULL ||
|
|
pErrorArray == NULL ||
|
|
pszTitle == NULL ||
|
|
pszCaption == NULL ||
|
|
pszColumnHeader == NULL)
|
|
{
|
|
return E_POINTER;
|
|
}
|
|
|
|
m_pNodeList = pNodeList;
|
|
m_pErrorArray = pErrorArray;
|
|
m_nErrorCount = nErrorCount;
|
|
m_szTitle = pszTitle;
|
|
m_szCaption = pszCaption;
|
|
m_szColumnHeader = pszColumnHeader;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
const int OBJ_LIST_NAME_COL_WIDTH = 100;
|
|
const int IDX_NAME_COL = 0;
|
|
const int IDX_ERR_COL = 1;
|
|
|
|
BOOL CMultiselectErrorDialog::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
SetWindowText(m_szTitle);
|
|
SetDlgItemText(IDC_STATIC_MESSAGE, m_szCaption);
|
|
|
|
HWND hList = GetDlgItem(IDC_ERROR_LIST)->GetSafeHwnd();
|
|
ListView_SetExtendedListViewStyle(hList, LVS_EX_FULLROWSELECT);
|
|
|
|
//
|
|
// Set the column headings.
|
|
//
|
|
RECT rect;
|
|
::GetClientRect(hList, &rect);
|
|
|
|
LV_COLUMN lvc = {0};
|
|
lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
|
|
lvc.fmt = LVCFMT_LEFT;
|
|
lvc.cx = OBJ_LIST_NAME_COL_WIDTH;
|
|
lvc.pszText = (PWSTR)(PCWSTR)m_szColumnHeader;
|
|
lvc.iSubItem = IDX_NAME_COL;
|
|
|
|
ListView_InsertColumn(hList, IDX_NAME_COL, &lvc);
|
|
|
|
CString szError;
|
|
VERIFY(szError.LoadString(IDS_ERROR));
|
|
|
|
lvc.cx = rect.right - OBJ_LIST_NAME_COL_WIDTH;
|
|
lvc.pszText = (PWSTR)(PCWSTR)szError;
|
|
lvc.iSubItem = IDX_ERR_COL;
|
|
|
|
ListView_InsertColumn(hList, IDX_ERR_COL, &lvc);
|
|
|
|
//
|
|
// Insert the errors
|
|
//
|
|
ASSERT(m_pErrorArray != NULL && m_pNodeList != NULL);
|
|
|
|
UINT nIdx = 0;
|
|
POSITION pos = m_pNodeList->GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CTreeNode* pNode = m_pNodeList->GetNext(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
if (nIdx < m_nErrorCount && m_pErrorArray[nIdx] != 0)
|
|
{
|
|
//
|
|
// Create the list view item
|
|
//
|
|
LV_ITEM lvi = {0};
|
|
lvi.mask = LVIF_TEXT | LVIF_PARAM;
|
|
lvi.iSubItem = IDX_NAME_COL;
|
|
|
|
lvi.lParam = (LPARAM)pNode->GetDisplayName();
|
|
lvi.pszText = (PWSTR)pNode->GetDisplayName();
|
|
lvi.iItem = nIdx;
|
|
|
|
//
|
|
// Insert the new item
|
|
//
|
|
int NewIndex = ListView_InsertItem(hList, &lvi);
|
|
ASSERT(NewIndex != -1);
|
|
if (NewIndex == -1)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Get the error message
|
|
//
|
|
CString szErrorMessage;
|
|
if (CDNSErrorInfo::GetErrorString(m_pErrorArray[nIdx],szErrorMessage))
|
|
{
|
|
ListView_SetItemText(hList, NewIndex, IDX_ERR_COL, (PWSTR)(PCWSTR)szErrorMessage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSMaskCtrl
|
|
|
|
// static alert function
|
|
int CDNSMaskCtrl::AlertFunc(HWND, DWORD dwCurrent, DWORD dwLow, DWORD dwHigh)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
CString szFormat;
|
|
szFormat.LoadString(IDS_MASK_ALERT);
|
|
|
|
CString s;
|
|
s.Format((LPCWSTR)szFormat, dwCurrent, dwLow, dwHigh);
|
|
AfxMessageBox(s);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
BOOL CDNSMaskCtrl::IsBlank()
|
|
{
|
|
return static_cast<BOOL>(SendMessage(DNS_MASK_CTRL_ISBLANK, 0, 0));
|
|
}
|
|
|
|
void CDNSMaskCtrl::SetFocusField(DWORD dwField)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_SETFOCUS, dwField, 0);
|
|
}
|
|
|
|
void CDNSMaskCtrl::SetFieldRange(DWORD dwField, DWORD dwMin, DWORD dwMax)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_SET_LOW_RANGE, dwField, dwMin);
|
|
SendMessage(DNS_MASK_CTRL_SET_HI_RANGE, dwField, dwMax);
|
|
}
|
|
|
|
void CDNSMaskCtrl::SetArray(DWORD* pArray, UINT nFields)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_SET, (WPARAM)pArray, (LPARAM)nFields);
|
|
}
|
|
|
|
void CDNSMaskCtrl::GetArray(DWORD* pArray, UINT nFields)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_GET, (WPARAM)pArray, (LPARAM)nFields);
|
|
}
|
|
|
|
void CDNSMaskCtrl::Clear(int nField)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_CLEAR, (WPARAM)nField, 0);
|
|
}
|
|
|
|
void CDNSMaskCtrl::SetAlertFunction( int (*lpfnAlert)(HWND, DWORD, DWORD, DWORD) )
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_SET_ALERT, (WPARAM)lpfnAlert, 0);
|
|
}
|
|
|
|
void CDNSMaskCtrl::EnableField(int nField, BOOL bEnable)
|
|
{
|
|
SendMessage(DNS_MASK_CTRL_ENABLE_FIELD, (WPARAM)nField, (LPARAM)bEnable);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSIPv4Control
|
|
|
|
|
|
|
|
void CDNSIPv4Control::SetIPv4Val(DWORD x)
|
|
{
|
|
DWORD dwArr[4];
|
|
dwArr[3] = FIRST_IPADDRESS(x);
|
|
dwArr[2] = SECOND_IPADDRESS(x);
|
|
dwArr[1] = THIRD_IPADDRESS(x);
|
|
dwArr[0] = FOURTH_IPADDRESS(x);
|
|
SetArray(dwArr,4);
|
|
}
|
|
|
|
#define IP_FIELD_VALUE(x) ((x == FIELD_EMPTY) ? 0 : x)
|
|
|
|
void CDNSIPv4Control::GetIPv4Val(DWORD* pX)
|
|
{
|
|
DWORD dwArr[4];
|
|
GetArray(dwArr,4);
|
|
// got an array of DWORDS, if a field has value FIELD_EMPTY,
|
|
// need to assign a value of 0
|
|
*pX = static_cast<DWORD>(MAKEIPADDRESS(IP_FIELD_VALUE(dwArr[3]),
|
|
IP_FIELD_VALUE(dwArr[2]),
|
|
IP_FIELD_VALUE(dwArr[1]),
|
|
IP_FIELD_VALUE(dwArr[0])));
|
|
}
|
|
|
|
BOOL CDNSIPv4Control::IsEmpty()
|
|
{
|
|
DWORD dwArr[4];
|
|
GetArray(dwArr,4);
|
|
return ((dwArr[0] == FIELD_EMPTY) && (dwArr[1] == FIELD_EMPTY) &&
|
|
(dwArr[2] == FIELD_EMPTY) && (dwArr[3] == FIELD_EMPTY));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSIPv6Control
|
|
|
|
// REVIEW_MARCOC: need to do the same as the IPv4, with FIELD_EMPTY ==> zero
|
|
|
|
void CDNSIPv6Control::SetIPv6Val(IPV6_ADDRESS* pIpv6Address)
|
|
{
|
|
// assume the format is a WORD[8] array
|
|
DWORD dwArr[8]; // internal format, unpack
|
|
for(int k=0; k<8; k++)
|
|
{
|
|
dwArr[k] = 0x0000FFFF & REVERSE_WORD_BYTES(pIpv6Address->IP6Word[k]);
|
|
}
|
|
|
|
SetArray(dwArr,8);
|
|
}
|
|
|
|
void CDNSIPv6Control::GetIPv6Val(IPV6_ADDRESS* pIpv6Address)
|
|
{
|
|
// assume the format is a WORD[8] array
|
|
DWORD dwArr[8]; // internal format
|
|
GetArray(dwArr,8);
|
|
// got an array of DWORDS, to move into WORD[8]
|
|
// if a field has value FIELD_EMPTY, need to assign a value of 0
|
|
for(int k=0; k<8; k++)
|
|
{
|
|
if (dwArr[k] == FIELD_EMPTY)
|
|
pIpv6Address->IP6Word[k] = (WORD)0;
|
|
else
|
|
{
|
|
ASSERT(HIWORD(dwArr[k]) == 0x0);
|
|
pIpv6Address->IP6Word[k] = REVERSE_WORD_BYTES(LOWORD(dwArr[k]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSTTLControl
|
|
void CDNSTTLControl::SetTTL(DWORD x)
|
|
{
|
|
DWORD dwArr[4];
|
|
// have to change from seconds into DDD:HH:MM:SS
|
|
DWORD dwMin = x/60;
|
|
dwArr[3] = x - dwMin*60; // # of seconds left
|
|
|
|
DWORD dwHours = dwMin/60;
|
|
dwArr[2] = dwMin - dwHours*60; // # of minutes left
|
|
|
|
DWORD dwDays = dwHours/24;
|
|
dwArr[1] = dwHours - dwDays*24; // # of hours left
|
|
|
|
dwArr[0] = dwDays; // # of days left
|
|
|
|
SetArray(dwArr,4);
|
|
}
|
|
|
|
void CDNSTTLControl::GetTTL(DWORD* pX)
|
|
{
|
|
// REVIEW_MARCOC: how do we deal with an empty field?
|
|
// do we force zero on it? Should we do it in the UI when exiting a field?
|
|
DWORD dwArr[4];
|
|
GetArray(dwArr,4);
|
|
// treat empty field as zero
|
|
for(int j=0; j<4;j++)
|
|
if (dwArr[j] == FIELD_EMPTY)
|
|
dwArr[j] = 0;
|
|
|
|
// have to convert back into seconds from DDD:HH:MM:SS
|
|
*pX = dwArr[0]*3600*24 // days
|
|
+ dwArr[1]*3600 // hours
|
|
+ dwArr[2]*60 // minutes
|
|
+ dwArr[3]; // seconds
|
|
|
|
// the max value is FFFFFFFF, that is 49710 days, 6 hours, 28 minutes and 15 seconds
|
|
// field validation allows to get to 49710 days, 23 hours, 59 minutes and 59 seconds
|
|
// causing wraparound
|
|
if (*pX < dwArr[0]*3600*24) // wrapped around
|
|
*pX = 0xFFFFFFFF; // max value
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// CDNSUnsignedIntEdit
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSUnsignedIntEdit, CEdit)
|
|
ON_CONTROL_REFLECT(EN_KILLFOCUS, OnKillFocus)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
|
|
UINT _StrToUint(LPCTSTR sz)
|
|
{
|
|
LONG n = 0;
|
|
while (*sz != NULL)
|
|
{
|
|
LONG nPrev = n;
|
|
n = n*10 + (TCHAR)(*sz - TEXT('0') ); // assume it is a digit
|
|
if (nPrev > n || n > UINT_MAX)
|
|
return (UINT)-1; // wrapped
|
|
sz++;
|
|
}
|
|
return (UINT)n;
|
|
}
|
|
|
|
UINT _ForceToRange(UINT nVal, UINT nMin, UINT nMax)
|
|
{
|
|
if (nVal < nMin)
|
|
nVal = nMin;
|
|
else if( nVal > nMax)
|
|
nVal = nMax;
|
|
return nVal;
|
|
}
|
|
BOOL CDNSUnsignedIntEdit::SetVal(UINT nVal)
|
|
{
|
|
UINT n = _ForceToRange(nVal, m_nMin, m_nMax);
|
|
|
|
TCHAR szBuf[128];
|
|
wsprintf(szBuf, _T("%u"), n);
|
|
SetWindowText(szBuf);
|
|
return (nVal == n);
|
|
}
|
|
|
|
UINT CDNSUnsignedIntEdit::GetVal()
|
|
{
|
|
TCHAR szBuf[128] = {0};
|
|
GetWindowText(szBuf,128);
|
|
return _StrToUint(szBuf);
|
|
}
|
|
|
|
void CDNSUnsignedIntEdit::OnKillFocus()
|
|
{
|
|
UINT nVal = GetVal();
|
|
UINT n = _ForceToRange(nVal, m_nMin, m_nMax);
|
|
if ( (n != nVal) || (nVal == (UINT)-1) )
|
|
SetVal(n);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// CDNSUpDownUnsignedIntEdit
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSUpDownUnsignedIntEdit, CDNSUnsignedIntEdit)
|
|
ON_CONTROL_REFLECT(EN_KILLFOCUS, OnKillFocus)
|
|
ON_CONTROL_REFLECT(EN_CHANGE, OnChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CDNSUpDownUnsignedIntEdit::OnKillFocus()
|
|
{
|
|
CDNSUnsignedIntEdit::OnKillFocus();
|
|
m_pEditGroup->SetButtonsState();
|
|
}
|
|
|
|
void CDNSUpDownUnsignedIntEdit::OnChange()
|
|
{
|
|
m_pEditGroup->OnEditChange();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// CDNSUpDownButton
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSUpDownButton, CButton)
|
|
ON_CONTROL_REFLECT(BN_CLICKED, OnClicked)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CDNSUpDownButton::OnClicked()
|
|
{
|
|
m_pEditGroup->OnClicked(m_bUp);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// CDNSUpDownUnsignedIntEditGroup
|
|
|
|
void CDNSUpDownUnsignedIntEditGroup::SetVal(UINT nVal)
|
|
{
|
|
m_edit.SetVal(nVal);
|
|
SetButtonsState();
|
|
}
|
|
|
|
UINT CDNSUpDownUnsignedIntEditGroup::GetVal()
|
|
{
|
|
return m_edit.GetVal();
|
|
}
|
|
|
|
|
|
|
|
void CDNSUpDownUnsignedIntEditGroup::OnClicked(BOOL bUp)
|
|
{
|
|
UINT n = m_edit.GetVal();
|
|
if (bUp)
|
|
{
|
|
m_edit.SetVal(++n);
|
|
}
|
|
else
|
|
{
|
|
m_edit.SetVal(--n);
|
|
}
|
|
SetButtonsState();
|
|
}
|
|
|
|
|
|
|
|
BOOL CDNSUpDownUnsignedIntEditGroup::Initialize(CWnd* pParentWnd, UINT nIDEdit,
|
|
UINT nIDBtnUp, UINT nIDBtnDown)
|
|
{
|
|
ASSERT(pParentWnd != NULL);
|
|
if (pParentWnd == NULL)
|
|
return FALSE;
|
|
|
|
m_edit.Set(this);
|
|
m_upBtn.Set(this,TRUE);
|
|
m_downBtn.Set(this,FALSE);
|
|
|
|
BOOL bRes = m_upBtn.SubclassDlgItem(nIDBtnUp, pParentWnd);
|
|
ASSERT(bRes);
|
|
bRes = m_downBtn.SubclassDlgItem(nIDBtnDown, pParentWnd);
|
|
ASSERT(bRes);
|
|
if (!bRes) return FALSE;
|
|
bRes = m_edit.SubclassDlgItem(nIDEdit, pParentWnd);
|
|
ASSERT(bRes);
|
|
return bRes;
|
|
}
|
|
|
|
void CDNSUpDownUnsignedIntEditGroup::SetButtonsState()
|
|
{
|
|
UINT n = m_edit.GetVal();
|
|
BOOL bUpEnabled = n < m_edit.GetMax();
|
|
BOOL bDownEnabled = n > m_edit.GetMin();
|
|
|
|
// have to see if buttos get disabled and move the focus accordingly
|
|
CWnd* pFocus = CWnd::GetFocus();
|
|
CWnd* pNewFocus = pFocus;
|
|
if ( (pFocus == &m_upBtn) && !bUpEnabled )
|
|
{
|
|
pNewFocus = &m_downBtn;
|
|
}
|
|
if ( (pFocus == &m_downBtn) && !bDownEnabled )
|
|
{
|
|
pNewFocus = &m_upBtn;
|
|
}
|
|
if ( ((pFocus == &m_downBtn) || (pFocus == &m_upBtn)) &&
|
|
!bDownEnabled && !bUpEnabled )
|
|
{
|
|
pNewFocus = &m_edit;
|
|
}
|
|
if (pNewFocus != pFocus)
|
|
pNewFocus->SetFocus();
|
|
|
|
m_upBtn.EnableWindow(bUpEnabled);
|
|
m_downBtn.EnableWindow(bDownEnabled);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// CDNSTimeIntervalEdit
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSTimeIntervalEdit, CDNSUnsignedIntEdit)
|
|
ON_CONTROL_REFLECT(EN_KILLFOCUS, OnKillFocus)
|
|
ON_CONTROL_REFLECT(EN_CHANGE, OnChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CDNSTimeIntervalEdit::OnKillFocus()
|
|
{
|
|
m_pEditGroup->OnEditKillFocus();
|
|
}
|
|
|
|
void CDNSTimeIntervalEdit::OnChange()
|
|
{
|
|
m_pEditGroup->OnEditChange();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// CDNSTimeUnitComboBox
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSTimeUnitComboBox, CComboBox)
|
|
ON_CONTROL_REFLECT(CBN_SELCHANGE, OnSelChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CDNSTimeUnitComboBox::OnSelChange()
|
|
{
|
|
m_pEditGroup->OnComboSelChange();
|
|
}
|
|
|
|
void CDNSTimeUnitComboBox::SetUnit(unitType u)
|
|
{
|
|
ASSERT((u >= sec) || (u <= days));
|
|
if (GetCount() - 1 < u)
|
|
SetCurSel(u - 2);
|
|
else
|
|
SetCurSel(u);
|
|
}
|
|
|
|
CDNSTimeUnitComboBox::unitType CDNSTimeUnitComboBox::GetUnit()
|
|
{
|
|
int n = GetCurSel();
|
|
unitType u = (unitType)n;
|
|
ASSERT((u >= sec) || (u <= days));
|
|
return u;
|
|
}
|
|
|
|
BOOL CDNSTimeUnitComboBox::LoadStrings(UINT nIDUnitsString, UINT nMaxAddCount)
|
|
{
|
|
return LoadStringsToComboBox(_Module.GetModuleInstance(),
|
|
this, nIDUnitsString, 256, nMaxAddCount);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CDNSTimeIntervalEditGroup
|
|
|
|
CDNSTimeIntervalEditGroup::CDNSTimeIntervalEditGroup(UINT nMinVal, UINT nMaxVal)
|
|
{
|
|
m_nMinVal = nMinVal;
|
|
m_nMaxVal = nMaxVal;
|
|
InitRangeInfo();
|
|
}
|
|
|
|
void CDNSTimeIntervalEditGroup::InitRangeInfo()
|
|
{
|
|
static UINT _secondsCount[4] =
|
|
{ 1, 60, 3600, 3600*24 }; // # of secods in a sec, min, hour, day
|
|
for (UINT k=0; k<4; k++)
|
|
{
|
|
if (m_nMinVal == 0)
|
|
{
|
|
m_rangeInfoArr[k].m_nMinVal = 0;
|
|
}
|
|
else
|
|
{
|
|
m_rangeInfoArr[k].m_nMinVal = m_nMinVal/_secondsCount[k];
|
|
if (k > 0)
|
|
m_rangeInfoArr[k].m_nMinVal++;
|
|
}
|
|
m_rangeInfoArr[k].m_nMaxVal = m_nMaxVal/_secondsCount[k];
|
|
if (m_rangeInfoArr[k].m_nMaxVal >= m_rangeInfoArr[k].m_nMinVal)
|
|
m_nRangeCount = k + 1;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CDNSTimeIntervalEditGroup::Initialize(CWnd* pParentWnd, UINT nIDEdit,
|
|
UINT nIDCombo, UINT nIDComboUnitsString)
|
|
{
|
|
ASSERT(pParentWnd != NULL);
|
|
if (pParentWnd == NULL)
|
|
return FALSE;
|
|
|
|
m_edit.Set(this);
|
|
m_timeUnitCombo.Set(this);
|
|
|
|
BOOL bRes = m_edit.SubclassDlgItem(nIDEdit, pParentWnd);
|
|
ASSERT(bRes);
|
|
if (!bRes) return FALSE;
|
|
bRes = m_timeUnitCombo.SubclassDlgItem(nIDCombo, pParentWnd);
|
|
ASSERT(bRes);
|
|
if (!bRes) return FALSE;
|
|
bRes = m_timeUnitCombo.LoadStrings(nIDComboUnitsString, m_nRangeCount);
|
|
return bRes;
|
|
}
|
|
|
|
void CDNSTimeIntervalEditGroup::SetVal(UINT nVal)
|
|
{
|
|
// set default values
|
|
nVal = _ForceToRange(nVal, m_nMinVal, m_nMaxVal);
|
|
UINT nMax = (UINT)-1;
|
|
CDNSTimeUnitComboBox::unitType u = CDNSTimeUnitComboBox::sec;
|
|
|
|
// select the best unit of measurement (i.e. no truncation)
|
|
if ((nVal/60)*60 == nVal)
|
|
{
|
|
// can promote to minutes
|
|
u = CDNSTimeUnitComboBox::min;
|
|
nMax = nMax/60;
|
|
nVal = nVal/60;
|
|
if ((nVal/60)*60 == nVal)
|
|
{
|
|
// can promote to hours
|
|
u = CDNSTimeUnitComboBox::hrs;
|
|
nMax = nMax/60;
|
|
nVal = nVal/60;
|
|
if ((nVal/24)*24 == nVal)
|
|
{
|
|
// can promote to days
|
|
u = CDNSTimeUnitComboBox::days;
|
|
nMax = nMax/24;
|
|
nVal = nVal/24;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_timeUnitCombo.SetUnit(u);
|
|
m_edit.SetRange(0,nMax);
|
|
m_edit.SetVal(nVal);
|
|
}
|
|
|
|
|
|
UINT CDNSTimeIntervalEditGroup::GetVal()
|
|
{
|
|
UINT nVal = m_edit.GetVal();
|
|
CDNSTimeUnitComboBox::unitType u = m_timeUnitCombo.GetUnit();
|
|
|
|
//
|
|
// the value must always to be in seconds
|
|
//
|
|
if (u != CDNSTimeUnitComboBox::sec)
|
|
{
|
|
switch(u)
|
|
{
|
|
case CDNSTimeUnitComboBox::min:
|
|
nVal *= 60;
|
|
break;
|
|
case CDNSTimeUnitComboBox::hrs:
|
|
nVal *= 3600;
|
|
break;
|
|
case CDNSTimeUnitComboBox::days:
|
|
nVal *= (3600*24);
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
}
|
|
|
|
if (nVal < m_nMinVal ||
|
|
nVal > m_nMaxVal)
|
|
{
|
|
UINT nRangeVal = _ForceToRange(nVal, m_nMinVal, m_nMaxVal);
|
|
SetVal(nRangeVal);
|
|
nVal = nRangeVal;
|
|
}
|
|
|
|
ASSERT(nVal >= m_nMinVal && nVal <= m_nMaxVal);
|
|
return nVal;
|
|
}
|
|
|
|
void CDNSTimeIntervalEditGroup::OnEditKillFocus()
|
|
{
|
|
UINT nVal = m_edit.GetVal();
|
|
CDNSTimeUnitComboBox::unitType u = m_timeUnitCombo.GetUnit();
|
|
|
|
//
|
|
// the value must always to be in seconds
|
|
//
|
|
if (u != CDNSTimeUnitComboBox::sec)
|
|
{
|
|
switch(u)
|
|
{
|
|
case CDNSTimeUnitComboBox::min:
|
|
nVal *= 60;
|
|
break;
|
|
case CDNSTimeUnitComboBox::hrs:
|
|
nVal *= 3600;
|
|
break;
|
|
case CDNSTimeUnitComboBox::days:
|
|
nVal *= (3600*24);
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
}
|
|
UINT nRangeVal = _ForceToRange(nVal, m_nMinVal, m_nMaxVal);
|
|
if (nRangeVal != nVal)
|
|
{
|
|
SetVal(nRangeVal);
|
|
}
|
|
}
|
|
|
|
void CDNSTimeIntervalEditGroup::OnComboSelChange()
|
|
{
|
|
CDNSTimeUnitComboBox::unitType u = m_timeUnitCombo.GetUnit();
|
|
// have to adjust the range
|
|
UINT nVal = m_edit.GetVal();
|
|
UINT nMax = (UINT)-1;
|
|
|
|
// have to adjust the range
|
|
switch(u)
|
|
{
|
|
case CDNSTimeUnitComboBox::sec:
|
|
break;
|
|
case CDNSTimeUnitComboBox::min:
|
|
nMax /= 60;
|
|
break;
|
|
case CDNSTimeUnitComboBox::hrs:
|
|
nMax /= 3600;
|
|
break;
|
|
case CDNSTimeUnitComboBox::days:
|
|
nMax /= (3600*24);
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
//m_edit.SetRange(0,nMax);
|
|
UINT k = (UINT)u;
|
|
m_edit.SetRange(m_rangeInfoArr[k].m_nMinVal, m_rangeInfoArr[k].m_nMaxVal);
|
|
nVal = _ForceToRange(nVal, m_rangeInfoArr[k].m_nMinVal, m_rangeInfoArr[k].m_nMaxVal);
|
|
m_edit.SetVal(nVal);
|
|
OnEditChange();
|
|
}
|
|
|
|
void CDNSTimeIntervalEditGroup::EnableUI(BOOL bEnable)
|
|
{
|
|
m_edit.EnableWindow(bEnable);
|
|
m_timeUnitCombo.EnableWindow(bEnable);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CDNSManageControlTextHelper
|
|
|
|
CDNSManageControlTextHelper::CDNSManageControlTextHelper(int nStates)
|
|
{
|
|
m_nID = 0;
|
|
m_pParentWnd = NULL;
|
|
ASSERT(nStates > 1);
|
|
m_nStates = nStates;
|
|
m_lpszText = NULL;
|
|
m_lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*m_nStates);
|
|
if (m_lpszArr != NULL)
|
|
{
|
|
memset(m_lpszArr, 0x0, sizeof(LPWSTR*)*m_nStates);
|
|
}
|
|
}
|
|
|
|
CDNSManageControlTextHelper::~CDNSManageControlTextHelper()
|
|
{
|
|
free(m_lpszArr);
|
|
if (m_lpszText != NULL)
|
|
free(m_lpszText);
|
|
}
|
|
|
|
BOOL CDNSManageControlTextHelper::Init(CWnd* pParentWnd, UINT nID, UINT* nStrArray)
|
|
{
|
|
ASSERT(m_pParentWnd == NULL);
|
|
ASSERT(pParentWnd != NULL);
|
|
m_pParentWnd = pParentWnd;
|
|
m_nID = nID;
|
|
|
|
CWnd* pWnd = m_pParentWnd->GetDlgItem(m_nID);
|
|
if (pWnd == NULL)
|
|
return FALSE;
|
|
|
|
// get the text out of the window
|
|
int nLen = pWnd->GetWindowTextLength();
|
|
ASSERT(m_lpszText == NULL);
|
|
m_lpszText = (WCHAR*)malloc(sizeof(WCHAR)*(nLen+1));
|
|
if (m_lpszText != NULL)
|
|
{
|
|
pWnd->GetWindowText(m_lpszText, nLen+1);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
ASSERT(m_lpszText != NULL);
|
|
|
|
//
|
|
// get the text for the window
|
|
//
|
|
int nSuccessEntries;
|
|
LoadStringArrayFromResource(m_lpszArr, nStrArray, m_nStates, &nSuccessEntries);
|
|
ASSERT(nSuccessEntries == m_nStates);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CDNSManageControlTextHelper::Init(CWnd* pParentWnd, UINT nID)
|
|
{
|
|
ASSERT(m_pParentWnd == NULL);
|
|
ASSERT(pParentWnd != NULL);
|
|
m_pParentWnd = pParentWnd;
|
|
m_nID = nID;
|
|
|
|
CWnd* pWnd = m_pParentWnd->GetDlgItem(m_nID);
|
|
if (pWnd == NULL)
|
|
return FALSE;
|
|
|
|
//
|
|
// get the text out of the window
|
|
//
|
|
int nLen = pWnd->GetWindowTextLength();
|
|
ASSERT(m_lpszText == NULL);
|
|
m_lpszText = (WCHAR*)malloc(sizeof(WCHAR)*(nLen+1));
|
|
if (m_lpszText != NULL)
|
|
{
|
|
pWnd->GetWindowText(m_lpszText, nLen+1);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
ASSERT(m_lpszText != NULL);
|
|
|
|
//
|
|
// get the text for the window
|
|
//
|
|
UINT nSuccessEntries;
|
|
ParseNewLineSeparatedString(m_lpszText, m_lpszArr, &nSuccessEntries);
|
|
ASSERT(nSuccessEntries == (UINT)m_nStates);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CDNSManageControlTextHelper::SetStateX(int nIndex)
|
|
{
|
|
CWnd* pWnd = m_pParentWnd->GetDlgItem(m_nID);
|
|
ASSERT(pWnd != NULL);
|
|
ASSERT( (nIndex >0) || (nIndex < m_nStates));
|
|
pWnd->SetWindowText(m_lpszArr[nIndex]);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CDNSToggleTextControlHelper
|
|
|
|
CDNSToggleTextControlHelper::CDNSToggleTextControlHelper()
|
|
: CDNSManageControlTextHelper(2)
|
|
{
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// CDNSManageButtonTextHelper
|
|
|
|
CDNSManageButtonTextHelper::CDNSManageButtonTextHelper(int nStates)
|
|
{
|
|
m_nID = 0;
|
|
m_pParentWnd = NULL;
|
|
m_nStates = nStates;
|
|
m_lpszText = NULL;
|
|
m_lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*m_nStates);
|
|
|
|
if (m_lpszArr != NULL)
|
|
{
|
|
memset(m_lpszArr, 0x0, sizeof(LPWSTR*)*m_nStates);
|
|
}
|
|
}
|
|
|
|
CDNSManageButtonTextHelper::~CDNSManageButtonTextHelper()
|
|
{
|
|
for (int k = 0; k < m_nStates; k++)
|
|
{
|
|
if (m_lpszArr[k] != NULL)
|
|
free(m_lpszArr[k]);
|
|
}
|
|
|
|
free(m_lpszArr);
|
|
}
|
|
|
|
void CDNSManageButtonTextHelper::SetStateX(int nIndex)
|
|
{
|
|
CWnd* pWnd = m_pParentWnd->GetDlgItem(m_nID);
|
|
ASSERT(pWnd != NULL);
|
|
ASSERT( (nIndex >0) || (nIndex < m_nStates));
|
|
pWnd->SetWindowText(m_lpszArr[nIndex]);
|
|
}
|
|
|
|
BOOL CDNSManageButtonTextHelper::Init(CWnd* pParentWnd, UINT nButtonID, UINT* nStrArray)
|
|
{
|
|
ASSERT(m_pParentWnd == NULL);
|
|
ASSERT(pParentWnd != NULL);
|
|
m_pParentWnd = pParentWnd;
|
|
m_nID = nButtonID;
|
|
|
|
CWnd* pWnd = m_pParentWnd->GetDlgItem(m_nID);
|
|
if (pWnd == NULL)
|
|
return FALSE;
|
|
|
|
// get the text for the window
|
|
int nSuccessEntries;
|
|
LoadStringArrayFromResource(m_lpszArr, nStrArray, m_nStates, &nSuccessEntries);
|
|
ASSERT(nSuccessEntries == m_nStates);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// CDNSButtonToggleTextHelper
|
|
|
|
CDNSButtonToggleTextHelper::CDNSButtonToggleTextHelper()
|
|
: CDNSManageButtonTextHelper(2)
|
|
{
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDlgWorkerThread
|
|
|
|
CDlgWorkerThread::CDlgWorkerThread()
|
|
{
|
|
m_dwErr = 0x0;
|
|
}
|
|
|
|
|
|
BOOL CDlgWorkerThread::Start(CLongOperationDialog* pDlg)
|
|
{
|
|
ASSERT(pDlg != NULL);
|
|
HWND hWnd = pDlg->GetSafeHwnd();
|
|
return CWorkerThread::Start(hWnd);
|
|
}
|
|
|
|
BOOL CDlgWorkerThread::PostMessageToDlg()
|
|
{
|
|
return PostMessageToWnd(CLongOperationDialog::s_nNotificationMessage,
|
|
(WPARAM)0, (LPARAM)0);
|
|
}
|
|
|
|
|
|
int CDlgWorkerThread::Run()
|
|
{
|
|
// do the stuff
|
|
OnDoAction();
|
|
VERIFY(PostMessageToDlg());
|
|
WaitForExitAcknowledge();
|
|
//TRACE(_T("exiting\n"));
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CLongOperationDialog dialog
|
|
|
|
UINT CLongOperationDialog::s_nNotificationMessage = WM_USER + 100;
|
|
|
|
CLongOperationDialog::CLongOperationDialog(CDlgWorkerThread* pThreadObj,
|
|
CWnd* pParentWnd,
|
|
UINT nAviID)
|
|
: CDialog(IDD_SEARCHING_DIALOG, pParentWnd)
|
|
{
|
|
ASSERT(pThreadObj != NULL);
|
|
m_bAbandoned = TRUE;
|
|
m_pThreadObj = pThreadObj;
|
|
m_nAviID = nAviID;
|
|
m_bExecuteNoUI = FALSE;
|
|
}
|
|
|
|
CLongOperationDialog::~CLongOperationDialog()
|
|
{
|
|
if(m_pThreadObj != NULL)
|
|
{
|
|
delete m_pThreadObj;
|
|
m_pThreadObj = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL CLongOperationDialog::LoadTitleString(UINT nID)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
return m_szTitle.LoadString(nID);
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CLongOperationDialog, CDialog)
|
|
ON_MESSAGE( CLongOperationDialog::s_nNotificationMessage, OnNotificationMessage )
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
afx_msg LONG CLongOperationDialog::OnNotificationMessage( WPARAM, LPARAM)
|
|
{
|
|
TRACE(_T("CLongOperationDialog::OnNotificationMessage()\n"));
|
|
|
|
ASSERT(m_pThreadObj != NULL);
|
|
if (m_pThreadObj != NULL)
|
|
{
|
|
m_pThreadObj->AcknowledgeExiting();
|
|
VERIFY(WAIT_OBJECT_0 == ::WaitForSingleObject(m_pThreadObj->m_hThread,INFINITE));
|
|
m_bAbandoned = FALSE;
|
|
PostMessage(WM_CLOSE,0,0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL CLongOperationDialog::OnInitDialog()
|
|
{
|
|
TRACE(_T("CLongOperationDialog::OnInitDialog()\n"));
|
|
|
|
CDialog::OnInitDialog();
|
|
|
|
if (!m_szTitle.IsEmpty())
|
|
SetWindowText(m_szTitle);
|
|
|
|
// load auto play AVI file if needed
|
|
if (m_nAviID != -1)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
CAnimateCtrl* pAnimate = (CAnimateCtrl*)GetDlgItem(IDC_SEARCH_ANIMATE);
|
|
VERIFY(pAnimate->Open(m_nAviID));
|
|
}
|
|
|
|
// spawn worker thread
|
|
GetThreadObj()->Start(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CLongOperationDialog::OnCancel()
|
|
{
|
|
TRACE(_T("CLongOperationDialog::OnCancel()\n"));
|
|
if (m_bAbandoned)
|
|
{
|
|
m_pThreadObj->Abandon();
|
|
m_pThreadObj = NULL;
|
|
}
|
|
CDialog::OnCancel();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// CNodeEnumerationThread
|
|
|
|
CNodeEnumerationThread::CNodeEnumerationThread(CComponentDataObject* pComponentDataObject,
|
|
CMTContainerNode* pNode)
|
|
{
|
|
m_pSink = new CNotificationSinkEvent;
|
|
ASSERT(m_pSink != NULL);
|
|
m_pNode = pNode;
|
|
m_pComponentDataObject = pComponentDataObject;
|
|
m_pComponentDataObject->GetNotificationSinkTable()->Advise(m_pSink);
|
|
}
|
|
|
|
CNodeEnumerationThread::~CNodeEnumerationThread()
|
|
{
|
|
if (m_pComponentDataObject != NULL)
|
|
m_pComponentDataObject->GetNotificationSinkTable()->Unadvise(m_pSink);
|
|
delete m_pSink;
|
|
}
|
|
|
|
void CNodeEnumerationThread::OnDoAction()
|
|
{
|
|
TRACE(_T("CNodeEnumerationThread::OnDoAction() before Wait\n"));
|
|
ASSERT(m_pSink != NULL);
|
|
|
|
VERIFY(m_pComponentDataObject->PostForceEnumeration(m_pNode));
|
|
m_pSink->Wait();
|
|
TRACE(_T("CNodeEnumerationThread::OnDoAction() after Wait\n"));
|
|
}
|
|
|
|
void CNodeEnumerationThread::OnAbandon()
|
|
{
|
|
ASSERT(m_pComponentDataObject != NULL);
|
|
m_pComponentDataObject->GetNotificationSinkTable()->Unadvise(m_pSink);
|
|
m_pComponentDataObject = NULL;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// CArrayCheckListBox
|
|
|
|
BOOL CArrayCheckListBox::Initialize(UINT nCtrlID, UINT nStringID, CWnd* pParentWnd)
|
|
{
|
|
if (!SubclassDlgItem(nCtrlID, pParentWnd))
|
|
return FALSE;
|
|
SetCheckStyle(BS_AUTOCHECKBOX);
|
|
CString szBuf;
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
if (!szBuf.LoadString(nStringID))
|
|
return FALSE;
|
|
}
|
|
LPWSTR* lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*m_nArrSize);
|
|
if (!lpszArr)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
UINT nArrEntries;
|
|
ParseNewLineSeparatedString(szBuf.GetBuffer(1),lpszArr, &nArrEntries);
|
|
szBuf.ReleaseBuffer();
|
|
ASSERT(nArrEntries == m_nArrSize);
|
|
for (UINT k=0; k<nArrEntries; k++)
|
|
AddString(lpszArr[k]);
|
|
|
|
if (lpszArr)
|
|
{
|
|
free(lpszArr);
|
|
lpszArr = 0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void CArrayCheckListBox::SetValue(DWORD dw)
|
|
{
|
|
for (UINT i=0; i< m_nArrSize; i++)
|
|
SetCheck(i, (dw & m_dwMaskArr[i]) != 0);
|
|
}
|
|
|
|
DWORD CArrayCheckListBox::GetValue()
|
|
{
|
|
DWORD dw = 0;
|
|
for (UINT i=0; i< m_nArrSize; i++)
|
|
dw |= GetCheck(i) ? m_dwMaskArr[i] : 0;
|
|
return dw;
|
|
}
|
|
|
|
void CArrayCheckListBox::SetArrValue(DWORD* dwArr, UINT nArrSize)
|
|
{
|
|
ASSERT(nArrSize <= m_nArrSize);
|
|
for (UINT i=0; i< nArrSize; i++)
|
|
SetCheck(i, dwArr[i] != 0);
|
|
}
|
|
|
|
void CArrayCheckListBox::GetArrValue(DWORD* dwArr, UINT nArrSize)
|
|
{
|
|
ASSERT(nArrSize <= m_nArrSize);
|
|
for (UINT i=0; i< m_nArrSize; i++)
|
|
dwArr[i] = GetCheck(i) != 0;
|
|
}
|
|
|
|
/*
|
|
//////////////////////////////////////////////////////////
|
|
// CDNSNameEditField
|
|
|
|
void CDNSNameEditField::SetReadOnly(BOOL bReadOnly)
|
|
{
|
|
// toggle the tabstop flag
|
|
LONG currStyle = ::GetWindowLong(m_edit.m_hWnd, GWL_STYLE);
|
|
LONG newStyle = currStyle;
|
|
if (bReadOnly)
|
|
newStyle &= ~WS_TABSTOP;
|
|
else
|
|
newStyle |= WS_TABSTOP;
|
|
if (newStyle != currStyle) {
|
|
::SetWindowLong(m_edit.m_hWnd, GWL_STYLE, newStyle);
|
|
}
|
|
|
|
// toggle the read only state
|
|
m_edit.SetReadOnly(bReadOnly);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// CDNSNameEditField::CDNSNameEditBox
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSNameEditField::CDNSNameEditBox, CEdit)
|
|
ON_CONTROL_REFLECT(EN_UPDATE, CDNSNameEditField::CDNSNameEditBox::OnUpdate)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CDNSNameEditField::CDNSNameEditBox::OnUpdate()
|
|
{
|
|
if (m_bUpdatePending)
|
|
return; // avoid infinite loop
|
|
|
|
GetWindowText(m_szScratchBuffer);
|
|
TRACE(_T("OnUpdate() Text = <%s>\n"), (LPCWSTR)m_szScratchBuffer);
|
|
|
|
DNS_STATUS errName = 0;
|
|
int nScratchBufferLen = m_szScratchBuffer.GetLength();
|
|
int nScratchBufferUTF8Len = UTF8StringLen(m_szScratchBuffer);
|
|
|
|
// validate max length
|
|
if ((m_nTextLimit >= 0) && (nScratchBufferUTF8Len > m_nTextLimit))
|
|
{
|
|
errName = -1;
|
|
}
|
|
|
|
// validate no dots
|
|
if ((errName == 0) && (m_dwFlags & DNS_NAME_EDIT_FIELD_NODOTS))
|
|
{
|
|
errName = m_szScratchBuffer.Find(L'.') != -1;
|
|
}
|
|
|
|
if ((errName == 0) && ((m_dwFlags & DNS_NAME_EDIT_FIELD_NOVALIDATE) == 0))
|
|
{
|
|
errName = Validate(nScratchBufferLen);
|
|
}
|
|
|
|
if (errName != 0)
|
|
{
|
|
// bad stuff
|
|
m_bUpdatePending = TRUE;
|
|
int nStartChar, nEndChar;
|
|
GetSel(nStartChar,nEndChar);
|
|
SetWindowText(m_szCurrText);
|
|
SetSel(nStartChar-1,nEndChar-1);
|
|
m_bUpdatePending = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// good stuff
|
|
m_szCurrText = m_szScratchBuffer;
|
|
m_nCurrTextLen = nScratchBufferLen;
|
|
m_nCurrUTF8TextLen = nScratchBufferUTF8Len;
|
|
}
|
|
|
|
}
|
|
|
|
DNS_STATUS CDNSNameEditField::CDNSNameEditBox::Validate(int nScratchBufferLen)
|
|
{
|
|
DNS_STATUS errName = 0;
|
|
|
|
if ((errName == 0) && (nScratchBufferLen > 0))
|
|
{
|
|
// check for wildcards records
|
|
int nFirstAsterisk = m_szScratchBuffer.Find(L'*');
|
|
if (m_dwFlags & DNS_NAME_EDIT_FIELD_NOWILDCARDS)
|
|
{
|
|
// wildcards not accepted
|
|
errName = (nFirstAsterisk != -1);
|
|
}
|
|
else
|
|
{
|
|
if (nFirstAsterisk >= 0) // found at least one
|
|
{
|
|
// string must be "*"
|
|
errName = !((nScratchBufferLen == 1) && (nFirstAsterisk == 0));
|
|
}
|
|
}
|
|
|
|
// validate name against RFC
|
|
LPCWSTR lpszName = (LPCWSTR)m_szScratchBuffer;
|
|
if ( (errName == 0) && (m_dwFlags & (DNS_NAME_EDIT_FIELD_NORFC | DNS_NAME_EDIT_FIELD_RFC)) )
|
|
{
|
|
errName = ::DnsValidateName_W(lpszName, DnsNameDomain);
|
|
TRACE(_T("::DnsValidateName_W(%ws) return %d.\n"), lpszName, errName);
|
|
if ((m_dwFlags & DNS_NAME_EDIT_FIELD_NORFC) && (errName == DNS_ERROR_NON_RFC_NAME))
|
|
{
|
|
// we relax RFC compliance
|
|
errName = 0;
|
|
}
|
|
else if ( (m_dwFlags & DNS_NAME_EDIT_FIELD_ALLOWNUMBERS) )
|
|
{
|
|
// Assume the name failed because it is all digits
|
|
BOOL bAllDigits = TRUE;
|
|
LPWSTR lpszBuf = (LPWSTR)(LPCWSTR)m_szScratchBuffer;
|
|
for (int idx = 0; idx < nScratchBufferLen; idx++)
|
|
{
|
|
if (!iswdigit(lpszBuf[idx]))
|
|
{
|
|
// If we run across something that isn't a digit then thats not why we failed.
|
|
bAllDigits = FALSE;
|
|
TRACE(_T("Not all the characters are digits but something is still wrong.\n"));
|
|
}
|
|
}
|
|
if (bAllDigits)
|
|
{
|
|
errName = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
TRACE(_T("CDNSNameEditField::CDNSNameEditBox::Validate returns %d.\n"), errName);
|
|
return errName;
|
|
}
|
|
*/
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNSZone_AgingDialog
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSZone_AgingDialog, CHelpDialog)
|
|
ON_BN_CLICKED(IDC_SCAVENGING_ENABLED, OnCheckScavenge)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSZone_AgingDialog::CDNSZone_AgingDialog(CPropertyPageHolderBase* pHolder, UINT nID, CComponentDataObject* pComponentData)
|
|
: CHelpDialog(nID, pComponentData)
|
|
{
|
|
m_pHolder = pHolder;
|
|
m_bDirty = FALSE;
|
|
m_bAdvancedView = FALSE;
|
|
m_bScavengeDirty = FALSE;
|
|
m_bNoRefreshDirty = FALSE;
|
|
m_bRefreshDirty = FALSE;
|
|
// m_bApplyAll = FALSE;
|
|
m_bADApplyAll = FALSE;
|
|
// m_bStandardApplyAll = FALSE;
|
|
m_dwDefaultRefreshInterval = 0;
|
|
m_dwDefaultNoRefreshInterval = 0;
|
|
m_bDefaultScavengingState = FALSE;
|
|
|
|
if (pComponentData != NULL)
|
|
{
|
|
m_pComponentData = pComponentData;
|
|
}
|
|
else
|
|
{
|
|
m_pComponentData = pHolder->GetComponentData();
|
|
}
|
|
}
|
|
|
|
BOOL CDNSZone_AgingDialog::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
if (m_pHolder != NULL)
|
|
m_pHolder->PushDialogHWnd(GetSafeHwnd());
|
|
|
|
m_refreshIntervalEditGroup.m_pPage = this;
|
|
m_norefreshIntervalEditGroup.m_pPage = this;
|
|
|
|
VERIFY(m_refreshIntervalEditGroup.Initialize(this,
|
|
IDC_REFR_INT_EDIT1, IDC_REFR_INT_COMBO1,IDS_TIME_AGING_INTERVAL_UNITS));
|
|
VERIFY(m_norefreshIntervalEditGroup.Initialize(this,
|
|
IDC_REFR_INT_EDIT2, IDC_REFR_INT_COMBO2,IDS_TIME_AGING_INTERVAL_UNITS));
|
|
|
|
SendDlgItemMessage(IDC_REFR_INT_EDIT1, EM_SETLIMITTEXT, (WPARAM)10, 0);
|
|
SendDlgItemMessage(IDC_REFR_INT_EDIT2, EM_SETLIMITTEXT, (WPARAM)10, 0);
|
|
|
|
SetUIData();
|
|
return TRUE;
|
|
}
|
|
|
|
void CDNSZone_AgingDialog::SetUIData()
|
|
{
|
|
m_refreshIntervalEditGroup.SetVal(m_dwRefreshInterval);
|
|
m_norefreshIntervalEditGroup.SetVal(m_dwNoRefreshInterval);
|
|
|
|
((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->SetCheck(m_fScavengingEnabled);
|
|
|
|
// Enable the time stamp if we are in advanced view and got here through the zone property pages
|
|
if (m_bAdvancedView && m_pHolder != NULL)
|
|
{
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC1)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC2)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_TIME_STAMP)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC1)->ShowWindow(TRUE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC2)->ShowWindow(TRUE);
|
|
GetDlgItem(IDC_TIME_STAMP)->ShowWindow(TRUE);
|
|
|
|
CString cstrDate;
|
|
GetTimeStampString(cstrDate);
|
|
GetDlgItem(IDC_TIME_STAMP)->SetWindowText(cstrDate);
|
|
}
|
|
else if (!m_bAdvancedView && m_pHolder != NULL)
|
|
{
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC1)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC2)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_TIME_STAMP)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC1)->ShowWindow(FALSE);
|
|
GetDlgItem(IDC_TIME_STAMP_STATIC2)->ShowWindow(FALSE);
|
|
GetDlgItem(IDC_TIME_STAMP)->ShowWindow(FALSE);
|
|
((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->SetCheck(m_fScavengingEnabled);
|
|
}
|
|
|
|
}
|
|
|
|
void CDNSZone_AgingDialog::OnCheckScavenge()
|
|
{
|
|
m_bScavengeDirty = TRUE;
|
|
GetDlgItem(IDOK)->EnableWindow(TRUE);
|
|
}
|
|
|
|
void CDNSZone_AgingDialog::SetDirty()
|
|
{
|
|
m_bDirty = TRUE;
|
|
GetDlgItem(IDOK)->EnableWindow(TRUE);
|
|
}
|
|
|
|
void CDNSZone_AgingDialog::GetTimeStampString(CString& strref)
|
|
{
|
|
SYSTEMTIME sysUTimeStamp, sysLTimeStamp;
|
|
VERIFY(SUCCEEDED(Dns_SystemHrToSystemTime(m_dwScavengingStart, &sysUTimeStamp)));
|
|
|
|
if (!::SystemTimeToTzSpecificLocalTime(NULL, &sysUTimeStamp, &sysLTimeStamp))
|
|
return;
|
|
|
|
// Format the string with respect to locale
|
|
PTSTR ptszDate = NULL;
|
|
int cchDate = 0;
|
|
cchDate = GetDateFormat(LOCALE_USER_DEFAULT, 0 ,
|
|
&sysLTimeStamp, NULL,
|
|
ptszDate, 0);
|
|
ptszDate = (PTSTR)malloc(sizeof(TCHAR) * cchDate);
|
|
if (ptszDate == NULL)
|
|
{
|
|
strref = L"";
|
|
return;
|
|
}
|
|
|
|
if (GetDateFormat(LOCALE_USER_DEFAULT, 0,
|
|
&sysLTimeStamp, NULL,
|
|
ptszDate, cchDate))
|
|
{
|
|
strref = ptszDate;
|
|
}
|
|
else
|
|
{
|
|
strref = L"";
|
|
}
|
|
free(ptszDate);
|
|
|
|
PTSTR ptszTime = NULL;
|
|
|
|
cchDate = GetTimeFormat(LOCALE_USER_DEFAULT, 0 ,
|
|
&sysLTimeStamp, NULL,
|
|
ptszTime, 0);
|
|
ptszTime = (PTSTR)malloc(sizeof(TCHAR) * cchDate);
|
|
if (GetTimeFormat(LOCALE_USER_DEFAULT, 0,
|
|
&sysLTimeStamp, NULL,
|
|
ptszTime, cchDate))
|
|
{
|
|
strref += _T(" ") + CString(ptszTime);
|
|
}
|
|
else
|
|
{
|
|
strref += _T("");
|
|
}
|
|
free(ptszTime);
|
|
}
|
|
|
|
|
|
void CDNSZone_AgingDialog::OnOK()
|
|
{
|
|
if (m_pHolder != NULL)
|
|
m_pHolder->PopDialogHWnd();
|
|
|
|
if (m_pHolder == NULL)
|
|
{
|
|
if (0 != m_refreshIntervalEditGroup.GetVal())
|
|
{
|
|
if (m_dwRefreshInterval != m_refreshIntervalEditGroup.GetVal())
|
|
{
|
|
m_dwRefreshInterval = m_refreshIntervalEditGroup.GetVal();
|
|
m_bRefreshDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bRefreshDirty = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DNSMessageBox(IDS_MSG_INVALID_REFRESH_INTERVAL);
|
|
return;
|
|
}
|
|
|
|
if (0 != m_norefreshIntervalEditGroup.GetVal())
|
|
{
|
|
if (m_dwNoRefreshInterval != m_norefreshIntervalEditGroup.GetVal())
|
|
{
|
|
m_dwNoRefreshInterval = m_norefreshIntervalEditGroup.GetVal();
|
|
m_bNoRefreshDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bNoRefreshDirty = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DNSMessageBox(IDS_MSG_INVALID_NOREFRESH_INTERVAL);
|
|
return;
|
|
}
|
|
|
|
if (m_fScavengingEnabled != static_cast<DWORD>(((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->GetCheck()))
|
|
{
|
|
m_fScavengingEnabled = ((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->GetCheck();
|
|
m_bScavengeDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bScavengeDirty = FALSE;
|
|
}
|
|
|
|
CDNSServer_AgingConfirm dlg(this);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
CHelpDialog::OnOK();
|
|
}
|
|
else
|
|
{
|
|
m_bRefreshDirty = FALSE;
|
|
m_bNoRefreshDirty = FALSE;
|
|
m_bScavengeDirty = FALSE;
|
|
|
|
m_dwRefreshInterval = m_dwDefaultRefreshInterval;
|
|
m_dwNoRefreshInterval = m_dwDefaultNoRefreshInterval;
|
|
m_fScavengingEnabled = m_bDefaultScavengingState;
|
|
|
|
SetUIData();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL bContinue = TRUE;
|
|
if (!((CDNSZoneNode*)m_pHolder->GetTreeNode())->IsDSIntegrated() &&
|
|
((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->GetCheck() &&
|
|
!m_fScavengingEnabled)
|
|
{
|
|
if (DNSMessageBox(IDS_MSG_FILE_WARNING_ZONE, MB_YESNO) == IDNO)
|
|
{
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
if (bContinue)
|
|
{
|
|
|
|
if (0 != m_refreshIntervalEditGroup.GetVal())
|
|
{
|
|
if (m_dwRefreshInterval != m_refreshIntervalEditGroup.GetVal())
|
|
{
|
|
m_dwRefreshInterval = m_refreshIntervalEditGroup.GetVal();
|
|
m_bRefreshDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bRefreshDirty = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DNSMessageBox(IDS_MSG_INVALID_REFRESH_INTERVAL);
|
|
return;
|
|
}
|
|
|
|
if (0 != m_norefreshIntervalEditGroup.GetVal())
|
|
{
|
|
if (m_dwNoRefreshInterval != m_norefreshIntervalEditGroup.GetVal())
|
|
{
|
|
m_dwNoRefreshInterval = m_norefreshIntervalEditGroup.GetVal();
|
|
m_bNoRefreshDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bNoRefreshDirty = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DNSMessageBox(IDS_MSG_INVALID_NOREFRESH_INTERVAL);
|
|
return;
|
|
}
|
|
|
|
if (m_fScavengingEnabled != static_cast<DWORD>(((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->GetCheck()))
|
|
{
|
|
m_fScavengingEnabled = ((CButton*)GetDlgItem(IDC_SCAVENGING_ENABLED))->GetCheck();
|
|
m_bScavengeDirty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bScavengeDirty = FALSE;
|
|
}
|
|
}
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
}
|
|
|
|
void CDNSZone_AgingDialog::OnCancel()
|
|
{
|
|
if (m_pHolder != NULL)
|
|
m_pHolder->PopDialogHWnd();
|
|
CHelpDialog::OnCancel();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CDNS_AGING_TimeIntervalEditGroup
|
|
|
|
void CDNS_AGING_TimeIntervalEditGroup::OnEditChange()
|
|
{
|
|
if (m_pPage != NULL)
|
|
m_pPage->SetDirty();
|
|
}
|
|
|
|
// REVIEW_JEFFJON : Both of these functions are some serious hacks and need to be fixed
|
|
// These hacks were put in to deal with a combo box that only has hours
|
|
// and days, instead of seconds, minutes, hours, and days.
|
|
void CDNS_AGING_TimeIntervalEditGroup::SetVal(UINT nVal)
|
|
{
|
|
// set default values
|
|
nVal = _ForceToRange(nVal, m_nMinVal, m_nMaxVal);
|
|
UINT nMax = (UINT)-1;
|
|
CDNSTimeUnitComboBox::unitType u = CDNSTimeUnitComboBox::hrs;
|
|
|
|
if ((nVal/24)*24 == nVal)
|
|
{
|
|
// can promote to days
|
|
u = CDNSTimeUnitComboBox::days;
|
|
nMax = nMax/24;
|
|
nVal = nVal/24;
|
|
}
|
|
|
|
m_timeUnitCombo.SetUnit(u);
|
|
m_edit.SetRange(0,nMax);
|
|
m_edit.SetVal(nVal);
|
|
}
|
|
|
|
|
|
UINT CDNS_AGING_TimeIntervalEditGroup::GetVal()
|
|
{
|
|
CDNSTimeUnitComboBox::unitType u = m_timeUnitCombo.GetUnit();
|
|
UINT nVal = m_edit.GetVal();
|
|
// the value must always to be in hours
|
|
if (u != CDNSTimeUnitComboBox::sec)
|
|
{
|
|
switch(u)
|
|
{
|
|
case CDNSTimeUnitComboBox::min:
|
|
nVal *= 24;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
}
|
|
ASSERT(nVal >= m_nMinVal && nVal <= m_nMaxVal);
|
|
return nVal;
|
|
}
|
|
|
|
void CDNS_AGING_TimeIntervalEditGroup::InitRangeInfo()
|
|
{
|
|
static UINT _secondsCount[2] =
|
|
{ 1, 24 }; // # of hours in a hour, day
|
|
for (UINT k=0; k<2; k++)
|
|
{
|
|
if (m_nMinVal == 0)
|
|
{
|
|
m_rangeInfoArr[k].m_nMinVal = 0;
|
|
}
|
|
else
|
|
{
|
|
m_rangeInfoArr[k].m_nMinVal = m_nMinVal/_secondsCount[k];
|
|
if (k > 0)
|
|
m_rangeInfoArr[k].m_nMinVal++;
|
|
}
|
|
m_rangeInfoArr[k].m_nMaxVal = m_nMaxVal/_secondsCount[k];
|
|
if (m_rangeInfoArr[k].m_nMaxVal >= m_rangeInfoArr[k].m_nMinVal)
|
|
m_nRangeCount = k + 1;
|
|
}
|
|
}
|
|
|
|
void CDNS_SERVER_AGING_TimeIntervalEditGroup::OnEditChange()
|
|
{
|
|
if (m_pPage2 != NULL)
|
|
m_pPage2->SetDirty(TRUE);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_AgingConfirm
|
|
|
|
BOOL CDNSServer_AgingConfirm::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
// Removed because we didn't want to expose the defaults for file based zones
|
|
// ((CButton*)GetDlgItem(IDC_CHECK_AD))->SetCheck(TRUE);
|
|
// ((CButton*)GetDlgItem(IDC_CHECK_AD))->EnableWindow(FALSE);
|
|
SetAgingUpdateValues();
|
|
return FALSE;
|
|
}
|
|
|
|
void CDNSServer_AgingConfirm::SetAgingUpdateValues()
|
|
{
|
|
CEdit* pcAgingProps = (CEdit*)GetDlgItem(IDC_EDIT_NEW_DEFAULTS);
|
|
ASSERT(pcAgingProps != NULL);
|
|
|
|
CString szScavengeFormat, szScavengeValue,
|
|
szRefreshFormat, szRefreshValue,
|
|
szNoRefreshFormat, szNoRefreshValue,
|
|
szTotalString;
|
|
|
|
if (m_pAgingDialog->m_bScavengeDirty)
|
|
{
|
|
CString szEnabled;
|
|
VERIFY(szScavengeFormat.LoadString(IDS_SERVER_SCAVENGE_FORMAT));
|
|
if (m_pAgingDialog->m_fScavengingEnabled)
|
|
{
|
|
VERIFY(szEnabled.LoadString(IDS_ENABLED));
|
|
}
|
|
else
|
|
{
|
|
VERIFY(szEnabled.LoadString(IDS_DISABLED));
|
|
}
|
|
szScavengeValue.Format(szScavengeFormat, szEnabled);
|
|
szTotalString += szScavengeValue + _T("\r\n");
|
|
}
|
|
|
|
if (m_pAgingDialog->m_bNoRefreshDirty)
|
|
{
|
|
CString szUnit;
|
|
VERIFY(szNoRefreshFormat.LoadString(IDS_SERVER_NO_REFRESH_FORMAT));
|
|
|
|
DWORD nVal = 0;
|
|
if (m_pAgingDialog->m_dwNoRefreshInterval % 24 == 0)
|
|
{
|
|
szUnit.LoadString(IDS_DAYS);
|
|
nVal = m_pAgingDialog->m_dwNoRefreshInterval / 24;
|
|
}
|
|
else
|
|
{
|
|
szUnit.LoadString(IDS_HOURS);
|
|
nVal = m_pAgingDialog->m_dwNoRefreshInterval;
|
|
}
|
|
|
|
szNoRefreshValue.Format(szNoRefreshFormat, nVal, szUnit);
|
|
szTotalString += szNoRefreshValue + _T("\r\n");
|
|
}
|
|
|
|
if (m_pAgingDialog->m_bRefreshDirty)
|
|
{
|
|
CString szUnit;
|
|
VERIFY(szRefreshFormat.LoadString(IDS_SERVER_REFRESH_FORMAT));
|
|
|
|
DWORD nVal = 0;
|
|
if (m_pAgingDialog->m_dwRefreshInterval % 24 == 0)
|
|
{
|
|
szUnit.LoadString(IDS_DAYS);
|
|
nVal = m_pAgingDialog->m_dwRefreshInterval / 24;
|
|
}
|
|
else
|
|
{
|
|
szUnit.LoadString(IDS_HOURS);
|
|
nVal = m_pAgingDialog->m_dwRefreshInterval;
|
|
}
|
|
|
|
szRefreshValue.Format(szRefreshFormat, nVal, szUnit);
|
|
szTotalString += szRefreshValue;
|
|
}
|
|
|
|
pcAgingProps->SetWindowText(szTotalString);
|
|
}
|
|
|
|
void CDNSServer_AgingConfirm::OnOK()
|
|
{
|
|
// Removed because we didn't want to expose the defaults for file based zones
|
|
/* if (((CButton*)GetDlgItem(IDC_CHECK_STANDARD))->GetCheck() && m_pAgingDialog->m_fScavengingEnabled)
|
|
{
|
|
if (DNSMessageBox(IDS_MSG_FILE_WARNING, MB_YESNO) == IDNO)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
m_pAgingDialog->m_bADApplyAll = ((CButton*)GetDlgItem(IDC_CHECK_AD_APPLY_ALL))->GetCheck();
|
|
// Removed because we didn't want to expose the defaults for file based zones
|
|
// m_pAgingDialog->m_bADApplyAll = ((CButton*)GetDlgItem(IDC_CHECK_AD))->GetCheck();
|
|
// m_pAgingDialog->m_bStandardApplyAll = ((CButton*)GetDlgItem(IDC_CHECK_STANDARD))->GetCheck();
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
WINAPI
|
|
DNSTzSpecificLocalTimeToSystemTime(
|
|
LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
|
|
LPSYSTEMTIME lpLocalTime,
|
|
LPSYSTEMTIME lpUniversalTime
|
|
)
|
|
{
|
|
|
|
TIME_ZONE_INFORMATION TziData;
|
|
LPTIME_ZONE_INFORMATION Tzi;
|
|
RTL_TIME_ZONE_INFORMATION tzi;
|
|
LARGE_INTEGER TimeZoneBias;
|
|
LARGE_INTEGER NewTimeZoneBias;
|
|
LARGE_INTEGER LocalCustomBias;
|
|
LARGE_INTEGER StandardTime;
|
|
LARGE_INTEGER DaylightTime;
|
|
LARGE_INTEGER CurrentLocalTime;
|
|
LARGE_INTEGER ComputedUniversalTime;
|
|
ULONG CurrentTimeZoneId = 0xffffffff;
|
|
|
|
//
|
|
// Get the timezone information into a useful format
|
|
//
|
|
if ( !ARGUMENT_PRESENT(lpTimeZoneInformation) ) {
|
|
|
|
//
|
|
// Convert universal time to local time using current timezone info
|
|
//
|
|
if (GetTimeZoneInformation(&TziData) == TIME_ZONE_ID_INVALID) {
|
|
return FALSE;
|
|
}
|
|
Tzi = &TziData;
|
|
}
|
|
else {
|
|
Tzi = lpTimeZoneInformation;
|
|
}
|
|
|
|
tzi.Bias = Tzi->Bias;
|
|
tzi.StandardBias = Tzi->StandardBias;
|
|
tzi.DaylightBias = Tzi->DaylightBias;
|
|
|
|
RtlMoveMemory(&tzi.StandardName,&Tzi->StandardName,sizeof(tzi.StandardName));
|
|
RtlMoveMemory(&tzi.DaylightName,&Tzi->DaylightName,sizeof(tzi.DaylightName));
|
|
|
|
tzi.StandardStart.Year = Tzi->StandardDate.wYear ;
|
|
tzi.StandardStart.Month = Tzi->StandardDate.wMonth ;
|
|
tzi.StandardStart.Weekday = Tzi->StandardDate.wDayOfWeek ;
|
|
tzi.StandardStart.Day = Tzi->StandardDate.wDay ;
|
|
tzi.StandardStart.Hour = Tzi->StandardDate.wHour ;
|
|
tzi.StandardStart.Minute = Tzi->StandardDate.wMinute ;
|
|
tzi.StandardStart.Second = Tzi->StandardDate.wSecond ;
|
|
tzi.StandardStart.Milliseconds = Tzi->StandardDate.wMilliseconds;
|
|
|
|
tzi.DaylightStart.Year = Tzi->DaylightDate.wYear ;
|
|
tzi.DaylightStart.Month = Tzi->DaylightDate.wMonth ;
|
|
tzi.DaylightStart.Weekday = Tzi->DaylightDate.wDayOfWeek ;
|
|
tzi.DaylightStart.Day = Tzi->DaylightDate.wDay ;
|
|
tzi.DaylightStart.Hour = Tzi->DaylightDate.wHour ;
|
|
tzi.DaylightStart.Minute = Tzi->DaylightDate.wMinute ;
|
|
tzi.DaylightStart.Second = Tzi->DaylightDate.wSecond ;
|
|
tzi.DaylightStart.Milliseconds = Tzi->DaylightDate.wMilliseconds;
|
|
|
|
//
|
|
// convert the input local time to NT style time
|
|
//
|
|
if ( !SystemTimeToFileTime(lpLocalTime,(LPFILETIME)&CurrentLocalTime) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Get the new timezone bias
|
|
//
|
|
|
|
NewTimeZoneBias.QuadPart = Int32x32To64(tzi.Bias*60, 10000000);
|
|
|
|
//
|
|
// Now see if we have stored cutover times
|
|
//
|
|
|
|
if ( tzi.StandardStart.Month && tzi.DaylightStart.Month ) {
|
|
|
|
//
|
|
// We have timezone cutover information. Compute the
|
|
// cutover dates and compute what our current bias
|
|
// is
|
|
//
|
|
|
|
if ( !RtlCutoverTimeToSystemTime(
|
|
&tzi.StandardStart,
|
|
&StandardTime,
|
|
&CurrentLocalTime,
|
|
TRUE
|
|
) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !RtlCutoverTimeToSystemTime(
|
|
&tzi.DaylightStart,
|
|
&DaylightTime,
|
|
&CurrentLocalTime,
|
|
TRUE
|
|
) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// If daylight < standard, then time >= daylight and
|
|
// less than standard is daylight
|
|
//
|
|
|
|
if ( DaylightTime.QuadPart < StandardTime.QuadPart ) {
|
|
|
|
//
|
|
// If today is >= DaylightTime and < StandardTime, then
|
|
// We are in daylight savings time
|
|
//
|
|
|
|
if ( (CurrentLocalTime.QuadPart >= DaylightTime.QuadPart) &&
|
|
(CurrentLocalTime.QuadPart < StandardTime.QuadPart) ) {
|
|
|
|
CurrentTimeZoneId = TIME_ZONE_ID_DAYLIGHT;
|
|
}
|
|
else {
|
|
CurrentTimeZoneId = TIME_ZONE_ID_STANDARD;
|
|
}
|
|
}
|
|
else {
|
|
|
|
//
|
|
// If today is >= StandardTime and < DaylightTime, then
|
|
// We are in standard time
|
|
//
|
|
|
|
if ( (CurrentLocalTime.QuadPart >= StandardTime.QuadPart ) &&
|
|
(CurrentLocalTime.QuadPart < DaylightTime.QuadPart ) ) {
|
|
|
|
CurrentTimeZoneId = TIME_ZONE_ID_STANDARD;
|
|
}
|
|
else {
|
|
CurrentTimeZoneId = TIME_ZONE_ID_DAYLIGHT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// At this point, we know our current timezone and the
|
|
// local time of the next cutover.
|
|
//
|
|
|
|
LocalCustomBias.QuadPart = Int32x32To64(
|
|
CurrentTimeZoneId == TIME_ZONE_ID_DAYLIGHT ?
|
|
tzi.DaylightBias*60 :
|
|
tzi.StandardBias*60, // Bias in seconds
|
|
10000000
|
|
);
|
|
|
|
TimeZoneBias.QuadPart = NewTimeZoneBias.QuadPart + LocalCustomBias.QuadPart;
|
|
|
|
}
|
|
else {
|
|
TimeZoneBias = NewTimeZoneBias;
|
|
}
|
|
|
|
ComputedUniversalTime.QuadPart = CurrentLocalTime.QuadPart + TimeZoneBias.QuadPart;
|
|
|
|
if ( !FileTimeToSystemTime((LPFILETIME)&ComputedUniversalTime,lpUniversalTime) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
LONGLONG
|
|
GetSystemTime64(
|
|
SYSTEMTIME* pSysTime
|
|
)
|
|
/*++
|
|
Function : GetLongSystemTime
|
|
Description:
|
|
Parameters :
|
|
Return : 0 on error, GetLastError for more
|
|
Remarks :
|
|
--*/
|
|
{
|
|
LONGLONG llTime=0;
|
|
LONGLONG llHigh=0;
|
|
FILETIME fileTime;
|
|
|
|
//
|
|
// No return checking cause we return 0 on error
|
|
//
|
|
|
|
SystemTimeToFileTime( pSysTime, &fileTime );
|
|
|
|
llTime = (LONGLONG) fileTime.dwLowDateTime;
|
|
llHigh = (LONGLONG) fileTime.dwHighDateTime;
|
|
llTime |= (llHigh << 32);
|
|
|
|
// this is 100ns blocks since 1601. Now convert to seconds
|
|
|
|
llTime = llTime / (10*1000*1000L);
|
|
|
|
return llTime;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL LoadComboBoxFromTable(CComboBox* pComboBox, PCOMBOBOX_TABLE_ENTRY pTable)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
if (pComboBox == NULL ||
|
|
pTable == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
PCOMBOBOX_TABLE_ENTRY pTableEntry = pTable;
|
|
while (pTableEntry->nComboStringID != 0)
|
|
{
|
|
CString szComboString;
|
|
if (!szComboString.LoadString(pTableEntry->nComboStringID))
|
|
{
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
int idx = pComboBox->AddString(szComboString);
|
|
if (idx != CB_ERR)
|
|
{
|
|
pComboBox->SetItemData(idx, pTableEntry->dwComboData);
|
|
}
|
|
else
|
|
{
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
pTableEntry++;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
BOOL SetComboSelByData(CComboBox* pComboBox, DWORD dwData)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
int iCount = pComboBox->GetCount();
|
|
for (int idx = 0; idx < iCount; idx++)
|
|
{
|
|
if (pComboBox->GetItemData(idx) == dwData)
|
|
{
|
|
pComboBox->SetCurSel(idx);
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
return bRet;
|
|
} |