bcgpeditctrl.h

关于远程网络监视程序的源码

		{
			// bottom of marker is deleted
			m_nEnd = nEndPos;
		}
		else if (m_nStart >= nStartPos && m_nEnd > nEndPos)
		{
			// top of marker is deleted
			m_nStart = nStartPos;
		}
		// the middle of the marker is deleted - do nothing
	}

	virtual void Serialize (CArchive& ar)
	{
		CBCGPEditMarker::Serialize (ar);
		if (ar.IsLoading ())
		{
			ar >> m_nStart;
			ar >> m_nEnd;
		}
		else
		{
			ar << m_nStart;
			ar << m_nEnd;
		}
	}

	int			m_nStart;
	int			m_nEnd;
	COLORREF	m_clrForeground;
	COLORREF	m_clrBackground;
	//COLORREF	m_clrSelForeground;
	//COLORREF	m_clrSelBackground;
};

// ----------
// Outlining:
// ----------

struct BCGCBPRODLLEXPORT BCGP_EDIT_OUTLINE_CHANGES
{
	BCGP_EDIT_OUTLINE_CHANGES () :
					m_nStartOffset (0), m_nEndOffset (0),
					m_bDestroyRemData (TRUE), m_bDestroyInsData (FALSE)
	{
	}
	BCGP_EDIT_OUTLINE_CHANGES (int nStart, int nEnd) :
					m_nStartOffset (nStart), m_nEndOffset (nEnd),
					m_bDestroyRemData (TRUE), m_bDestroyInsData (FALSE)
	{
	}
	virtual ~BCGP_EDIT_OUTLINE_CHANGES ()
	{
		if (m_bDestroyInsData)
		{
			while (!m_lstInserted.IsEmpty ())
			{
				delete m_lstInserted.RemoveHead ();
			}
		}
		if (m_bDestroyRemData)
		{
			while (!m_lstRemoved.IsEmpty ())
			{
				delete m_lstRemoved.RemoveHead ();
			}
		}
	}

	CObList	m_lstRemoved;
	CObList	m_lstInserted;
	int		m_nStartOffset;
	int		m_nEndOffset;

	BOOL	m_bDestroyRemData;
	BOOL	m_bDestroyInsData;

};

struct BCGCBPRODLLEXPORT BCGP_EDIT_UNDO_OUTLINE_DATA : public BCGP_BASE_UNDO_DATA
{
	BCGP_EDIT_UNDO_OUTLINE_DATA () : 
					m_pData (NULL), m_bForward (FALSE), m_bDestroyData (FALSE)
	{
	}
	BCGP_EDIT_UNDO_OUTLINE_DATA (BCGP_EDIT_OUTLINE_CHANGES*	pChanges, BOOL bForward = FALSE) :
					m_pData (pChanges), m_bForward (bForward), m_bDestroyData (FALSE)
	{
	}
	virtual ~BCGP_EDIT_UNDO_OUTLINE_DATA ()
	{
		if (m_bDestroyData)
		{
			delete m_pData;
		}
	}

	BCGP_EDIT_OUTLINE_CHANGES*	m_pData;
	BOOL						m_bForward;
	BOOL						m_bDestroyData;
};

class BCGCBPRODLLEXPORT CBCGPOutlineBaseNode: public CObject
{
	DECLARE_SERIAL (CBCGPOutlineBaseNode)
	typedef CBCGPEditMarkerRange CBCGPEditOutlineRange;

	// Data:
public:
	int			m_nStart;
	int			m_nEnd;
	int			m_nNameOffset;
	BOOL		m_bCollapsed;
	CString		m_strReplace;
	CRect		m_rectTool;
	int			m_nBlockType;	// g_nOBTUndefined, g_nOBTUserBlock or valid block type index
	DWORD		m_dwFlags;		// g_dwOBFComplete, g_dwOBFLeft, g_dwOBFRight
	LPVOID		m_pData;

public:
	CBCGPOutlineBaseNode () : m_nStart (-1),
							   m_nEnd (-1),
							   m_nNameOffset (0),
							   m_strReplace (_T("...")),
							   m_nBlockType (g_nOBTUndefined),
							   m_pData (NULL)
	{
		m_bCollapsed	= FALSE;
		m_dwFlags		= g_dwOBFComplete;
		m_rectTool.SetRectEmpty ();
	}

	CBCGPOutlineBaseNode (const CBCGPOutlineBaseNode& srcBlock)
	{
		Copy (srcBlock);
	}

	virtual ~CBCGPOutlineBaseNode ()
	{
		DestroyData ();
	}

	virtual CBCGPOutlineBaseNode& operator=(const CBCGPOutlineBaseNode& srcBlock)
	{
		Copy (srcBlock);
		return *this;
	}

