CStaticTreeCtrl - A CStatic derived custom Tree control

// StaticTreeCtrl.cpp : implementation file
//

#include "stdafx.h"
#include "CustomTreeControl.h"
#include "StaticTreeCtrl.h"
#include "ContextMenu.h"
#include "DLG_TreeNodeText.h"

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

/////////////////////////////////////////////////////////////////////////////
// CStaticTreeCtrl

CStaticTreeCtrl::CStaticTreeCtrl()
{
	m_pTopNode				= new CTreeNode();	// The tree top

	m_iIndent				= 16;				// Indentation for tree branches
	m_iPadding				= 4;				// Padding between tree and the control border

	m_bShowLines			= TRUE;				// Show lines by default
	m_bScrollBarMessage		= FALSE;			// Only relevant when calculating the scrollbar

	m_iDocHeight			= 0;				// A polite yet meaningless default

	m_crDefaultTextColor	= RGB(58,58,58);	// Some default
	m_crConnectingLines		= RGB(128,128,128);	// Some default

	m_bAudioOn				= FALSE;			// The context menu audio

	// Safeguards
	SetTextFont( 8, FALSE, FALSE, "Arial Unicode MS" );
	m_pSelected				= NULL;	
}

CStaticTreeCtrl::~CStaticTreeCtrl()
{
	DeleteNode( m_pTopNode );	// Delete all childs if there are any
	delete m_pTopNode;			// Delete top node
	m_pTopNode = NULL;
	
	m_Font.DeleteObject();

	if( m_bmpBackground.GetSafeHandle() != NULL )
		m_bmpBackground.DeleteObject();
}


BEGIN_MESSAGE_MAP(CStaticTreeCtrl, CStatic)
	//{{AFX_MSG_MAP(CStaticTreeCtrl)
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_VSCROLL()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEWHEEL()
	ON_WM_CONTEXTMENU()
	ON_COMMAND(CM_INSERTCHILD, OnCM_InsertChild)
	ON_COMMAND(CM_INSERTSIBLING, OnCM_InsertSibling)
	ON_COMMAND(CM_DELETENODE, OnCM_DeleteNode)
	ON_COMMAND(CM_MODIFYNODETEXT, OnCM_ModifyNodeText)
	ON_COMMAND(CM_CHANGENODECOLOR, OnCM_ChangeNodeColor)
	ON_COMMAND(CM_TOGGLECONNECTINGLINES, OnCM_ToggleConnectingLines)
	ON_COMMAND(CM_SETCONNECTINGLINESCOLOR, OnCM_SetConnectingLinesColor)
	ON_COMMAND(CM_SETFONT, OnCM_SetFont)
	ON_COMMAND(CM_SETDEFAULTCOLOR, OnCM_SetDefaultColor)
	ON_COMMAND(CM_SETBACKGROUNDBITMAP, OnCM_SetBackgroundBitmap)
	ON_COMMAND(CM_TOGGLEMENUSOUND, OnCM_ToggleMenuSound)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
//	PUBLIC METHODS
/////////////////////////////////////////////////////////////////////////////

CStaticTreeCtrl& CStaticTreeCtrl::SetTextFont( LONG nHeight, BOOL bBold, BOOL bItalic, const CString& csFaceName )
{
	m_lgFont.lfHeight			= -MulDiv( nHeight, GetDeviceCaps( GetDC()->m_hDC, LOGPIXELSY ), 72 );
	m_lgFont.lfWidth			= 0;
	m_lgFont.lfEscapement		= 0;
	m_lgFont.lfOrientation		= 0;
	m_lgFont.lfWeight			= ( bBold )? FW_BOLD:FW_DONTCARE;
	m_lgFont.lfItalic			= (BYTE)( ( bItalic )? TRUE:FALSE );
	m_lgFont.lfUnderline		= FALSE;
	m_lgFont.lfStrikeOut		= FALSE;
	m_lgFont.lfCharSet			= DEFAULT_CHARSET;
	m_lgFont.lfOutPrecision		= OUT_DEFAULT_PRECIS;
	m_lgFont.lfClipPrecision	= CLIP_DEFAULT_PRECIS;
	m_lgFont.lfQuality			= DEFAULT_QUALITY;
	m_lgFont.lfPitchAndFamily	= DEFAULT_PITCH | FF_DONTCARE;

	STRCPY( m_lgFont.lfFaceName, csFaceName );

	if( m_Font.GetSafeHandle() != NULL )
		m_Font.DeleteObject();
	
	m_Font.CreateFontIndirect( &m_lgFont );

	// Calculate node height for this font
	CDC		*pDC		= GetDC();
	int		iSaved		= pDC->SaveDC();
	CFont*	pOldFont	= pDC->SelectObject( &m_Font );

	// Calculate the height of this font with a character likely to be 'big'
	// and don't forget to add a little padding
	m_iLineHeight	= pDC->GetTextExtent( "X" ).cy + 4;

	pDC->SelectObject( pOldFont );
	pDC->RestoreDC( iSaved );
	ReleaseDC( pDC );

	return *this;
}

