leftview.cpp

有关界面的编程源码。很有参考价值！值得一看

// LeftView.cpp : implementation file
//

#include "stdafx.h"
#include "Redit.h"
#include "LeftView.h"
#include "DetailView.h"
#include "DlgCreateKey.h"
#include "DlgRenameKey.h"
#include "MainFrm.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CLeftView


IMPLEMENT_DYNCREATE(CLeftView, CTreeView)

CLeftView::CLeftView()
{
}

CLeftView::~CLeftView()
{
}


BEGIN_MESSAGE_MAP(CLeftView, CTreeView)
	//{{AFX_MSG_MAP(CLeftView)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	ON_NOTIFY_REFLECT(NM_RCLICK, OnRclick)
	ON_NOTIFY_REFLECT(TVN_ITEMEXPANDED, OnItemexpanded)
	ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelchanged)
	ON_WM_DESTROY()
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_TREERCLICK_NEW_KEY, OnCreateNewKey)
	ON_COMMAND(ID_TREERCLICK_NEW_STRINGVALUE, OnNewStringValue)
	ON_COMMAND(ID_TREERCLICK_NEW_DWORDVALUE, OnNewDwordValue)
	ON_COMMAND(ID_TREERCLICK_DELETE, OnKeyDelete)
	ON_COMMAND(ID_TREERCLICK_RENAME, OnKeyRename)
	ON_MESSAGE(MW_SHOWKEYPATH, OnShowKeyPath)
	ON_MESSAGE(MW_COPYKEYPATH, OnCopyKeyPath)
	ON_MESSAGE(MW_REFRESH, OnViewRefresh)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLeftView drawing

void CLeftView::OnDraw(CDC* pDC)
{
	CDocument* pDoc = GetDocument();
	// TODO: add draw code here
}

/////////////////////////////////////////////////////////////////////////////
// CLeftView diagnostics

#ifdef _DEBUG
void CLeftView::AssertValid() const
{
	CTreeView::AssertValid();
}

void CLeftView::Dump(CDumpContext& dc) const
{
	CTreeView::Dump(dc);
}
#endif //_DEBUG

BOOL CLeftView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CTreeView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CLeftView message handlers
void CLeftView::OnInitialUpdate() 
{
	CTreeView::OnInitialUpdate();

	Clear(); 

	CTreeCtrl &treeCtl = GetTreeCtrl();
	treeCtl.ModifyStyle(0, TVS_HASLINES|TVS_LINESATROOT|TVS_HASBUTTONS);

	m_ImageList.Create(IDB_BITMAP1, 16, 5, RGB(255, 0, 255));
	treeCtl.SetImageList(&m_ImageList, TVSIL_NORMAL);

	CRegNode *pnodeItem, *pnodeItemParent;
	pnodeItemParent = new CRegNode(_T("Local Device"), REGNODE_TYPE_KEY|REGNODE_TYPE_TOPMOST);
	::AddNode(pnodeItemParent, NULL);

	pnodeItem = new CRegNode(_T("HKEY_CLASSES_ROOT"), REGNODE_TYPE_KEY|REGNODE_TYPE_ROOT);
	::AddNode(pnodeItem, pnodeItemParent);

	pnodeItem = new CRegNode(_T("HKEY_CURRENT_USER"), REGNODE_TYPE_KEY|REGNODE_TYPE_ROOT);
	::AddNode(pnodeItem, pnodeItemParent);

	pnodeItem = new CRegNode(_T("HKEY_LOCAL_MACHINE"), REGNODE_TYPE_KEY|REGNODE_TYPE_ROOT);
	::AddNode(pnodeItem, pnodeItemParent);

	pnodeItem = new CRegNode(_T("HKEY_USERS"), REGNODE_TYPE_KEY|REGNODE_TYPE_ROOT);
	::AddNode(pnodeItem, pnodeItemParent);

	pnodeItemParent->m_hItem = treeCtl.InsertItem(pnodeItemParent->m_strName, 31, 12, TVI_ROOT);
	pnodeItemParent->m_bLoaded = TRUE;
	treeCtl.SetItemData(pnodeItemParent->m_hItem, (DWORD)pnodeItemParent);
	DisplayKey(pnodeItemParent);
	if (m_TreeTrayMenu.LoadMenu(MAKEINTRESOURCE(IDR_MENU_TREERCLICK)))
	{
		m_TreeTraySubMenu.Attach(m_TreeTrayMenu.GetSubMenu(0)->Detach());		
	}
}