	virtual	void Copy (const CBCGPOutlineBaseNode& srcBlock)
	{
		m_nStart		= srcBlock.m_nStart;
		m_nEnd			= srcBlock.m_nEnd;
		m_nNameOffset	= srcBlock.m_nNameOffset;
		m_bCollapsed	= srcBlock.m_bCollapsed;
		m_strReplace	= srcBlock.m_strReplace;
		m_rectTool.SetRectEmpty ();
		m_nBlockType	= srcBlock.m_nBlockType;
		m_dwFlags		= srcBlock.m_dwFlags;
		CopyData ((DWORD) srcBlock.m_pData);
	}
	
	virtual void CopyData (DWORD dwData) {}
	virtual void DestroyData ()
	{
		m_pData = NULL;
	}

	virtual void Serialize (CArchive& ar)
	{
		CObject::Serialize (ar);
		if (ar.IsLoading ())
		{
			ar >> m_nStart;
			ar >> m_nEnd;
			ar >> m_nNameOffset;
			ar >> m_bCollapsed;
			ar >> m_strReplace;
			ar >> m_nBlockType;
			ar >> m_dwFlags;
			m_rectTool.SetRectEmpty ();
		}
		else
		{
			ar << m_nStart;
			ar << m_nEnd;
			ar << m_nNameOffset;
			ar << m_bCollapsed;
			ar << m_strReplace;
			ar << m_nBlockType;
			ar << m_dwFlags;
		}

		SerializeData (ar);
	}

	virtual void SerializeData (CArchive& ar)
	{
		if (ar.IsLoading ())
		{
			ar << (DWORD) m_pData;
		}
		else
		{
			DWORD dw = 0;
			ar >> dw;
			m_pData = (LPVOID) dw;
		}
	}

	virtual void Move (int nDelta)
	{
		m_nStart += nDelta;
		m_nEnd += nDelta;
	}

	virtual CBCGPEditOutlineRange IsInRangeByOffset (int nStartPos, int nEndPos) const
	{
		if (m_nStart > nEndPos || m_nEnd < nStartPos)
		{
			return NOT_IN_RANGE;
		}

		if (m_nStart >= nStartPos && m_nStart <= nEndPos &&
			m_nEnd <= nEndPos)
		{
			return FULL_IN_RANGE;
		}

		return PARTIAL_IN_RANGE;
	}
	
	virtual void UpdateBlocksForDeletedRange (int nStart, int nEnd)
	{
		if ((m_nStart == -1 && m_nEnd == -1) || 
			m_nEnd < nStart)
		{
			return;
		}

		if (m_nStart > nEnd)
		{
			if (m_nStart - m_nNameOffset <= nEnd)
			{
				// update block name offset:
				if (m_nStart - m_nNameOffset <= nStart)
				{
					// the middle of the block name is deleted
					m_nNameOffset = max (0, m_nNameOffset - (nEnd - nStart));
				}
				else
				{
					// top of the block name is deleted
					m_nNameOffset = m_nStart - nEnd;
				}
			}

			Move (nStart - nEnd);
			return;
		}

		if (m_nStart >= nStart && m_nStart <= nEnd &&
			m_nEnd <= nEnd)
		{
			// the whole block is in the deleted range - nothing to update
			return;
		}
		
		if (m_nStart < nStart && m_nEnd <= nEnd)
		{
			// bottom of block is deleted
			m_nEnd = nStart - 1;
		}
		else if (m_nStart >= nStart && m_nEnd > nEnd)
		{
			// top of block is deleted
			m_nStart = nStart;

			if (m_nNameOffset > 0)
			{
				// update block name offset
				m_nNameOffset = max (0, nStart - m_nStart + m_nNameOffset);
			}

			m_nEnd -= nEnd - nStart;
		}
		else
		{
			// the middle of the block is deleted - update bottom
			m_nEnd -= nEnd - nStart;
		}
	}

	virtual void UpdateBlocksForInsertedText (int nOffset, int nCount)
	{
		ASSERT (nCount >= 0);

		if (m_nStart == -1 && m_nEnd == -1)
		{
			return;
		}

		if (m_nEnd < nOffset)
		{
			// text is inserted after the block - nothing to update
			return;
		}

		if (m_nStart >= nOffset)
		{
			if (m_nStart - m_nNameOffset < nOffset)
			{
				// update block name offset
				m_nNameOffset += nCount;
			}

			Move (nCount);
		}
		else if (m_nStart < nOffset && nOffset <= m_nEnd)
		{
			// the inserted text is in the middle of the block - update bottom
			m_nEnd += nCount;
		}
	}
};

class CBCGPOutlineParser;
class CBCGPOutlineNode : public CBCGPOutlineBaseNode
{
	friend class CBCGPOutlineParser;
	DECLARE_SERIAL(CBCGPOutlineNode)

	// Data:
protected:
	CObList					m_lstNodes;
	CBCGPOutlineNode*		m_pParentNode;

public:
	CBCGPOutlineNode(): CBCGPOutlineBaseNode (), m_pParentNode (NULL)
	{
	}
	CBCGPOutlineNode(const CBCGPOutlineBaseNode& srcBlock)
		: CBCGPOutlineBaseNode (srcBlock), m_pParentNode (NULL)
	{
	}
	virtual ~CBCGPOutlineNode () 
	{
		DeleteAllBlocks ();
		m_pParentNode = NULL;
	}