CStaticTreeCtrl& CStaticTreeCtrl::SetDefaultTextColor( COLORREF crText )
{
	m_crDefaultTextColor = crText;
	
	return *this;
}


HTREENODE CStaticTreeCtrl::InsertSibling(	HTREENODE pInsertAfter, const CString& csLabel,
											COLORREF crText /* = 0 */, BOOL bUseDefaultTextColor /* = TRUE */,
											BOOL bInvalidate /* = FALSE  */)
{
	ASSERT( pInsertAfter != NULL );	// Make sure the node exists
	
	HTREENODE pNewNode = new CTreeNode();

	pNewNode->csLabel	= csLabel;					// New node's label

	if( bUseDefaultTextColor )
		pNewNode->bUseDefaultTextColor = TRUE;		// Use the default text color
	else
		pNewNode->crText = crText;					// New node's text color

	pNewNode->pParent	= pInsertAfter->pParent;	// Nas the same parent

	// Insert the new node between pInsertAfter and its next sibling
	pNewNode->pSibling		= pInsertAfter->pSibling;
	pInsertAfter->pSibling	= pNewNode;

	// Repaint the control if so desired
	if( bInvalidate )
		Invalidate();
	
	return pNewNode;
}

HTREENODE CStaticTreeCtrl::InsertChild( HTREENODE pParent, const CString& csLabel,
										COLORREF crText /* = 0 */, BOOL bUseDefaultTextColor /* = TRUE */,
										BOOL bInvalidate /* = FALSE  */)
{
	ASSERT( pParent != NULL );	// Make sure the node exists
	
	if( pParent == HTOPNODE )	// Check for top node
		pParent = m_pTopNode;
	
	HTREENODE pNewNode = new CTreeNode();

	// Basic node information
	pNewNode->csLabel	= csLabel;	// New node's label

	if( bUseDefaultTextColor )
		pNewNode->bUseDefaultTextColor = TRUE;		// Use the default text color
	else
		pNewNode->crText = crText;					// New node's text color

	pNewNode->pParent	= pParent;	// New node's parent

	// Insert the new node as pParent's first child
	pNewNode->pSibling	= pParent->pChild;
	pParent->pChild		= pNewNode;

	// Repaint the control if so desired
	if( bInvalidate )
		Invalidate();
	
	return pNewNode;
}

void CStaticTreeCtrl::DeleteNode( HTREENODE pNode, BOOL bInvalidate /* = FALSE  */)
{
	ASSERT( pNode != NULL );	// Make sure the node exists

	// Don't delete the top node
	if( pNode == HTOPNODE )
		DeleteNode( m_pTopNode, bInvalidate );

	// Delete childs
	if( pNode->pChild != NULL )
		DeleteNodeRecursive( pNode->pChild );

	// If this node is not the top node, fix pointers in sibling list
	if( pNode != m_pTopNode )
	{
		HTREENODE pRunner = pNode->pParent;
		
		// If first child, set the parent pointer to the next sibling
		// Otherwise, find sibling before and set its sibling pointer to the node's sibling
		if( pRunner->pChild == pNode )
			pRunner->pChild = pNode->pSibling;
		else
		{
			pRunner = pRunner->pChild;

			// Loop until the next node is the one being deleted
			while( pRunner->pSibling != pNode )
				pRunner = pRunner->pSibling;

			pRunner->pSibling = pNode->pSibling;
		}

		delete pNode;

		pNode = NULL;
	}

	// Repaint the control if so desired
	if( bInvalidate )
		Invalidate();
}

void CStaticTreeCtrl::ToggleNode( HTREENODE pNode, BOOL bInvalidate /* = FALSE  */)
{
	ASSERT( pNode != NULL );

	pNode->bOpen = !( pNode->bOpen );

	if( bInvalidate )
		Invalidate();
}