void CLeftView::OnItemexpanded(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;

	if (pNMTreeView && pNMTreeView->itemNew.hItem)
	{
		CRegNode *pNode = (CRegNode *)GetTreeCtrl().GetItemData(pNMTreeView->itemNew.hItem);
		if (pNode && !(pNode->m_dwType & REGNODE_TYPE_ROOT) && (pNode->m_dwType & REGNODE_TYPE_KEY))
		{
			LoadKey(pNode);
			DisplayKey(pNode);
			LoadValues(pNode);
		}
	}
	*pResult = 0;
}

void CLeftView::DisplayKey(CRegNode *pNode)
{
	CTreeCtrl &treeCtl = GetTreeCtrl();

	CRegNode *pTemp;
	pTemp = pNode->m_pFirstChild;
	
	while (pTemp)
	{
		if (!pTemp->m_hItem && !(pTemp->m_dwType & REGNODE_TYPE_VALUE))
		{
			pTemp->m_hItem = treeCtl.InsertItem(pTemp->m_strName, 31, 12, pNode ? pNode->m_hItem : TVI_ROOT, TVI_LAST);
			treeCtl.SetItemData(pTemp->m_hItem, (DWORD)pTemp);
		}
		pTemp = pTemp->m_pNextSibling;
	}
}

void CLeftView::DisplayValue(CRegNode *pNode)
{
	CDetailView *pView = GetListView();
	pView->DisplayValues(pNode);
	
}

void CLeftView::OnSelchanged(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	// TODO: Add your control notification handler code here
	
	if (pNMTreeView && pNMTreeView->itemNew.hItem)
	{
		CRegNode *pNode = (CRegNode *)GetTreeCtrl().GetItemData(pNMTreeView->itemNew.hItem);
		if (pNode && !(pNode->m_dwType & REGNODE_TYPE_TOPMOST) && (pNode->m_dwType & REGNODE_TYPE_KEY))
		{
			LoadKey(pNode);
			DisplayKey(pNode);
			LoadValues(pNode);
			DisplayValue(pNode);
			DisplayKeyPath(pNMTreeView->itemNew.hItem);
		}
	}
	*pResult = 0;
}

void CLeftView::PostNcDestroy() 
{
	// TODO: Add your specialized code here and/or call the base class	
	CTreeView::PostNcDestroy();
}

void CLeftView::OnDestroy() 
{
	// TODO: Add your message handler code here
	Clear();
	CTreeView::OnDestroy();
}

void CLeftView::DisplayKeyPath(HTREEITEM hItem)
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	CRegNode *pNode;
	CString strTemp1;

	while (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pNode)
		{
			strTemp1 = pNode->m_strName + _T("\\") + strTemp1;
		}		
		hItem = treeCtl.GetParentItem(hItem);
	}
	((CMainFrame *)AfxGetMainWnd())->SetMessageText(strTemp1);
}

void CLeftView::Clear()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hRootItem = treeCtl.GetRootItem();
	if (hRootItem)
	{
		CRegNode *pNode = (CRegNode *)treeCtl.GetItemData(hRootItem);

		if (pNode)
			delete pNode;
	}
	if (m_ImageList.GetSafeHandle())
		m_ImageList.DeleteImageList();

	treeCtl.DeleteAllItems();
}

LONG CLeftView::OnShowKeyPath(WPARAM wParam, LPARAM lParam)
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	CRegNode *pNode;
	CString strTemp1;
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	int nTimes = 1, len;
	while (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pNode)
		{
			strTemp1 = pNode->m_strName + _T("\\") + strTemp1;
			len = strTemp1.GetLength();
			while (len >= 20 * nTimes) // display 20 chars per line
			{
				strTemp1 = strTemp1.Mid(0, (len - 20 * nTimes) > 0 ? len - 20 *nTimes : 0) + _T('\n') + strTemp1.Right(20 * nTimes);
				nTimes++;
			}
		}		
		hItem = treeCtl.GetParentItem(hItem);
	}
	if (strTemp1.GetLength())
	{
		AfxMessageBox(strTemp1);
	}
	return 0L;
}


void CLeftView::OnRclick(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// TODO: Add your control notification handler code here
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	CPoint point, pointSc;
	UINT nFlags;
	GetCursorPos(&point);
	pointSc = point;
	ScreenToClient(&point);
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hItem = treeCtl.HitTest(point, &nFlags);
	if ((nFlags & TVHT_ONITEM) && hItem)
	{
		CRegNode *pNode = (CRegNode *)GetTreeCtrl().GetItemData(hItem);
		if (pNode && !(pNode->m_dwType & REGNODE_TYPE_TOPMOST))
		{
			BOOL bRet = m_TreeTraySubMenu.TrackPopupMenu(TPM_LEFTALIGN, pointSc.x, pointSc.y, this, NULL);
		}
	}	
	*pResult = 0;
}