	// Functions:
public:
	CBCGPOutlineBaseNode*	GetValue ()				{return this;}
	CObList*				GetNodes ()				{return &m_lstNodes;}
	CBCGPOutlineNode*		GetParentNode () const	{return m_pParentNode;}

	virtual CBCGPOutlineNode* AddBlock (const CBCGPOutlineBaseNode& srcNode, 
										BCGP_EDIT_OUTLINE_CHANGES& changes)
	{
		CBCGPOutlineNode* pNewNode = new CBCGPOutlineNode (srcNode);

		return AddNode (pNewNode, changes);
	}
	
	void GetAllBlocks (CObList& lstBlocks, BOOL bRecursive = TRUE) const;
	void DeleteAllBlocks ()
	{
		while (!m_lstNodes.IsEmpty ())
		{
			delete m_lstNodes.RemoveHead ();
		}
	}

	int GetCount (BOOL bRecursive = TRUE) const
	{
		if (bRecursive)
		{
			int nCount = 0;
			for (POSITION pos = m_lstNodes.GetHeadPosition (); pos != NULL; nCount++)
			{
				CBCGPOutlineNode* pSubNode = DYNAMIC_DOWNCAST(CBCGPOutlineNode, m_lstNodes.GetNext (pos));
				ASSERT_VALID (pSubNode);
				nCount += pSubNode->GetCount (bRecursive);
			}
			return nCount;
		}
		else
		{
			return m_lstNodes.GetCount ();
		}
	}

	// task-oriented:
public:
	CBCGPOutlineNode*	FindCollapsedBlock (int nOffset) const;
	CBCGPOutlineNode*	FindCollapsedBlockInRange (int nStart, int nEnd, BOOL bForward = TRUE) const;
	CBCGPOutlineNode*	FindCollapsedBlockByPoint (CPoint point, int nStart, int nEnd) const;
	CBCGPOutlineNode*	GetInnermostBlock (int nOffset) const;
	void				GetBlocksInRange (int nStart, int nEnd, CObList& lstOutlineBlocks, 
										  BOOL bFullInRangeOnly = TRUE, BOOL bRecursive = TRUE) const;
	BOOL				DeleteInnermostBlock (int nOffset, BCGP_EDIT_OUTLINE_CHANGES& changes);
	int					DeleteBlocksInRange (int nStart, int nEnd, BCGP_EDIT_OUTLINE_CHANGES& changes);
	int					ToggleOutliningInRange (int nStart, int nEnd);
	int					ToggleAllOutlining ();

	virtual void Serialize (CArchive& ar)
	{
		CBCGPOutlineBaseNode::Serialize (ar);

		SerializeNodes (ar);
	}
	
	virtual void SerializeNodes (CArchive& ar)
	{
		m_lstNodes.Serialize (ar);

		if (ar.IsLoading ())
		{
		}
		else
		{
			for (POSITION pos = m_lstNodes.GetHeadPosition (); pos != NULL; )
			{
				CBCGPOutlineNode* pSubNode = DYNAMIC_DOWNCAST(CBCGPOutlineNode, m_lstNodes.GetNext (pos));
				ASSERT_VALID (pSubNode);
				pSubNode->m_pParentNode = this;
			}
		}
	}

	int		Print (CString &str, int nLevel = 0, int nCount = 0) const;
	void	Verify () const;

	virtual void UpdateBlocksForDeletedRange (int nStart, int nEnd);
	virtual void UpdateBlocksForInsertedText (int nOffset, int nCount);

protected:
	virtual CBCGPOutlineNode* AddNode (CBCGPOutlineNode* pNewNode, BCGP_EDIT_OUTLINE_CHANGES& changes);
	virtual CBCGPOutlineNode* RemoveNode (POSITION posNode, BCGP_EDIT_OUTLINE_CHANGES& changes, BOOL bRemoveSubNodes = FALSE);

	void GetTopBlocksInRange (int nStart, int nEnd, CObList& lstBlocks) const;
	static void ToggleOutliningInternal (CObList &lstBlocks);
};


class CBCGPIntelliSenseWnd;
class CBCGPEditCtrl;
class CBCGPOutlineParser;

class BCGCBPRODLLEXPORT CBCGPEditCtrlDropTarget : public COleDropTarget
{
public:
	CBCGPEditCtrlDropTarget()
	{
		m_pOwner = NULL;
	}

// Attributes
protected:
	CBCGPEditCtrl* m_pOwner;

// Operations
public:
	BOOL Register (CBCGPEditCtrl* pOwner);

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CBCGPTabDropTarget)
	public:
	virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);
	virtual void OnDragLeave(CWnd* pWnd);
	virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);
	virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, DROPEFFECT dropList, CPoint point);
	//}}AFX_VIRTUAL
};

class BCGCBPRODLLEXPORT CBCGPIntelliSenseData : public CObject
{
public:
	CString		m_strItemName;
	CString		m_strItemHelp;
	int			m_nImageListIndex;
	DWORD		m_dwData;