void CStaticTreeCtrl::SetNodeColor( HTREENODE pNode, COLORREF crText, BOOL bInvalidate /* = FALSE  */)
{
	ASSERT( pNode != NULL );

	pNode->bUseDefaultTextColor	= FALSE;
	pNode->crText				= crText;

	if( bInvalidate )
		Invalidate();
}

void CStaticTreeCtrl::SetBackgroundBitmap( BOOL bInvalidate /* = FALSE  */)
{
	CFileDialog fd( TRUE, NULL, NULL, OFN_EXPLORER | OFN_FILEMUSTEXIST, _T("Bitmap Files (*.bmp)|*.bmp||"), this );

	// If the user clicked 'ok'
	if( fd.DoModal() == IDOK )
	{
		// If there is a bitmap already loaded, delete it
	    if( m_bmpBackground.GetSafeHandle() != NULL )
			m_bmpBackground.DeleteObject();
		
		// Load the bitmap from the file selected
		HBITMAP hBitmap =	(HBITMAP)LoadImage( NULL, fd.GetPathName(), IMAGE_BITMAP, 
												0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION | LR_DEFAULTSIZE );

		// Attach it to the CBitmap object
		m_bmpBackground.Attach( hBitmap );

		// Repaint if so desired
		if( bInvalidate )
			Invalidate();
	}
}

/////////////////////////////////////////////////////////////////////////////
//	PROTECTED METHODS
/////////////////////////////////////////////////////////////////////////////

void CStaticTreeCtrl::DeleteNodeRecursive( HTREENODE pNode )
{
	if( pNode->pSibling != NULL )
		DeleteNodeRecursive( pNode->pSibling );

	if( pNode->pChild != NULL )
		DeleteNodeRecursive( pNode->pChild );

	delete pNode;

	pNode = NULL;
}

int CStaticTreeCtrl::DrawNodesRecursive( CDC* pDC, HTREENODE pNode, int x, int y, CRect rFrame )
{
	int		iDocHeight = 0;		// Total document height
	CRect	rNode;

	// The node's location and dimensions on screen
	rNode.left		= x;
	rNode.top		= y;
	rNode.right		= rFrame.right - m_iPadding;
	rNode.bottom	= y + m_iLineHeight;

	pNode->rNode.CopyRect( rNode );		// Record the rectangle

	COLORREF cr			= ( pNode->bUseDefaultTextColor )? m_crDefaultTextColor:pNode->crText;
	COLORREF crOldText	= pDC->SetTextColor( cr );

	// MULTILINE TEXT - begins
	CString	cs		= pNode->csLabel;
	int		iPos	= 0;

	// Draw text until there is nothing left to draw
	while( cs.GetLength() > 0 )
	{
		// Height of a line of text
		rNode.bottom = rNode.top + m_iLineHeight;

		// Find out how much text fits in one line
		iPos = HowMuchTextFits( pDC, rFrame.right - m_iPadding - rNode.left, cs );

		// Draw only if the node is visible
		if( rNode.bottom > 0 && rNode.top < rFrame.bottom )
			pDC->DrawText( cs.Left( iPos + 1 ), rNode, DT_LEFT | DT_SINGLELINE | DT_VCENTER );

		// Eliminate the text that has been already drawn
		cs = cs.Mid( iPos + 1 );

		// The node grows everytime another line of text is drawn
		pNode->rNode.UnionRect( pNode->rNode, rNode );

		// Move down the drawing rectangle for the next line of text
		rNode.top = rNode.bottom;
	}
	// MULTILINE TEXT - ends

	pDC->SetTextColor( crOldText );

	// If there are no child or siblings, then this branch is done
	if( pNode->pChild == NULL &&  pNode->pSibling == NULL )
		return pNode->rNode.Height();

	// If the node is open AND it has childs, then draw those
	if( pNode->bOpen && pNode->pChild != NULL )
		iDocHeight = DrawNodesRecursive( pDC, pNode->pChild, x + m_iIndent, y + pNode->rNode.Height(), rFrame );

	// If the node has siblings, then draw those
	if( pNode->pSibling != NULL )
		iDocHeight += DrawNodesRecursive( pDC, pNode->pSibling, x, y + pNode->rNode.Height() + iDocHeight, rFrame );

	return iDocHeight + pNode->rNode.Height();
}