void CLeftView::OnCreateNewKey()
{
	CDlgCreateKey dlg;
	CRegNode *pnodeItem, *pnodeItemParent;
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	DWORD dwDisposition;
	HKEY hNewKey, hKeyParent;
	LONG lErr;
	if (hItem)
	{
		pnodeItemParent = (CRegNode *)treeCtl.GetItemData(hItem);
		if (dlg.DoModal() == IDOK)
		{
			hKeyParent = pnodeItemParent->GetKeyHandle();
			lErr = RegCreateKeyEx(hKeyParent, dlg.m_strKeyName, 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hNewKey, &dwDisposition);
			if (lErr == ERROR_SUCCESS)
			{
				pnodeItem = new CRegNode(dlg.m_strKeyName, REGNODE_TYPE_KEY);
				::AddNode(pnodeItem, pnodeItemParent);
				pnodeItem->m_hItem = treeCtl.InsertItem(pnodeItem->m_strName, 31, 12, hItem);
				treeCtl.SetItemData(pnodeItem->m_hItem, (DWORD)pnodeItem);
				RegCloseKey(hNewKey);
				pnodeItem->m_bLoaded = TRUE;
			}
			RegCloseKey(hKeyParent);
		}
	}
}

void CLeftView::OnNewStringValue()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	CRegNode *pNode;

	if (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pNode)
		{
			DisplayValue(pNode); // just to initialize the current node;
			CDetailView *pView = GetListView();
			pView->SendMessage(WM_COMMAND, ID_TEST_NEW_STRINGVALUE, 0);
		}
	}
}

void CLeftView::OnNewDwordValue()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	CRegNode *pNode;

	if (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pNode)
		{
			DisplayValue(pNode); // just to initialize the current node;
			CDetailView *pView = GetListView();
			pView->SendMessage(WM_COMMAND, ID_TEST_NEW_DWORDVALUE, 0);
		}
	}
}

void CLeftView::OnKeyDelete()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	CRegNode *pNode;
	CString strTemp;
	if (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		// only allow delete nodes of one level down from Standard HKLM HKCU keys
		if (pNode)
		{
			strTemp.Format(_T("Do you really want to delete this key (%s), its subkeys and values?"), (LPCTSTR)pNode->m_strName);
			if (pNode->m_pParent && pNode->m_pParent->m_pParent &&  (AfxMessageBox(strTemp, MB_YESNO) == IDYES))
			{
				treeCtl.DeleteItem(pNode->m_hItem);
				// delete all subkeys
				CRegNode *pTemp = pNode->m_pFirstChild, *pTemp2;
				while (pTemp)
				{
					pTemp2 = pTemp;
					pTemp = pTemp->m_pNextSibling;
					delete pTemp2;
				}
				pNode->m_pFirstChild = NULL;
				pNode->m_bLoaded = FALSE;
				// load this key recursively (only keys and subkeys)
				LoadKeysRecursive(pNode);
				if (DeleteKeyRecursive(pNode))
				{
					DeleteNode(pNode);
				}
			}
		}
	}
}

void CLeftView::OnKeyRename()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	CRegNode *pNode;
	CString strTemp1;
	CDlgRenameKey dlg;
	HTREEITEM hItem, hItem2, hItem3;

	hItem = treeCtl.GetSelectedItem();
	if (hItem)
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
	if (!pNode)
		return;
	// load all values subkeys and values
	// delete key, values, subkeys and values
	// create new key, values, subkeys and values
	// delete all subkeys
	dlg.m_strOldKeyName = pNode->m_strName;
	if (dlg.DoModal() == IDOK && dlg.m_strNewKeyName.GetLength())
	{
		// delete all subkeys and values
		// reset to not loaded
		CRegNode *pTemp = pNode->m_pFirstChild, *pTemp2;
		while (pTemp)
		{
			pTemp2 = pTemp;
			pTemp = pTemp->m_pNextSibling;
			delete pTemp2;
		}
		pNode->m_pFirstChild = NULL;
		pNode->m_bLoaded = FALSE;
		pNode->m_bValuesLoaded = FALSE;
		// load this key recursively keys and subkeys and values
		LoadKeysRecursive(pNode, TRUE);
		// delete this key from registry only
		if (DeleteKeyRecursive(pNode))
		{
			// change the key name
			pNode->m_strName = dlg.m_strNewKeyName;
			// create the key, subkeys and values in registry
			CreateKeyRecursive(pNode, TRUE);
			// change item text and delete all sub tree items
			treeCtl.SetItemText(pNode->m_hItem, (LPCTSTR)pNode->m_strName);
			hItem2 = treeCtl.GetNextItem(pNode->m_hItem, TVGN_CHILD);
			while (hItem2)
			{
				hItem3 = treeCtl.GetNextItem(hItem2, TVGN_NEXT);
				treeCtl.DeleteItem(hItem2);
				hItem2 = hItem3;
			}
		}
	}
}

