bcgpeditctrl.cpp

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

			break;

		case VK_NEXT:
			PageDown ();
			break;

		case VK_RETURN:
			break;

		case VK_TAB:
			bShift ? PageUp () : PageDown ();
			break;
																				   
		case VK_BACK:
			break;
													  
		case VK_DELETE:
			break;

		case VK_ESCAPE:
			break;

		case VK_INSERT:
			break;
		}
		CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
		return;
	}							 

	m_nPrevKey = m_nLastKey;
	m_nLastKey = nChar;

	if (nChar == VK_ESCAPE && m_iStartSel != -1 ||
		nChar == VK_DELETE || nChar == VK_UP || nChar == VK_DOWN ||
		nChar == VK_PRIOR || nChar == VK_NEXT)
    {																																																																																																																																																																									
		CPoint ptCurrOffset;
		OffsetToPoint (m_nCurrOffset, ptCurrOffset);

		if (!m_rectText.PtInRect (ptCurrOffset))
		{
			SetCaret (m_nCurrOffset, TRUE);
		}
    }
		
	switch (nChar)
	{
	case VK_LEFT:
		if (bCtrl)
		{
			if (bShift)
			{
				MakeSelection (ST_PREV_WORD);
			}
			else
			{
				RemoveSelection ();
				PrevWord ();
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_PREV_SYMBOL);
		}
		else
		{
			if (!RemoveSelection ())
			{
				Left ();
			}
		}
		break;

	case VK_RIGHT:
		if (bCtrl)
		{
			if (bShift)
			{
				MakeSelection (ST_NEXT_WORD);
			}
			else
			{
				RemoveSelection (FALSE);
				NextWord ();
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_NEXT_SYMBOL);
		}
		else
		{
			if (!RemoveSelection (FALSE))
			{
				Right ();
			}
		}
		break;

	case VK_HOME:
		if (bCtrl)
		{
			if (bShift)
			{
				MakeSelection (ST_START_OF_TEXT);
			}
			else
			{
				RemoveSelection ();
				StartOfText ();
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_HOME);
		}
		else
		{
			RemoveSelection ();
			Home ();
		}
		break;

	case VK_END:
		if (bCtrl)
		{
			if (bShift)
			{
				MakeSelection (ST_END_OF_TEXT);
			}
			else
			{
				RemoveSelection (FALSE);
				EndOfText ();
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_END);
		}
		else
		{
			RemoveSelection (FALSE);
			End ();
		}
		break;

	case VK_UP:
		if (bCtrl)
		{
			if (!bShift)
			{
				ScrollText (FALSE);
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_PREV_LINE);
		}
		else
		{
			BOOL bResult = RemoveSelection ();
			Up (!bResult);
		}
		break;

	case VK_DOWN:
		if (bCtrl)
		{
			if (!bShift)
			{
				ScrollText (TRUE);
			}
		}
		else if (bShift)
		{
			MakeSelection (ST_NEXT_LINE);
		}
		else
		{
			BOOL bResult = RemoveSelection (FALSE);
			Down (!bResult);
		}
		break;

	case VK_PRIOR:
		if (!bCtrl)
		{
			if (!bShift)
			{
				RemoveSelection ();
				PageUp ();
			}
			else
			{
				MakeSelection (ST_PREV_PAGE);
			}
		}
		break;

	case VK_NEXT:
		if (!bCtrl)
		{
			if (!bShift)
			{
				RemoveSelection ();
				PageDown ();
			}
			else
			{
				MakeSelection (ST_NEXT_PAGE);
			}
		}
		break;

	case VK_RETURN:
		DeleteSelectedText (TRUE, FALSE, TRUE);		
		if (GetOverrideMode ())
		{
			Down ();
			Home ();
		}
		else
		{
			SetLastUndoReason (g_dwUATEnter);
			InsertNewLine (TRUE);
		}
		m_nLastMaxColumn = GetColumnFromOffset (m_nCurrOffset, TRUE);
		break;

	case VK_TAB:
		if (!bCtrl)
		{
			if (!bShift && m_iStartSel == -1)
			{
				SetLastUndoReason (g_dwUATTab);
				InsertTab (TRUE);
			}	
			else if (bShift && m_iStartSel == -1)
			{
				PrevIndent ();
			}
			else if (bShift && m_iStartSel != -1)
			{
				IndentSelection (FALSE);
			}
			else
			{
				if (!IndentSelection (TRUE))
				{
					DeleteSelectedText (FALSE, FALSE, TRUE);
					InsertTab (TRUE);
				}
			}
		}
		break;

	case VK_BACK:
		if (m_nCurrOffset > 0)
		{
			CPoint pt;
			OffsetToPoint (m_nCurrOffset - 1, pt);

			if (pt.y >= 0)
			{
				m_nCurrOffset--;
				SetLastUndoReason (g_dwUATBackspace);
				if (!OnDelete (TRUE))
				{
					m_nCurrOffset++;
				}
				SetCaret (m_nCurrOffset, TRUE, TRUE);
			}
			else
			{
				int nOldOffset = m_nCurrOffset;
				SetCaret (m_nCurrOffset - 1, TRUE, FALSE);
				SetLastUndoReason (g_dwUATBackspace	);
				if (!OnDelete (TRUE))
				{
					SetCaret (nOldOffset, TRUE, TRUE);
				}
			}
		}
		break;									  
												  
	case VK_DELETE:
		SetLastUndoReason (g_dwUATDelete);
		OnDelete (TRUE);
		break;

	case VK_ESCAPE:
		RemoveSelection (FALSE, TRUE);
		break;

	case VK_INSERT:
		OnSetOvrMode ();
		break;
	}
		  
	CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}