int CStaticTreeCtrl::HowMuchTextFits( CDC* pDC, int iAvailableWidth, CString csText )
{
	int iValidSoFar = csText.GetLength() - 1;					// Assume the entire text fits

	// If the text's pixel width is larger than what's available
	if( pDC->GetTextExtent( csText ).cx > iAvailableWidth )
	{
		int iNextBlank	= 0;	// Position of the next blank in text
		int iPixelWidth	= 0;	// Text's pixel width

		// Loop until we can fit no more of the text
		while( iPixelWidth < iAvailableWidth )
		{
			iValidSoFar	= iNextBlank;							// Record the char pos so far
			iNextBlank	= csText.Find( ' ', iNextBlank + 1 );	// Advance one word at a time

			// Have reached the end of the string?
			if( iNextBlank == -1 )
				iNextBlank = csText.GetLength();

			// Calculate the new width
			iPixelWidth = pDC->GetTextExtent( csText.Left( iNextBlank ) ).cx;
		}
	}

	return iValidSoFar;
}

void CStaticTreeCtrl::DrawLinesRecursive( CDC* pDC, HTREENODE pNode )
{
	// Draw lines from childs if the node is open before drawing lines from this node
	if( pNode->bOpen && pNode->pChild != NULL )
		DrawLinesRecursive( pDC, pNode->pChild );

	// Where is the elbow joint of this connecting line?
	int iJointX	= pNode->rNode.left - m_iIndent - 6;
	int iJointY	= pNode->rNode.top + ( m_iLineHeight / 2 );

	// If the parent is not the top node, throw a connecting line to it
	if( pNode->pParent != m_pTopNode )
	{
		// How far up from the joint is the parent?
		int iDispY = iJointY - pNode->pParent->rNode.top - ( m_iLineHeight / 2 );
		
		// Use 1 pixel wide rectangles to draw lines
		pDC->FillSolidRect( iJointX, iJointY, m_iIndent, 1, m_crConnectingLines );	// Horizontal line
		pDC->FillSolidRect( iJointX, iJointY, 1, -iDispY, m_crConnectingLines );		// Vertical line
	}

	// Put a solid dot to mark a node
	pDC->FillSolidRect( iJointX + m_iIndent - 2, iJointY - 2, 5, 5, m_crConnectingLines );

	// Hollow out the dot if the node has no childs
	if( pNode->pChild == NULL )
		pDC->FillSolidRect( iJointX + m_iIndent - 1, iJointY - 1, 3, 3, RGB(255,255,255) );

	// Draw the next sibling if there are any
	if( pNode->pSibling != NULL )
		DrawLinesRecursive( pDC, pNode->pSibling );
}

void CStaticTreeCtrl::ResetScrollBar()
{
	// Flag to avoid a call from OnSize while resetting the scrollbar
	m_bScrollBarMessage = TRUE;

	CRect rFrame;

	GetClientRect( rFrame );

	// Need for scrollbars?
	if( rFrame.Height() > m_iDocHeight + 8 )
	{
		ShowScrollBar( SB_VERT, FALSE );	// Hide it
		SetScrollPos( SB_VERT, 0 );
	}
	else
	{
		SCROLLINFO	si;
		si.cbSize = sizeof(SCROLLINFO);
		si.fMask = SIF_PAGE | SIF_RANGE;
		si.nPage = rFrame.Height();
		si.nMax = m_iDocHeight + 8;
		si.nMin = 0 ;

		SetScrollInfo( SB_VERT, &si );
		EnableScrollBarCtrl( SB_VERT, TRUE );
	}

	m_bScrollBarMessage = FALSE;
}

HTREENODE CStaticTreeCtrl::FindNodeByPoint( const CPoint& point, HTREENODE pNode )
{
	HTREENODE pFound = NULL;

	// Found it?
	if( pNode->rNode.PtInRect( point ) )
		pFound = pNode;
	
	// If this node isn't it then check the node's childs if it is open and there are any
	if( pFound == NULL && pNode->bOpen && pNode->pChild != NULL )
		pFound = FindNodeByPoint( point, pNode->pChild );

	// If didn't find it among the node's childs, then check the next sibling 
	if( pFound == NULL && pNode->pSibling != NULL )
		pFound = FindNodeByPoint( point, pNode->pSibling );

	return pFound;
}