LONG CLeftView::OnCopyKeyPath(WPARAM wParam, LPARAM lParam)
{
	CTreeCtrl &treeCtl = GetTreeCtrl();
	CRegNode *pNode;
	CString strTemp1;
	HTREEITEM hItem = treeCtl.GetSelectedItem();
	while (hItem)
	{
		pNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pNode)
		{
			strTemp1 = pNode->m_strName + _T("\\") + strTemp1;
		}		
		hItem = treeCtl.GetParentItem(hItem);
	}
	if (strTemp1.GetLength())
	{
		if (!OpenClipboard())
		{
			AfxMessageBox(_T("Cannot copy to the Clipboard"));
			return 0;
		}
		  // Remove the current Clipboard contents
		if(!EmptyClipboard())
		{
			AfxMessageBox(_T("Cannot copy to Clipboard"));
			return 0;
		}
		// Get the currently selected data
		// For the appropriate data formats...
		HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, (strTemp1.GetLength() + 1)* sizeof(TCHAR));
		LPVOID lpData = GlobalLock(hData);
		memcpy(lpData, (LPCTSTR)strTemp1, (strTemp1.GetLength() + 1)* sizeof(TCHAR));
		GlobalUnlock(hData);

#ifdef UNICODE
		if (::SetClipboardData(CF_UNICODETEXT, hData) == NULL)
#else
		if (::SetClipboardData(CF_TEXT, hData) == NULL)
#endif
		{
			AfxMessageBox(_T("Cannot copy to Clipboard"));
			CloseClipboard();
			return 0;
		}
		CloseClipboard();
	}
	return 1L;
}


void CLeftView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CTreeCtrl &treeCtl = GetTreeCtrl();

#if defined(_WIN32_WCE)
#if !defined(_X86_) && !defined(WIN32_PLATFORM_HPC2000)
	UINT nHitFlags;
	HTREEITEM hItem = treeCtl.HitTest(point, &nHitFlags);
	if ((nHitFlags & TVHT_ONITEM) && hItem)
	{
		CRegNode *pNode = (CRegNode *)GetTreeCtrl().GetItemData(hItem);
		if (pNode && !(pNode->m_dwType & REGNODE_TYPE_TOPMOST))
		{
			m_PtGesture = point;
			ClientToScreen(&m_PtGesture);
			//SHRecognizeGesture(point, TRUE);
		}
	}
#endif
#endif
	
	CTreeView::OnLButtonDown(nFlags, point);
}

/*
#if defined(_WIN32_WCE) 
#if !defined(_X86_) && !defined(WIN32_PLATFORM_HPC2000)
void CLeftView::OnContextMenu(WPARAM wParam, LPARAM lParam)
{
	NMRGINFO *pInfo = (NMRGINFO *)lParam;
	BOOL bRet = m_TreeTraySubMenu.TrackPopupMenu(TPM_LEFTALIGN, m_PtGesture.x, m_PtGesture.y, this, NULL);
}
#endif
#endif
*/

void CLeftView::OnViewRefresh()
{
	CTreeCtrl &treeCtl = GetTreeCtrl();

	HTREEITEM hItem = treeCtl.GetRootItem();
	CRegNode *pRootNode, *pTemp, *pTemp2, *pTemp3;
	if (hItem)
	{
		pRootNode = (CRegNode *)treeCtl.GetItemData(hItem);
		if (pRootNode)
		{					
			// delete everything under system reg keys
			// first delete tree nodes, then the node ptrs, because while deleting
			// selection change message happens
			pTemp = pRootNode->m_pFirstChild;
			while (pTemp)
			{
				pTemp2 = pTemp->m_pFirstChild;
				while (pTemp2)
				{
					pTemp3 = pTemp2;
					pTemp2 = pTemp2->m_pNextSibling;
					if (pTemp3->m_hItem)
						treeCtl.DeleteItem(pTemp3->m_hItem);
				}
				pTemp = pTemp->m_pNextSibling;
			}

			pTemp = pRootNode->m_pFirstChild;
			while (pTemp)
			{
				pTemp2 = pTemp->m_pFirstChild;
				while (pTemp2)
				{
					pTemp3 = pTemp2;
					pTemp2 = pTemp2->m_pNextSibling;
					delete pTemp3;
				}
				// reset 
				pTemp->m_pFirstChild = NULL;
				pTemp->m_bLoaded = FALSE;
				pTemp = pTemp->m_pNextSibling;
			}
			// 
			DisplayKey(pRootNode);
		}
	}
}