hello world

neo/tools/common/PropTree/PropTree.cpp

@@ -0,0 +1,923 @@
+// PropTree.cpp : implementation file
+//
+//  Copyright (C) 1998-2001 Scott Ramsay
+//	sramsay@gonavi.com
+//	http://www.gonavi.com
+//
+//  This material is provided "as is", with absolutely no warranty expressed
+//  or implied. Any use is at your own risk.
+// 
+//  Permission to use or copy this software for any purpose is hereby granted 
+//  without fee, provided the above notices are retained on all copies.
+//  Permission to modify the code and to distribute modified code is granted,
+//  provided the above notices are retained, and a notice that the code was
+//  modified is included with the above copyright notice.
+// 
+//	If you use this code, drop me an email.  I'd like to know if you find the code
+//	useful.
+
+//#include "stdafx.h"
+#include "../../../idlib/precompiled.h"
+#pragma hdrstop
+
+#include "PropTree.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+#define PROPTREEITEM_EXPANDCOLUMN		16			// width of the expand column
+#define PROPTREEITEM_COLRNG				5			// width of splitter
+
+//static AFX_EXTENSION_MODULE PropTreeDLL = {NULL, NULL};
+static const CString strOfficeFontName	= _T("Tahoma");
+static const CString strDefaultFontName = _T("MS Sans Serif");
+
+HINSTANCE ghInst;
+
+/*extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID)
+{
+	if (dwReason == DLL_PROCESS_ATTACH)
+	{
+		TRACE0("PROPTREE.DLL Initializing!\n");
+		
+		if (!AfxInitExtensionModule(PropTreeDLL, hInstance))
+			return 0;
+
+		new CDynLinkLibrary(PropTreeDLL);
+
+		ghInst = hInstance;
+	}
+	else if (dwReason == DLL_PROCESS_DETACH)
+	{
+		TRACE0("PROPTREE.DLL Terminating!\n");
+		AfxTermExtensionModule(PropTreeDLL);
+	}
+
+	return 1;
+}*/
+
+void InitPropTree(HINSTANCE hInstance) {
+	ghInst = hInstance;
+}
+
+static int CALLBACK FontFamilyProcFonts(const LOGFONT FAR* lplf, const TEXTMETRIC FAR*, ULONG, LPARAM)
+{
+	ASSERT(lplf != NULL);
+	CString strFont = lplf->lfFaceName;
+	return strFont.CollateNoCase (strOfficeFontName) == 0 ? 0 : 1;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CPropTree
+
+UINT CPropTree::s_nInstanceCount;
+CFont* CPropTree::s_pNormalFont;
+CFont* CPropTree::s_pBoldFont;
+CPropTreeItem* CPropTree::s_pFound;
+
+CPropTree::CPropTree() :
+	m_bShowInfo(TRUE),
+	m_nInfoHeight(50),
+	m_pVisbleList(NULL),
+	m_Origin(100,0),
+	m_nLastUID(1),
+	m_pFocus(NULL),
+	m_bDisableInput(FALSE)
+{
+	m_Root.Expand();
+
+	// init global resources only once
+	if (!s_nInstanceCount)
+		InitGlobalResources();
+	s_nInstanceCount++;
+}
+
+
+CPropTree::~CPropTree()
+{
+	DeleteAllItems();
+
+	s_nInstanceCount--;
+
+	// free global resource when ALL CPropTrees are destroyed
+	if (!s_nInstanceCount)
+		FreeGlobalResources();
+}
+
+
+BEGIN_MESSAGE_MAP(CPropTree, CWnd)
+	//{{AFX_MSG_MAP(CPropTree)
+	ON_WM_CREATE()
+	ON_WM_SIZE()
+	ON_WM_ENABLE()
+	ON_WM_SYSCOLORCHANGE()
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+/////////////////////////////////////////////////////////////////////////////
+// CPropTree message handlers
+
+const POINT& CPropTree::GetOrigin()
+{
+	return m_Origin;
+}
+
+
+BOOL CPropTree::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
+{
+	CWnd* pWnd = this;
+
+	LPCTSTR pszCreateClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW, ::LoadCursor(NULL, IDC_ARROW));
+
+	return pWnd->Create(pszCreateClass, _T(""), dwStyle, rect, pParentWnd, nID);
+}
+
+
+int CPropTree::OnCreate(LPCREATESTRUCT lpCreateStruct) 
+{
+	if (CWnd::OnCreate(lpCreateStruct) == -1)
+		return -1;
+
+	DWORD dwStyle;
+	CRect rc;
+
+	GetClientRect(rc);
+
+	// create CPropTreeList
+	//
+
+	dwStyle = WS_VISIBLE|WS_CHILD|WS_VSCROLL;
+
+	if (!m_List.Create(dwStyle, rc, this, 100))
+	{
+		TRACE0("Failed to create CPropTreeList\n");
+		return -1;
+	}
+
+	m_List.SetPropOwner(this);
+
+	// create CPropTreeInfo
+	//
+
+	dwStyle &= ~WS_VSCROLL;
+
+	if (!m_Info.Create(_T(""), dwStyle, rc, this))
+	{
+		TRACE0("Failed to create CPropTreeInfo\n");
+		return -1;
+	}
+
+	m_Info.SetPropOwner(this);
+
+	return 0;
+}
+
+
+CWnd* CPropTree::GetCtrlParent()
+{
+	return &m_List;
+}
+
+
+void CPropTree::OnSize(UINT nType, int cx, int cy) 
+{
+	CWnd::OnSize(nType, cx, cy);
+	ResizeChildWindows(cx, cy);
+}
+
+
+void CPropTree::ResizeChildWindows(int cx, int cy)
+{
+	if (m_bShowInfo)
+	{
+		if (IsWindow(m_List.m_hWnd))
+			m_List.MoveWindow(0, 0, cx, cy - m_nInfoHeight);
+
+		if (IsWindow(m_Info.m_hWnd))
+			m_Info.MoveWindow(0, cy - m_nInfoHeight, cx, m_nInfoHeight);
+	}
+	else
+	{
+		if (IsWindow(m_List.m_hWnd))
+			m_List.MoveWindow(0, 0, cx, cy);
+	}
+}
+
+
+void CPropTree::InitGlobalResources()
+{
+	NONCLIENTMETRICS info;
+	info.cbSize = sizeof(info);
+
+	::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
+
+	LOGFONT lf;
+	memset(&lf, 0, sizeof (LOGFONT));
+
+	CWindowDC dc(NULL);
+	lf.lfCharSet = (BYTE)GetTextCharsetInfo(dc.GetSafeHdc(), NULL, 0);
+
+	lf.lfHeight = info.lfMenuFont.lfHeight;
+	lf.lfWeight = info.lfMenuFont.lfWeight;
+	lf.lfItalic = info.lfMenuFont.lfItalic;
+
+	// check if we should use system font
+	_tcscpy(lf.lfFaceName, info.lfMenuFont.lfFaceName);
+
+	BOOL fUseSystemFont = (info.lfMenuFont.lfCharSet > SYMBOL_CHARSET);
+	if (!fUseSystemFont)
+	{
+		// check for "Tahoma" font existance:
+		if (::EnumFontFamilies(dc.GetSafeHdc(), NULL, FontFamilyProcFonts, 0)==0)
+		{
+			// Found! Use MS Office font!
+			_tcscpy(lf.lfFaceName, strOfficeFontName);
+		}
+		else
+		{
+			// Not found. Use default font:
+			_tcscpy(lf.lfFaceName, strDefaultFontName);
+		}
+	}
+
+	s_pNormalFont = new CFont;
+	s_pNormalFont->CreateFontIndirect(&lf);
+
+	lf.lfWeight = FW_BOLD;
+	s_pBoldFont = new CFont;
+	s_pBoldFont->CreateFontIndirect(&lf);
+}
+
+
+void CPropTree::FreeGlobalResources()
+{
+	if (s_pNormalFont)
+	{
+		delete s_pNormalFont;
+		s_pNormalFont = NULL;
+	}
+
+	if (s_pBoldFont)
+	{
+		delete s_pBoldFont;
+		s_pBoldFont = NULL;
+	}
+}
+
+
+CFont* CPropTree::GetNormalFont()
+{
+	return s_pNormalFont;
+}
+
+
+CFont* CPropTree::GetBoldFont()
+{
+	return s_pBoldFont;
+}
+
+
+CPropTreeItem* CPropTree::GetFocusedItem()
+{
+	return m_pFocus;
+}
+
+
+CPropTreeItem* CPropTree::GetRootItem()
+{
+	return &m_Root;
+}
+
+
+void CPropTree::ClearVisibleList()
+{
+	m_pVisbleList = NULL;
+}
+
+
+CPropTreeItem* CPropTree::GetVisibleList()
+{
+	return m_pVisbleList;
+}
+
+
+void CPropTree::AddToVisibleList(CPropTreeItem* pItem)
+{
+	if (!pItem)
+		return;
+
+	// check for an empty visible list
+	if (!m_pVisbleList)
+		m_pVisbleList = pItem;
+	else
+	{
+		// Add the new item to the end of the list
+		CPropTreeItem* pNext;
+
+		pNext = m_pVisbleList;
+		while (pNext->GetNextVisible())
+			pNext = pNext->GetNextVisible();
+
+		pNext->SetNextVisible(pItem);
+	}
+
+	pItem->SetNextVisible(NULL);
+}
+
+
+BOOL CPropTree::EnumItems(CPropTreeItem* pItem, ENUMPROPITEMPROC proc, LPARAM lParam)
+{
+	if (!pItem || !proc)
+		return FALSE;
+
+	CPropTreeItem* pNext;
+
+	// don't count the root item in any enumerations
+	if (pItem!=&m_Root && !proc(this, pItem, lParam))
+		return FALSE;
+
+	// recurse thru all child items
+	pNext = pItem->GetChild();
+
+	while (pNext)
+	{
+		if (!EnumItems(pNext, proc, lParam))
+			return FALSE;
+
+		pNext = pNext->GetSibling();
+	}
+
+	return TRUE;
+}
+
+
+void CPropTree::SetOriginOffset(LONG nOffset)
+{
+	m_Origin.y = nOffset;
+}
+
+	
+void CPropTree::UpdatedItems()
+{
+	if (!IsWindow(m_hWnd))
+		return;
+
+	Invalidate();
+
+	m_List.UpdateResize();
+	m_List.Invalidate();
+}
+
+
+void CPropTree::DeleteAllItems()
+{
+	Delete(NULL);
+	UpdatedItems();
+	m_nLastUID = 1; // reset uid counter
+}
+
+
+void CPropTree::DeleteItem(CPropTreeItem* pItem)
+{
+	Delete(pItem);
+	UpdatedItems();
+}
+
+
+LONG CPropTree::GetColumn()
+{
+	return m_Origin.x;
+}
+
+
+void CPropTree::SetColumn(LONG nColumn)
+{
+	CRect rc;
+
+	GetClientRect(rc);
+	
+	if (rc.IsRectEmpty())
+		nColumn = __max(PROPTREEITEM_EXPANDCOLUMN, nColumn);
+	else
+		nColumn = __min(__max(PROPTREEITEM_EXPANDCOLUMN, nColumn), rc.Width() - PROPTREEITEM_EXPANDCOLUMN);
+
+	m_Origin.x = nColumn;
+
+	Invalidate();
+}
+
+
+void CPropTree::Delete(CPropTreeItem* pItem)
+{
+	if (pItem && pItem!=&m_Root && SendNotify(PTN_DELETEITEM, pItem))
+		return;
+
+	// passing in a NULL item is the same as calling DeleteAllItems
+	if (!pItem)
+		pItem = &m_Root;
+
+	// Clear the visible list before anything gets deleted
+	ClearVisibleList();
+
+	// delete children
+
+	CPropTreeItem* pIter;
+	CPropTreeItem* pNext;
+
+	pIter = pItem->GetChild();
+	while (pIter)
+	{
+		pNext = pIter->GetSibling();
+		DeleteItem(pIter);
+		pIter = pNext;
+	}
+
+	// unlink from tree
+	if (pItem->GetParent())
+	{
+		if (pItem->GetParent()->GetChild()==pItem)
+			pItem->GetParent()->SetChild(pItem->GetSibling());
+		else
+		{
+			pIter = pItem->GetParent()->GetChild();
+			while (pIter->GetSibling() && pIter->GetSibling()!=pItem)
+				pIter = pIter->GetSibling();
+
+			if (pIter->GetSibling())
+				pIter->SetSibling(pItem->GetSibling());
+		}
+	}
+
+	if (pItem!=&m_Root)
+	{
+		if (pItem==GetFocusedItem())
+			SetFocusedItem(NULL);
+		delete pItem;
+	}
+}
+
+
+void CPropTree::SetFocusedItem(CPropTreeItem* pItem)
+{
+	m_pFocus = pItem;
+	EnsureVisible(m_pFocus);
+
+	if (!IsWindow(m_hWnd))
+		return;
+
+	Invalidate();
+}
+
+
+void CPropTree::ShowInfoText(BOOL bShow)
+{
+	m_bShowInfo = bShow;
+
+	CRect rc;
+
+	GetClientRect(rc);
+	ResizeChildWindows(rc.Width(), rc.Height());
+}
+
+
+BOOL CPropTree::IsItemVisible(CPropTreeItem* pItem)
+{
+	if (!pItem)
+		return FALSE;
+
+	for (CPropTreeItem* pNext = m_pVisbleList; pNext; pNext = pNext->GetNextVisible())
+	{
+		if (pNext==pItem)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+void CPropTree::EnsureVisible(CPropTreeItem* pItem)
+{
+	if (!pItem)
+		return;
+
+	// item is not scroll visible (expand all parents)
+	if (!IsItemVisible(pItem))
+	{
+		CPropTreeItem* pParent;
+
+		pParent = pItem->GetParent();
+		while (pParent)
+		{
+			pParent->Expand();
+			pParent = pParent->GetParent();
+		}
+
+		UpdatedItems();
+		UpdateWindow();
+	}
+
+	ASSERT(IsItemVisible(pItem));
+
+	CRect rc;
+
+	m_List.GetClientRect(rc);
+	rc.OffsetRect(0, m_Origin.y);
+	rc.bottom -= pItem->GetHeight();
+
+	CPoint pt;
+
+	pt = pItem->GetLocation();
+
+	if (!rc.PtInRect(pt))
+	{
+		LONG oy;
+
+		if (pt.y < rc.top)
+			oy = pt.y;
+		else
+			oy = pt.y - rc.Height() + pItem->GetHeight();
+
+		m_List.OnVScroll(SB_THUMBTRACK, oy, NULL);
+	}
+}
+
+
+CPropTreeItem* CPropTree::InsertItem(CPropTreeItem* pItem, CPropTreeItem* pParent)
+{
+	if (!pItem)
+		return NULL;
+
+	if (!pParent)
+		pParent = &m_Root;
+
+	if (!pParent->GetChild())
+		pParent->SetChild(pItem);
+	else
+	{
+		// add to end of the sibling list
+		CPropTreeItem* pNext;
+
+		pNext = pParent->GetChild();
+		while (pNext->GetSibling())
+			pNext = pNext->GetSibling();
+
+		pNext->SetSibling(pItem);
+	}
+
+	pItem->SetParent(pParent);
+	pItem->SetPropOwner(this);
+
+	// auto generate a default ID
+	pItem->SetCtrlID(m_nLastUID++);
+
+	SendNotify(PTN_INSERTITEM, pItem);
+
+	UpdatedItems();
+
+	return pItem;
+}
+
+
+
+LONG CPropTree::HitTest(const POINT& pt)
+{
+	POINT p = pt;
+
+	CPropTreeItem* pItem;
+
+	// convert screen to tree coordinates
+	p.y += m_Origin.y;
+
+	if ((pItem = FindItem(pt))!=NULL)
+	{
+		if (!pItem->IsRootLevel() && pt.x >= m_Origin.x - PROPTREEITEM_COLRNG && pt.x <= m_Origin.x + PROPTREEITEM_COLRNG)
+			return HTCOLUMN;
+
+		if (pItem->HitButton(p)) {
+			return HTBUTTON;
+		}
+
+		if (pt.x > m_Origin.x + PROPTREEITEM_COLRNG)
+			return HTATTRIBUTE;
+
+		if (pItem->HitExpand(p))
+			return HTEXPAND;
+
+		if (pItem->HitCheckBox(p))
+			return HTCHECKBOX;
+
+		return HTLABEL;
+	}
+
+	return HTCLIENT;
+}
+
+
+CPropTreeItem* CPropTree::FindItem(const POINT& pt)
+{
+	CPropTreeItem* pItem;
+
+	CPoint p = pt;
+
+	// convert screen to tree coordinates
+	p.y += m_Origin.y;
+
+	// search the visible list for the item
+	for (pItem = m_pVisbleList; pItem; pItem = pItem->GetNextVisible())
+	{
+		CPoint ipt = pItem->GetLocation();
+		if (p.y>=ipt.y && p.y<ipt.y + pItem->GetHeight())
+			return pItem;
+	}
+
+	return NULL;
+}
+
+
+CPropTreeItem* CPropTree::FindItem(UINT nCtrlID)
+{
+	s_pFound = NULL;
+
+	EnumItems(&m_Root, EnumFindItem, nCtrlID);
+
+	return s_pFound;
+}
+
+
+BOOL CALLBACK CPropTree::EnumFindItem(CPropTree*, CPropTreeItem* pItem, LPARAM lParam)
+{
+	ASSERT(pItem!=NULL);
+
+	if (pItem->GetCtrlID()==(UINT)lParam)
+	{
+		s_pFound = pItem;
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+BOOL CPropTree::IsDisableInput()
+{
+	return m_bDisableInput;
+}
+
+
+void CPropTree::DisableInput(BOOL bDisable)
+{
+	m_bDisableInput = bDisable;
+
+	CWnd* pWnd;
+
+	if ((pWnd = GetParent())!=NULL)
+		pWnd->EnableWindow(!bDisable);
+}
+
+
+void CPropTree::SelectItems(CPropTreeItem* pItem, BOOL bSelect)
+{
+	if (!pItem)
+		pItem = &m_Root;
+
+	EnumItems(pItem, EnumSelectAll, (LPARAM)bSelect);
+}
+
+
+CPropTreeItem* CPropTree::FocusFirst()
+{
+	CPropTreeItem *pold;
+
+	pold = m_pFocus;
+
+	SetFocusedItem(m_pVisbleList);
+
+	if (m_pFocus)
+	{
+		SelectItems(NULL, FALSE);
+		m_pFocus->Select();
+	}
+
+	if (pold!=m_pFocus)
+		SendNotify(PTN_SELCHANGE, m_pFocus);
+
+	return m_pFocus;
+}
+
+
+CPropTreeItem* CPropTree::FocusLast()
+{
+	CPropTreeItem* pNext;
+	CPropTreeItem* pChange;
+
+	pChange = m_pFocus;
+
+	pNext = m_pVisbleList;
+
+	if (pNext)
+	{
+		while (pNext->GetNextVisible())
+			pNext = pNext->GetNextVisible();
+
+		SetFocusedItem(pNext);
+
+		if (m_pFocus)
+		{
+			SelectItems(NULL, FALSE);
+			m_pFocus->Select();
+		}
+	}
+
+	if (pChange!=m_pFocus)
+		SendNotify(PTN_SELCHANGE, m_pFocus);
+
+	return pNext;
+}
+
+
+CPropTreeItem* CPropTree::FocusPrev()
+{
+	CPropTreeItem* pNext;
+	CPropTreeItem* pChange;
+
+	pChange = m_pFocus;
+
+	if (m_pFocus==NULL)
+	{
+		// get the last visible item
+		pNext = m_pVisbleList;
+		while (pNext && pNext->GetNextVisible())
+			pNext = pNext->GetNextVisible();
+	}
+	else
+	{
+		pNext = m_pVisbleList;
+		while (pNext && pNext->GetNextVisible()!=m_pFocus)
+			pNext = pNext->GetNextVisible();
+	}
+
+	if (pNext)
+		SetFocusedItem(pNext);
+	
+	if (m_pFocus)
+	{
+		SelectItems(NULL, FALSE);
+		m_pFocus->Select();
+	}
+
+	if (pChange!=m_pFocus)
+		SendNotify(PTN_SELCHANGE, m_pFocus);
+
+	return pNext;
+}
+
+
+CPropTreeItem* CPropTree::FocusNext()
+{
+	CPropTreeItem* pNext;
+	CPropTreeItem* pChange;
+
+	pChange = m_pFocus;
+
+	if (m_pFocus==NULL)
+		pNext = m_pVisbleList;
+	else
+	if (m_pFocus->GetNextVisible())
+		pNext = m_pFocus->GetNextVisible();
+	else
+		pNext = NULL;
+
+	if (pNext)
+		SetFocusedItem(pNext);
+
+	if (m_pFocus)
+	{
+		SelectItems(NULL, FALSE);
+		m_pFocus->Select();
+	}
+
+	if (pChange!=m_pFocus)
+		SendNotify(PTN_SELCHANGE, m_pFocus);
+
+	return pNext;
+}
+
+
+void CPropTree::UpdateMoveAllItems()
+{
+	EnumItems(&m_Root, EnumMoveAll);
+}
+
+
+void CPropTree::RefreshItems(CPropTreeItem* pItem)
+{
+	if (!pItem)
+		pItem = &m_Root;
+
+	EnumItems(pItem, EnumRefreshAll);
+
+	UpdatedItems();
+}
+
+
+BOOL CALLBACK CPropTree::EnumSelectAll(CPropTree*, CPropTreeItem* pItem, LPARAM lParam)
+{
+	if (!pItem)
+		return FALSE;
+
+	pItem->Select((BOOL)lParam);
+
+	return TRUE;
+}
+
+
+BOOL CALLBACK CPropTree::EnumRefreshAll(CPropTree*, CPropTreeItem* pItem, LPARAM)
+{
+	if (!pItem)
+		return FALSE;
+
+	pItem->OnRefresh();
+
+	return TRUE;
+}
+
+
+BOOL CALLBACK CPropTree::EnumMoveAll(CPropTree*, CPropTreeItem* pItem, LPARAM)
+{
+	if (!pItem)
+		return FALSE;
+
+	pItem->OnMove();
+
+	return TRUE;
+}
+
+
+LRESULT CPropTree::SendNotify(UINT nNotifyCode, CPropTreeItem* pItem)
+{
+	if (!IsWindow(m_hWnd))
+		return 0L;
+
+	if (!(GetStyle() & PTS_NOTIFY))
+		return 0L;
+
+	NMPROPTREE nmmp;
+	LPNMHDR lpnm;
+
+	lpnm = NULL;
+
+	switch (nNotifyCode)
+	{
+		case PTN_INSERTITEM:
+		case PTN_DELETEITEM:
+		case PTN_DELETEALLITEMS:
+		case PTN_ITEMCHANGED:
+		case PTN_ITEMBUTTONCLICK:
+		case PTN_SELCHANGE:
+		case PTN_ITEMEXPANDING:
+		case PTN_COLUMNCLICK:
+		case PTN_PROPCLICK:
+		case PTN_CHECKCLICK:
+			lpnm = (LPNMHDR)&nmmp;
+			nmmp.pItem = pItem;
+			break;
+	}
+
+	if (lpnm)
+	{
+		UINT id = (UINT)::GetMenu(m_hWnd);
+		lpnm->code = nNotifyCode;
+		lpnm->hwndFrom = m_hWnd;
+		lpnm->idFrom = id;
+	
+		return GetParent()->SendMessage(WM_NOTIFY, (WPARAM)id, (LPARAM)lpnm);
+	}
+
+	return 0L;
+}
+
+
+void CPropTree::OnEnable(BOOL bEnable) 
+{
+	CWnd::OnEnable(bEnable);
+	Invalidate();
+}
+
+
+void CPropTree::OnSysColorChange() 
+{
+	CWnd::OnSysColorChange();
+	
+	Invalidate();	
+}
+
+
+BOOL CPropTree::IsSingleSelection()
+{
+	// right now only support single selection
+	return TRUE;
+}