BOOL CStaticTreeCtrl::NodeTextDlg( CString& csText )
{
	BOOL				bRet = FALSE;
	CDLG_TreeNodeText	tntDlg;

	tntDlg.m_csItemText = csText;

	if( tntDlg.DoModal() == IDOK )
	{
		csText	= tntDlg.m_csItemText;
		bRet	= TRUE;
	}

	return bRet;
}

/////////////////////////////////////////////////////////////////////////////
// CStaticTreeCtrl message handlers

void CStaticTreeCtrl::OnPaint() 
{
	CPaintDC dc(this); // Device context for painting
	
	// Double-buffering
	CDC*		pDCMem		= new CDC;
	CBitmap*	pOldBitmap	= NULL;
	CBitmap		bmpCanvas;
	CRect		rFrame;

	GetClientRect( rFrame );

	pDCMem->CreateCompatibleDC( &dc );

	bmpCanvas.CreateCompatibleBitmap( &dc, rFrame.Width(), rFrame.Height() );

	pOldBitmap = pDCMem->SelectObject( &bmpCanvas );

	// START DRAW -------------------------------------------------

	// If there is a bitmap loaded, use it
	// Otherwise, paint the background white
    if( m_bmpBackground.GetSafeHandle() != NULL )
    {
		CDC*	pDCTemp = new CDC;;
		BITMAP	bmp;

		pDCTemp->CreateCompatibleDC( &dc );

		m_bmpBackground.GetBitmap( &bmp );

		// Select the bitmap into the temp device context
		CBitmap* pOldBitmap = (CBitmap*) pDCTemp->SelectObject( &m_bmpBackground );

		// Stretch the bitmap to fill the entire control area
		pDCMem->StretchBlt( 0, 0, rFrame.Width(), rFrame.Height(), pDCTemp, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY );

		pDCTemp->SelectObject( pOldBitmap ); 
		
		delete pDCTemp;
	}
	else
		pDCMem->FillSolidRect( rFrame, RGB(255,255,255) );

	UINT	nMode		= pDCMem->SetBkMode( TRANSPARENT );
	CFont*	pOldFont	= pDCMem->SelectObject( &m_Font );

	int iLastNodePos = 0;

	if( m_pTopNode->pChild != NULL )
	{
		iLastNodePos = DrawNodesRecursive(	pDCMem, m_pTopNode->pChild,
											rFrame.left + m_iIndent,
											m_iPadding - GetScrollPos( SB_VERT ),
											rFrame );

		if( m_bShowLines )
			DrawLinesRecursive( pDCMem, m_pTopNode->pChild );
	}

	pDCMem->SelectObject( pOldFont );
	pDCMem->SetBkMode( nMode );

	pDCMem->Draw3dRect( rFrame, RGB(0,0,0), RGB(0,0,0) );	// Border
	
	// END DRAW   -------------------------------------------------

	dc.BitBlt( 0, 0, rFrame.Width(), rFrame.Height(), pDCMem, 0, 0, SRCCOPY );

	pDCMem->SelectObject( pOldBitmap );

	delete pDCMem;

	// Has the total document height changed?
	if( iLastNodePos != m_iDocHeight )
	{
		BOOL bInvalidate = ( ( m_iDocHeight < rFrame.Height() ) != ( iLastNodePos < rFrame.Height() ) );
		
		m_iDocHeight = iLastNodePos;

		ResetScrollBar();

		// If the scrollbar has just been hidden/shown, repaint
		if( bInvalidate )
			Invalidate();
	}
}

void CStaticTreeCtrl::OnSize(UINT nType, int cx, int cy) 
{
	// Setting the scroll sends its own size message. Prevent it thus avoiding an ugly loop.
	// Other than that, resizing the control means that the tree height may change (word-wrap).
	if( !m_bScrollBarMessage )
		ResetScrollBar();
	
	CStatic::OnSize(nType, cx, cy);
}

void CStaticTreeCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	int iScrollBarPos = GetScrollPos( SB_VERT );

	CRect rFrame;

	GetClientRect( rFrame );

	switch( nSBCode )
	{
		case SB_LINEUP:
			iScrollBarPos = max( iScrollBarPos - m_iLineHeight, 0 );
		break;

		case SB_LINEDOWN:
			iScrollBarPos = min( iScrollBarPos + m_iLineHeight, GetScrollLimit( SB_VERT ) );
		break;

		case SB_PAGEUP:
			iScrollBarPos = max( iScrollBarPos - rFrame.Height(), 0 );
		break;

		case SB_PAGEDOWN:
			iScrollBarPos = min( iScrollBarPos + rFrame.Height(), GetScrollLimit( SB_VERT ) );
		break;

		case SB_THUMBTRACK:
		case SB_THUMBPOSITION:
		{
			SCROLLINFO si;

			ZeroMemory( &si, sizeof(SCROLLINFO) );

			si.cbSize	= sizeof(SCROLLINFO);
			si.fMask	= SIF_TRACKPOS;

			if( GetScrollInfo( SB_VERT, &si, SIF_TRACKPOS ) )
				iScrollBarPos = si.nTrackPos;
			else
				iScrollBarPos = (UINT)nPos;
			break;
		}
	}		

	SetScrollPos( SB_VERT, iScrollBarPos );
	
	Invalidate();
	
	CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
}

LRESULT CStaticTreeCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
	if( message == WM_NCHITTEST || message == WM_NCLBUTTONDOWN || message == WM_NCLBUTTONDBLCLK )
		return ::DefWindowProc( m_hWnd, message, wParam, lParam );
	
	return CStatic::WindowProc(message, wParam, lParam);
}


void CStaticTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
{
	HTREENODE pClickedOn = NULL;		// Assume no node was clicked on

	if( m_pTopNode->pChild != NULL)		// If the tree is populated, search it
		pClickedOn = FindNodeByPoint( point, m_pTopNode->pChild );

	if( pClickedOn != NULL )			// If a node was clicked on
		ToggleNode( pClickedOn, TRUE );
	else
		CStatic::OnLButtonUp(nFlags, point);
}

BOOL CStaticTreeCtrl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	// zDelta greater than 0, means rotating away from the user, that is, scrolling up
	OnVScroll( ( zDelta > 0 )? SB_LINEUP:SB_LINEDOWN, 0, NULL );

	return CStatic::OnMouseWheel(nFlags, zDelta, pt);
}

void CStaticTreeCtrl::OnContextMenu(CWnd* /*pWnd*/, CPoint point) 
{
	CPoint cp( point );

	// WM_CONTEXTMENU passes absolute coordinates, we need them local
	ScreenToClient( &cp );

	// Find the node that has been clicked on
	if( m_pTopNode->pChild == NULL )
		m_pSelected = NULL;		// Empty tree
	else
		m_pSelected = FindNodeByPoint( cp, m_pTopNode->pChild );

	CContextMenu ccmPopUp;

	ccmPopUp.CreatePopupMenu();

	// Customize the menu appearance and behavior
	ccmPopUp
		.ToggleSound	( m_bAudioOn )
		.SetTextFont	( &m_Font )
		.SetColors		( RGB(70,36,36), RGB(253,249,249), RGB(172,96,96), RGB(244,234,234), RGB(182,109,109) );

	// Get a device context so that it'll be possible for the context menu
	// to calculate the size of the menu item's text
	CDC		*pDC		= GetDC();
	int		iSaved		= pDC->SaveDC();
	CFont*	pOldFont	= pDC->SelectObject( &m_Font );

	// ADDING MENU ITEMS - Start

	// If a node has been clicked on, use the first 45 chars of its text as the
	// first menu item (always disabled)
	if( m_pSelected != NULL )
	{
		CString	csDots	= ( m_pSelected->csLabel.GetLength() > 45 )? _T("..."):_T("");
		CString cs		= m_pSelected->csLabel.Left( 45 ) + csDots;

		ccmPopUp.AppendMenuItem( MF_DISABLED, WM_APP, cs, _T(""), pDC );
		ccmPopUp.AppendMenuItem( MF_SEPARATOR, 0, _T(""), _T(""), pDC );
	}

	UINT nFlag = ( m_pSelected != NULL )? MF_ENABLED:MF_GRAYED;

	// Node related items
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_INSERTCHILD, _T("Insert Child"), _T("insertChild.wav"), pDC );
	ccmPopUp.AppendMenuItem( nFlag, CM_INSERTSIBLING, _T("Insert Sibling"), _T("insertSibling.wav"), pDC );
	ccmPopUp.AppendMenuItem( nFlag, CM_DELETENODE, _T("Delete Node"), _T("deleteNode.wav"), pDC );
	ccmPopUp.AppendMenuItem( nFlag, CM_MODIFYNODETEXT, _T("Modify Node Text"), _T("modifyNodeText.wav"), pDC );
	ccmPopUp.AppendMenuItem( nFlag, CM_CHANGENODECOLOR, _T("Change Node Color"), _T("changeNodeColor.wav"), pDC );

	ccmPopUp.AppendMenuItem( MF_SEPARATOR, 0, _T(""), _T(""), pDC );

	// Connecting lines related items
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_TOGGLECONNECTINGLINES, _T("Toggle Connecting Lines"), _T("toggleConnectingLines.wav"), pDC );
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_SETCONNECTINGLINESCOLOR, _T("Set Connecting Lines Color"), 	_T("setConnectingLinesColor.wav"), pDC );

	ccmPopUp.AppendMenuItem( MF_SEPARATOR, 0, _T(""), _T(""), pDC );
	
	// Tree appearance items
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_SETFONT, _T("Set Font"), _T("setFont.wav"), pDC );
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_SETDEFAULTCOLOR, _T("Set Default Text Color"), _T("setDefaultColor.wav"), pDC );
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_SETBACKGROUNDBITMAP, _T("Set Background Bitmap"), _T("setBackgroundBitmap.wav"), pDC );

	ccmPopUp.AppendMenuItem( MF_SEPARATOR, 0, _T(""), _T(""), pDC );
	
	// Context menu sound toggle item
	ccmPopUp.AppendMenuItem( MF_ENABLED, CM_TOGGLEMENUSOUND, _T("Toggle Menu Sound"), _T("toggleMenuSound.wav"), pDC );

	// ADDING MENU ITEMS - End

	// Display the context menu
	ccmPopUp.TrackPopupMenu( TPM_LEFTALIGN, point.x, point.y, this );

	// Clean up
	pDC->SelectObject( pOldFont );
	pDC->RestoreDC( iSaved );
	ReleaseDC( pDC );
}

