mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1849 lines
48 KiB
1849 lines
48 KiB
//+----------------------------------------------------------------------------
|
|
//
|
|
// DS Administration MMC snapin.
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
//
|
|
// File: DSDlgs.cpp
|
|
//
|
|
// Contents: TBD
|
|
//
|
|
// History: 02-Oct-96 WayneSc Created
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
|
|
#include "dssnap.h"
|
|
#include "uiutil.h"
|
|
|
|
#include "DSDlgs.h"
|
|
|
|
#include "helpids.h"
|
|
|
|
#include "dsrole.h" // DsRoleGetPrimaryDomainInformation
|
|
#include <lm.h>
|
|
#include <dsgetdc.h>
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChangePassword dialog
|
|
CChangePassword::CChangePassword(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CChangePassword::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CChangePassword)
|
|
m_ConfirmPwd = _T("");
|
|
m_NewPwd = _T("");
|
|
m_ChangePwd = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bAllowMustChangePwdCheck = TRUE;
|
|
}
|
|
|
|
BOOL CChangePassword::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
SendDlgItemMessage(IDC_NEW_PASSWORD, EM_LIMITTEXT, (WPARAM)127, 0);
|
|
SendDlgItemMessage(IDC_CONFIRM_PASSWORD, EM_LIMITTEXT, (WPARAM)127, 0);
|
|
|
|
GetDlgItem(IDC_CHECK_PASSWORD_MUST_CHANGE)->EnableWindow(m_bAllowMustChangePwdCheck);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CChangePassword::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CChangePassword)
|
|
DDX_Text(pDX, IDC_CONFIRM_PASSWORD, m_ConfirmPwd);
|
|
DDX_Text(pDX, IDC_NEW_PASSWORD, m_NewPwd);
|
|
DDX_Check(pDX, IDC_CHECK_PASSWORD_MUST_CHANGE, m_ChangePwd);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
void CChangePassword::Clear()
|
|
{
|
|
m_ConfirmPwd = _T("");
|
|
m_NewPwd = _T("");
|
|
|
|
SetDlgItemText(IDC_NEW_PASSWORD, L"");
|
|
SetDlgItemText(IDC_CONFIRM_PASSWORD, L"");
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CChangePassword, CHelpDialog)
|
|
END_MESSAGE_MAP()
|
|
|
|
void CChangePassword::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_CHANGE_PASSWORD);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Helper functions for CChooseDomainDlg and CChooseDCDlg
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: BrowseDomainTree
|
|
//
|
|
// Synopsis: This function invokes IDsBrowseDomainTree::BrowseTo(),
|
|
// which brings up the domain tree browse dialog, and returns the
|
|
// selected domain's DNS name
|
|
//
|
|
// NOTE: the OUT parameter needs to be LocalFreeString() by the caller
|
|
// NOTE: this function will return S_FALSE if user clicks Cancel button
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT BrowseDomainTree(
|
|
IN HWND hwndParent,
|
|
IN LPCTSTR pszServer,
|
|
OUT LPTSTR *ppszDomainDnsName
|
|
)
|
|
{
|
|
ASSERT(ppszDomainDnsName);
|
|
ASSERT(!(*ppszDomainDnsName)); // prevent memory leak
|
|
|
|
*ppszDomainDnsName = NULL;
|
|
|
|
CComPtr<IDsBrowseDomainTree> spDsDomains;
|
|
HRESULT hr = ::CoCreateInstance(CLSID_DsDomainTreeBrowser,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IDsBrowseDomainTree,
|
|
reinterpret_cast<void **>(&spDsDomains));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pszServer && *pszServer)
|
|
hr = spDsDomains->SetComputer(pszServer, NULL, NULL); // use default credential
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPTSTR lpszDomainPath;
|
|
hr = spDsDomains->BrowseTo(
|
|
hwndParent, //HWND hwndParent
|
|
&lpszDomainPath, // LPWSTR *ppszTargetPath
|
|
DBDTF_RETURNINBOUND);
|
|
if ( (hr == S_OK) && lpszDomainPath)
|
|
{
|
|
*ppszDomainDnsName = lpszDomainPath; //should be freed by CoTaskMemFree later
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT GetDCOfDomain(
|
|
IN CString& csDomainName,
|
|
OUT CString& csDCName,
|
|
IN BOOL bForce
|
|
)
|
|
{
|
|
ASSERT(csDomainName.IsEmpty() == FALSE);
|
|
|
|
CString csServerName;
|
|
DWORD dwErr = 0;
|
|
|
|
csDCName.Empty();
|
|
|
|
PDOMAIN_CONTROLLER_INFO pDCInfo = NULL;
|
|
if (bForce)
|
|
dwErr = DsGetDcName(NULL, csDomainName, NULL, NULL,
|
|
DS_DIRECTORY_SERVICE_PREFERRED | DS_FORCE_REDISCOVERY, &pDCInfo);
|
|
else
|
|
dwErr = DsGetDcName(NULL, csDomainName, NULL, NULL,
|
|
DS_DIRECTORY_SERVICE_PREFERRED, &pDCInfo);
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
if ( !(pDCInfo->Flags & DS_DS_FLAG) )
|
|
{
|
|
// down level domain
|
|
NetApiBufferFree(pDCInfo);
|
|
return S_OK;
|
|
}
|
|
|
|
csDCName = pDCInfo->DomainControllerName;
|
|
NetApiBufferFree(pDCInfo);
|
|
}
|
|
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetDnsNameOfDomainOrForest
|
|
//
|
|
// Synopsis: Given a server name or a domain name (either NETBIOS or DNS),
|
|
// this function will return the DNS name for its domain or forest.
|
|
//
|
|
// Parameters:
|
|
// csName, // a server name or a domain name
|
|
// csDnsName, // hold the returning DNS name
|
|
// bIsInputADomainName, // TRUE if csName is a domain name, FALSE if it's a server name
|
|
// bRequireDomain // TRUE for a domain dns name, FALSE for a forest dns name
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT GetDnsNameOfDomainOrForest(
|
|
IN CString& csName,
|
|
OUT CString& csDnsName,
|
|
IN BOOL bIsInputADomainName,
|
|
IN BOOL bRequireDomain
|
|
)
|
|
{
|
|
|
|
BOOL bRetry = FALSE;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pBuffer = NULL;
|
|
CString csServerName;
|
|
DWORD dwErr = 0;
|
|
|
|
csDnsName.Empty();
|
|
|
|
do {
|
|
if (bIsInputADomainName)
|
|
{
|
|
PDOMAIN_CONTROLLER_INFO pDCInfo = NULL;
|
|
if (bRetry)
|
|
dwErr = DsGetDcName(NULL, csName, NULL, NULL,
|
|
DS_DIRECTORY_SERVICE_PREFERRED | DS_FORCE_REDISCOVERY, &pDCInfo);
|
|
else
|
|
dwErr = DsGetDcName(NULL, csName, NULL, NULL,
|
|
DS_DIRECTORY_SERVICE_PREFERRED, &pDCInfo);
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
if ( !(pDCInfo->Flags & DS_DS_FLAG) )
|
|
{
|
|
// down level domain
|
|
NetApiBufferFree(pDCInfo);
|
|
return S_OK;
|
|
}
|
|
|
|
DWORD dwExpectFlag = (bRequireDomain ?
|
|
DS_DNS_DOMAIN_FLAG :
|
|
DS_DNS_FOREST_FLAG);
|
|
|
|
if (pDCInfo->Flags & dwExpectFlag)
|
|
{
|
|
// skip call to DsRoleGetPrimaryDomainInformation()
|
|
csDnsName = (bRequireDomain ?
|
|
pDCInfo->DomainName :
|
|
pDCInfo->DnsForestName);
|
|
NetApiBufferFree(pDCInfo);
|
|
|
|
//
|
|
// The DNS name is in absolute form, remove the ending dot
|
|
//
|
|
if (csDnsName.Right(1) == _T("."))
|
|
csDnsName.SetAt(csDnsName.GetLength() - 1, _T('\0'));
|
|
|
|
return S_OK;
|
|
|
|
} else {
|
|
csServerName = pDCInfo->DomainControllerName;
|
|
NetApiBufferFree(pDCInfo);
|
|
}
|
|
} else
|
|
{
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
} else
|
|
{
|
|
csServerName = csName;
|
|
}
|
|
|
|
dwErr = DsRoleGetPrimaryDomainInformation(
|
|
csServerName,
|
|
DsRolePrimaryDomainInfoBasic,
|
|
(PBYTE *)&pBuffer);
|
|
if (RPC_S_SERVER_UNAVAILABLE == dwErr && bIsInputADomainName && !bRetry)
|
|
bRetry = TRUE; // only retry once
|
|
else
|
|
break;
|
|
|
|
} while (1);
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
csDnsName = (bRequireDomain ?
|
|
pBuffer->DomainNameDns :
|
|
pBuffer->DomainForestName);
|
|
if (csDnsName.IsEmpty())
|
|
{
|
|
if (pBuffer->Flags & DSROLE_PRIMARY_DS_RUNNING)
|
|
csDnsName = pBuffer->DomainNameFlat;
|
|
}
|
|
|
|
DsRoleFreeMemory(pBuffer);
|
|
|
|
//
|
|
// In case the DNS name is in absolute form, remove the ending dot
|
|
//
|
|
if (csDnsName.Right(1) == _T("."))
|
|
csDnsName.SetAt(csDnsName.GetLength() - 1, _T('\0'));
|
|
|
|
}
|
|
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChooseDomainDlg dialog
|
|
|
|
|
|
CChooseDomainDlg::CChooseDomainDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CChooseDomainDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CChooseDomainDlg)
|
|
m_csTargetDomain = _T("");
|
|
m_bSaveCurrent = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CChooseDomainDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CChooseDomainDlg)
|
|
DDX_Text(pDX, IDC_SELECTDOMAIN_DOMAIN, m_csTargetDomain);
|
|
DDX_Check(pDX, IDC_SAVE_CURRENT_CHECK, m_bSaveCurrent);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CChooseDomainDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CChooseDomainDlg)
|
|
ON_BN_CLICKED(IDC_SELECTDOMAIN_BROWSE, OnSelectdomainBrowse)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChooseDomainDlg message handlers
|
|
|
|
void CChooseDomainDlg::OnSelectdomainBrowse()
|
|
{
|
|
CWaitCursor cwait;
|
|
|
|
HRESULT hr = S_OK;
|
|
LPTSTR lpszDomainDnsName = NULL;
|
|
CString csDomainName, csDCName;
|
|
|
|
GetDlgItemText(IDC_SELECTDOMAIN_DOMAIN, csDomainName);
|
|
csDomainName.TrimLeft();
|
|
csDomainName.TrimRight();
|
|
if (!csDomainName.IsEmpty())
|
|
hr = GetDCOfDomain(csDomainName, csDCName, FALSE);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = BrowseDomainTree(m_hWnd, csDCName, &lpszDomainDnsName);
|
|
if ( FAILED(hr) &&
|
|
!csDCName.IsEmpty() &&
|
|
HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) == hr )
|
|
{
|
|
// force the cached info in DsGetDcName to be refreshed
|
|
hr = GetDCOfDomain(csDomainName, csDCName, TRUE);
|
|
if (SUCCEEDED(hr))
|
|
hr = BrowseDomainTree(m_hWnd, csDCName, &lpszDomainDnsName);
|
|
}
|
|
|
|
if ( (hr == S_OK) && lpszDomainDnsName )
|
|
{
|
|
SetDlgItemText(IDC_SELECTDOMAIN_DOMAIN, lpszDomainDnsName);
|
|
CoTaskMemFree(lpszDomainDnsName);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDomainName)));
|
|
|
|
ReportErrorEx(m_hWnd,IDS_CANT_BROWSE_DOMAIN, hr,
|
|
MB_OK | MB_ICONERROR, apv, 1, 0);
|
|
}
|
|
|
|
GetDlgItem(IDC_SELECTDOMAIN_DOMAIN)->SetFocus();
|
|
}
|
|
|
|
void CChooseDomainDlg::OnOK()
|
|
{
|
|
CWaitCursor cwait;
|
|
HRESULT hr = S_OK;
|
|
CString csName, csDnsName;
|
|
|
|
//
|
|
// Validate contents in the domain edit box
|
|
//
|
|
GetDlgItemText(IDC_SELECTDOMAIN_DOMAIN, csName);
|
|
if (csName.IsEmpty())
|
|
{
|
|
ReportMessageEx(m_hWnd, IDS_INCORRECT_INPUT,
|
|
MB_OK | MB_ICONSTOP);
|
|
(GetDlgItem(IDC_SELECTDOMAIN_DOMAIN))->SetFocus();
|
|
return;
|
|
}
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
csName,
|
|
csDnsName,
|
|
TRUE,
|
|
!m_bSiteRepl);
|
|
if (csDnsName.IsEmpty())
|
|
{
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csName)));
|
|
|
|
if (FAILED(hr))
|
|
ReportErrorEx(m_hWnd, IDS_SELECTDOMAIN_INCORRECT_DOMAIN_DUETO, hr,
|
|
MB_OK | MB_ICONSTOP, apv, 1, 0);
|
|
else
|
|
ReportMessageEx(m_hWnd, IDS_SELECTDOMAIN_DOWNLEVEL_DOMAIN,
|
|
MB_OK | MB_ICONSTOP, apv, 1);
|
|
|
|
SetDlgItemText(IDC_SELECTDOMAIN_DOMAIN, _T(""));
|
|
(GetDlgItem (IDC_SELECTDOMAIN_DOMAIN))->SetFocus();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// When exiting from the dialog
|
|
// use DNS domain name;
|
|
//
|
|
SetDlgItemText(IDC_SELECTDOMAIN_DOMAIN, csDnsName);
|
|
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
|
|
BOOL CChooseDomainDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
//
|
|
// for siterepl snapin only,
|
|
// change dialog title to "Choose Target Forest"
|
|
// change domain label to "Root domain:"
|
|
// hide browse button
|
|
//
|
|
if (m_bSiteRepl)
|
|
{
|
|
CString csDlgTitle, csLabel;
|
|
csDlgTitle.LoadString(IDS_SELECTDOMAIN_TITLE_FOREST);
|
|
SetWindowText(csDlgTitle);
|
|
csLabel.LoadString(IDS_SELECTDOMAIN_DOMAIN_LABEL);
|
|
SetDlgItemText(IDC_SELECTDOMAIN_LABEL, csLabel);
|
|
|
|
// Hide & Disable the Browse button for SiteRepl snapin
|
|
(GetDlgItem(IDC_SELECTDOMAIN_BROWSE))->ShowWindow(SW_HIDE);
|
|
(GetDlgItem(IDC_SELECTDOMAIN_BROWSE))->EnableWindow(FALSE);
|
|
}
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CChooseDomainDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_SELECT_DOMAIN);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChooseDCDlg dialog
|
|
|
|
BEGIN_MESSAGE_MAP(CSelectDCEdit, CEdit)
|
|
ON_WM_KILLFOCUS()
|
|
END_MESSAGE_MAP()
|
|
|
|
void CSelectDCEdit::OnKillFocus(CWnd* pNewWnd)
|
|
{
|
|
//
|
|
// subclass the domain edit control.
|
|
// When focus moves to OK/Cancel/Browse button, do not invoke
|
|
// RefreshDCListView
|
|
//
|
|
m_bHandleKillFocus = TRUE;
|
|
if (pNewWnd)
|
|
{
|
|
int id = pNewWnd->GetDlgCtrlID();
|
|
if (id == IDOK ||
|
|
id == IDCANCEL ||
|
|
id == IDC_SELECTDC_BROWSE)
|
|
{
|
|
m_bHandleKillFocus = FALSE;
|
|
}
|
|
}
|
|
|
|
CEdit::OnKillFocus(pNewWnd);
|
|
}
|
|
|
|
|
|
CChooseDCDlg::CChooseDCDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CChooseDCDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CChooseDCDlg)
|
|
m_csTargetDomainController = _T("");
|
|
m_csTargetDomain = _T("");
|
|
//}}AFX_DATA_INIT
|
|
m_csPrevDomain = _T("");
|
|
m_pDCBufferManager = NULL;
|
|
m_csAnyDC.LoadString(IDS_ANY_DOMAIN_CONTROLLER);
|
|
m_csWaiting.LoadString(IDS_WAITING);
|
|
m_csError.LoadString(IDS_ERROR);
|
|
}
|
|
|
|
CChooseDCDlg::~CChooseDCDlg()
|
|
{
|
|
TRACE(_T("CChooseDCDlg::~CChooseDCDlg\n"));
|
|
|
|
if (m_pDCBufferManager)
|
|
{
|
|
//
|
|
// signal all related running threads to terminate
|
|
//
|
|
m_pDCBufferManager->SignalExit();
|
|
|
|
//
|
|
// decrement the reference count on the CDCBufferManager instance
|
|
//
|
|
m_pDCBufferManager->Release();
|
|
}
|
|
|
|
CHelpDialog::~CHelpDialog();
|
|
}
|
|
|
|
void CChooseDCDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CChooseDCDlg)
|
|
DDX_Control(pDX, IDC_SELECTDC_DCLISTVIEW, m_hDCListView);
|
|
DDX_Text(pDX, IDC_SELECTDC_DCEDIT, m_csTargetDomainController);
|
|
DDX_Text(pDX, IDC_SELECTDC_DOMAIN, m_csTargetDomain);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CChooseDCDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CChooseDCDlg)
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_SELECTDC_DCLISTVIEW, OnItemchangedSelectdcDCListView)
|
|
ON_EN_KILLFOCUS(IDC_SELECTDC_DOMAIN, OnKillfocusSelectdcDomain)
|
|
ON_BN_CLICKED(IDC_SELECTDC_BROWSE, OnSelectdcBrowse)
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_SELECTDC_DCLISTVIEW, OnColumnclickSelectdcDCListView)
|
|
//}}AFX_MSG_MAP
|
|
ON_MESSAGE(WM_USER_GETDC_THREAD_DONE, OnGetDCThreadDone)
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChooseDCDlg message handlers
|
|
typedef struct _DCListViewItem
|
|
{
|
|
CString csName;
|
|
CString csSite;
|
|
} DCLISTVIEWITEM;
|
|
|
|
BOOL CChooseDCDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
//
|
|
// sub-class the domain edit control, in order to intercept WM_KILLFOCUS
|
|
// if the new focus will be set on Cancel button, don't process
|
|
// EN_KILLFOCUS (i.e., don't start the thread to refresh DC list view )
|
|
//
|
|
VERIFY(m_selectDCEdit.SubclassDlgItem(IDC_SELECTDC_DOMAIN, this));
|
|
|
|
//
|
|
// create instance of CDCBufferManager
|
|
// m_pDCBufferManager will be set to NULL if CreateInstance() failed.
|
|
//
|
|
(void) CDCBufferManager::CreateInstance(m_hWnd, &m_pDCBufferManager);
|
|
|
|
//
|
|
// display currently targeted domain controller
|
|
//
|
|
CString csText, csFormat;
|
|
csFormat.LoadString(IDS_SELECTDC_DCEDIT_TITLE);
|
|
csText.Format(csFormat, m_csTargetDomainController);
|
|
SetDlgItemText(IDC_SELECTDC_DCEDIT_TITLE, csText);
|
|
|
|
//
|
|
// calculate the listview column width
|
|
//
|
|
RECT rect;
|
|
ZeroMemory(&rect, sizeof(rect));
|
|
(GetDlgItem(IDC_SELECTDC_DCLISTVIEW))->GetWindowRect(&rect);
|
|
int nControlWidth = rect.right - rect.left;
|
|
int nVScrollbarWidth = GetSystemMetrics(SM_CXVSCROLL);
|
|
int nBorderWidth = GetSystemMetrics(SM_CXBORDER);
|
|
int nControlNetWidth = nControlWidth - nVScrollbarWidth - 4 * nBorderWidth;
|
|
int nWidth1 = nControlNetWidth / 2;
|
|
int nWidth2 = nControlNetWidth - nWidth1;
|
|
|
|
//
|
|
// insert two columns of DC list view
|
|
//
|
|
LV_COLUMN col;
|
|
CString cstrText;
|
|
ZeroMemory(&col, sizeof(col));
|
|
col.mask = LVCF_TEXT | LVCF_WIDTH;
|
|
col.cx = nWidth1;
|
|
cstrText.LoadString(IDS_SELECTDC_DCLISTVIEW_NAME);
|
|
col.pszText = const_cast<LPTSTR>(static_cast<LPCTSTR>(cstrText));
|
|
ListView_InsertColumn(m_hDCListView, 0, &col);
|
|
col.cx = nWidth2;
|
|
cstrText.LoadString(IDS_SELECTDC_DCLISTVIEW_SITE);
|
|
col.pszText = const_cast<LPTSTR>(static_cast<LPCTSTR>(cstrText));
|
|
ListView_InsertColumn(m_hDCListView, 1, &col);
|
|
|
|
//
|
|
// Set full row selection style
|
|
//
|
|
ListView_SetExtendedListViewStyleEx(m_hDCListView, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
|
|
|
|
//
|
|
// disable the list view control
|
|
// In case we failed to create a CDCBufferManager instance, user can
|
|
// still use this dialog to type in a domain name and a DC name.
|
|
//
|
|
m_hDCListView.EnableWindow(FALSE);
|
|
|
|
//
|
|
// insert items into DC list view
|
|
//
|
|
RefreshDCListView();
|
|
|
|
if (!m_bSiteRepl)
|
|
{
|
|
//
|
|
// Disable domain edit box and hide&disable Browse button for non-siterepl snapins
|
|
//
|
|
(reinterpret_cast<CEdit *>(GetDlgItem(IDC_SELECTDC_DOMAIN)))->SetReadOnly(TRUE);
|
|
(GetDlgItem(IDC_SELECTDC_BROWSE))->ShowWindow(SW_HIDE);
|
|
(GetDlgItem(IDC_SELECTDC_BROWSE))->EnableWindow(FALSE);
|
|
|
|
//
|
|
// for non-siterepl snapins, set focus to the DC edit box;
|
|
// for siterepl snapin, the focus will be set on the domain edit box.
|
|
//
|
|
(GetDlgItem(IDC_SELECTDC_DCEDIT))->SetFocus();
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
// return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
int CALLBACK ListViewCompareProc(
|
|
IN LPARAM lParam1,
|
|
IN LPARAM lParam2,
|
|
IN LPARAM lParamSort)
|
|
{
|
|
DCLISTVIEWITEM *pItem1 = (DCLISTVIEWITEM *)lParam1;
|
|
DCLISTVIEWITEM *pItem2 = (DCLISTVIEWITEM *)lParam2;
|
|
int iResult = 0;
|
|
|
|
if (pItem1 && pItem2)
|
|
{
|
|
switch( lParamSort)
|
|
{
|
|
case 0: // Sort by Name.
|
|
iResult = pItem1->csName.CompareNoCase(pItem2->csName);
|
|
break;
|
|
case 1: // Sort by Site.
|
|
iResult = pItem1->csSite.CompareNoCase(pItem2->csSite);
|
|
break;
|
|
default:
|
|
iResult = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(iResult);
|
|
}
|
|
|
|
void CChooseDCDlg::OnColumnclickSelectdcDCListView(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
|
|
ListView_SortItems( m_hDCListView,
|
|
ListViewCompareProc,
|
|
(LPARAM)(pNMListView->iSubItem));
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
#define MAX_LENGTH_DCNAME 1024
|
|
void CChooseDCDlg::OnItemchangedSelectdcDCListView(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
|
|
//
|
|
// set DC edit box to the currently selected item in the dc list view
|
|
//
|
|
|
|
if ( (pNMListView->uChanged & LVIF_STATE) &&
|
|
(pNMListView->uNewState & LVIS_SELECTED) )
|
|
{
|
|
TCHAR pszBuffer[MAX_LENGTH_DCNAME];
|
|
|
|
ListView_GetItemText(
|
|
(GetDlgItem(IDC_SELECTDC_DCLISTVIEW))->GetSafeHwnd(),
|
|
pNMListView->iItem,
|
|
0,
|
|
pszBuffer,
|
|
MAX_LENGTH_DCNAME * sizeof(TCHAR)
|
|
);
|
|
|
|
SetDlgItemText(IDC_SELECTDC_DCEDIT, pszBuffer);
|
|
}
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CChooseDCDlg::OnKillfocusSelectdcDomain()
|
|
{
|
|
TRACE(_T("CChooseDCDlg::OnKillfocusSelectdcDomain\n"));
|
|
|
|
//
|
|
// when focus leaves domain edit box, refresh the items in the dc list view
|
|
// we do this only for siterepl snapin whose domain edit box is enabled.
|
|
//
|
|
if (m_selectDCEdit.m_bHandleKillFocus)
|
|
{
|
|
if (m_bSiteRepl)
|
|
RefreshDCListView();
|
|
}
|
|
}
|
|
|
|
void CChooseDCDlg::OnSelectdcBrowse()
|
|
{
|
|
CWaitCursor cwait;
|
|
|
|
//
|
|
// bring up the domain tree browse dialog
|
|
//
|
|
HRESULT hr = S_OK;
|
|
LPTSTR lpszDomainDnsName = NULL;
|
|
CString csDomainName, csDCName;
|
|
|
|
GetDlgItemText(IDC_SELECTDC_DOMAIN, csDomainName);
|
|
csDomainName.TrimLeft();
|
|
csDomainName.TrimRight();
|
|
if (!csDomainName.IsEmpty())
|
|
hr = GetDCOfDomain(csDomainName, csDCName, FALSE);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = BrowseDomainTree(m_hWnd, csDCName, &lpszDomainDnsName);
|
|
if ( FAILED(hr) &&
|
|
!csDCName.IsEmpty() &&
|
|
HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) == hr )
|
|
{
|
|
// force the cached info in DsGetDcName to be refreshed
|
|
hr = GetDCOfDomain(csDomainName, csDCName, TRUE);
|
|
if (SUCCEEDED(hr))
|
|
hr = BrowseDomainTree(m_hWnd, csDCName, &lpszDomainDnsName);
|
|
}
|
|
|
|
if ( (hr == S_OK) && lpszDomainDnsName )
|
|
{
|
|
SetDlgItemText(IDC_SELECTDC_DOMAIN, lpszDomainDnsName);
|
|
CoTaskMemFree(lpszDomainDnsName);
|
|
|
|
RefreshDCListView();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDomainName)));
|
|
|
|
ReportErrorEx(m_hWnd,IDS_CANT_BROWSE_DOMAIN, hr,
|
|
MB_OK | MB_ICONERROR, apv, 1, 0);
|
|
}
|
|
|
|
GetDlgItem(IDC_SELECTDC_DOMAIN)->SetFocus();
|
|
}
|
|
|
|
void CChooseDCDlg::OnOK()
|
|
{
|
|
TRACE(_T("CChooseDCDlg::OnOK\n"));
|
|
|
|
CWaitCursor wait;
|
|
HRESULT hr = S_OK;
|
|
|
|
CString csDnsForSelectedDomain;
|
|
CString csDnsForCurrentForest, csDnsForSelectedForest;
|
|
|
|
if (m_bSiteRepl)
|
|
{
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
m_csTargetDomain,
|
|
csDnsForCurrentForest,
|
|
TRUE,
|
|
FALSE); // get forest name
|
|
if (csDnsForCurrentForest.IsEmpty())
|
|
csDnsForCurrentForest = m_csTargetDomain;
|
|
}
|
|
|
|
//
|
|
// Validate contents in the DC edit box
|
|
//
|
|
CString csDCEdit;
|
|
GetDlgItemText(IDC_SELECTDC_DCEDIT, csDCEdit);
|
|
|
|
// treat empty csDCEdit as same as m_csAnyDC
|
|
if (!csDCEdit.IsEmpty() && m_csAnyDC.CompareNoCase(csDCEdit))
|
|
{
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
csDCEdit,
|
|
csDnsForSelectedDomain,
|
|
FALSE,
|
|
TRUE); // get domain name
|
|
if (SUCCEEDED(hr) && m_bSiteRepl)
|
|
{
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
csDCEdit,
|
|
csDnsForSelectedForest,
|
|
FALSE,
|
|
FALSE); // get forest name
|
|
}
|
|
if (csDnsForSelectedDomain.IsEmpty() || (m_bSiteRepl && csDnsForSelectedForest.IsEmpty()) )
|
|
{
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDCEdit)));
|
|
|
|
if (FAILED(hr))
|
|
ReportErrorEx(m_hWnd, IDS_SELECTDC_INCORRECT_DC_DUETO, hr,
|
|
MB_OK | MB_ICONSTOP, apv, 1, 0);
|
|
else
|
|
ReportMessageEx(m_hWnd, IDS_SELECTDC_DOWNLEVEL_DC,
|
|
MB_OK | MB_ICONSTOP, apv, 1);
|
|
|
|
(GetDlgItem(IDC_SELECTDC_DCEDIT))->SetFocus();
|
|
|
|
return;
|
|
}
|
|
|
|
} else
|
|
{
|
|
|
|
//
|
|
// Validate contents in the domain edit box
|
|
//
|
|
CString csDomain;
|
|
GetDlgItemText(IDC_SELECTDC_DOMAIN, csDomain);
|
|
if (csDomain.IsEmpty())
|
|
{
|
|
ReportMessageEx(m_hWnd, IDS_INCORRECT_INPUT,
|
|
MB_OK | MB_ICONSTOP);
|
|
(GetDlgItem(IDC_SELECTDC_DOMAIN))->SetFocus();
|
|
return;
|
|
}
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
csDomain,
|
|
csDnsForSelectedDomain,
|
|
TRUE,
|
|
TRUE); // get domain name
|
|
if (SUCCEEDED(hr) && m_bSiteRepl)
|
|
{
|
|
hr = GetDnsNameOfDomainOrForest(
|
|
csDomain,
|
|
csDnsForSelectedForest,
|
|
TRUE,
|
|
FALSE); // get forest name
|
|
}
|
|
if (csDnsForSelectedDomain.IsEmpty() || (m_bSiteRepl && csDnsForSelectedForest.IsEmpty()) )
|
|
{
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDomain)));
|
|
|
|
if (FAILED(hr))
|
|
ReportErrorEx(m_hWnd, IDS_SELECTDC_INCORRECT_DOMAIN_DUETO, hr,
|
|
MB_OK | MB_ICONSTOP, apv, 1, 0);
|
|
else
|
|
ReportMessageEx(m_hWnd, IDS_SELECTDC_DOWNLEVEL_DOMAIN,
|
|
MB_OK | MB_ICONSTOP, apv, 1);
|
|
|
|
SetDlgItemText(IDC_SELECTDC_DOMAIN, _T(""));
|
|
(GetDlgItem(IDC_SELECTDC_DOMAIN))->SetFocus();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// if the current selected forest/domain does not belong to the current administering forest/domain,
|
|
// ask user if he really wants to administer the selected forest/domain
|
|
// via the selected DC (or any writable DC)?
|
|
//
|
|
if ( (m_bSiteRepl && csDnsForSelectedForest.CompareNoCase(csDnsForCurrentForest)) ||
|
|
(!m_bSiteRepl && csDnsForSelectedDomain.CompareNoCase(m_csTargetDomain)) )
|
|
{
|
|
int nArgs = 0;
|
|
int id = 0;
|
|
PVOID apv[3];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(m_bSiteRepl ? csDnsForCurrentForest : m_csTargetDomain)));
|
|
apv[1] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(m_bSiteRepl ? csDnsForSelectedForest : csDnsForSelectedDomain)));
|
|
if (m_csAnyDC.CompareNoCase(csDCEdit))
|
|
{
|
|
nArgs = 3;
|
|
apv[2] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDCEdit)));
|
|
id = (m_bSiteRepl ?
|
|
IDS_SELECTDC_UNMATCHED_DC_DOMAIN_SITEREPL :
|
|
IDS_SELECTDC_UNMATCHED_DC_DOMAIN);
|
|
} else
|
|
{
|
|
nArgs = 2;
|
|
id = (m_bSiteRepl ?
|
|
IDS_SELECTDC_UNMATCHED_DC_DOMAIN_SITEREPL_ANY :
|
|
IDS_SELECTDC_UNMATCHED_DC_DOMAIN_ANY);
|
|
}
|
|
|
|
if (IDYES != ReportMessageEx(m_hWnd, id, MB_YESNO, apv, nArgs))
|
|
{
|
|
(GetDlgItem(IDC_SELECTDC_DCEDIT))->SetFocus();
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// When exiting from the dialog
|
|
// use DNS domain name;
|
|
// use blank string if "Any Writable DC"
|
|
// clean list view control
|
|
//
|
|
SetDlgItemText(IDC_SELECTDC_DOMAIN, csDnsForSelectedDomain);
|
|
if (0 == m_csAnyDC.CompareNoCase(csDCEdit))
|
|
SetDlgItemText(IDC_SELECTDC_DCEDIT, _T(""));
|
|
FreeDCItems(m_hDCListView);
|
|
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
void CChooseDCDlg::OnCancel()
|
|
{
|
|
TRACE(_T("CChooseDCDlg::OnCancel\n"));
|
|
|
|
//
|
|
// When exiting from the dialog
|
|
// clean list view control
|
|
//
|
|
FreeDCItems(m_hDCListView);
|
|
|
|
CHelpDialog::OnCancel();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CChooseDCDlg::InsertSpecialMsg
|
|
//
|
|
// Synopsis: Insert "Waiting..." or "Error" into the list view control,
|
|
// and disable the control to prevent it from being selected.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CChooseDCDlg::InsertSpecialMsg(
|
|
IN BOOL bWaiting
|
|
)
|
|
{
|
|
LV_ITEM item;
|
|
|
|
//
|
|
// clear DC list view
|
|
//
|
|
FreeDCItems(m_hDCListView);
|
|
|
|
ZeroMemory(&item, sizeof(item));
|
|
item.mask = LVIF_TEXT;
|
|
item.pszText = const_cast<LPTSTR>(
|
|
static_cast<LPCTSTR>(bWaiting ? m_csWaiting: m_csError));
|
|
ListView_InsertItem(m_hDCListView, &item);
|
|
|
|
//
|
|
// disable the list view to prevent user from clicking on "Waiting..."
|
|
//
|
|
m_hDCListView.EnableWindow(FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CChooseDCDlg::InsertDCListView
|
|
//
|
|
// Synopsis: Insert items into the list view control of the owner dialog.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CChooseDCDlg::InsertDCListView(
|
|
IN CDCSITEINFO *pEntry
|
|
)
|
|
{
|
|
ASSERT(pEntry);
|
|
|
|
DWORD cInfo = pEntry->GetNumOfInfo();
|
|
PDS_DOMAIN_CONTROLLER_INFO_1 pDCInfo = pEntry->GetDCInfo();
|
|
|
|
ASSERT(cInfo > 0);
|
|
ASSERT(pDCInfo);
|
|
|
|
LV_ITEM item;
|
|
int index = 0;
|
|
DCLISTVIEWITEM *pItem = NULL;
|
|
DWORD dwErr = 0;
|
|
|
|
//
|
|
// clear DC list view
|
|
//
|
|
FreeDCItems(m_hDCListView);
|
|
|
|
//
|
|
// insert DC list view
|
|
//
|
|
ZeroMemory(&item, sizeof(item));
|
|
item.mask = LVIF_TEXT | LVIF_PARAM;
|
|
|
|
for (DWORD i=0; i<cInfo; i++) {
|
|
|
|
ASSERT(pDCInfo[i].NetbiosName || pDCInfo[i].DnsHostName);
|
|
|
|
if (pDCInfo[i].DnsHostName)
|
|
item.pszText = pDCInfo[i].DnsHostName;
|
|
else
|
|
item.pszText = pDCInfo[i].NetbiosName;
|
|
|
|
pItem = new DCLISTVIEWITEM;
|
|
if (!pItem)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
pItem->csName = item.pszText;
|
|
if (pDCInfo[i].SiteName)
|
|
pItem->csSite = pDCInfo[i].SiteName;
|
|
else
|
|
pItem->csSite = _T("");
|
|
|
|
item.lParam = reinterpret_cast<LPARAM>(pItem);
|
|
|
|
index = ListView_InsertItem(m_hDCListView, &item);
|
|
ListView_SetItemText(m_hDCListView, index, 1,
|
|
const_cast<LPTSTR>(static_cast<LPCTSTR>(pItem->csSite)));
|
|
}
|
|
|
|
if (ERROR_NOT_ENOUGH_MEMORY != dwErr)
|
|
{
|
|
// add "All writable domain controllers" into the list-view .
|
|
|
|
item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE;
|
|
item.pszText = const_cast<LPTSTR>(static_cast<LPCTSTR>(m_csAnyDC));
|
|
item.state = LVIS_FOCUSED | LVIS_SELECTED;
|
|
|
|
pItem = new DCLISTVIEWITEM;
|
|
if (!pItem)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else
|
|
{
|
|
pItem->csName = _T(""); // always sorted as the top item
|
|
pItem->csSite = _T("");
|
|
|
|
item.lParam = reinterpret_cast<LPARAM>(pItem);
|
|
|
|
index = ListView_InsertItem(m_hDCListView, &item);
|
|
ListView_SetItemText(m_hDCListView, index, 1,
|
|
const_cast<LPTSTR>(static_cast<LPCTSTR>(pItem->csSite)));
|
|
}
|
|
}
|
|
|
|
if (ERROR_NOT_ENOUGH_MEMORY == dwErr)
|
|
{
|
|
FreeDCItems(m_hDCListView);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
m_hDCListView.EnableWindow(TRUE);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void CChooseDCDlg::OnGetDCThreadDone(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(m_pDCBufferManager);
|
|
|
|
CDCSITEINFO* pEntry = reinterpret_cast<CDCSITEINFO*>(wParam);
|
|
HRESULT hr = (HRESULT)lParam;
|
|
|
|
ASSERT(pEntry);
|
|
|
|
CString csDomain = pEntry->GetDomainName();
|
|
CString csCurrentDomain;
|
|
|
|
GetDlgItemText(IDC_SELECTDC_DOMAIN, csCurrentDomain);
|
|
|
|
TRACE(_T("CChooseDCDlg::OnGetDCThreadDone targetDomain=%s, currentDomain=%s, hr=%x\n"),
|
|
csDomain, csCurrentDomain, hr);
|
|
|
|
if (csCurrentDomain.CompareNoCase(csDomain) == 0)
|
|
{
|
|
switch (pEntry->GetEntryType())
|
|
{
|
|
case BUFFER_ENTRY_TYPE_VALID:
|
|
hr = InsertDCListView(pEntry);
|
|
if (SUCCEEDED(hr))
|
|
break;
|
|
// fall through if error
|
|
case BUFFER_ENTRY_TYPE_ERROR:
|
|
RefreshDCListViewErrorReport(csDomain, hr);
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CChooseDCDlg::RefreshDCListViewErrorReport(
|
|
IN PCTSTR pszDomainName,
|
|
IN HRESULT hr
|
|
)
|
|
{
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<PTSTR>(pszDomainName));
|
|
ReportErrorEx(m_hWnd, IDS_NO_DCS_FOUND, hr,
|
|
MB_OK | MB_ICONINFORMATION, apv, 1, 0);
|
|
|
|
InsertSpecialMsg(FALSE); // insert "Error"
|
|
|
|
if (m_bSiteRepl)
|
|
(GetDlgItem(IDC_SELECTDC_DOMAIN))->SetFocus();
|
|
else
|
|
(GetDlgItem(IDC_SELECTDC_DCEDIT))->SetFocus();
|
|
}
|
|
|
|
void CChooseDCDlg::RefreshDCListView()
|
|
{
|
|
CString csDomain, csFormat, csText;
|
|
|
|
GetDlgItemText(IDC_SELECTDC_DOMAIN, csDomain);
|
|
if ( csDomain.IsEmpty() ||
|
|
(0 == csDomain.CompareNoCase(m_csPrevDomain)) )
|
|
return;
|
|
|
|
TRACE(_T("CChooseDCDlg::RefreshDCListView for %s\n"), csDomain);
|
|
|
|
//
|
|
// update m_csPrevDomain
|
|
// to prevent LoadInfo() from being invoked multiple times when
|
|
// a serial of WM_KILLFOCUS happening on the same DomainName
|
|
//
|
|
m_csPrevDomain = csDomain;
|
|
|
|
//
|
|
// clear dc edit box
|
|
//
|
|
SetDlgItemText(IDC_SELECTDC_DCEDIT, _T(""));
|
|
|
|
//
|
|
// update the msg on top of the dc list view
|
|
//
|
|
csFormat.LoadString(IDS_SELECTDC_DCLISTVIEW_TITLE);
|
|
csText.Format(csFormat, csDomain);
|
|
SetDlgItemText(IDC_SELECTDC_DCLISTVIEW_TITLE, csText);
|
|
|
|
if (m_pDCBufferManager)
|
|
{
|
|
//
|
|
// insert "Waiting..." into the list view control
|
|
//
|
|
InsertSpecialMsg(TRUE);
|
|
|
|
UpdateWindow();
|
|
|
|
CWaitCursor cwait;
|
|
|
|
//
|
|
// Make sure csDomain is a valid domain name
|
|
//
|
|
CString csSelectedDomainDns;
|
|
HRESULT hr = GetDnsNameOfDomainOrForest(
|
|
csDomain,
|
|
csSelectedDomainDns,
|
|
TRUE,
|
|
TRUE); // We're interested in domain name not forest name here
|
|
if (FAILED(hr))
|
|
{
|
|
RefreshDCListViewErrorReport(csDomain, hr);
|
|
return;
|
|
}
|
|
|
|
if (csSelectedDomainDns.IsEmpty())
|
|
{
|
|
// down-level domain
|
|
PVOID apv[1];
|
|
apv[0] = static_cast<PVOID>(const_cast<LPTSTR>(static_cast<LPCTSTR>(csDomain)));
|
|
ReportMessageEx(m_hWnd, IDS_SELECTDC_DOWNLEVEL_DOMAIN,
|
|
MB_OK | MB_ICONSTOP, apv, 1);
|
|
|
|
InsertSpecialMsg(FALSE); // insert "Error"
|
|
(GetDlgItem(IDC_SELECTDC_DOMAIN))->SetFocus();
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// start the thread to calculate a list of DCs in the current selected domain
|
|
//
|
|
CDCSITEINFO *pEntry = NULL;
|
|
hr = m_pDCBufferManager->LoadInfo(csSelectedDomainDns, &pEntry);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Either we get a valid ptr back (ie. data is ready), insert it;
|
|
// or, a thread is alreay in progress, wait until a THREAD_DONE message.
|
|
//
|
|
if (pEntry)
|
|
{
|
|
ASSERT(pEntry->GetEntryType() == BUFFER_ENTRY_TYPE_VALID);
|
|
hr = InsertDCListView(pEntry);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
RefreshDCListViewErrorReport(csSelectedDomainDns, hr);
|
|
}
|
|
|
|
return;
|
|
}
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CChooseDCDlg::FreeDCItems
|
|
//
|
|
// Synopsis: Clear the lParam associated with each item in the list view control.
|
|
// The lParam is needed to support column-sorting.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CChooseDCDlg::FreeDCItems(CListCtrl& clv)
|
|
{
|
|
int index = -1;
|
|
LPARAM lParam = 0;
|
|
|
|
while ( -1 != (index = clv.GetNextItem(index, LVNI_ALL)) )
|
|
{
|
|
lParam = clv.GetItemData(index);
|
|
|
|
if (lParam)
|
|
delete ((DCLISTVIEWITEM *)lParam);
|
|
}
|
|
|
|
ListView_DeleteAllItems(clv.GetSafeHwnd());
|
|
}
|
|
|
|
void CChooseDCDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_SELECT_DC);
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// CDsAdminChooseDCObj
|
|
|
|
STDMETHODIMP CDsAdminChooseDCObj::InvokeDialog(
|
|
/*IN*/ HWND hwndParent,
|
|
/*IN*/ LPCWSTR lpszTargetDomain,
|
|
/*IN*/ LPCWSTR lpszTargetDomainController,
|
|
/*IN*/ ULONG uFlags,
|
|
/*OUT*/ BSTR* bstrSelectedDC)
|
|
{
|
|
TRACE(L"CDsAdminChooseDCObj::InvokeDialog(\n");
|
|
TRACE(L" HWND hwndParent = 0x%x\n", hwndParent);
|
|
TRACE(L" LPCWSTR lpszTargetDomain = %s\n", lpszTargetDomain);
|
|
TRACE(L" LPCWSTR lpszTargetDomainController = %s\n", lpszTargetDomainController);
|
|
TRACE(L" ULONG uFlags = 0x%x\n", uFlags);
|
|
TRACE(L" BSTR* bstrSelectedDC = 0x%x)\n", bstrSelectedDC);
|
|
|
|
|
|
|
|
if (!::IsWindow(hwndParent) || (bstrSelectedDC == NULL))
|
|
{
|
|
TRACE(L"InvokeDialog() Failed, invalid arg.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CChooseDCDlg DCdlg(CWnd::FromHandle(hwndParent));
|
|
|
|
// load current bind info
|
|
DCdlg.m_bSiteRepl = TRUE;
|
|
DCdlg.m_csTargetDomain = lpszTargetDomain;
|
|
DCdlg.m_csTargetDomainController = lpszTargetDomainController;
|
|
|
|
//
|
|
// invoke the dialog
|
|
//
|
|
HRESULT hr = S_FALSE;
|
|
if (DCdlg.DoModal() == IDOK)
|
|
{
|
|
TRACE(L"DCdlg.DoModal() returned IDOK\n");
|
|
TRACE(L"DCdlg.m_csTargetDomainController = <%s>\n", (LPCWSTR)(DCdlg.m_csTargetDomainController));
|
|
TRACE(L"DCdlg.m_csTargetDomain = <%s>\n", (LPCWSTR)(DCdlg.m_csTargetDomain));
|
|
|
|
LPCWSTR lpsz = NULL;
|
|
if (DCdlg.m_csTargetDomainController.IsEmpty())
|
|
{
|
|
lpsz = DCdlg.m_csTargetDomain;
|
|
}
|
|
else
|
|
{
|
|
lpsz = DCdlg.m_csTargetDomainController;
|
|
}
|
|
*bstrSelectedDC = ::SysAllocString(lpsz);
|
|
TRACE(L"returning *bstrSelectedDC = <%s>\n", *bstrSelectedDC);
|
|
hr = S_OK;
|
|
}
|
|
|
|
TRACE(L"InvokeDialog() returning hr = 0x%x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameUserDlg dialog
|
|
|
|
|
|
CRenameUserDlg::CRenameUserDlg(CDSComponentData* pComponentData, CWnd* pParent /*=NULL*/)
|
|
: m_pComponentData(pComponentData),
|
|
CHelpDialog(CRenameUserDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CRenameUserDlg)
|
|
m_login = _T("");
|
|
m_samaccountname = _T("");
|
|
m_domain = _T("");
|
|
m_dldomain = _T("");
|
|
m_first = _T("");
|
|
m_last = _T("");
|
|
m_cn = _T("");
|
|
m_oldcn = _T("");
|
|
m_displayname = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CRenameUserDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CRenameUserDlg)
|
|
DDX_Text(pDX, IDC_EDIT_OBJECT_NAME, m_cn);
|
|
DDX_Text(pDX, IDC_EDIT_DISPLAY_NAME, m_displayname);
|
|
DDX_Text(pDX, IDC_FIRST_NAME_EDIT, m_first);
|
|
DDX_Text(pDX, IDC_LAST_NAME_EDIT, m_last);
|
|
DDX_Text(pDX, IDC_NT5_USER_EDIT, m_login);
|
|
DDX_Text(pDX, IDC_NT4_USER_EDIT, m_samaccountname);
|
|
DDX_Text(pDX, IDC_NT4_DOMAIN_EDIT, m_dldomain);
|
|
DDX_CBString(pDX, IDC_NT5_DOMAIN_COMBO, m_domain);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRenameUserDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CRenameUserDlg)
|
|
ON_EN_CHANGE(IDC_EDIT_OBJECT_NAME, OnObjectNameChange)
|
|
ON_EN_CHANGE(IDC_FIRST_NAME_EDIT, OnNameChange)
|
|
ON_EN_CHANGE(IDC_LAST_NAME_EDIT, OnNameChange)
|
|
ON_EN_CHANGE(IDC_NT5_USER_EDIT, OnUserNameChange)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameUserDlg message handlers
|
|
|
|
BOOL CRenameUserDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
CString csdomain;
|
|
|
|
m_nameFormatter.Initialize(m_pComponentData->GetBasePathsInfo(),
|
|
L"user");
|
|
|
|
((CComboBox*)GetDlgItem (IDC_NT5_DOMAIN_COMBO))->AddString (m_domain);
|
|
((CComboBox*)GetDlgItem (IDC_NT5_DOMAIN_COMBO))->SetCurSel(0);
|
|
|
|
POSITION pos = m_domains.GetHeadPosition();
|
|
while (pos != NULL) {
|
|
csdomain = m_domains.GetNext(INOUT pos);
|
|
((CComboBox*)GetDlgItem (IDC_NT5_DOMAIN_COMBO))->AddString (csdomain);
|
|
}
|
|
|
|
((CEdit *)GetDlgItem(IDC_EDIT_OBJECT_NAME))->SetLimitText(64);
|
|
((CEdit *)GetDlgItem(IDC_FIRST_NAME_EDIT))->SetLimitText(64);
|
|
((CEdit *)GetDlgItem(IDC_LAST_NAME_EDIT))->SetLimitText(64);
|
|
((CEdit *)GetDlgItem(IDC_EDIT_DISPLAY_NAME))->SetLimitText(259);
|
|
((CEdit *)GetDlgItem(IDC_NT4_USER_EDIT))->SetLimitText(20);
|
|
|
|
CString szObjectName;
|
|
GetDlgItemText(IDC_EDIT_OBJECT_NAME, szObjectName);
|
|
szObjectName.TrimLeft();
|
|
szObjectName.TrimRight();
|
|
if (szObjectName.IsEmpty())
|
|
{
|
|
GetDlgItem(IDOK)->EnableWindow(FALSE);
|
|
}
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CRenameUserDlg::OnObjectNameChange()
|
|
{
|
|
CString szObjectName;
|
|
GetDlgItemText(IDC_EDIT_OBJECT_NAME, szObjectName);
|
|
szObjectName.TrimLeft();
|
|
szObjectName.TrimRight();
|
|
if (szObjectName.IsEmpty())
|
|
{
|
|
GetDlgItem(IDOK)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDOK)->EnableWindow(TRUE);
|
|
}
|
|
}
|
|
|
|
void CRenameUserDlg::OnNameChange()
|
|
{
|
|
GetDlgItemText(IDC_EDIT_FIRST_NAME, OUT m_first);
|
|
GetDlgItemText(IDC_EDIT_LAST_NAME, OUT m_last);
|
|
|
|
m_first.TrimLeft();
|
|
m_first.TrimRight();
|
|
|
|
m_last.TrimLeft();
|
|
m_last.TrimRight();
|
|
|
|
m_nameFormatter.FormatName(m_cn,
|
|
m_first.IsEmpty() ? NULL : (LPCWSTR)m_first,
|
|
NULL,
|
|
m_last.IsEmpty() ? NULL : (LPCWSTR)m_last);
|
|
|
|
SetDlgItemText(IDC_EDIT_DISPLAY_NAME, m_cn);
|
|
}
|
|
|
|
void CRenameUserDlg::OnUserNameChange()
|
|
{
|
|
GetDlgItemText(IDC_NT5_USER_EDIT, m_login);
|
|
SetDlgItemText(IDC_NT4_USER_EDIT, m_login);
|
|
}
|
|
|
|
void CRenameUserDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_RENAME_USER);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameGroupDlg message handlers
|
|
|
|
BOOL CRenameGroupDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
((CEdit *)GetDlgItem(IDC_EDIT_OBJECT_NAME))->SetLimitText(64);
|
|
((CEdit *)GetDlgItem(IDC_NT4_USER_EDIT))->SetLimitText(m_samtextlimit);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameGroupDlg dialog
|
|
|
|
|
|
CRenameGroupDlg::CRenameGroupDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CRenameGroupDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CRenameGroupDlg)
|
|
m_samaccountname = _T("");
|
|
m_cn = _T("");
|
|
m_samtextlimit = 256;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CRenameGroupDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CRenameGroupDlg)
|
|
DDX_Text(pDX, IDC_NT4_USER_EDIT, m_samaccountname);
|
|
DDX_Text(pDX, IDC_EDIT_OBJECT_NAME, m_cn);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRenameGroupDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CRenameGroupDlg)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
void CRenameGroupDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_RENAME_GROUP);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameContactDlg message handlers
|
|
|
|
BOOL CRenameContactDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
void CRenameContactDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_RENAME_CONTACT);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameContactDlg dialog
|
|
|
|
|
|
CRenameContactDlg::CRenameContactDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CRenameContactDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CRenameContactDlg)
|
|
m_cn = _T("");
|
|
m_first = _T("");
|
|
m_last = _T("");
|
|
m_disp = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CRenameContactDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CRenameContactDlg)
|
|
DDX_Text(pDX, IDC_EDIT_OBJECT_NAME, m_cn);
|
|
DDX_Text(pDX, IDC_FIRST_NAME_EDIT, m_first);
|
|
DDX_Text(pDX, IDC_LAST_NAME_EDIT, m_last);
|
|
DDX_Text(pDX, IDC_DISP_NAME_EDIT, m_disp);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRenameContactDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CRenameContactDlg)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameGenericDlg message handlers
|
|
|
|
BOOL CRenameGenericDlg::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
((CEdit *)GetDlgItem(IDC_EDIT_OBJECT_NAME))->SetLimitText(64);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRenameGenericDlg dialog
|
|
|
|
|
|
CRenameGenericDlg::CRenameGenericDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CRenameGenericDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CRenameGenericDlg)
|
|
m_cn = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CRenameGenericDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CRenameGenericDlg)
|
|
DDX_Text(pDX, IDC_EDIT_OBJECT_NAME, m_cn);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRenameGenericDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CRenameGenericDlg)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
|
|
void CRenameGenericDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_RENAME_COMPUTER);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSpecialMessageBox dialog
|
|
|
|
|
|
CSpecialMessageBox::CSpecialMessageBox(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CSpecialMessageBox::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CSpecialMessageBox)
|
|
m_title = _T("");
|
|
m_message = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CSpecialMessageBox::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CSpecialMessageBox)
|
|
DDX_Text(pDX, IDC_STATIC_MESSAGE, m_message);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CSpecialMessageBox, CDialog)
|
|
//{{AFX_MSG_MAP(CSpecialMessageBox)
|
|
ON_BN_CLICKED(IDC_BUTTON_YES, OnYesButton)
|
|
ON_BN_CLICKED(IDC_BUTTON_NO, OnNoButton)
|
|
ON_BN_CLICKED(IDC_BUTTON_YESTOALL, OnYesToAllButton)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSpecialMessageBox message handlers
|
|
|
|
BOOL CSpecialMessageBox::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
if (!m_title.IsEmpty()) {
|
|
SetWindowText (m_title);
|
|
}
|
|
|
|
GetDlgItem(IDC_BUTTON_NO)->SetFocus();
|
|
return FALSE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void
|
|
CSpecialMessageBox::OnYesButton()
|
|
{
|
|
CDialog::EndDialog (IDYES);
|
|
}
|
|
|
|
void
|
|
CSpecialMessageBox::OnNoButton()
|
|
{
|
|
CDialog::EndDialog (IDNO);
|
|
}
|
|
|
|
void
|
|
CSpecialMessageBox::OnYesToAllButton()
|
|
{
|
|
CDialog::EndDialog (IDC_BUTTON_YESTOALL);
|
|
}
|
|
|
|
#ifdef FIXUPDC
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CFixupDC dialog
|
|
|
|
|
|
CFixupDC::CFixupDC(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CFixupDC::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CFixupDC)
|
|
m_strServer = _T("");
|
|
//}}AFX_DATA_INIT
|
|
|
|
for (int i=0; i<NUM_FIXUP_OPTIONS; i++) {
|
|
m_bCheck[i] = FALSE;
|
|
}
|
|
}
|
|
|
|
void CFixupDC::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CFixupDC)
|
|
DDX_Text(pDX, IDC_FIXUP_DC_SERVER, m_strServer);
|
|
//}}AFX_DATA_MAP
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK0, m_bCheck[0]);
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK1, m_bCheck[1]);
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK2, m_bCheck[2]);
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK3, m_bCheck[3]);
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK4, m_bCheck[4]);
|
|
DDX_Check(pDX, IDC_FIXUP_DC_CHECK5, m_bCheck[5]);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CFixupDC, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CFixupDC)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CFixupDC message handlers
|
|
|
|
extern FixupOptionsMsg g_FixupOptionsMsg[];
|
|
|
|
BOOL CFixupDC::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
HWND hCheck = NULL;
|
|
GetDlgItem(IDC_FIXUP_DC_CHECK0, &hCheck);
|
|
::SetFocus(hCheck);
|
|
|
|
for (int i=0; i<NUM_FIXUP_OPTIONS; i++)
|
|
m_bCheck[i] = g_FixupOptionsMsg[i].bDefaultOn;
|
|
|
|
UpdateData(FALSE);
|
|
|
|
return FALSE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CFixupDC::OnOK()
|
|
{
|
|
UpdateData(TRUE);
|
|
|
|
// make sure user has selected some checkboxes
|
|
BOOL bCheck = FALSE;
|
|
for (int i=0; !bCheck && (i<NUM_FIXUP_OPTIONS); i++) {
|
|
bCheck = bCheck || m_bCheck[i];
|
|
}
|
|
if (!bCheck)
|
|
{
|
|
ReportMessageEx(m_hWnd, IDS_FIXUP_DC_SELECTION_WARNING, MB_OK);
|
|
return;
|
|
}
|
|
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
void CFixupDC::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_FIXUP_DC);
|
|
}
|
|
}
|
|
#endif // FIXUPDC
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPasswordDlg dialog
|
|
|
|
|
|
CPasswordDlg::CPasswordDlg(CWnd* pParent /*=NULL*/)
|
|
: CHelpDialog(CPasswordDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CPasswordDlg)
|
|
m_strPassword = _T("");
|
|
m_strUserName = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CPasswordDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CHelpDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CPasswordDlg)
|
|
DDX_Text(pDX, IDC_PASSWORD, m_strPassword);
|
|
DDX_Text(pDX, IDC_USER_NAME, m_strUserName);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CPasswordDlg, CHelpDialog)
|
|
//{{AFX_MSG_MAP(CPasswordDlg)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPasswordDlg message handlers
|
|
|
|
void CPasswordDlg::OnOK()
|
|
{
|
|
UpdateData(TRUE);
|
|
if (m_strUserName.IsEmpty()) {
|
|
ReportMessageEx(m_hWnd, IDS_PASSWORD_DLG_WARNING, MB_OK);
|
|
return;
|
|
}
|
|
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
void CPasswordDlg::DoContextHelp(HWND hWndControl)
|
|
{
|
|
if (hWndControl)
|
|
{
|
|
::WinHelp(hWndControl,
|
|
DSADMIN_CONTEXT_HELP_FILE,
|
|
HELP_WM_HELP,
|
|
(DWORD_PTR)(LPTSTR)g_aHelpIDs_IDD_PASSWORD);
|
|
}
|
|
}
|