//*****************************************************************************
BOOL CBCGPEditCtrl::OnSetOvrMode ()
{
	if (m_bReadOnly)
	{
		OnFailedOperation (g_dwOpSetOvrMode | g_dwOpReasonReadOnly);
		return FALSE;
	}

	SetOverrideMode (!GetOverrideMode ());
	::DestroyCaret ();
	CSize sizeCaret = GetCaretSize ();
	::CreateCaret (GetSafeHwnd (), NULL, sizeCaret.cx, sizeCaret.cy);
	ShowCaret ();
	return TRUE;
}
//*****************************************************************************
CSize CBCGPEditCtrl::GetCaretSize () const
{
	return GetOverrideMode () ? CSize (m_nMaxCharWidth, m_nLineHeight) : 
						CSize (2, m_nLineHeight);
}
//*****************************************************************************
void CBCGPEditCtrl::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if ((isprint (nChar) || nChar >= 127) && !m_bReadOnly)
	{
		DeleteSelectedText (TRUE, FALSE, TRUE);
		SetLastUndoReason (g_dwUATTyping);
		InsertChar ((TCHAR) nChar, TRUE);

		CObList lstIntelliSenseData;
		CString strIntelliSense;
		int nCurrOffset = m_nCurrOffset;

		if (IsIntelliSenseEnabled() &&
			(nCurrOffset > 0) &&
			(nCurrOffset <= m_strBuffer.GetLength()) &&
			m_strIntelliSenseChars.Find (m_strBuffer.GetAt(nCurrOffset - 1)) != -1)
		{
			if (OnFillIntelliSenseList (nCurrOffset, lstIntelliSenseData))
			{
				CPoint pt (0, 0);

				OffsetToPoint (m_nCurrOffset = nCurrOffset, pt);
				ClientToScreen (&pt);

				InvokeIntelliSense (lstIntelliSenseData, pt);
			}
		}
	}

	CWnd::OnChar(nChar, nRepCnt, nFlags);
}
//*****************************************************************************
BOOL CBCGPEditCtrl::OnFillIntelliSenseList (int& nCurrOffset, CObList& lstIntelliSenseData) const
{
	CString strIntelliSence;

	if (!OnBeforeInvokeIntelliSense(m_strBuffer, nCurrOffset, strIntelliSence))
	{
		return FALSE;
	}

	VERIFY(FillIntelliSenseList(lstIntelliSenseData, strIntelliSence.GetBuffer(0)));

	return !lstIntelliSenseData.IsEmpty();
}
//*****************************************************************************
BOOL CBCGPEditCtrl::InvokeIntelliSense()
{
	CObList lstIntelliSenseData;
	int nCurrOffset = m_nCurrOffset;

	if (!OnFillIntelliSenseList(nCurrOffset, lstIntelliSenseData))
	{
		OnFailedOperation (g_dwOpInvokeIS);
		return FALSE;
	}

	CPoint pt;

	OffsetToPoint(m_nCurrOffset, pt);
	ClientToScreen (&pt);
	
	return InvokeIntelliSense (lstIntelliSenseData, pt);
}
//*****************************************************************************
BOOL CBCGPEditCtrl::InvokeIntelliSense (CObList& lstIntelliSenseData, 
										CPoint ptTopLeft)
{
	ASSERT (m_bIntelliSenseSupport);
	
	if (lstIntelliSenseData.IsEmpty())
	{
		return FALSE;
	}

	CBCGPIntelliSenseWnd* pIntelliSenseWnd = new CBCGPIntelliSenseWnd;
	return pIntelliSenseWnd->Create (lstIntelliSenseData, 
		WS_POPUP | WS_VISIBLE | MFS_SYNCACTIVE | MFS_4THICKFRAME, 
		ptTopLeft, this, m_pIntelliSenseLBFont, m_pIntelliSenseImgList);
}
//*****************************************************************************
BOOL CBCGPEditCtrl::InvokeSymList ()
{
	ASSERT (m_bEnableSymSupport);
	CObList lstIntelliSenseData;
	int nCurrOffset = m_nCurrOffset;

	if (!OnFillSymListData (nCurrOffset, lstIntelliSenseData))
	{
		OnFailedOperation (g_dwOpInvokeIS);
		return FALSE;
	}

	CPoint pt;

	OffsetToPoint(m_nCurrOffset, pt);
	ClientToScreen (&pt);

	return InvokeSymList (lstIntelliSenseData, pt);
}
//*****************************************************************************
BOOL CBCGPEditCtrl::OnFillSymListData (int& nCurrOffset, CObList& lstIntelliSenseData) const 
{
	ASSERT (m_bEnableSymSupport);

	for (POSITION pos = m_lstSymDefs.GetHeadPosition (); pos != NULL;)
	{
		BCGP_EDIT_SYM_DEF symDef = m_lstSymDefs.GetNext (pos);
		CBCGPIntelliSenseData* pData = new CBCGPIntelliSenseData;
		pData->m_nImageListIndex = symDef.m_nIndex;
		pData->m_strItemName = symDef.m_strSymText;
		pData->m_dwData = symDef.m_chReplacement;
		lstIntelliSenseData.AddTail (pData);
	}

	return !lstIntelliSenseData.IsEmpty ();
}
//*****************************************************************************
BOOL CBCGPEditCtrl::InvokeSymList (CObList& lstIntelliSenseData, 
									CPoint ptTopLeft)
{
	ASSERT (m_bEnableSymSupport);
	if (lstIntelliSenseData.IsEmpty())
	{
		return FALSE;
	}

	CBCGPIntelliSenseWnd* pIntelliSenseWnd = new CBCGPIntelliSenseWnd;
	return pIntelliSenseWnd->Create (lstIntelliSenseData, 
		WS_POPUP | WS_VISIBLE | MFS_SYNCACTIVE | MFS_4THICKFRAME, 
		ptTopLeft, this, m_pIntelliSenseLBFont, m_pSymbolsImgList, 
		RUNTIME_CLASS (CBCGPSymImagesLB));
}
//**************************************************************************************
BOOL CBCGPEditCtrl::LookUpSymbol (LPCTSTR lpcszBuffer, int nOffset, int nCount, 
								  TCHAR chSymbol, BCGP_EDIT_SYM_DEF& symDef, 
								  int& nSymExtraLen, BOOL bForward)
{
	ASSERT (m_bEnableSymSupport);
	for (POSITION pos = m_lstSymDefs.GetHeadPosition (); pos != NULL;)
	{
		BCGP_EDIT_SYM_DEF& nextSym = m_lstSymDefs.GetNext (pos);
		if (nextSym.m_chReplacement == chSymbol)
		{
			symDef = nextSym;
			nSymExtraLen = 0;
			return TRUE;
		}

		if (!nextSym.m_strSymSequence.IsEmpty ())
		{
			int nLen = nextSym.m_strSymSequence.GetLength ();
			if (bForward && nCount - nOffset < nLen ||
				!bForward && nOffset - nLen + 1 < 0)
			{
				continue;
			}
			LPCTSTR lpcszBuffToCompare = bForward ? lpcszBuffer + nOffset : 
										 lpcszBuffer + nOffset - nLen + 1;			
			if (_tcsncmp (lpcszBuffToCompare, nextSym.m_strSymSequence, nLen * sizeof (TCHAR)) == 0)
			{
				symDef = nextSym;
				nSymExtraLen = nLen - 1;
				return TRUE;
			}
		}
	}
	
	return FALSE;
}
//*****************************************************************************
int  CBCGPEditCtrl::GetSymbolExtraLen (CString& strBuffer, int nOffset, BOOL bForward)
{
	ASSERT (m_bEnableSymSupport);
	int nSymExtraLen = 0;
	BCGP_EDIT_SYM_DEF symDef;

	if (!bForward)
	{
		nOffset--;
	}

	if (nOffset < 0)
	{
		nOffset = 0;
	}

	LookUpSymbol (strBuffer, nOffset, strBuffer.GetLength (), strBuffer.GetAt (nOffset), 
						symDef, nSymExtraLen, bForward);
	return nSymExtraLen;
}
//*****************************************************************************
BOOL CBCGPEditCtrl::EnableIntelliSense(BOOL bFl /* = TRUE */)
{
	const BOOL bIntelliSense = m_bIntelliSenseSupport;
	m_bIntelliSenseSupport = bFl;

	return bIntelliSense;
}
//*****************************************************************************
void CBCGPEditCtrl::OnSize(UINT nType, int cx, int cy) 
{
	CWnd::OnSize(nType, cx, cy);
	
	RecalcLayout ();

	CRect rect (0, 0, cx, cy);
	m_wndToolTip.SetToolRect (this, GetDlgCtrlID (), rect);
}
//*****************************************************************************
void CBCGPEditCtrl::RecalcLayout ()
{
	CRect rectClient;
	GetClientRect (rectClient);

	m_rectText = rectClient;
	m_rectText.left += m_nLeftMarginWidth;
	if (m_bEnableLineNumbersMargin)
	{
		m_rectText.left += m_nLineNumbersMarginWidth;
	}
	if (m_bEnableOutlineMargin)
	{
		m_rectText.left += m_nOutlineMarginWidth;
	}

	UpdateScrollBars ();