void CStaticTreeCtrl::OnCM_InsertChild()
{
	CString csText("");

	if( NodeTextDlg( csText ) == TRUE )
	{
		if( m_pSelected == NULL )
			InsertChild( m_pTopNode, csText );
		else
		{
			InsertChild( m_pSelected, csText );
			m_pSelected = NULL;
		}

		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_InsertSibling()
{
	CString csText("");

	if( NodeTextDlg( csText ) == TRUE )
	{
		InsertSibling( m_pSelected, csText );
		m_pSelected = NULL;
		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_DeleteNode()
{
	DeleteNode( m_pSelected, TRUE );

	m_pSelected = NULL;
}

void CStaticTreeCtrl::OnCM_ModifyNodeText()
{
	if( NodeTextDlg( m_pSelected->csLabel ) == TRUE )
	{
		m_pSelected = NULL;
		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_ChangeNodeColor()
{
	COLORREF cr = ( m_pSelected->bUseDefaultTextColor )? m_crDefaultTextColor:m_pSelected->crText;

	CColorDialog ccd( cr, CC_FULLOPEN | CC_ANYCOLOR );

	if ( ccd.DoModal() == IDOK )
		SetNodeColor( m_pSelected, ccd.GetColor(), TRUE );

	m_pSelected = NULL;
}

void CStaticTreeCtrl::OnCM_ToggleConnectingLines()
{
	m_bShowLines = !m_bShowLines;

	Invalidate();
}

void CStaticTreeCtrl::OnCM_SetConnectingLinesColor()
{
	CColorDialog ccd( m_crConnectingLines, CC_FULLOPEN | CC_ANYCOLOR );

	if ( ccd.DoModal() == IDOK )
	{
		m_crConnectingLines =  ccd.GetColor();
		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_SetFont()
{
	CFontDialog cfd( &m_lgFont , CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT );

	if(  cfd.DoModal() == IDOK )
	{
		SetTextFont( cfd.GetSize() / 10, cfd.IsBold(), cfd.IsItalic(), cfd.GetFaceName() );
		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_SetDefaultColor()
{
	CColorDialog ccd( m_crDefaultTextColor, CC_FULLOPEN | CC_ANYCOLOR );

	if ( ccd.DoModal() == IDOK )
	{
		m_crDefaultTextColor = ccd.GetColor();
		Invalidate();
	}
}

void CStaticTreeCtrl::OnCM_SetBackgroundBitmap()
{
	SetBackgroundBitmap( TRUE );
}

void CStaticTreeCtrl::OnCM_ToggleMenuSound()
{
	m_bAudioOn = !m_bAudioOn;
}