bcgpproplist.cpp

远程网络监视程序的源码

//*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2000 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions 
// of the accompanying license agreement.
//*******************************************************************************
//
// BCGPPropList.cpp : implementation file
//

#include "stdafx.h"
#include "bcgcbpro.h"
#include "BCGPColorBar.h"
#include "BCGPPropList.h"
#include "BCGPWorkspace.h"
#include "BCGPShellManager.h"
#include "BCGPDrawManager.h"
#include "BCGPMaskEdit.h"
#include "MenuImages.h"
#include "BCGPVisualManager.h"
#include "BCGPToolbarComboBoxButton.h"

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

#define ID_HEADER		1
#define ID_SCROLL_VERT	2
#define STRETCH_DELTA	2

#define TEXT_MARGIN		4

extern CBCGPWorkspace* g_pWorkspace;

/////////////////////////////////////////////////////////////////////////////
// CBCGPProp

IMPLEMENT_DYNAMIC(CBCGPProp, CObject)

#define PROP_HAS_LIST	0x0001
#define PROP_HAS_BUTTON	0x0002
#define PROP_HAS_SPIN	0x0004

CString CBCGPProp::m_strFormatShort = _T("%d");
CString CBCGPProp::m_strFormatLong = _T("%ld");
CString CBCGPProp::m_strFormatUShort = _T("%u");
CString CBCGPProp::m_strFormatULong = _T("%u");
CString CBCGPProp::m_strFormatFloat = _T("%f");
CString CBCGPProp::m_strFormatDouble = _T("%lf");

