able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/dnsmgr/browser.cpp

1114 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: browser.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 "record.h"
#include "zone.h"
#include "browser.h"
#ifdef DEBUG_ALLOCATOR
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#endif
/////////////////////////////////////////////////////////////////////////////////
#define N_TOOLBAR_COMMAND_GO_UP IDC_TOOLBAR_CTRL
////////////////////////////////////////////////////////////////////////
// CDNSComboBoxEx
inline CImageList* CDNSComboBoxEx::SetImageList(CImageList* pImageList)
{
ASSERT(::IsWindow(m_hWnd));
return CImageList::FromHandle((HIMAGELIST)
::SendMessage(m_hWnd, CBEM_SETIMAGELIST,
0, (LPARAM)pImageList->GetSafeHandle()));
}
inline int CDNSComboBoxEx::GetCount() const
{
ASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETCOUNT, 0, 0);
}
inline int CDNSComboBoxEx::GetCurSel() const
{
ASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETCURSEL, 0, 0);
}
inline int CDNSComboBoxEx::SetCurSel(int nSelect)
{
ASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETCURSEL, nSelect, 0);
}
inline int CDNSComboBoxEx::InsertItem(const COMBOBOXEXITEM* pItem)
{
ASSERT(::IsWindow(m_hWnd));
return (int) ::SendMessage(m_hWnd, CBEM_INSERTITEM, 0, (LPARAM)pItem);
}
LPARAM CDNSComboBoxEx::GetItemData(int nIndex) const
{
COMBOBOXEXITEM item;
item.iItem = nIndex;
item.mask = CBEIF_LPARAM;
ASSERT(::IsWindow(m_hWnd));
if (::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)&item))
{
return item.lParam;
}
return NULL;
}
BOOL CDNSComboBoxEx::SetItemData(int nIndex, LPARAM lParam)
{
COMBOBOXEXITEM item;
item.iItem = nIndex;
item.mask = CBEIF_LPARAM;
item.lParam = lParam;
ASSERT(::IsWindow(m_hWnd));
return (::SendMessage(m_hWnd, CBEM_SETITEM, 0, (LPARAM)&item) != 0);
}
inline void CDNSComboBoxEx::ResetContent()
{
ASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, CB_RESETCONTENT, 0, 0);
}
inline DWORD CDNSComboBoxEx::GetExtendedStyle() const
{
ASSERT(::IsWindow(m_hWnd));
return (DWORD) ::SendMessage(m_hWnd, CBEM_GETEXSTYLE, 0, 0);
}
inline DWORD CDNSComboBoxEx::SetExtendedStyle(DWORD dwExMask, DWORD dwExStyle)
{
ASSERT(::IsWindow(m_hWnd));
return (DWORD) ::SendMessage(m_hWnd, CBEM_SETEXSTYLE, (WPARAM)dwExMask, (LPARAM)dwExStyle);
}
inline BOOL CDNSComboBoxEx::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT)
{
return CreateEx(0, // extended style
WC_COMBOBOXEX, // window class
NULL, // window name
dwStyle, // window style
rect.left, rect.top, // x,y
rect.right - rect.left, rect.bottom - rect.top, // width, height
pParentWnd->GetSafeHwnd(), // parent window
NULL, // menu
NULL); // lpParam for window creation
}
//////////////////////////////////////////////////////////////////////////
// CDNSBrowseItem
inline int CDNSBrowseItem::GetImageIndex(BOOL bOpenImage)
{
if (m_pTreeNode == NULL)
return 0; // error
return m_pTreeNode->GetImageIndex(bOpenImage);
}
inline LPCWSTR CDNSBrowseItem::GetString(int nCol)
{
if (m_pTreeNode == NULL)
return L"ERROR"; // error
return m_pTreeNode->GetString(nCol);
}
inline BOOL CDNSBrowseItem::AddChild(CDNSBrowseItem* pChildBrowseItem)
{
ASSERT(m_pTreeNode != NULL);
if (!m_pTreeNode->IsContainer())
return FALSE;
pChildBrowseItem->m_pParent = this;
m_childList.AddTail(pChildBrowseItem);
return TRUE;
}
inline BOOL CDNSBrowseItem::IsContainer()
{
ASSERT(m_pTreeNode != NULL);
return m_pTreeNode->IsContainer();
}
BOOL CDNSBrowseItem::RemoveChildren(CDNSBrowseItem* pNotThisItem)
{
BOOL bFound = FALSE;
while (!m_childList.IsEmpty())
{
CDNSBrowseItem* pItem = m_childList.RemoveTail();
ASSERT(pItem != NULL);
if (pItem == pNotThisItem)
{
ASSERT(!bFound);
bFound = TRUE;
}
else
{
delete pItem;
}
}
if (bFound)
{
m_childList.AddTail(pNotThisItem);
}
return bFound;
}
void CDNSBrowseItem::AddTreeNodeChildren(CDNSFilterCombo* pFilter,
CComponentDataObject*)
{
ASSERT(m_pTreeNode != NULL);
if (!m_pTreeNode->IsContainer())
return;
CContainerNode* pContNode = (CContainerNode*)m_pTreeNode;
CNodeList* pChildList = pContNode->GetContainerChildList();
POSITION pos;
for (pos = pChildList->GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrChildNode = pChildList->GetNext(pos);
if (pFilter->IsValidTreeNode(pCurrChildNode))
{
CDNSBrowseItem* pItem = new CDNSBrowseItem;
pItem->SetTreeNode(pCurrChildNode);
AddChild(pItem);
}
}
pChildList = pContNode->GetLeafChildList();
POSITION pos2;
for (pos2 = pChildList->GetHeadPosition(); pos2 != NULL; )
{
CTreeNode* pCurrChildNode = pChildList->GetNext(pos2);
if (pFilter->IsValidTreeNode(pCurrChildNode))
{
CDNSBrowseItem* pItem = new CDNSBrowseItem;
pItem->SetTreeNode(pCurrChildNode);
AddChild(pItem);
}
}
}
void CDNSBrowseItem::AddToContainerCombo(CDNSCurrContainerCombo* pCtrl,
CDNSBrowseItem* pSelectedBrowseItem,
int nIndent,int* pNCurrIndex)
{
// add itself
pCtrl->InsertBrowseItem(this, *pNCurrIndex, nIndent);
if (this == pSelectedBrowseItem)
{
pCtrl->SetCurSel(*pNCurrIndex);
return;
}
m_nIndex = *pNCurrIndex; // index in the combobox, for lookup
(*pNCurrIndex)++;
// depth first on children
POSITION pos;
for( pos = m_childList.GetHeadPosition(); pos != NULL; )
{
CDNSBrowseItem* pCurrentChild = m_childList.GetNext(pos);
if (pCurrentChild->IsContainer())
pCurrentChild->AddToContainerCombo(pCtrl, pSelectedBrowseItem,
(nIndent+1), pNCurrIndex);
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSFilterCombo
BOOL CDNSFilterCombo::Initialize(UINT nCtrlID, UINT nIDFilterString, CDNSBrowserDlg* pDlg)
{
ASSERT(m_option != LAST); // must have a filter selected
if (!SubclassDlgItem(nCtrlID,pDlg))
return FALSE;
// load string with '\n' separated string options
int nMaxLen = 512;
WCHAR* szBuf = 0;
szBuf = (WCHAR*)malloc(sizeof(WCHAR)*nMaxLen);
if (!szBuf)
{
return FALSE;
}
if ( ::LoadString(_Module.GetModuleInstance(), nIDFilterString, szBuf, nMaxLen) == 0)
{
free(szBuf);
return FALSE;
}
// parse and get an array of pointers to each potential
// entry in the combobox
LPWSTR* lpszArr = 0;
lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*nMaxLen);
if (!lpszArr)
{
free(szBuf);
return FALSE;
}
UINT nArrEntries;
ParseNewLineSeparatedString(szBuf,lpszArr, &nArrEntries);
// determine which entries are actually inserted
int nEntry = 0;
int nSelEntry = -1;
for (UINT k=0; k<nArrEntries; k++)
{
if (CanAddToUIString(k))
{
if (k == (UINT)m_option)
nSelEntry = nEntry;
AddString(lpszArr[k]);
SetItemData(nEntry,(DWORD)k);
nEntry++;
}
}
ASSERT( (nSelEntry > -1) && (nSelEntry < nEntry));
SetCurSel(nSelEntry);
if (szBuf)
{
free(szBuf);
}
if (lpszArr)
{
free(lpszArr);
}
return TRUE;
}
void CDNSFilterCombo::OnSelectionChange()
{
int nSel = GetCurSel();
ASSERT(nSel != -1);
if (nSel == -1)
return;
ASSERT(((DNSBrowseFilterOptionType)nSel) <= LAST);
m_option = (DNSBrowseFilterOptionType)GetItemData(nSel);
}
BOOL CDNSFilterCombo::CanAddToUIString(UINT n)
{
switch(m_option)
{
case SERVER:
return (n == (UINT)SERVER);
case ZONE_FWD:
return (n == (UINT)ZONE_FWD);
case ZONE_REV:
return (n == (UINT)ZONE_REV);
case RECORD_A:
return (n == (UINT)RECORD_A) || (n == (UINT)RECORD_ALL);
case RECORD_CNAME:
return (n == (UINT)RECORD_CNAME) || (n == (UINT)RECORD_ALL);
case RECORD_A_AND_CNAME:
return (n == (UINT)RECORD_A) ||
(n == (UINT)RECORD_CNAME) ||
(n == (UINT)RECORD_A_AND_CNAME) ||
(n == (UINT)RECORD_ALL);
case RECORD_RP:
return (n == (UINT)RECORD_RP) || (n == (UINT)RECORD_ALL);
case RECORD_TEXT:
return (n == (UINT)RECORD_TEXT) || (n == (UINT)RECORD_ALL);
case RECORD_MB:
return (n == (UINT)RECORD_MB) || (n == (UINT)RECORD_ALL);
case RECORD_ALL:
return (n == (UINT)RECORD_ALL);
};
return FALSE;
}
BOOL CDNSFilterCombo::IsValidTreeNode(CTreeNode* pTreeNode)
{
BOOL bValid = FALSE; // by default, filter out
if (pTreeNode->IsContainer())
{
if (IS_CLASS(*pTreeNode, CDNSServerNode))
{
if (m_szExcludeServerName.IsEmpty())
bValid = TRUE;
else
bValid = m_szExcludeServerName != pTreeNode->GetDisplayName();
}
else if (IS_CLASS(*pTreeNode, CDNSForwardZonesNode ))
{
bValid = (m_option != ZONE_REV);
}
else if (IS_CLASS(*pTreeNode, CDNSReverseZonesNode ))
{
bValid = (m_option == ZONE_REV);
}
else if (IS_CLASS(*pTreeNode, CDNSZoneNode))
{
bValid = TRUE; // already screened at the auth. zones folder
}
else if (IS_CLASS(*pTreeNode, CDNSDomainNode))
{
// zone filtering stops at the zone level
bValid = (m_option != ZONE_FWD) && (m_option != ZONE_REV);
}
}
else // it is a record
{
WORD wType = ((CDNSRecordNodeBase*)pTreeNode)->GetType();
switch(m_option)
{
case RECORD_A:
bValid = (wType == DNS_TYPE_A);
break;
case RECORD_CNAME:
bValid = (wType == DNS_TYPE_CNAME);
break;
case RECORD_A_AND_CNAME:
bValid = (wType == DNS_TYPE_A) || (wType == DNS_TYPE_CNAME);
break;
case RECORD_RP:
bValid = (wType == DNS_TYPE_RP);
break;
case RECORD_TEXT:
bValid = (wType == DNS_TYPE_TEXT);
break;
case RECORD_MB:
bValid = (wType == DNS_TYPE_MB);
break;
case RECORD_ALL:
bValid = TRUE;
}; // switch
} //if else
return bValid;
}
BOOL CDNSFilterCombo::IsValidResult(CDNSBrowseItem* pBrowseItem)
{
if (pBrowseItem == NULL)
return FALSE;
CTreeNode* pTreeNode = pBrowseItem->GetTreeNode();
if (pTreeNode == NULL)
return FALSE;
BOOL bValid = FALSE;
if (pTreeNode->IsContainer())
{
CDNSMTContainerNode* pContainer = (CDNSMTContainerNode*)pTreeNode;
if ( (m_option == ZONE_FWD) || (m_option == ZONE_REV) )
{
bValid = IS_CLASS(*pContainer, CDNSZoneNode);
}
else if (m_option == SERVER)
{
bValid = IS_CLASS(*pContainer, CDNSServerNode);
}
}
else // it is a record
{
WORD wType = ((CDNSRecordNodeBase*)pTreeNode)->GetType();
switch(m_option)
{
case RECORD_ALL:
bValid = TRUE;
break;
case RECORD_A:
bValid = (wType == DNS_TYPE_A);
break;
case RECORD_CNAME:
bValid = (wType == DNS_TYPE_CNAME);
break;
case RECORD_A_AND_CNAME:
bValid = (wType == DNS_TYPE_A) || (wType == DNS_TYPE_CNAME);
break;
case RECORD_RP:
bValid = (wType == DNS_TYPE_RP);
break;
case RECORD_TEXT:
bValid = (wType == DNS_TYPE_TEXT);
break;
case RECORD_MB:
bValid = (wType == DNS_TYPE_MB);
break;
};
}
return bValid;
}
void CDNSFilterCombo::GetStringOf(CDNSBrowseItem* pBrowseItem,
CString& szResult)
{
if (pBrowseItem == NULL)
return;
CTreeNode* pTreeNode = pBrowseItem->GetTreeNode();
if (pTreeNode == NULL)
return;
if (pTreeNode->IsContainer())
{
CDNSMTContainerNode* pContainer = (CDNSMTContainerNode*)pTreeNode;
if (IS_CLASS(*pTreeNode, CDNSZoneNode))
{
szResult = (dynamic_cast<CDNSZoneNode*>(pContainer))->GetFullName();
}
else if (IS_CLASS(*pTreeNode , CDNSServerNode))
{
szResult = pContainer->GetDisplayName();
}
else
{
szResult.Empty();
}
}
else // it is a record
{
CDNSRecordNodeBase* pRecordNode = (CDNSRecordNodeBase*)pTreeNode;
WORD wType = pRecordNode->GetType();
if (wType == DNS_TYPE_MB)
{
szResult = ((CDNS_MB_RecordNode*)pRecordNode)->GetNameNodeString();
}
//else if (wType == DNS_TYPE_RP)
//{
//}
else
{
// for generic RR's we just get the FQDN
pRecordNode->GetFullName(szResult);
}
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSCurrContainerCombo
BOOL CDNSCurrContainerCombo::Initialize(UINT nCtrlID, UINT nBitmapID, CDNSBrowserDlg* pDlg)
{
if (!SubclassDlgItem(nCtrlID,pDlg))
return FALSE;
if (!m_imageList.Create(nBitmapID, 16, 1, BMP_COLOR_MASK))
return FALSE;
SetImageList(&m_imageList);
return TRUE;
}
CDNSBrowseItem* CDNSCurrContainerCombo::GetSelection()
{
CDNSBrowseItem* pBrowseItem = NULL;
int nSel = GetCurSel();
if (nSel >= 0)
{
pBrowseItem = reinterpret_cast<CDNSBrowseItem*>(GetItemData(nSel));
}
return pBrowseItem;
}
void CDNSCurrContainerCombo::InsertBrowseItem(CDNSBrowseItem* pBrowseItem,
int nIndex,
int nIndent)
{
ASSERT(pBrowseItem != NULL);
LPCWSTR lpszString = pBrowseItem->GetString(N_HEADER_NAME);
COMBOBOXEXITEM cbei;
cbei.mask = CBEIF_TEXT | CBEIF_INDENT | CBEIF_IMAGE | CBEIF_SELECTEDIMAGE;
// Initialize the COMBOBOXEXITEM struct.
cbei.iItem = nIndex;
cbei.pszText = (LPWSTR)lpszString;
cbei.cchTextMax = static_cast<int>(wcslen(lpszString));
cbei.iImage = pBrowseItem->GetImageIndex(FALSE);
cbei.iSelectedImage = pBrowseItem->GetImageIndex(TRUE);
cbei.iIndent = nIndent;
VERIFY(InsertItem(&cbei) != -1);
SetItemData(nIndex,reinterpret_cast<LPARAM>(pBrowseItem));
}
void CDNSCurrContainerCombo::SetTree(CDNSBrowseItem* pRootBrowseItem,
CDNSBrowseItem* pSelectedBrowseItem)
{
ASSERT(pRootBrowseItem != NULL);
ASSERT(pSelectedBrowseItem != NULL);
// remove all the contents
ResetContent();
// add depth first to the listbox
int nCurrIndex = 0;
int nIndent = 0;
pRootBrowseItem->AddToContainerCombo(this, pSelectedBrowseItem,
nIndent, &nCurrIndex);
}
//////////////////////////////////////////////////////////////////////////
// CDNSChildrenListView
BOOL CDNSChildrenListView::Initialize(UINT nCtrlID, UINT nBitmapID, CDNSBrowserDlg* pDlg)
{
m_pDlg = pDlg;
if (!SubclassDlgItem(nCtrlID,pDlg))
return FALSE;
if (!m_imageList.Create(nBitmapID, 16, 1, BMP_COLOR_MASK))
return FALSE;
SetImageList(&m_imageList, LVSIL_SMALL);
//
// get width of control, width of potential scrollbar, width needed for sub-item
// string
// get size of control to help set the column widths
CRect controlRect;
GetClientRect(controlRect);
int controlWidth = controlRect.Width();
int scrollThumbWidth = ::GetSystemMetrics(SM_CXHTHUMB);
// clean net width
int nNetControlWidth = controlWidth - scrollThumbWidth -
12 * ::GetSystemMetrics(SM_CXBORDER);
// fields widths
int nTotalUnscaledWidth = 0;
for (int iCol = 0; iCol < N_DEFAULT_HEADER_COLS; iCol++)
nTotalUnscaledWidth += _DefaultHeaderStrings[iCol].nWidth;
// set up columns
for (iCol = 0; iCol < N_DEFAULT_HEADER_COLS; iCol++)
{
int nWidth = nNetControlWidth *
_DefaultHeaderStrings[iCol].nWidth / nTotalUnscaledWidth;
InsertColumn(iCol, _DefaultHeaderStrings[iCol].szBuffer,
_DefaultHeaderStrings[iCol].nFormat,
nWidth);
}
return TRUE;
}
void CDNSChildrenListView::SetChildren(CDNSBrowseItem* pBrowseItem)
{
// clear the listview
DeleteAllItems();
if (pBrowseItem == NULL)
return;
// add all the children that satisfy the filtering option
POSITION pos;
int itemIndex = 0;
CDNSBrowseItem* pSelection = NULL;
for( pos = pBrowseItem->m_childList.GetHeadPosition(); pos != NULL; )
{
CDNSBrowseItem* pCurrentChild = pBrowseItem->m_childList.GetNext(pos);
// insert the name into the list view item, clear the subitem text
UINT nState = 0;
if (itemIndex == 0 )
{
nState = LVIS_SELECTED | LVIS_FOCUSED; // have at lest one item, select it
pSelection = pCurrentChild;
}
VERIFY(-1 != InsertItem(LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE,
itemIndex,
pCurrentChild->GetString(N_HEADER_NAME),
nState,
0,
pCurrentChild->GetImageIndex(FALSE),
(LPARAM)pCurrentChild));
// set the text for subitems
for (int iCol = N_HEADER_TYPE; iCol<N_DEFAULT_HEADER_COLS; iCol++)
VERIFY(SetItemText(itemIndex, iCol, pCurrentChild->GetString(iCol)));
// move to next index into the collection
itemIndex++;
}
m_pDlg->UpdateSelectionEdit(pSelection);
// enable/disable the OK button
GetParent()->GetDlgItem(IDOK)->EnableWindow(FALSE);
// enable/disable "UP" button
m_pDlg->m_toolbar.EnableButton(N_TOOLBAR_COMMAND_GO_UP, pBrowseItem->m_pParent != NULL);
}
CDNSBrowseItem* CDNSChildrenListView::GetSelection()
{
int nSel = GetNextItem(-1, LVIS_SELECTED);
return (nSel >= 0) ? (CDNSBrowseItem*)GetItemData(nSel) : NULL;
}
///////////////////////////////////////////////////////////////////////////////
// CDNSBrowserDlg
BEGIN_MESSAGE_MAP(CDNSBrowserDlg, CHelpDialog)
ON_COMMAND(N_TOOLBAR_COMMAND_GO_UP, OnButtonUp)
ON_NOTIFY_EX( TTN_NEEDTEXT, 0, OnTooltip)
ON_CBN_SELCHANGE(IDC_COMBO_SEL_NODE, OnSelchangeComboSelNode)
ON_NOTIFY(NM_DBLCLK, IDC_LIST_NODE_ITEMS, OnDblclkListNodeItems)
ON_NOTIFY(LVN_ITEMCHANGED, IDC_LIST_NODE_ITEMS, OnItemchangedListNodeItems)
ON_CBN_SELCHANGE(IDC_COMBO_FILTER, OnSelchangeComboFilter)
END_MESSAGE_MAP()
CDNSBrowserDlg::CDNSBrowserDlg(CComponentDataObject* pComponentDataObject,
CPropertyPageHolderBase* pHolder,
DNSBrowseFilterOptionType option, BOOL bEnableEdit,
LPCTSTR lpszExcludeServerName)
: CHelpDialog(IDD_BROWSE_DIALOG, pComponentDataObject)
{
ASSERT(pComponentDataObject != NULL);
m_pComponentDataObject = pComponentDataObject;
m_pHolder = pHolder;
m_filter.Set(option, lpszExcludeServerName);
m_bEnableEdit = bEnableEdit;
// point to the DNS snapin static folder
m_pMasterRootNode = m_pComponentDataObject->GetRootData();
// create a browse root item
m_pBrowseRootItem = new CDNSBrowseItem;
m_pBrowseRootItem->SetTreeNode(m_pMasterRootNode);
m_pCurrSelContainer = NULL;
m_pFinalSelection = NULL;
}
INT_PTR CDNSBrowserDlg::DoModal()
{
// make sure commoncontrolex initialized (for ComboBoxEx)
INITCOMMONCONTROLSEX icex;
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = ICC_USEREX_CLASSES;
if (!InitCommonControlsEx(&icex))
return -1;
return CHelpDialog::DoModal();
}
void CDNSBrowserDlg::OnCancel()
{
if (m_pHolder != NULL)
m_pHolder->PopDialogHWnd();
CHelpDialog::OnCancel();
}
CDNSBrowserDlg::~CDNSBrowserDlg()
{
if (m_pBrowseRootItem != NULL)
{
delete m_pBrowseRootItem;
m_pBrowseRootItem = NULL;
}
}
CEdit* CDNSBrowserDlg::GetSelectionEdit()
{
return (CEdit*)GetDlgItem(IDC_SELECTION_EDIT);
}
CTreeNode* CDNSBrowserDlg::GetSelection()
{
if (m_pFinalSelection == NULL)
return NULL;
return m_pFinalSelection->GetTreeNode();
}
LPCTSTR CDNSBrowserDlg::GetSelectionString()
{
return m_szSelectionString;
}
BOOL CDNSBrowserDlg::OnInitDialog()
{
CHelpDialog::OnInitDialog();
if (m_pHolder != NULL)
m_pHolder->PushDialogHWnd(m_hWnd);
InitializeControls();
InitBrowseTree();
m_pCurrSelContainer = m_pBrowseRootItem;
m_currContainer.SetTree(m_pBrowseRootItem, m_pBrowseRootItem);
m_childrenList.SetChildren(m_pBrowseRootItem);
return TRUE;
}
//////////// CBrowseDlg : message handlers ////////////////
void CDNSBrowserDlg::OnButtonUp()
{
CDNSBrowseItem* pSelectedBrowseItem = m_currContainer.GetSelection();
ASSERT(pSelectedBrowseItem != NULL);
if (pSelectedBrowseItem == NULL)
return;
ASSERT(pSelectedBrowseItem->m_pParent != NULL);
if (pSelectedBrowseItem->m_pParent == NULL)
return;
MoveUpHelper(pSelectedBrowseItem->m_pParent);
}
BOOL CDNSBrowserDlg::OnTooltip(UINT, NMHDR* pHdr, LRESULT* plRes)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
ASSERT(pHdr->code == TTN_NEEDTEXT);
LPTOOLTIPTEXT pTT = (LPTOOLTIPTEXT)(pHdr);
pTT->lpszText = (LPTSTR)IDS_BROWSE_TOOLTIP;
pTT->hinst = AfxGetApp()->m_hInstance;
*plRes = 0;
return TRUE;
}
void CDNSBrowserDlg::OnSelchangeComboSelNode()
{
CDNSBrowseItem* pSelectedBrowseItem = m_currContainer.GetSelection();
ASSERT(pSelectedBrowseItem != NULL);
if (pSelectedBrowseItem == NULL)
return;
MoveUpHelper(pSelectedBrowseItem);
}
void CDNSBrowserDlg::OnDblclkListNodeItems(NMHDR* pNMHDR, LRESULT* pResult)
{
*pResult = 0;
ASSERT(pNMHDR->code == NM_DBLCLK);
HandleOkOrDblClick();
}
void CDNSBrowserDlg::OnOK()
{
HandleOkOrDblClick();
}
void CDNSBrowserDlg::OnItemchangedListNodeItems(NMHDR*, LRESULT*)
{
//EnableOkButton(m_filter.IsValidResult(pSelectedBrowseItem));
CDNSBrowseItem* pSelectedBrowseItem = m_childrenList.GetSelection();
BOOL bEnable = pSelectedBrowseItem != NULL;
if (bEnable)
bEnable = m_filter.IsValidResult(pSelectedBrowseItem) ||
pSelectedBrowseItem->IsContainer();
EnableOkButton(bEnable);
UpdateSelectionEdit(pSelectedBrowseItem);
}
void CDNSBrowserDlg::OnSelchangeComboFilter()
{
m_filter.OnSelectionChange();
ReEnumerateChildren();
GetSelectionEdit()->EnableWindow(m_bEnableEdit);//m_filter.Get() == SERVER);
}
////////////// CBrowseDlg : internal helpers //////////////////////
void CDNSBrowserDlg::InitializeToolbar()
{
CWnd* pWnd = GetDlgItem(IDC_TOOLBAR_CTRL);
CRect r;
pWnd->GetWindowRect(r);
ScreenToClient(r);
pWnd->DestroyWindow();
DWORD dwStyle = WS_CHILD | WS_VISIBLE | CCS_NORESIZE | CCS_TOP | CCS_NODIVIDER | TBSTYLE_TOOLTIPS ;
m_toolbar.Create(dwStyle,r,this, IDC_TOOLBAR_CTRL);
m_toolbar.AddBitmap(1, IDB_BROWSE_TOOLBAR);
TBBUTTON btn[2];
btn[0].iBitmap = 0; // zero-based index of button image
btn[0].idCommand = 0; // command to be sent when button pressed
btn[0].fsState = 0; // button state--see below
btn[0].fsStyle = TBSTYLE_SEP; // button style--see below
btn[0].dwData = 0; // application-defined value
btn[0].iString = NULL; // zero-based index of button label string
btn[1].iBitmap = 0; // zero-based index of button image
btn[1].idCommand = N_TOOLBAR_COMMAND_GO_UP; // command to be sent when button pressed
btn[1].fsState = TBSTATE_ENABLED; // button state--see below
btn[1].fsStyle = TBSTYLE_BUTTON; // button style--see below
btn[1].dwData = 0; // application-defined value
btn[1].iString = NULL; // zero-based index of button label string
m_toolbar.AddButtons(2, btn);
}
void CDNSBrowserDlg::InitializeControls()
{
// init the controls
VERIFY(m_currContainer.Initialize(IDC_COMBO_SEL_NODE, IDB_16x16, this));
VERIFY(m_childrenList.Initialize(IDC_LIST_NODE_ITEMS, IDB_16x16, this));
VERIFY(m_filter.Initialize(IDC_COMBO_FILTER, IDS_BROWSE_FILTER_OPTIONS, this));
InitializeToolbar();
GetSelectionEdit()->EnableWindow(m_bEnableEdit);//m_filter.Get() == SERVER);
}
void CDNSBrowserDlg::EnableOkButton(BOOL bEnable)
{
GetDlgItem(IDOK)->EnableWindow(bEnable);
}
void CDNSBrowserDlg::HandleOkOrDblClick()
{
CDNSBrowseItem* pSelectedBrowseItem = m_childrenList.GetSelection();
ASSERT(pSelectedBrowseItem != NULL);
if (pSelectedBrowseItem == NULL)
return;
if (m_filter.IsValidResult(pSelectedBrowseItem))
{
if (m_bEnableEdit)
{
GetSelectionEdit()->GetWindowText(m_szSelectionString);
m_szSelectionString.TrimLeft();
m_szSelectionString.TrimRight();
}
m_pFinalSelection = pSelectedBrowseItem;
if (m_pHolder != NULL)
m_pHolder->PopDialogHWnd();
CHelpDialog::OnOK();
}
else
{
MoveDownHelper();
}
}
void CDNSBrowserDlg::UpdateSelectionEdit(CDNSBrowseItem* pBrowseItem)
{
if (pBrowseItem == NULL)
m_szSelectionString.Empty();
else
m_filter.GetStringOf(pBrowseItem, m_szSelectionString);
GetSelectionEdit()->SetWindowText(m_szSelectionString);
}
void CDNSBrowserDlg::InitBrowseTree()
{
ASSERT(m_pMasterRootNode != NULL);
ASSERT(m_pBrowseRootItem != NULL);
// assume we have no children
//ASSERT(m_pBrowseRootItem->m_childList.GetCount() == 0);
// get all the child nodes of the snapin root
AddTreeNodeChildrenHelper(m_pBrowseRootItem, &m_filter);
}
void CDNSBrowserDlg::ReEnumerateChildren()
{
ASSERT(m_pMasterRootNode != NULL);
ASSERT(m_pBrowseRootItem != NULL);
ASSERT(m_pCurrSelContainer != NULL);
m_pCurrSelContainer->RemoveChildren(NULL);
AddTreeNodeChildrenHelper(m_pCurrSelContainer, &m_filter);
m_childrenList.SetChildren(m_pCurrSelContainer);
}
void CDNSBrowserDlg::ExpandBrowseTree(CDNSBrowseItem* pCurrBrowseItem,
CDNSBrowseItem* pChildBrowseItem)
{
ASSERT(m_pMasterRootNode != NULL);
ASSERT(m_pBrowseRootItem != NULL);
ASSERT(pCurrBrowseItem != NULL);
ASSERT(pChildBrowseItem != NULL);
ASSERT(pChildBrowseItem->m_pParent == pCurrBrowseItem);
// we are going down one level:
// 1. remove all the children of the current item but the specified child
VERIFY(pCurrBrowseItem->RemoveChildren(pChildBrowseItem));
// 2. move down to the child
// 3. enumerate all the children of the specified child (filtering)
AddTreeNodeChildrenHelper(pChildBrowseItem, &m_filter);
}
void CDNSBrowserDlg::ContractBrowseTree(CDNSBrowseItem* pParentBrowseItem)
{
ASSERT(m_pMasterRootNode != NULL);
ASSERT(m_pBrowseRootItem != NULL);
ASSERT(pParentBrowseItem != NULL);
// we are going up one of more levels (possibly up to the root)
// 1. remove all the children below the specified item
pParentBrowseItem->RemoveChildren(NULL);
// 3. enumerate all the children of the specified item (filtering)
AddTreeNodeChildrenHelper(pParentBrowseItem, &m_filter);
}
void CDNSBrowserDlg::MoveUpHelper(CDNSBrowseItem* pNewBrowseItem)
{
ASSERT(m_pCurrSelContainer != NULL);
ASSERT(pNewBrowseItem != NULL);
if (m_pCurrSelContainer == pNewBrowseItem)
return; // the same was picked, nothing to do
#ifdef _DEBUG
// we assume that the new item is NOT a child of the current selection
CDNSBrowseItem* pItem = pNewBrowseItem;
BOOL bFound = FALSE;
while (pItem != NULL)
{
bFound = (pItem == m_pCurrSelContainer);
if (bFound)
break;
pItem = pItem->m_pParent;
}
ASSERT(!bFound);
#endif
ContractBrowseTree(pNewBrowseItem);
m_currContainer.SetTree(m_pBrowseRootItem, pNewBrowseItem);
m_childrenList.SetChildren(pNewBrowseItem);
// set new selection
m_pCurrSelContainer = pNewBrowseItem;
}
void CDNSBrowserDlg::MoveDownHelper()
{
CDNSBrowseItem* pChildBrowseItem = m_childrenList.GetSelection();
if (pChildBrowseItem == NULL)
{
return;
}
//
// If it is not a container we should do something else, for now we will just return
//
if (!pChildBrowseItem->IsContainer())
{
return;
}
//
// get the selection in the combobox
//
CDNSBrowseItem* pSelectedBrowseItem = m_currContainer.GetSelection();
ASSERT(pSelectedBrowseItem != NULL);
if (pSelectedBrowseItem == NULL)
{
return;
}
ExpandBrowseTree(pSelectedBrowseItem, pChildBrowseItem);
m_currContainer.SetTree(m_pBrowseRootItem, pChildBrowseItem);
m_childrenList.SetChildren(pChildBrowseItem);
m_pCurrSelContainer = pChildBrowseItem;
SetForegroundWindow();
}
class CBrowseExecContext : public CExecContext
{
public:
virtual void Execute(LPARAM arg)
{
m_dlg->AddTreeNodeChildrenHelper(m_pBrowseItem, m_pFilter, (BOOL)arg);
}
CDNSBrowserDlg* m_dlg;
CDNSBrowseItem* m_pBrowseItem;
CDNSFilterCombo* m_pFilter;
};
void CDNSBrowserDlg::AddTreeNodeChildrenHelper(CDNSBrowseItem* pBrowseItem,
CDNSFilterCombo* pFilter, BOOL bExpand)
{
if (bExpand)
{
// need to do this always from the UI thread (main for Wiz, 2nd for prop pages)
CTreeNode* pTreeNode = pBrowseItem->GetTreeNode();
if (!pTreeNode->IsContainer())
return;
CContainerNode* pContNode = (CContainerNode*)pTreeNode;
if ( (pContNode->GetContainer() != NULL) && (!pContNode->IsEnumerated()) )
{
EnumerateMTNodeHelper((CMTContainerNode*)pContNode,
m_pComponentDataObject);
}
}
// have to figure out if we are running in the main thread
if (_MainThreadId == ::GetCurrentThreadId())
{
pBrowseItem->AddTreeNodeChildren(pFilter, m_pComponentDataObject);
return;
}
// we are from a secondary thread, execute in the context for the main
// thread by posting a message and waiting
ASSERT(m_pComponentDataObject != NULL);
CBrowseExecContext ctx;
ctx.m_dlg = this;
ctx.m_pBrowseItem = pBrowseItem;
ctx.m_pFilter = pFilter;
TRACE(_T("before post message()\n"));
VERIFY(m_pComponentDataObject->PostExecMessage(&ctx,(WPARAM)FALSE));
ctx.Wait();
TRACE(_T("after wait()\n"));
}
Reference in a new issue Copy permalink