CBCGPProp::CBCGPProp(const CString& strName, const _variant_t& varValue, 
				   LPCTSTR lpszDescr, DWORD dwData, LPCTSTR lpszEditMask,
				   LPCTSTR lpszEditTemplate, LPCTSTR lpszValidChars) :
	m_strName (strName),
	m_varValue (varValue),
	m_strDescr (lpszDescr == NULL ? _T("") : lpszDescr),
	m_strEditMask (lpszEditMask == NULL ? _T("") : lpszEditMask),
	m_strEditTempl (lpszEditTemplate == NULL ? _T("") : lpszEditTemplate),
	m_strValidChars (lpszValidChars == NULL ? _T("") : lpszValidChars),
	m_dwData (dwData)
{
	m_bGroup = FALSE;

	Init ();
	SetFlags ();

	if (m_varValue.vt == VT_BOOL)
	{
		m_bAllowEdit = FALSE;
	}
}
//******************************************************************************************
CBCGPProp::CBCGPProp(const CString& strGroupName, DWORD dwData) :
	m_strName (strGroupName),
	m_dwData (dwData)
{
	m_bGroup = TRUE;

	Init ();
	SetFlags ();
}
//****************************************************************************************
void CBCGPProp::SetFlags ()
{
	m_dwFlags = 0;

	switch (m_varValue.vt)
	{
	case VT_BSTR:
    case VT_R4:
    case VT_R8:
    case VT_I2:
	case VT_I4:
    case VT_UI2:
	case VT_UI4:
		break;

	case VT_DATE:
		break;

    case VT_BOOL:
		m_dwFlags = PROP_HAS_LIST;
		break;

	default:
		break;
	}
}
//******************************************************************************************
void CBCGPProp::Init ()
{
	m_pWndList = NULL;
	m_bExpanded = TRUE;
	m_bEnabled = TRUE;
	m_pParent = NULL;
	m_pWndInPlace = NULL;
	m_pWndCombo = NULL;
	m_pWndSpin = NULL;
	m_bInPlaceEdit = FALSE;
	m_bButtonIsDown = FALSE;
	m_bAllowEdit = TRUE;
	m_bNameIsTrancated = FALSE;
	m_bValueIsTrancated = FALSE;

	m_Rect.SetRectEmpty ();
	m_rectButton.SetRectEmpty ();

	m_nMinValue = 0;
	m_nMaxValue = 0;
}
//*******************************************************************************************
CBCGPProp::~CBCGPProp()
{
	while (!m_lstSubItems.IsEmpty ())
	{
		delete m_lstSubItems.RemoveHead ();
	}

	OnDestroyWindow ();
}
//******************************************************************************************
void CBCGPProp::OnDestroyWindow ()
{
	if (m_pWndCombo != NULL)
	{
		m_pWndCombo->DestroyWindow ();
		delete m_pWndCombo;
		m_pWndCombo = NULL;
	}

	if (m_pWndInPlace != NULL)
	{
		m_pWndInPlace->DestroyWindow ();
		delete m_pWndInPlace;
		m_pWndInPlace = NULL;
	}

	if (m_pWndSpin != NULL)
	{
		m_pWndSpin->DestroyWindow ();
		delete m_pWndSpin;
		m_pWndSpin = NULL;
	}

	if (m_varValue.vt == VT_BOOL)
	{
		m_lstOptions.RemoveAll ();
	}
}
//****************************************************************************************
BOOL CBCGPProp::HasButton () const
{
	return	(m_dwFlags & PROP_HAS_LIST) ||
			(m_dwFlags & PROP_HAS_BUTTON);
}
//****************************************************************************************
BOOL CBCGPProp::AddSubItem (CBCGPProp* pProp)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pProp);

	if (!IsGroup ())
	{
		ASSERT(FALSE);
		return FALSE;
	}

	if (pProp->m_pWndList != NULL)
	{
		for (POSITION pos = pProp->m_pWndList->m_lstProps.GetHeadPosition (); pos != NULL;)
		{
			CBCGPProp* pListProp = pProp->m_pWndList->m_lstProps.GetNext (pos);
			ASSERT_VALID (pListProp);

			if (pListProp == pProp || pListProp->IsSubItem (pProp))
			{
				// Can't ad the same property twice
				ASSERT (FALSE);
				return FALSE;
			}
		}
	}

	pProp->m_pParent = this;

	m_lstSubItems.AddTail (pProp);
	pProp->m_pWndList = m_pWndList;

	return TRUE;
}
//*******************************************************************************************
BOOL CBCGPProp::AddOption (LPCTSTR lpszOption)
{
	ASSERT_VALID (this);
	ASSERT (lpszOption != NULL);

	if (m_lstOptions.Find (lpszOption) != NULL)
	{
		return FALSE;
	}

	m_lstOptions.AddTail (lpszOption);
	m_dwFlags = PROP_HAS_LIST;

	return TRUE;
}
//****************************************************************************************
void CBCGPProp::RemoveAllOptions ()
{
	m_lstOptions.RemoveAll ();
	m_dwFlags = 0;
}
//*****************************************************************************************
int CBCGPProp::GetExpandedSubItems () const
{
	ASSERT_VALID (this);

	if (!m_bExpanded)
	{
		return 0;
	}

	int nCount = 0;

	for (POSITION pos = m_lstSubItems.GetHeadPosition (); pos != NULL;)
	{
		CBCGPProp* pProp = m_lstSubItems.GetNext (pos);
		ASSERT_VALID (pProp);

		nCount += pProp->GetExpandedSubItems () + 1;
	}

	return nCount;
}
//*******************************************************************************************
CBCGPProp* CBCGPProp::HitTest (CPoint point, ClickArea* pnArea)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pWndList);

	if (m_Rect.PtInRect (point))
	{
		if (pnArea != NULL)
		{
			if (IsGroup () && point.x < m_Rect.left + m_Rect.Height ())
			{
				*pnArea = ClickExpandBox;
			}
			else if (HasValueField () && 
				point.x > m_pWndList->m_rectList.left + m_pWndList->m_nLeftColumnWidth)
			{
				*pnArea = ClickValue;
			}
			else
			{
				*pnArea = ClickName;
			}
		}

		return this;
	}

	for (POSITION pos = m_lstSubItems.GetHeadPosition (); pos != NULL;)
	{
		CBCGPProp* pProp = m_lstSubItems.GetNext (pos);
		ASSERT_VALID (pProp);

		CBCGPProp* pHit = pProp->HitTest (point, pnArea);
		if (pHit != NULL)
		{
			return pHit;
		}
	}

	return NULL;
}
//*******************************************************************************************
void CBCGPProp::Expand (BOOL bExpand)
{
	ASSERT_VALID (this);
	ASSERT (IsGroup ());

	if (m_bExpanded == bExpand ||
		m_lstSubItems.IsEmpty ())
	{
		return;
	}

	m_bExpanded = bExpand;

	if (m_pWndList != NULL && m_pWndList->GetSafeHwnd () != NULL)
	{
		ASSERT_VALID (m_pWndList);
		m_pWndList->AdjustLayout ();

		CRect rectRedraw = m_pWndList->m_rectList;
		rectRedraw.top = m_Rect.top;

		m_pWndList->RedrawWindow (rectRedraw);
	}
}
//*******************************************************************************************
void CBCGPProp::Redraw ()
{
	ASSERT_VALID (this);

	if (m_pWndList != NULL)
	{
		ASSERT_VALID (m_pWndList);
		m_pWndList->RedrawWindow (m_Rect);
	}
}
//*******************************************************************************************
void CBCGPProp::EnableSpinControl (BOOL bEnable, int nMin, int nMax)
{
	ASSERT_VALID (this);

	switch (m_varValue.vt)
	{
    case VT_I2:
	case VT_I4:
    case VT_UI2:
	case VT_UI4:
		break;

	default:
		ASSERT (FALSE);
		return;
	}

	m_nMinValue = nMin;
	m_nMaxValue = nMax;

	if (bEnable)
	{
		m_dwFlags |= PROP_HAS_SPIN;
	}
	else
	{
		m_dwFlags &= ~PROP_HAS_SPIN;
	}
}
//*******************************************************************************************
BOOL CBCGPProp::IsSelected () const
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pWndList);

	return m_pWndList->m_pSel == this;
}
//******************************************************************************************
void CBCGPProp::SetName (LPCTSTR lpszName, BOOL bRedraw)
{
	ASSERT_VALID (this);

	if (lpszName == NULL)
	{
		ASSERT (FALSE);
		return;
	}

	m_strName = lpszName;

	if (bRedraw)
	{
		Redraw ();
	}
}
//******************************************************************************************
void CBCGPProp::SetValue (const _variant_t& varValue)
{
	ASSERT_VALID (this);

	if (m_varValue.vt != VT_EMPTY && m_varValue.vt != varValue.vt)
	{
		ASSERT (FALSE);
		return;
	}

	BOOL bInPlaceEdit = m_bInPlaceEdit;
	if (bInPlaceEdit)
	{
		OnEndEdit ();
	}

	m_varValue = varValue;
	Redraw ();

	if (bInPlaceEdit)
	{
		ASSERT_VALID (m_pWndList);
		m_pWndList->EditItem (this);
	}
}
//*****************************************************************************************
BOOL CBCGPProp::IsParentExpanded () const
{
	ASSERT_VALID (this);

	for (CBCGPProp* pProp = m_pParent; pProp != NULL;)
	{
		ASSERT_VALID (pProp);

		if (!pProp->IsExpanded ())
		{
			return FALSE;
		}

		pProp = pProp->m_pParent;
	}

	return TRUE;
}
//******************************************************************************************
int CBCGPProp::GetHierarchyLevel () const
{
	ASSERT_VALID (this);

	int nLevel = 0;
	for (CBCGPProp* pParent = m_pParent; pParent != NULL;
		pParent = pParent->m_pParent)
	{
		nLevel++;
	}

	return nLevel;
}
//*******************************************************************************************
CBCGPProp* CBCGPProp::GetSubItem (int nIndex) const
{
	ASSERT_VALID (this);

	if (nIndex < 0 || nIndex >= m_lstSubItems.GetCount ())
	{
		ASSERT (FALSE);
		return NULL;
	}

	return m_lstSubItems.GetAt (m_lstSubItems.FindIndex (nIndex));
}
//*******************************************************************************************
void CBCGPProp::Enable (BOOL bEnable/* = TRUE*/)
{
	ASSERT_VALID (this);

	if (m_bEnabled != bEnable)
	{
		m_bEnabled = bEnable;

		if (m_pWndList->GetSafeHwnd () != NULL)
		{
			ASSERT_VALID (m_pWndList);
			m_pWndList->InvalidateRect (m_Rect);
		}
	}
}
//*******************************************************************************************
void CBCGPProp::SetOwnerList (CBCGPPropList* pWndList)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pWndList);

	m_pWndList = pWndList;

	for (POSITION pos = m_lstSubItems.GetHeadPosition (); pos != NULL;)
	{
		CBCGPProp* pProp = m_lstSubItems.GetNext (pos);
		ASSERT_VALID (pProp);

		pProp->SetOwnerList (m_pWndList);
	}
}
//*******************************************************************************************
void CBCGPProp::Repos (int& y)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pWndList);

	CRect rectOld = m_Rect;

	if (IsParentExpanded () || m_pWndList->m_bAlphabeticMode)
	{
		int dx = m_pWndList->m_bAlphabeticMode ?
			m_pWndList->m_nRowHeight :
			GetHierarchyLevel () * m_pWndList->m_nRowHeight;

		m_Rect = CRect (
			m_pWndList->m_rectList.left + dx,
			y, 
			m_pWndList->m_rectList.right, 
			y + m_pWndList->m_nRowHeight);

		if (!m_rectButton.IsRectEmpty ())
		{
			m_rectButton.top = m_Rect.top + 1;
			m_rectButton.bottom = m_Rect.bottom;
		}

		y += m_pWndList->m_nRowHeight;

		CRect rectName = m_Rect;
		rectName.right = m_pWndList->m_rectList.left + m_pWndList->m_nLeftColumnWidth;

		if (IsWindow (m_pWndList->m_ToolTip.GetSafeHwnd ()))
		{