对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditCtrl.cpp：源码内容

CXTPFontDC fontDC(&dc, GetPaintManager()->GetFont());
m_DrawTextProcessor.RecalcRowHeight(&dc, GetPaintManager()->GetFont());
if (m_hWnd && ::IsWindow(m_hWnd))
{
//m_pToolTip->SetFont(GetPaintManager()->GetFontToolTip());
CalculateEditbarLength();
Invalidate(FALSE);
_UpdateIMEStatus();
}
}
void CXTPSyntaxEditCtrl::_UpdateIMEStatus()
{
m_bIMEsupported = m_ImmWrapper.ImmIsIME();
if (!m_bIMEsupported || !m_hWnd || !::IsWindow(m_hWnd))
return;
// IME Support
XTP_HIMC hIMC = m_ImmWrapper.ImmGetContext(m_hWnd);
if (hIMC)
{
LOGFONT lfFont;
::ZeroMemory(&lfFont, sizeof(lfFont));
BOOL bFont = GetPaintManager()->GetFont()->GetLogFont(&lfFont);
ASSERT(bFont);
if (bFont)
{
VERIFY(m_ImmWrapper.ImmSetCompositionFont(hIMC, &lfFont));
}
VERIFY(m_ImmWrapper.ImmReleaseContext(m_hWnd, hIMC));
}
}
LRESULT CXTPSyntaxEditCtrl::OnGetFont(WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
return (LRESULT)GetPaintManager()->GetFont()->GetSafeHandle();
}
LRESULT CXTPSyntaxEditCtrl::OnSetFont(WPARAM wParam, LPARAM lParam)
{
HFONT hFont = (HFONT)wParam;
LOGFONT lfFont;
LOGFONT *pLF = NULL; // set the default font if hFont == NULL
if (hFont)
{
::ZeroMemory(&lfFont, sizeof(LOGFONT));
if (!::GetObject(hFont, sizeof(LOGFONT), &lfFont))
{
ASSERT(FALSE);
return 0;
}
pLF = &lfFont;
}
SetFontIndirect(pLF, FALSE);
if (LOWORD(lParam))
UpdateWindow();
//Default();
return 0;
}
LRESULT CXTPSyntaxEditCtrl::OnInputLanguage(WPARAM, LPARAM)
{
_UpdateIMEStatus();
if (m_bIMEsupported)
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
Default();
return 1;
}
void CXTPSyntaxEditCtrl::SetDocModified(BOOL bModified)
{
XTP_EDIT_NMHDR_DOCMODIFIED dm;
// NMHDR codes
dm.nmhdr.code = XTP_EDIT_NM_SETDOCMODIFIED;
dm.nmhdr.hwndFrom = m_hWnd;
dm.nmhdr.idFrom = GetDlgCtrlID();
// modified flag
dm.bModified = bModified;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)dm.nmhdr.idFrom, (LPARAM)&dm);
}
}
void CXTPSyntaxEditCtrl::InsertString(LPCTSTR szText, int iRow, int iCol, BOOL bDeleteSelection)
{
if (!CanEditDoc())
return;
int nPrevRow = GetCurrentDocumentRow();
if (nPrevRow != iRow)
SetCurrentDocumentRow(iRow);
m_nCurrentCol = iCol;
if (bDeleteSelection)
DeleteSelection();
// At first determine what type of CRLF it has
const int nTextLen = (int)_tcsclen(szText);
if (nTextLen == 0)
return;
int nRowFrom = GetCurrentDocumentRow();
int nColFrom = m_nCurrentCol;
//**----------------------
OnBeforeEditChanged(nRowFrom, nColFrom);
//**----------------------
if (GetAutoIndent() && m_nAutoIndentCol > 0)
{
CString strInsertText(
CString(_T('t'), m_nInsertTabCount) +
CString(_T(' '), m_nInsertSpaceCount));
m_pBuffer->InsertText(strInsertText, GetCurrentDocumentRow(), m_nCurrentCol);
m_nCurrentCol = m_nInsertTabCount + m_nInsertSpaceCount + 1;
m_nAutoIndentCol = 0;
}
XTP_EDIT_LINECOL finalLC;
BOOL bInsRes = m_pBuffer->InsertText(szText, GetCurrentDocumentRow(),
m_nCurrentCol, TRUE, &finalLC);
if (bDeleteSelection)
m_pBuffer->GetUndoRedoManager()->ChainLastCommand();
if (bInsRes)
{
SetCurrentDocumentRow(finalLC.nLine);
m_nCurrentCol = finalLC.nCol;
m_nDispCol = CalcDispCol(GetLineText(finalLC.nLine), m_nCurrentCol);
}
RecalcScrollBars();
UINT nAction = XTP_EDIT_EDITACTION_MODIFYROW;
int nCurDocRow = GetCurrentDocumentRow();
if (nCurDocRow > nPrevRow)
nAction |= XTP_EDIT_EDITACTION_INSERTROW;
//**----------------------
OnEditChanged(nRowFrom, nColFrom, nCurDocRow, m_nCurrentCol, xtpEditActInsert);
//**----------------------
NotifyEditChanged(nPrevRow, nCurDocRow, nAction);
SetCurCaretPos(nCurDocRow, m_nDispCol, FALSE/*, FALSE*/);
}
void CXTPSyntaxEditCtrl::InsertTextBlock(LPCTSTR szText, int iRow, int iCol, BOOL bDeleteSelection)
{
if (!CanEditDoc())
return;
int nPrevRow = GetCurrentDocumentRow();
if (nPrevRow != iRow)
{
SetCurrentDocumentRow(iRow);
}
m_nCurrentCol = iCol;
if (bDeleteSelection)
{
DeleteSelection();
}
// At first determine what type of CRLF it has
const int nTextLen = (int)_tcsclen(szText);
if (nTextLen == 0)
return;
int nRowFrom = GetCurrentDocumentRow();
int nColFrom = m_nCurrentCol;
//**----------------------
OnBeforeEditChanged(nRowFrom, nColFrom);
//**----------------------
XTP_EDIT_LINECOL finalLC;
BOOL bInsRes = m_pBuffer->InsertTextBlock(szText, GetCurrentDocumentRow(),
iCol, TRUE, &finalLC);
UNREFERENCED_PARAMETER(bInsRes);
if (bDeleteSelection)
m_pBuffer->GetUndoRedoManager()->ChainLastCommand();
RecalcScrollBars();
UINT nAction = XTP_EDIT_EDITACTION_MODIFYROW;
int nCurDocRow = GetCurrentDocumentRow();
if (nCurDocRow > nPrevRow)
nAction |= XTP_EDIT_EDITACTION_INSERTROW;
//**----------------------
OnEditChanged(nRowFrom, nColFrom, nCurDocRow, m_nCurrentCol, xtpEditActInsert);
//**----------------------
NotifyEditChanged(nPrevRow, nCurDocRow, nAction);
SetCurCaretPos(nCurDocRow, m_nDispCol, FALSE/*, FALSE*/);
}
void CXTPSyntaxEditCtrl::UpdateScrollPos(DWORD dwUpdate/* = XTP_EDIT_UPDATE_ALL*/)
{
XTP_EDIT_NMHDR_SETSCROLLPOS ssp;
// NMHDR codes
ssp.nmhdr.code = XTP_EDIT_NM_UPDATESCROLLPOS;
ssp.nmhdr.hwndFrom = m_hWnd;
ssp.nmhdr.idFrom = GetDlgCtrlID();
// Update flag
ssp.dwUpdate = dwUpdate;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)ssp.nmhdr.idFrom, (LPARAM)&ssp);
}
}
void CXTPSyntaxEditCtrl::_EnableScrollBarNotify(DWORD dwScrollBar, DWORD dwState)
{
ASSERT(dwScrollBar != 0 && (dwScrollBar & (WS_VSCROLL|WS_HSCROLL)) != 0);
XTP_EDIT_NMHDR_ENABLESCROLLBAR nmEScroll;
// NMHDR codes
nmEScroll.nmhdr.code = XTP_EDIT_NM_ENABLESCROLLBAR;
nmEScroll.nmhdr.hwndFrom = m_hWnd;
nmEScroll.nmhdr.idFrom = GetDlgCtrlID();
// Update flag
nmEScroll.dwScrollBar = dwScrollBar;
nmEScroll.dwState = dwState;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)nmEScroll.nmhdr.idFrom, (LPARAM)&nmEScroll);
}
}
void CXTPSyntaxEditCtrl::SetOverwriteMode(BOOL bOverwriteMode)
{
if (bOverwriteMode != m_pBuffer->GetOverwriteFlag() )
{
m_pBuffer->SetOverwriteFlag(bOverwriteMode);
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE/*, FALSE*/);
}
}
BOOL CXTPSyntaxEditCtrl::OnEraseBkgnd(CDC* pDC)
{
UNREFERENCED_PARAMETER(pDC);
return TRUE;
}
XTP_EDIT_LINECOL CXTPSyntaxEditCtrl::_SubtractSelSizeFromPos(XTP_EDIT_LINECOL lcDispPos)
{
XTP_EDIT_LINECOL lcStart = m_Selection.GetNormalStart_disp();
XTP_EDIT_LINECOL lcEnd = m_Selection.GetNormalEnd_disp();
if (lcDispPos <= lcStart)
return lcDispPos;
if (lcDispPos < lcEnd && !m_Selection.bBlockSelectionMode)
{
ASSERT(FALSE);
lcDispPos = lcEnd;
}
if (m_Selection.bBlockSelectionMode)
{
if (lcDispPos.nLine >= lcStart.nLine && lcDispPos.nLine <= lcEnd.nLine)
{
if (lcDispPos.nCol >= lcEnd.nCol)
lcDispPos.nCol -= lcEnd.nCol - lcStart.nCol;
}
}
else
{
if (lcEnd.nLine != lcStart.nLine)
lcDispPos.nLine -= lcEnd.nLine - lcStart.nLine;
if (lcEnd.nLine == lcDispPos.nLine)
{
if (lcEnd.nLine == lcStart.nLine)
{
ASSERT(lcDispPos.nCol >= lcEnd.nCol);
lcDispPos.nCol -= lcEnd.nCol - lcStart.nCol;
}
else
{
lcDispPos.nCol -= lcEnd.nCol;
}
}
}
return lcDispPos;
}
void CXTPSyntaxEditCtrl::CopyOrMoveText(BOOL bCopy)
{
if (!m_Selection.IsSelExist() || m_Selection.IsInSel_disp(m_ptDropPos.y, m_ptDropPos.x))
return;
CMemFile memfile(CalcAveDataSize(m_Selection.GetNormalStart_str().nLine,
m_Selection.GetNormalEnd_str().nLine));
BOOL bRes = m_pBuffer->GetBuffer(m_Selection.GetNormalStart_disp(),
m_Selection.GetNormalEnd_disp(), memfile,
m_Selection.bBlockSelectionMode);
if (!bRes)
return;
memfile.Write((const void *)_T(""), sizeof(TCHAR));
BYTE *pBytes = memfile.Detach();
CString strDropText = (LPTSTR)pBytes;
free(pBytes);
// First insert the text
if (m_ptDropPos.y > GetRowCount())
m_ptDropPos.y = GetRowCount();
XTP_EDIT_LINECOL lcDropPos_disp = XTP_EDIT_LINECOL::MakeLineCol(m_ptDropPos.y, m_ptDropPos.x);
BOOL bBlockSelectionMode = m_Selection.bBlockSelectionMode;
if (!bCopy)
{
if (!(lcDropPos_disp < m_Selection.GetNormalStart_disp()))
{
lcDropPos_disp = _SubtractSelSizeFromPos(lcDropPos_disp);
}
DeleteSelection(); // reset current selection
}
CString strText;
m_pBuffer->GetLineText(lcDropPos_disp.nLine, strText);
int nAbsDropCol = CalcAbsCol(strText, lcDropPos_disp.nCol);
//**----------------------
OnBeforeEditChanged(lcDropPos_disp.nLine, nAbsDropCol);
//**----------------------
BOOL bReplace = GetTabWithSpace();
SetTabWithSpace(FALSE);
XTP_EDIT_LINECOL finalLC;
BOOL bInsRes = FALSE;
if (bBlockSelectionMode)
{
bInsRes = m_pBuffer->InsertTextBlock(strDropText, lcDropPos_disp.nLine, nAbsDropCol,
TRUE, &finalLC);
}
else
{
bInsRes = m_pBuffer->InsertText(strDropText, lcDropPos_disp.nLine, nAbsDropCol,
TRUE, &finalLC);
}
SetTabWithSpace(bReplace);
if (!bCopy)
{
m_pBuffer->GetUndoRedoManager()->ChainLastCommand();
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_MOVE);
}
else
{
// It's a drag copy
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_COPY);
}
m_Selection.Reset_str(lcDropPos_disp.nLine, nAbsDropCol - 1);
m_Selection.SetEnd_str(finalLC.nLine, finalLC.nCol - 1);
m_Selection.bBlockSelectionMode = bBlockSelectionMode;
int nRowFrom = m_Selection.GetNormalStart_str().nLine;
int nRowTo = m_Selection.GetNormalEnd_str().nLine;
//**----------------------
OnEditChanged(nRowFrom, m_Selection.GetNormalStart_str().nCol + 1,
nRowTo, m_Selection.GetNormalEnd_str().nCol + 1, xtpEditActInsert);
//**----------------------
CalculateEditbarLength();
SetCurCaretPos(m_Selection.GetEnd_disp().nLine, m_Selection.GetEnd_disp().nCol);
SetDocModified();
//**----------------------
// OnEditChanged(nRowFrom, m_Selection.GetNormalStart_str().nCol,
// nRowTo, m_Selection.GetNormalEnd_str().nCol, xtpEditActInsert);
//**----------------------
UINT nAction = (XTP_EDIT_EDITACTION_MODIFYROW | XTP_EDIT_EDITACTION_INSERTROW);
NotifyEditChanged(nRowFrom, nRowTo, nAction);
}
void CXTPSyntaxEditCtrl::OnContextMenu(CWnd* pWnd, CPoint point)
{
if (GetCapture() == this)
{
ReleaseCapture();
}
if (m_bRightButtonDrag && m_bDragging && m_bDroppable)
{
HandleDrop(FALSE);
}
else
{
CXTPClientRect rcWnd(this);
ClientToScreen(&rcWnd);
m_bDragging = FALSE;
if (m_pParentWnd && rcWnd.PtInRect(point))
{
CWnd::HideCaret();
m_pParentWnd->SendMessage(WM_CONTEXTMENU, (WPARAM)pWnd->GetSafeHwnd(), (LPARAM)MAKELONG(point.x, point.y));
CWnd::ShowCaret();
Invalidate(FALSE);
UpdateWindow();
}
}
m_bRightButtonDrag = FALSE;
}
void CXTPSyntaxEditCtrl::OnDragCopy()
{
CopyOrMoveText(TRUE);
m_bRightButtonDrag = FALSE;
}
void CXTPSyntaxEditCtrl::OnDragMove()
{
CopyOrMoveText(FALSE);
m_bRightButtonDrag = FALSE;
}
void CXTPSyntaxEditCtrl::RestoreCursor()
{
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
// Invalidate(FALSE);
}
void CXTPSyntaxEditCtrl::SetRowBkColor(int nRow, COLORREF crBack)
{
if (nRow == -1)
{
m_mapRowBkColor.RemoveAll();
return;
}
if (crBack == RGB(255,255,255) || crBack == COLORREF_NULL)
m_mapRowBkColor.RemoveKey(nRow);
else
m_mapRowBkColor[nRow] = crBack;
}
void CXTPSyntaxEditCtrl::SetRowColor(int nRow, COLORREF clrFront)
{
if (nRow == -1)
{
m_mapRowColor.RemoveAll();
return;
}
if (clrFront == RGB(0,0,0) || clrFront == COLORREF_NULL)
m_mapRowColor.RemoveKey(nRow);
else
m_mapRowColor[nRow] = clrFront;
}
COLORREF CXTPSyntaxEditCtrl::GetRowColor(int nRow)
{
COLORREF clrFront;
if (!m_mapRowColor.Lookup(nRow, clrFront))
{
clrFront = RGB(0,0,0);
}
return clrFront;
}
COLORREF CXTPSyntaxEditCtrl::GetRowBkColor(int nRow)
{
COLORREF crBack;
if (!m_mapRowBkColor.Lookup(nRow, crBack))
{
crBack = RGB(255,255,255);
}
return crBack;
}
AFX_STATIC void CopyRowColorMap(CXTPSyntaxEditRowColorMap& dest, const CXTPSyntaxEditRowColorMap& src)
{
dest.RemoveAll();
for (POSITION pos = src.GetStartPosition(); pos;)
{
int nRow;
COLORREF crBack;
src.GetNextAssoc(pos, nRow, crBack);
dest[nRow] = crBack;
}
}
const CXTPSyntaxEditCtrl& CXTPSyntaxEditCtrl::operator=(const CXTPSyntaxEditCtrl& src)
{
if (::IsWindow(src.m_hWnd))
{
SetCurrentDocumentRow(src.m_nCurrentDocumentRow);
m_nCurrentCol = src.m_nCurrentCol;
m_nDispCol = src.m_nDispCol;
CopyRowColorMap(m_mapRowBkColor, src.m_mapRowBkColor);
CopyRowColorMap(m_mapRowColor, src.m_mapRowColor);
SetSelMargin(src.m_bSelMargin);
SetLineNumbers(src.m_bLineNumbers);
SetCollapsibleNodes(src.m_bDrawNodes);
CalculateEditbarLength();
EnableWhiteSpace(src.m_bEnableWhiteSpace);
SetTabWithSpace(src.m_bTabWithSpace);
SetAutoIndent(src.m_bAutoIndent);
SetSyntaxColor(src.m_bSyntaxColor);
EnableVirtualSpace(src.m_bVirtualSpace);
RecalcScrollBars();
SetScrollPos(SB_HORZ, 0);
m_DrawTextProcessor.SetScrollXOffset(0);
}
return *this;
}
CWnd * CXTPSyntaxEditCtrl::GetEffectiveParent() const
{
CWnd *pScrollWnd = GetParent();
if (GetParent())
{
pScrollWnd = GetParent();
if (!IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
{
pScrollWnd = GetParent();
}
}
else
{
pScrollWnd = const_cast<CXTPSyntaxEditCtrl *>(this);
}
return pScrollWnd;
}
DWORD CXTPSyntaxEditCtrl::GetAutoscrollDirection(int* pnCols, int* pnRows)
{
CPoint ptCursor;
GetCursorPos(&ptCursor);
ScreenToClient(&ptCursor);
CRect rcText = m_DrawTextProcessor.GetTextRect();
int nAutoZoneY = min(m_DrawTextProcessor.GetRowHeight(), rcText.Height()/4);
int nAutoZoneX2 = min(m_DrawTextProcessor.GetTextMetrics().tmAveCharWidth, rcText.Width()/4);
DWORD dwDirection = 0;
int nScrollX = 0, nScrollY = 0;
if (ptCursor.y < rcText.top + nAutoZoneY)
{
dwDirection += xtpTop;
nScrollY = -1 - (rcText.top + nAutoZoneY - ptCursor.y) / (nAutoZoneY / 2);
}
if (ptCursor.y > rcText.bottom - nAutoZoneY)
{
dwDirection += xtpBottom;
nScrollY = 1 + (ptCursor.y - rcText.bottom + nAutoZoneY) / (nAutoZoneY / 2);
}
if (ptCursor.x < rcText.left)
{
dwDirection += xtpLeft;
nScrollX = -1 - (rcText.left - ptCursor.x) / (nAutoZoneX2 / 2);
}
if (ptCursor.x > rcText.right - nAutoZoneX2)
{
dwDirection += xtpRight;
nScrollX = 1 + (ptCursor.x - rcText.right + nAutoZoneX2) / (nAutoZoneX2 / 2);
}
if (pnCols)
*pnCols = nScrollX;
if (pnRows)
*pnRows = nScrollY;
return dwDirection;
}
void CXTPSyntaxEditCtrl::OnTimer(UINT_PTR nIDEvent)
{
if (nIDEvent == TIMER_AUTOSCROLL_ID)
{
int nScrollX = 0, nScrollY = 0;
m_dwAutoScrollDirection = GetAutoscrollDirection(&nScrollX, &nScrollY);
if (nScrollX || nScrollY)
{
Scroll(nScrollX, nScrollY);
OnTimer(TIMER_SELECTION_ID);
//UpdateWindow();
}
BOOL bLButton = (::GetKeyState(VK_LBUTTON) & KF_UP) == KF_UP;
if (!m_dwAutoScrollDirection || !bLButton)
{
m_dwAutoScrollDirection = 0;
KillTimer(TIMER_AUTOSCROLL_ID);
}
}
else if (nIDEvent == TIMER_SELECTION_ID)
{
if ((::GetKeyState(VK_LBUTTON) & KF_UP) == 0)
{
m_Selection.bSelectingRunning = FALSE;
KillTimer(TIMER_SELECTION_ID);
return;
}
CPoint ptCursor;
GetCursorPos(&ptCursor);
ScreenToClient(&ptCursor);
BOOL bIsAutoScrollTimer = !!m_dwAutoScrollDirection;
m_dwAutoScrollDirection = GetAutoscrollDirection();
if (m_dwAutoScrollDirection)
{
if (!bIsAutoScrollTimer)
SetTimer(TIMER_AUTOSCROLL_ID, TIMER_AUTOSCROLL_TIME, NULL);
}
else
{
m_dwAutoScrollDirection = 0;
KillTimer(TIMER_AUTOSCROLL_ID);
}
//-------------------------------------------------------------------
CRect rcBookmark, rcLineNum, rcNodes, rcText;
CalcEditRects(&rcBookmark, &rcLineNum, &rcNodes, &rcText);
CRect rcLineNumAndNodes(rcLineNum);
rcLineNumAndNodes.right = rcNodes.right;
int nNewRow = 0, nNewCol = 0, nNewDispRow = 0, nNewDispCol = 0;
BOOL bVirtualSpace = m_Selection.IsbBlockSelectionMode() ? TRUE : -1;
RowColFromPoint(ptCursor, &nNewRow, &nNewCol, &nNewDispRow, &nNewDispCol, bVirtualSpace);
BOOL bSelFromLeftBar = rcLineNumAndNodes.PtInRect(ptCursor);
if (bSelFromLeftBar && m_Selection.nSelStartTextRowFromLeftBar)
{
if (nNewRow >= m_Selection.nSelStartTextRowFromLeftBar)
{
nNewRow++;
m_Selection.SetStart_str(m_Selection.nSelStartTextRowFromLeftBar, 0);
}
else
{
m_Selection.SetStart_str(m_Selection.nSelStartTextRowFromLeftBar+1, 0);
}
}
int nEndRow_prev = m_Selection.GetEnd_disp().nLine;
int nEndDispCol_prev = m_Selection.GetEnd_disp().nCol;
if (nEndRow_prev != nNewRow || nEndDispCol_prev != nNewDispCol)
{
// TRACE(_T("OnTimer.sel. RowColFromPoint: nNewRow=%d, nNewCol=%d, nNewDispRow=%d, nNewDispCol=%d n"),
// nNewRow, nNewCol, nNewDispRow, nNewDispCol);
m_Selection.SetEnd_disp(nNewRow, nNewDispCol);
if (m_Selection.bWordSelectionMode)
{
XTP_EDIT_LINECOL lcWord1, lcWord2;
BOOL bOverSpace = FALSE;
UINT nFindDir = m_Selection.IsSelNormal() ? XTP_EDIT_FINDWORD_NEXT : XTP_EDIT_FINDWORD_PREV;
BOOL bFind = FindWordEx_str(nFindDir, m_Selection.GetEnd_str(), lcWord1, lcWord2, bOverSpace);
//TRACE(_T("2-FindWordEx_str = %d (%d,%d - %d,%d)"), bFind,
// lcWord1.nLine, lcWord1.nCol,lcWord2.nLine, lcWord2.nCol);
XTP_EDIT_LINECOL& lcWordEnd = m_Selection.IsSelNormal() ? lcWord2 : lcWord1;
lcWordEnd.nCol--;
if (bFind && lcWordEnd.IsValidData() && lcWordEnd != m_Selection.GetEnd_str())
{
m_Selection.SetEnd_str(lcWordEnd.nLine, lcWordEnd.nCol);
}
}
SetCurrentDocumentRow(nNewRow);
m_nDispCol = m_Selection.GetEnd_disp().nCol;
m_nCurrentCol = m_Selection.GetEnd_str().nCol + 1;
int nCaretLine = m_Selection.GetEnd_disp().nLine;
if (bSelFromLeftBar && m_Selection.GetEnd_disp() >= m_Selection.GetStart_disp())
nCaretLine = max(1, nCaretLine - 1);
SetCurCaretPos(nCaretLine, m_nDispCol, FALSE, FALSE);
//TRACE(_T("Selection: (row=%d, strPos=%d, DispCol=%d)-(row=%d, strPos=%d, DispCol=%d) n"),
// m_Selection.GetStart_str().nLine, m_Selection.GetStart_str().nCol, m_Selection.GetStart_disp().nCol,
// m_Selection.GetEnd_str().nLine, m_Selection.GetEnd_str().nCol, m_Selection.GetEnd_disp().nCol);
Invalidate(FALSE);
UpdateWindow();
}
}
else if (nIDEvent == TIMER_REDRAW_WHEN_PARSE)
{
KillTimer(TIMER_REDRAW_WHEN_PARSE);
Invalidate(FALSE);
UpdateWindow();
}
}
BOOL CXTPSyntaxEditCtrl::Select(int nRow1, int nDispCol1, int nRow2, int nDispCol2, BOOL bRedraw)
{
if (nRow1 < 1 || nRow1 > GetRowCount())
return FALSE;
if (nRow2 < 1 || nRow2 > GetRowCount())
return FALSE;
m_Selection.Reset_disp(nRow1, nDispCol1);
m_Selection.SetEnd_disp(nRow2, nDispCol2);
SetCurrentDocumentRow(m_Selection.GetNormalEnd_disp().nLine);
m_nDispCol = m_Selection.GetNormalEnd_disp().nCol;
m_nCurrentCol = m_Selection.GetNormalEnd_str().nCol + 1;
if (bRedraw)
{
Invalidate(FALSE);
}
return TRUE;
}
void CXTPSyntaxEditCtrl::Unselect()
{
if (m_Selection.IsSelExist())
{
m_Selection.Reset_disp(m_Selection.GetEnd_disp().nLine,
m_Selection.GetEnd_disp().nCol);
Invalidate(FALSE);
}
}
BOOL CXTPSyntaxEditCtrl::ReplaceSel(LPCTSTR szNewText)
{
if (m_Selection.IsSelExist())
{
SetCurrentDocumentRow(m_Selection.GetNormalStart_disp().nLine);
m_nDispCol = m_Selection.GetNormalStart_disp().nCol;
m_nCurrentCol = m_Selection.GetNormalStart_str().nCol + 1; //CalcAbsCol(GetLineText(m_Selection.GetNormalStart_disp().nLine), m_nDispCol);
}
BOOL bOverwriteMode = m_pBuffer->GetOverwriteFlag();
m_pBuffer->SetOverwriteFlag(FALSE);
InsertString(szNewText, GetCurrentDocumentRow(), m_nCurrentCol, TRUE);
m_pBuffer->SetOverwriteFlag(bOverwriteMode);
return TRUE;
}
int CXTPSyntaxEditCtrl::ReplaceAll(LPCTSTR szFindText, LPCTSTR szReplaceText,
BOOL bMatchWholeWord, BOOL bMatchCase)
{
int nMatchFound = 0;
if (_tcsclen(szFindText) == 0)
{
return 0;
}
int iTopRow = GetTopRow();
int iCurRow = GetCurRow();
int iCurCol = GetCurCol();
SetCurPos(1,1,FALSE,FALSE);
CWaitCursor wait;
BOOL bFirst = TRUE;
while (GetCurRow() <= GetRowCount())
{
BOOL bFound = Find(szFindText,
bMatchWholeWord, bMatchCase,
TRUE, FALSE);
if (bFound)
{
ReplaceSel(szReplaceText);
if (!bFirst)
GetEditBuffer()->GetUndoRedoManager()->ChainLastCommand();
}
else
break;
bFirst = FALSE;
nMatchFound++;
}
if (!bFirst)
GetEditBuffer()->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_REPLACE_ALL);
SetTopRow(iTopRow);
SetCurPos(iCurRow, iCurCol);
return nMatchFound;
}
BOOL CXTPSyntaxEditCtrl::Find(LPCTSTR szText, BOOL bMatchWholeWord, BOOL bMatchCase, BOOL bSearchDown,
BOOL bRedraw, int nStartRow, int nStartCol)
{
// First check the current row
CString strLineText;
int iStartCol = m_nCurrentCol;
int iStartRow = GetCurrentDocumentRow();
int nTopRow = m_nTopRow;
int nBottomRow = GetDocumentRow(GetRowPerPage());
if (m_Selection.IsSelExist())
{
if (bSearchDown)
{
iStartCol = m_Selection.GetNormalEnd_str().nCol + 1; // m_ptEndSel.x;
iStartRow = m_Selection.GetNormalEnd_str().nLine; // m_ptEndSel.y;
}
else
{
iStartCol = m_Selection.GetNormalStart_str().nCol + 1; // m_ptStartSel.x;
iStartRow = m_Selection.GetNormalStart_str().nLine; // m_ptStartSel.y;
}
}
iStartCol = nStartCol < 0 ? iStartCol : nStartCol;
iStartRow = nStartRow < 0 ? iStartRow : nStartRow;
m_pBuffer->GetLineText(iStartRow, strLineText);
BOOL bResult = MatchText(iStartRow, strLineText, szText, iStartCol, bMatchWholeWord, bMatchCase, bSearchDown, bRedraw);
if (bResult)
return TRUE;
if (bSearchDown)
{
for (int i = (iStartRow + 1); i <= GetRowCount(); i++)
{
m_pBuffer->GetLineText(i, strLineText);
bResult = MatchText(i, strLineText, szText, 0, bMatchWholeWord, bMatchCase, TRUE, bRedraw);
if (bResult)
break;
}
}
else
{
for (int i = (iStartRow - 1); i >= 1; i--)
{
m_pBuffer->GetLineText(i, strLineText);
bResult = MatchText(i, strLineText, szText, (int)_tcsclen(strLineText) + 1, bMatchWholeWord, bMatchCase, FALSE, bRedraw);
if (bResult)
break;
}
}
if (bResult)
{
if (m_Selection.GetStart_str().nLine > nBottomRow)
{
ShiftCurrentVisibleRowDown(2 * GetRowPerPage() / 3);
}
else if (m_Selection.GetStart_str().nLine < nTopRow)
{
ShiftCurrentVisibleRowUp(GetRowPerPage() / 3);
}
SetCurCaretPos(m_Selection.GetNormalEnd_disp().nLine, m_Selection.GetNormalEnd_disp().nCol);
}
return bResult;
}
BOOL CXTPSyntaxEditCtrl::MatchText(int nRow, LPCTSTR szLineText, LPCTSTR szMatchText, int nStartPos, BOOL bMatchWholeWord, BOOL bMatchCase, BOOL bSearchForward, BOOL bRedraw)
{
BOOL bMatched = FALSE;
const int nLen = (int)_tcsclen(szLineText);
const int nSearchLen = (int)_tcsclen(szMatchText);
static LPCTSTR szSeps = _T("() t<>{}:;,.=%"'!@#$^&*-\|[]/?");
if (bSearchForward)
{
for (int i = nStartPos; i <= (nLen - nSearchLen + 1); i++)
{
int nFound = -1;
if (bMatchCase)
nFound = _tcsncmp((szLineText + i - 1), szMatchText, nSearchLen);
else
nFound = _tcsnicmp((szLineText + i - 1), szMatchText, nSearchLen);
bMatched = (nFound == 0);
if (bMatchWholeWord && nFound == 0)
{
BOOL bSepAfter = FALSE;
BOOL bSepBefore = FALSE;
if ((i - 1 + nSearchLen) >= nLen)
{
bSepAfter = TRUE;
}
else
{
LPCTSTR pcszTextAfter = (szLineText + i - 1) + nSearchLen;
bSepAfter = (_tcschr(szSeps, *pcszTextAfter) != 0);
}
if (i == 1)
bSepBefore = TRUE;
else
bSepBefore = (_tcschr(szSeps, *(szLineText + i - 2)) != 0);
if (!bSepAfter || !bSepBefore)
bMatched = FALSE;
}
if (bMatched)
{
int nDispCol1 = CalcDispCol(szLineText, i);
int nDispCol2 = CalcDispCol(szLineText, (i + nSearchLen));
Select(nRow, nDispCol1, nRow, nDispCol2, bRedraw);
m_nDispCol = nDispCol2;
m_nCurrentCol = (i + nSearchLen);
SetCurCaretPos(m_Selection.GetNormalEnd_disp().nLine,
m_Selection.GetNormalEnd_disp().nCol, FALSE/*, FALSE*/);
break;
}
}
}
else
{
for (int i = (nStartPos-nSearchLen); i >= 1 ; i--)
{
int nFound = -1;
if (bMatchCase)
nFound = _tcsncmp((szLineText + i - 1), szMatchText, nSearchLen);
else
nFound = _tcsnicmp((szLineText + i - 1), szMatchText, nSearchLen);
bMatched = (nFound == 0);
if (bMatchWholeWord && nFound == 0)
{
BOOL bSepAfter = FALSE;
BOOL bSepBefore = FALSE;
if ((i - 1 + nSearchLen) >= nLen)
{
bSepAfter = TRUE;
}
else
{
LPCTSTR pcszTextAfter = (szLineText + i - 1) + nSearchLen;
bSepAfter = (_tcschr(szSeps, *pcszTextAfter) != 0);
}
if (i == 1)
bSepBefore = TRUE;
else
bSepBefore = (_tcschr(szSeps, *(szLineText + i - 2)) != 0);
if (!bSepAfter || !bSepBefore)
bMatched = FALSE;
}
if (bMatched)
{
int nDispCol1 = CalcDispCol(szLineText, i);
int nDispCol2 = CalcDispCol(szLineText, (i + nSearchLen));
Select(nRow, nDispCol2, nRow, nDispCol1, bRedraw);
m_nDispCol = nDispCol1;
m_nCurrentCol = i;
SetCurCaretPos(m_Selection.GetNormalEnd_disp().nLine,
m_Selection.GetNormalEnd_disp().nCol, FALSE/*, FALSE*/);
break;
}
}
}
return bMatched;
}
void CXTPSyntaxEditCtrl::ShowHScrollBar(BOOL bShow)
{
ShowScrollBar(SB_HORZ, bShow);
}
void CXTPSyntaxEditCtrl::SelectWord(CPoint point)
{
int nRow = 0, nCol = 0;
if (!RowColFromPoint(point, &nRow, &nCol))
return;
XTP_EDIT_LINECOL lcWord1, lcWord2;
BOOL bOverSpace = FALSE;
UINT nFindDir = XTP_EDIT_FINDWORD_NEXT;
BOOL bFind = FindWordEx(nFindDir, nRow, nCol, lcWord1, lcWord2, bOverSpace);
if (bFind && lcWord1.IsValidData() && lcWord2.IsValidData() && !bOverSpace)
{
m_Selection.SetStart_str(lcWord1.nLine, lcWord1.nCol-1);
m_Selection.SetEnd_str(lcWord2.nLine, lcWord2.nCol-1);
SetCurCaretPos(m_Selection.GetEnd_disp().nLine,
m_Selection.GetEnd_disp().nCol);
Invalidate(FALSE);
UpdateWindow();
}
}
void CXTPSyntaxEditCtrl::FindWord(UINT nFindWhat)
{
XTP_EDIT_LINECOL lcWord1, lcWord2;
BOOL bOverSpace;
BOOL bFind = FindWordEx(nFindWhat, GetCurrentDocumentRow(), m_nCurrentCol,
lcWord1, lcWord2, bOverSpace);
XTP_EDIT_LINECOL& lcWordEnd = (nFindWhat == XTP_EDIT_FINDWORD_NEXT) ? lcWord2 : lcWord1;
if (!bFind || !lcWordEnd.IsValidData())
return;
int nDispCol = CalcDispCol(lcWordEnd.nLine, lcWordEnd.nCol);
SetCurCaretPos(lcWordEnd.nLine, nDispCol);
}
BOOL CXTPSyntaxEditCtrl::FindWordEx_str(UINT nFindWhat, XTP_EDIT_LINECOL lcPos_str,
XTP_EDIT_LINECOL& rlcWordStart, XTP_EDIT_LINECOL& rlcWordEnd,
BOOL& rbOverSpace)
{
return FindWordEx(nFindWhat, lcPos_str.nLine, lcPos_str.nCol + 1, rlcWordStart,
rlcWordEnd, rbOverSpace);
}
BOOL CXTPSyntaxEditCtrl::FindWordEx(UINT nFindWhat, int nTextRow, int nCol,
XTP_EDIT_LINECOL& rlcWordStart, XTP_EDIT_LINECOL& rlcWordEnd, BOOL& rbOverSpace)
{
// set word invalid borders
rlcWordStart = rlcWordEnd = XTP_EDIT_LINECOL::MINPOS;
rbOverSpace = FALSE;
CString strLineText;
const TCHAR* pCh = NULL;
const TCHAR szSeps[] = _T("[]{}()<>.,;:!?=*&%@^#-"'/");
// const TCHAR szSepsAll[] = _T("[]{}()<>.,;:!?=*&%@^#-"'/nrt ");
const TCHAR szSpaceSeps[] = _T(" t");
const TCHAR szNLSeps[] = _T("rn");
int nDir = nFindWhat == XTP_EDIT_FINDWORD_PREV ? -1 : 1;
nCol = min(nCol-1, GetEditBuffer()->GetLineTextLengthC(nTextRow));
XTP_EDIT_LINECOL lcPosStart = XTP_EDIT_LINECOL::MakeLineCol(nTextRow, max(0, nCol));
CXTPSyntaxEditTextIterator txtIter(GetEditBuffer());
BOOL bSeek = txtIter.SeekPos(lcPosStart);
if (!bSeek)
return FALSE;
pCh = (nDir < 0) ? txtIter.SeekPrev() : txtIter.GetText(2);
if (!pCh)
return FALSE;
// Is over space/tab
BOOL bOverSpace = !!_tcschr(szSpaceSeps, *pCh);
BOOL bOverNL = !!_tcschr(szNLSeps, *pCh);
rbOverSpace = (bOverSpace || bOverNL);
if (!pCh)
return FALSE;
BOOL bStartCharSep = !!_tcschr(szSeps, *pCh);
if (rbOverSpace && nDir < 0)
{
while (pCh && (_tcschr(szSpaceSeps, *pCh) ||
!bOverSpace && _tcschr(szNLSeps, *pCh)) )
{
rlcWordEnd = txtIter.GetPosLC();
pCh = txtIter.SeekPrev();
}
if (!pCh || rlcWordEnd.nCol == 0 || bOverNL)
{
rlcWordEnd.nCol++;
rlcWordStart = rlcWordEnd;
return TRUE;
}
bStartCharSep = !!_tcschr(szSeps, *pCh);
}
if (rbOverSpace && nDir > 0) // one word border find - find the other one
{
XTP_EDIT_LINECOL& rlc1 = (nDir < 0) ? rlcWordEnd : rlcWordStart;
XTP_EDIT_LINECOL& rlc2 = (nDir < 0) ? rlcWordStart : rlcWordEnd;
rlc1 = txtIter.GetPosLC();
rlc2 = txtIter.GetPosLC();
while (pCh && (_tcschr(szSpaceSeps, *pCh) ||
_tcschr(szNLSeps, *pCh)) )
{
pCh = (nDir < 0) ? txtIter.SeekPrev() : txtIter.SeekNext(1, 2);
rlc2 = txtIter.GetPosLC();
}
}
else //find 2 word borders
{
rlcWordStart = txtIter.GetPosLC();
while (pCh && !((bStartCharSep == (!_tcschr(szSeps, *pCh))) ||
_tcschr(szSpaceSeps, *pCh) || _tcschr(szNLSeps, *pCh)))
{
rlcWordStart = txtIter.GetPosLC();
pCh = txtIter.SeekPrev();
}
pCh = txtIter.SeekNext(1, 2);
rlcWordEnd = txtIter.GetPosLC();
while (pCh && !(bStartCharSep == !_tcschr(szSeps, *pCh) ||
_tcschr(szSpaceSeps, *pCh) || _tcschr(szNLSeps, *pCh))
)
{
pCh = txtIter.SeekNext(1, 2);
rlcWordEnd = txtIter.GetPosLC();
}
if (rlcWordEnd > txtIter.GetPosLC_last(FALSE))
rlcWordEnd = txtIter.GetPosLC_last(FALSE);
}
rlcWordStart.nCol++;
rlcWordEnd.nCol++;
return TRUE;
}
void CXTPSyntaxEditCtrl::DeleteSelectedLines(int iForceDeleteRow)
{
int iLineFrom, iLineTo;
int iColTo = 1;
if (m_Selection.IsSelExist())
{
iLineFrom = m_Selection.GetNormalStart_str().nLine;
iLineTo = m_Selection.GetNormalEnd_str().nLine;;
}
else
{
iLineFrom = iForceDeleteRow;
iLineTo = iLineFrom + 1;
}
if (iLineTo > GetRowCount())
{
iLineTo = GetRowCount();
const int iLen = (int)_tcsclen(GetLineText(iLineTo));
if (iLen == 0 && (iLineTo < 1 || iLineTo < iLineFrom))
iColTo = 1;
else
iColTo = iLen + 1;
if (iLineFrom == iLineTo && iColTo == 1 && iLen == 0) // Nothing to delete
return;
}
m_Selection.Reset_disp(iLineFrom, 1);
int nFlags = xtpEditLMRefresh_Delete | xtpEditLMRefresh_Delete_only1;
if (iColTo > 1)
nFlags |= xtpEditLMRefresh_Delete_only2;
GetLineMarksManager()->RefreshLineMarks(iLineFrom, iLineTo, nFlags);
DeleteBuffer(iLineFrom, 1, iLineTo, iColTo);
}
BOOL CXTPSyntaxEditCtrl::IncreaseIndent()
{
if (!m_Selection.IsSelExist() ||
(m_Selection.GetStart_disp().nLine == m_Selection.GetEnd_disp().nLine &&
m_Selection.GetStart_disp().nLine < GetRowCount()))
{
if (!m_pBuffer->GetOverwriteFlag())
return FALSE;
CString strLineText = GetLineText(GetCurrentDocumentRow());
const int iLineLen = (int)_tcsclen(strLineText);
int iMaxDispCol = CalcDispCol(strLineText, (iLineLen + 1));
if (m_nDispCol >= iMaxDispCol)
return FALSE;
if (m_nCurrentCol > (iLineLen + 1))
m_nCurrentCol = (iLineLen + 1);
m_nDispCol += (GetTabSize() - (m_nDispCol % GetTabSize())); // Align by tab size
if (m_nDispCol < 1)
m_nDispCol = 1;
m_nDispCol = CalcValidDispCol(strLineText, m_nDispCol);
m_nCurrentCol = CalcAbsCol(strLineText, m_nDispCol);
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol);
return TRUE;
}
int iRowFrom = m_Selection.GetNormalStart_str().nLine;
int iRowTo = m_Selection.GetNormalEnd_str().nLine;
if (m_Selection.GetEnd_disp().nCol == 1 && iRowTo > iRowFrom)
iRowTo--;
if (!CanEditDoc())
return FALSE;
BOOL bModified = FALSE;
// First insert tabs in front
// If overwrite flag is not set
if (!m_pBuffer->GetOverwriteFlag())
{
const CString strText(GetTabWithSpace() ? CString((TCHAR)(' '), GetTabSize()) : _T("x09"));
for (int i = iRowFrom; i <= iRowTo; i++)
{
//**----------------------
OnBeforeEditChanged(i, 1);
//**----------------------
m_pBuffer->InsertText(strText, i, 1);
bModified = TRUE;
if (i > iRowFrom)
{
m_pBuffer->GetUndoRedoManager()->ChainLastCommand();
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_INDENTATION);
}
//**----------------------
OnEditChanged(i, 1, i, 2, xtpEditActInsert);
//**----------------------
}
if (bModified)
{
NotifyEditChanged(iRowFrom, iRowTo, XTP_EDIT_EDITACTION_MODIFYROW);
}
}
// Select the lines
m_Selection.Reset_disp(iRowFrom, 1);
m_Selection.SetEnd_disp(iRowTo + 1, 1);
if (bModified)
SetDocModified();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol);
UpdateWindow();
UpdateScrollPos();
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::DecreaseIndent()
{
if (!m_Selection.IsSelExist())
{
if (m_nCurrentCol < 1)
m_nCurrentCol = 1;
LPCTSTR szLineText = GetLineText(GetCurrentDocumentRow());
int iAddFactor = 1;
if ((m_nDispCol - 1) % GetTabSize())
iAddFactor = 0;
m_nDispCol = 1 + ((((m_nDispCol - 1) / GetTabSize()) - iAddFactor) * GetTabSize()); // Align by tab size
if (m_nDispCol < 1)
m_nDispCol = 1;
m_nDispCol = CalcValidDispCol(szLineText, m_nDispCol);
m_nCurrentCol = CalcAbsCol(szLineText, m_nDispCol);
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol);
return TRUE;
}
int iRowFrom = m_Selection.GetNormalStart_str().nLine;
int iRowTo = m_Selection.GetNormalEnd_str().nLine;
if (m_Selection.GetEnd_disp().nCol == 1 && iRowTo > iRowFrom)
iRowTo--;
if (!CanEditDoc())
return FALSE;
CString strLineText;
BOOL bFrontDeleted = FALSE;
BOOL bModified = FALSE;
// First tabs or blank spaces from front
for (int i = iRowFrom; i <= iRowTo; i++)
{
GetLineText(i, strLineText);
const int iLen = (int)_tcsclen(strLineText);
if (iLen == 0)
continue;
//**----------------------
OnBeforeEditChanged(i, 1);
//**----------------------
if (strLineText.GetAt(0) == _T('t'))
{
m_pBuffer->DeleteText(i, 1, i, 2);
bFrontDeleted = TRUE;
bModified = TRUE;
}
else
{
// No tab found in the front
// try to find blank spaces
int iSpaceCount = 0;
for (int iCol = 0; iCol < GetTabSize() && iCol < iLen; iCol++)
{
if (strLineText.GetAt(iCol) == 0x20)
iSpaceCount++;
else
break;
}
if (iSpaceCount)
{
m_pBuffer->DeleteText(i, 1, i, (iSpaceCount + 1));
bFrontDeleted = TRUE;
bModified = TRUE;
}
}
if (bFrontDeleted)
{
m_pBuffer->GetUndoRedoManager()->ChainLastCommand();
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_INDENT_DECREASE);
}
//**----------------------
OnEditChanged(i, 1, i, 1, xtpEditActDelete);
//**----------------------
}
if (bModified)
{
NotifyEditChanged(iRowFrom, iRowTo, XTP_EDIT_EDITACTION_MODIFYROW);
}
// Select the lines
m_Selection.Reset_disp(iRowFrom, 1);
m_Selection.SetEnd_disp(iRowTo + 1, 1);
if (bModified)
SetDocModified();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol);
UpdateWindow();
UpdateScrollPos();
return TRUE;
}
void CXTPSyntaxEditCtrl::RecalcScrollBars()
{
_RecalcScrollBars();
CalculateEditbarLength();
}
void CXTPSyntaxEditCtrl::_RecalcHScrollMaxWidth()
{
CRect rcText = m_DrawTextProcessor.GetTextRect();
int nPageX = rcText.Width();
int nMaxX = m_DrawTextProcessor.GetRowsMaxWidth();
nMaxX += max(nPageX/4, m_DrawTextProcessor.GetTextMetrics().tmAveCharWidth * 20);
nMaxX = max(nMaxX, rcText.Width() * 2);
m_nHScrollMaxWidth = max(nMaxX, m_nHScrollMaxWidth);
}
void CXTPSyntaxEditCtrl::_RecalcScrollBars()
{
if (!GetPaintManager()->GetFont()->GetSafeHandle())
return;
if (!m_hWnd || !::IsWindow(m_hWnd))
return;
// create scroll bar info
SCROLLINFO info;
ZeroMemory(&info, sizeof(SCROLLINFO));
info.cbSize = sizeof(SCROLLINFO);
info.fMask = SIF_ALL;
int nVisRows = GetVisibleRowsCount();
CRect rcText = m_DrawTextProcessor.GetTextRect();
int nPageX = rcText.Width();
int nPageY = m_DrawTextProcessor.GetRowsCount(FALSE);
_RecalcHScrollMaxWidth();
if (GetRowCount() <= 0)
{
GetScrollInfo(SB_VERT, &info);
info.cbSize = sizeof(info);
info.fMask = SIF_DISABLENOSCROLL | SIF_PAGE | SIF_RANGE;
info.nPage = nPageY;
info.nMax= nPageY;
if (GetVertScrollBar())
{
SetScrollInfo(SB_VERT, &info);
EnableScrollBarCtrl(SB_VERT);
}
info.fMask = SIF_ALL;
GetScrollInfo(SB_HORZ, &info);
info.nMax = m_nHScrollMaxWidth;
info.nPage = nPageX;
info.fMask = SIF_DISABLENOSCROLL | SIF_PAGE | SIF_RANGE;
if (GetHorzScrollBar())
SetScrollInfo(SB_HORZ, &info);
}
else
{
info.fMask = SIF_ALL;
GetScrollInfo(SB_HORZ, &info);
info.nMin = 0;
info.nMax = max(m_nHScrollMaxWidth, info.nMax);
info.nPage = nPageX;
info.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
if (GetHorzScrollBar())
{
SetScrollInfo(SB_HORZ, &info);
EnableScrollBarCtrl(SB_HORZ);
}
//---------------------------------------
info.fMask = SIF_ALL;
GetScrollInfo(SB_VERT, &info);
int nMaxRowInPage = GetRowPerPage();
BOOL bVertScrl = (nVisRows >= nMaxRowInPage);
if (GetVertScrollBar())
{
if (bVertScrl)
{
int nVisRow = GetVisibleRowsCount(m_nTopRow);
info.nMin = 1;
info.nMax = nVisRows;
info.nPage = nPageY;
info.nPos = nVisRow;
info.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
SetScrollInfo(SB_VERT, &info);
}
else
{
m_nTopRow = 1;
Invalidate(FALSE);
}
EnableScrollBarCtrl(SB_VERT, bVertScrl);
}
}
if (GetCurrentDocumentRow() > GetRowCount())
SetCurCaretPos(GetRowCount(), m_nDispCol);
}
void CXTPSyntaxEditCtrl::RecalcVertScrollPos()
{
if (!::IsWindow(m_hWnd))
return;
if (!GetPaintManager()->GetFont()->GetSafeHandle())
return;
if (!GetVertScrollBar())
return;
int nPageRows = GetRowPerPage();
int nTotalVisRows = GetVisibleRowsCount();
BOOL bVertScrl = (nTotalVisRows >= nPageRows);
if (bVertScrl)
{
int nVisRow = GetVisibleRowsCount(m_nTopRow);
SCROLLINFO si;
ZeroMemory(&si, sizeof(SCROLLINFO));
si.cbSize = sizeof(si);
si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
si.nMin = 1;
si.nMax = nTotalVisRows;
si.nPage = nPageRows;
si.nPos = nVisRow;
VERIFY(SetScrollInfo(SB_VERT, &si));
}
else
{
m_nTopRow = 1;
Invalidate(FALSE);
}
EnableScrollBarCtrl(SB_VERT, bVertScrl);
}
void CXTPSyntaxEditCtrl::RecalcHorzScrollPos()
{
if (!::IsWindow(m_hWnd))
return;
if (!GetPaintManager()->GetFont()->GetSafeHandle())
return;
if (!GetHorzScrollBar())
return;
_RecalcHScrollMaxWidth();
int nPos = GetScrollPos(SB_HORZ);
SCROLLINFO si;
ZeroMemory(&si, sizeof(SCROLLINFO));
si.cbSize = sizeof(si);
si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
si.nMin = 0;
si.nMax = si.nMax = max(m_nHScrollMaxWidth, si.nMax);
si.nPage = m_DrawTextProcessor.GetTextRect().Width();
si.nPos = nPos;
VERIFY(SetScrollInfo(SB_HORZ, &si, FALSE));
}
void CXTPSyntaxEditCtrl::NotifyCurRowCol(int iRow, int iCol)
{
// Notify the parent class that position has been changed
XTP_EDIT_NMHDR_ROWCOLCHANGED src;
// NMHDR codes
src.nmhdr.code = XTP_EDIT_NM_ROWCOLCHANGED;
src.nmhdr.hwndFrom = m_hWnd;
src.nmhdr.idFrom = GetDlgCtrlID();
// Row col specific codes
src.nRow = iRow;
src.nCol = iCol;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)src.nmhdr.idFrom, (LPARAM)&src);
}
}
void CXTPSyntaxEditCtrl::ValidateCol(const int nRow, int &nCol, int& nAbsCol)
{
CString strText;
GetLineText(nRow, strText);
nCol = CalcValidDispCol(strText, nCol);
nAbsCol = CalcAbsCol(strText, nCol);
}
void CXTPSyntaxEditCtrl::EnableOleDrag(BOOL bEnableDrag)
{
m_bEnableOleDrag = bEnableDrag;
}
HGLOBAL CXTPSyntaxEditCtrl::GetSelectionBuffer(UINT nFormat)
{
if (!m_Selection.IsSelExist())
return NULL;
if (nFormat != CF_TEXT && nFormat != CF_UNICODETEXT)
return NULL;
CMemFile file(CalcAveDataSize(m_Selection.GetNormalStart_str().nLine,
m_Selection.GetNormalEnd_str().nLine));
BOOL bRes = m_pBuffer->GetBuffer(m_Selection.GetNormalStart_disp(),
m_Selection.GetNormalEnd_disp(), file,
m_Selection.bBlockSelectionMode, TRUE);
if (!bRes)
return NULL;
file.Seek(0, CFile::end);
file.Write(_T(""), sizeof(TCHAR));
int nLen = (int)file.GetLength();
BYTE *pBytes = file.Detach();
UINT uCodePage = m_pBuffer->GetCodePage();
#ifdef _UNICODE
// If Unicode defined then for CF_TEXT conversion is needed
if (nFormat == CF_TEXT)
{
nLen = ::WideCharToMultiByte(uCodePage, 0, (LPWSTR)pBytes, -1, NULL, 0, NULL, NULL);
}
#else
if (nFormat == CF_UNICODETEXT)
{
nLen = ::MultiByteToWideChar(uCodePage, 0, (LPCSTR)pBytes, -1, NULL, 0);
nLen *= sizeof(wchar_t);
}
#endif
HGLOBAL hMem = ::GlobalAlloc(GMEM_MOVEABLE, nLen);
if (!hMem)
return 0;
void *pText = ::GlobalLock(hMem);
#ifdef _UNICODE
if (nFormat == CF_UNICODETEXT)
MEMCPY_S(pText, pBytes, nLen);
else
{
::WideCharToMultiByte(uCodePage, 0, (LPWSTR)pBytes, -1, (LPSTR)pText, nLen, NULL, NULL);
}
#else
if (nFormat == CF_TEXT)
MEMCPY_S(pText, pBytes, nLen);
else
{
::MultiByteToWideChar(uCodePage, 0, (LPSTR)pBytes, -1, (LPWSTR)pText, (nLen / sizeof(wchar_t)));
}
#endif
::GlobalUnlock(hMem);
::free(pBytes);
return hMem;
}
int CXTPSyntaxEditCtrl::GetSelectionText(CString &strText)
{
if (!m_Selection.IsSelExist())
return 0;
CMemFile file(CalcAveDataSize(m_Selection.GetNormalStart_str().nLine,
m_Selection.GetNormalEnd_str().nLine));
BOOL bRes = m_pBuffer->GetBuffer(m_Selection.GetNormalStart_disp(),
m_Selection.GetNormalEnd_disp(), file,
m_Selection.bBlockSelectionMode, TRUE);
if (!bRes)
return 0;
file.Write((LPVOID)_T(""), sizeof(TCHAR));
int iLen = (int)file.GetLength();
BYTE *pBytes = file.Detach();
strText = (LPTSTR)pBytes;
free(pBytes);
return iLen;
}
void CXTPSyntaxEditCtrl::SetDropPos(int iRow, int iCol)
{
m_ptDropPos.y = iRow;
m_ptDropPos.x = iCol;
}
void CXTPSyntaxEditCtrl::OnShowWindow(BOOL bShow, UINT nStatus)
{
CWnd::OnShowWindow(bShow, nStatus);
}
void CXTPSyntaxEditCtrl::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized)
{
CWnd::OnActivate(nState, pWndOther, bMinimized);
SetActive(nState != WA_INACTIVE);
}
void CXTPSyntaxEditCtrl::SetActive(BOOL bIsActive)
{
m_bIsActive = bIsActive;
if (::IsWindow(m_hWnd))
{
RedrawWindow();
}
}
void CXTPSyntaxEditCtrl::HandleDrop(BOOL bCopy)
{
if (!CanEditDoc())
return;
if (!m_bRightButtonDrag)
CopyOrMoveText(bCopy);
else
{
CMenu menu;
menu.CreatePopupMenu();
CString csMenuText;
XTPResourceManager()->LoadString(&csMenuText, XTP_IDS_EDIT_MOVE_HERE);
menu.AppendMenu(MF_STRING, XTP_IDC_EDIT_DRAG_MOVE, csMenuText);
XTPResourceManager()->LoadString(&csMenuText, XTP_IDS_EDIT_COPY_HERE);
menu.AppendMenu(MF_STRING, XTP_IDC_EDIT_DRAG_COPY, csMenuText);
menu.AppendMenu(MF_SEPARATOR);
XTPResourceManager()->LoadString(&csMenuText, XTP_IDS_EDIT_CANCEL);
menu.AppendMenu(MF_STRING, IDCANCEL, csMenuText);
CPoint pt;
GetCursorPos(&pt);
int nID = menu.TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON|TPM_NONOTIFY|TPM_RETURNCMD, pt.x, pt.y, this);
if (nID == XTP_IDC_EDIT_DRAG_MOVE || nID == XTP_IDC_EDIT_DRAG_COPY)
CopyOrMoveText(nID == XTP_IDC_EDIT_DRAG_COPY);
}
m_bRightButtonDrag = FALSE;
m_bDragging = FALSE;
}
void CXTPSyntaxEditCtrl::ShowDefaultContextMenu()
{
CPoint ptCur;
GetCursorPos(&ptCur);
OnContextMenu(this, ptCur);
}
void CXTPSyntaxEditCtrl::CancelRightButtonDrag()
{
m_bRightButtonDrag = FALSE;
}
BOOL CXTPSyntaxEditCtrl::IsRightButtonDrag()
{
return m_bRightButtonDrag;
}
void CXTPSyntaxEditCtrl::SetRightButtonDrag(BOOL bRightButtonDrag)
{
m_bRightButtonDrag = bRightButtonDrag;
}
void CXTPSyntaxEditCtrl::EnableWhiteSpace(BOOL bShow)
{
m_bEnableWhiteSpace = bShow;
Invalidate(FALSE);
}
BOOL CXTPSyntaxEditCtrl::IsEnabledWhiteSpace()
{
return m_bEnableWhiteSpace;
}
void CXTPSyntaxEditCtrl::EnableVirtualSpace(BOOL bEnable, BOOL bUpdateReg)
{
SetValueBool(XTP_EDIT_REG_VIRTUALSPACE, bEnable, m_bVirtualSpace, bUpdateReg);
}
void CXTPSyntaxEditCtrl::SetCollapsibleNodes(BOOL bDrawNodes, BOOL bUpdateReg)
{
SetValueBool(XTP_EDIT_REG_COLLAPSIBLENODES, bDrawNodes, m_bDrawNodes, bUpdateReg);
CalculateEditbarLength();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, TRUE);
if (!m_bDrawNodes)
ExpandAll();
else
Invalidate(FALSE);
}
BOOL CXTPSyntaxEditCtrl::SetTabWithSpace(BOOL bTabWithSpace, BOOL bUpdateReg/*=FALSE*/)
{
if (!SetValueBool(XTP_EDIT_REG_TABWITHSPACE, bTabWithSpace, m_bTabWithSpace, bUpdateReg))
return FALSE;
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::GetTabWithSpace() const
{
return m_bTabWithSpace;
}
void CXTPSyntaxEditCtrl::NotifySelInit()
{
NotifyParent(XTP_EDIT_NM_SELINIT);
}
BOOL CXTPSyntaxEditCtrl::SetTabSize(int nTabSize, BOOL bUpdateReg)
{
if (!m_pBuffer->SetTabSize(nTabSize, bUpdateReg))
return FALSE;
m_DrawTextProcessor.SetTabSize(nTabSize);
CString strText;
GetLineText(GetCurrentDocumentRow(), strText);
m_nDispCol = CalcDispCol(strText, m_nCurrentCol);
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
return TRUE;
}
int CXTPSyntaxEditCtrl::GetTabSize() const
{
return m_pBuffer ? m_pBuffer->GetTabSize() : 4;
}
BOOL CXTPSyntaxEditCtrl::SetSyntaxColor(BOOL bSyntaxColor, BOOL bUpdateReg)
{
if (!SetValueBool(XTP_EDIT_REG_SYNTAXCOLOR, bSyntaxColor, m_bSyntaxColor, bUpdateReg))
return FALSE;
m_arOnScreenSchCache.RemoveAll();
m_pBuffer->EnableParser(bSyntaxColor);
return TRUE;
}
LRESULT CXTPSyntaxEditCtrl::NotifyParent(UINT uCode)
{
ASSERT_VALID(m_pParentWnd);
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
NMHDR hdr;
hdr.hwndFrom = m_hWnd;
hdr.code = uCode;
hdr.idFrom = GetDlgCtrlID();
return m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)hdr.idFrom, (LPARAM)&hdr);
}
return -1;
}
LRESULT CXTPSyntaxEditCtrl::NotifyMouseEvent(UINT uCode, UINT nFlags, const CPoint& point)
{
UNREFERENCED_PARAMETER(nFlags);
ASSERT_VALID(GetParent());
if (::IsWindow(GetParent()->GetSafeHwnd()))
{
NMMOUSE hdrMouse;
::ZeroMemory(&hdrMouse, sizeof(hdrMouse));
hdrMouse.hdr.hwndFrom = m_hWnd;
hdrMouse.hdr.code = uCode;
hdrMouse.hdr.idFrom = GetDlgCtrlID();
hdrMouse.pt = point;
return GetParent()->SendMessage(WM_NOTIFY, (WPARAM)hdrMouse.hdr.idFrom,
(LPARAM)&hdrMouse);
}
return -1;
}
BOOL CXTPSyntaxEditCtrl::SetSelMargin(BOOL bSelMargin, BOOL bUpdateReg)
{
if (!SetValueBool(XTP_EDIT_REG_SELMARGIN, bSelMargin, m_bSelMargin, bUpdateReg))
return FALSE;
CalculateEditbarLength();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::SetScrollBars(BOOL bHorzSBar, BOOL bVertSBar, BOOL bUpdateReg/*=FALSE*/)
{
if (!SetValueBool(XTP_EDIT_REG_HSCROLLBAR, bHorzSBar, m_bHorzScrollBar, bUpdateReg))
return FALSE;
if (!SetValueBool(XTP_EDIT_REG_VSCROLLBAR, bVertSBar, m_bVertScrollBar, bUpdateReg))
return FALSE;
DWORD dwStyle = ::GetWindowLong(m_hWnd, GWL_STYLE) & ~(WS_HSCROLL|WS_VSCROLL);
if (bHorzSBar && !IsCreateScrollbarOnParent())
dwStyle |= WS_HSCROLL;
if (bVertSBar && !IsCreateScrollbarOnParent())
dwStyle |= WS_VSCROLL;
EnableScrollBarCtrl(SB_HORZ, m_bHorzScrollBar);
EnableScrollBarCtrl(SB_VERT, m_bVertScrollBar);
::SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::CanEditDoc()
{
if (IsReadOnly())
return FALSE;
BOOL bCancel = (BOOL)NotifyParent(XTP_EDIT_NM_EDITCHANGING);
return !bCancel;
}
void CXTPSyntaxEditCtrl::NotifyEditChanged(int iRowFrom, int iRowTo, UINT nActions)
{
XTP_EDIT_NMHDR_EDITCHANGED sec;
sec.nmhdr.code = XTP_EDIT_NM_EDITCHANGED;
sec.nmhdr.hwndFrom = m_hWnd;
sec.nmhdr.idFrom = GetDlgCtrlID();
sec.nRowFrom = iRowFrom;
sec.nRowTo = iRowTo;
sec.nAction = nActions;
RefreshLineMarks(&sec);
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)sec.nmhdr.idFrom, (LPARAM)&sec);
}
}
BOOL CXTPSyntaxEditCtrl::CreateInsertText(LPTSTR szText,
CString& strTextToIns,
int& iNewRow,
int& iNewCol,
int& iNewDispCol,
int& iEditRowFrom,
int& iEditRowTo,
int& iChainActionCount)
{
// As this function will always be called by OnChar
// We can assume szText will contain only one character
// or the CRLF
int nCurDocRow = GetCurrentDocumentRow();
CString strLineText;
GetLineText(nCurDocRow, strLineText);
int nLineLenC = (int)_tcsclen(strLineText);
BOOL bTextCRLF = m_pBuffer->IsTextCRLF(szText);
BOOL bProcess = TRUE;
if (!bTextCRLF)
{
if (szText[0] == 0x09 && !GetTabWithSpace() &&
m_nCurrentCol > 1 && nLineLenC > 0)
{
int nAlign = (m_nDispCol-1) % GetTabSize();
iNewDispCol = m_nDispCol - nAlign + GetTabSize();
int nDispCol = CalcDispCol(strLineText, nLineLenC + 1);
int nCurCol = m_nCurrentCol;
if (nDispCol < m_nDispCol)
{
nCurCol = nLineLenC+1;
}
else
{
nDispCol = m_nDispCol;
}
int nCharsToCheck = nCurCol-1;
if (nCharsToCheck)
{
LPCTSTR pCheck = _tcsninc((LPCTSTR)strLineText, max(0, nCurCol - 1 - 1));
int nBlanks;
for (nBlanks = 0; pCheck && nBlanks < nCharsToCheck; nBlanks++)
{
if (!pCheck || *pCheck != _T(' '))
break;
pCheck = _tcsdec((LPCTSTR)strLineText, pCheck);
}
if (nBlanks > 0)
{
int nAdditionalTabs = 0;
int nDC = m_nDispCol - nBlanks;
nDC += GetTabSize() - nDC % GetTabSize();
for(; nDC < m_nDispCol; nDC += GetTabSize())
{
nAdditionalTabs++;
}
m_pBuffer->SetOverwriteFlag(FALSE);
nCurDocRow = GetCurrentDocumentRow();
//**----------------------
OnBeforeEditChanged(nCurDocRow, nCurCol - nBlanks);
m_pBuffer->DeleteText(nCurDocRow, nCurCol - nBlanks, nCurDocRow, nCurCol);
OnEditChanged(nCurDocRow, nCurCol - nBlanks, nCurDocRow, nCurCol, xtpEditActDelete);
//**----------------------
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_FORMAT);
m_nDispCol -= nBlanks;
m_nCurrentCol -= nBlanks;
iChainActionCount = 2;
GetLineText(nCurDocRow, strLineText);
nLineLenC = (int)_tcsclen(strLineText);
if (nAdditionalTabs)
{
strTextToIns += CString(_T('t'), nAdditionalTabs);
}
}
}
}
else
{
iNewDispCol = m_nDispCol + (szText[0] == 0x09 ? GetTabSize() : 1);
iNewCol = m_nCurrentCol + (szText[0] == 0x09 ? (GetTabWithSpace() ? GetTabSize() : 1) : 1);
if (GetAutoIndent() && m_nAutoIndentCol > 0)
{
strTextToIns += CString(_T('t'), m_nInsertTabCount) +
CString(_T(' '), m_nInsertSpaceCount);
m_nDispCol = 1;
m_nCurrentCol = 1;
}
}
iNewRow = GetCurrentDocumentRow();
strTextToIns += szText;
m_nAutoIndentCol = 0;
m_nInsertTabCount = 0;
m_nInsertSpaceCount = 0;
}
else if (bTextCRLF)
{
// Enter pressed
nCurDocRow = GetCurrentDocumentRow();
iNewRow = nCurDocRow + 1;
iNewCol = iNewDispCol = 1;
iEditRowFrom = nCurDocRow;
iEditRowTo = iEditRowFrom + 1;
strTextToIns = szText;
if (!GetAutoIndent())
return TRUE;
BOOL bInsertMid = (m_nCurrentCol <= nLineLenC);
DoAutoIndentIfNeed(GetCurrentDocumentRow(), m_nDispCol);
if (m_nAutoIndentCol > 0 && bInsertMid)
{
CString strTabs;
FillTabs(strTabs, m_nAutoIndentCol);
strTextToIns += strTabs;
iNewDispCol = m_nAutoIndentCol;
iNewCol = (int)_tcsclen(strTabs);
m_nAutoIndentCol = 0;
}
}
return bProcess;
}
void CXTPSyntaxEditCtrl::DoAutoIndentIfNeed(int nBaseDocRow, int nDispCol_prev)
{
if (!m_bAutoIndent)
return;
m_nAutoIndentCol = 0;
if (nDispCol_prev == 1)
return;
CString strTempLineText;
BOOL bFound = FALSE;
GetLineText(nBaseDocRow, strTempLineText);
LPCTSTR pChar = (LPCTSTR)strTempLineText;
for (; pChar && *pChar; pChar = _tcsinc(pChar))
{
if (*pChar == 0x09)
{
m_nAutoIndentCol += (GetTabSize() - (m_nAutoIndentCol % GetTabSize()));
}
else if (*pChar == 0x20)
{
m_nAutoIndentCol++;
}
else
{
bFound = TRUE;
break;
}
}
if (!bFound && nDispCol_prev > 1)
{
bFound = TRUE;
m_nAutoIndentCol = nDispCol_prev - 1;
}
if (nDispCol_prev > 1 && m_nAutoIndentCol > nDispCol_prev - 1)
m_nAutoIndentCol = nDispCol_prev - 1;
if (bFound)
{
m_nInsertTabCount = m_nAutoIndentCol / GetTabSize();
m_nInsertSpaceCount = m_nAutoIndentCol % GetTabSize();
m_nAutoIndentCol++;
}
else
{
m_nAutoIndentCol = 0;
m_nInsertTabCount = 0;
m_nInsertSpaceCount = 0;
}
}
void CXTPSyntaxEditCtrl::FillTabs(CString &rstrTextToIns, int nDispColl)
{
int nTabsCount = GetTabWithSpace() ? 0 : (nDispColl-1) / GetTabSize();
int nSpaceCount = nDispColl - nTabsCount * GetTabSize() - 1;
if (nTabsCount)
{
CString strTabs(_T('t'), nTabsCount);
rstrTextToIns += strTabs;
}
if (nSpaceCount)
{
CString strSpaces(_T(' '), nSpaceCount);
rstrTextToIns += strSpaces;
}
}
BOOL CXTPSyntaxEditCtrl::IsRowVisible(int iRow)
{
if (iRow > GetRowCount() || iRow < 1)
return FALSE;
int iMaxRowInPage = GetRowPerPage();
return (iRow >= m_nTopRow && iRow <= (m_nTopRow + iMaxRowInPage));
}
BOOL CXTPSyntaxEditCtrl::LowercaseSelection()
{
return DoChangeSelectionCase(FALSE);
}
BOOL CXTPSyntaxEditCtrl::UppercaseSelection()
{
return DoChangeSelectionCase(TRUE);
}
BOOL CXTPSyntaxEditCtrl::DoChangeSelectionCase(BOOL bUpper)
{
if (!m_Selection.IsSelExist())
return FALSE;
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(FALSE);
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(TRUE);
int nRowStrat = m_Selection.GetNormalStart_disp().nLine;
int nRowEnd = m_Selection.GetNormalEnd_disp().nLine;
for (int nRow = nRowStrat; nRow <= nRowEnd; nRow++)
{
int nVisFrom = 0;
int nVisTo = INT_MAX;
if (m_Selection.bBlockSelectionMode || nRow == nRowStrat)
nVisFrom = m_Selection.GetNormalStart_disp().nCol;
if (m_Selection.bBlockSelectionMode || nRow == nRowEnd)
nVisTo = m_Selection.GetNormalEnd_disp().nCol;
m_pBuffer->ChangeCase(nRow, nVisFrom, nVisTo, bUpper);
}
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(FALSE);
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(XTP_IDS_EDIT_CASE);
InvalidateRows(nRowStrat, nRowEnd);
Invalidate(FALSE);
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::DoChangeSelectionTabify(BOOL bTabify)
{
if (!IsSelectionExist())
return FALSE;
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(FALSE);
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(TRUE);
int nRowStrat = m_Selection.GetNormalStart_disp().nLine;
int nRowEnd = m_Selection.GetNormalEnd_disp().nLine;
for (int nRow = nRowStrat; nRow <= nRowEnd; nRow++)
{
int nVisFrom = 0;
int nVisTo = INT_MAX;
if (m_Selection.bBlockSelectionMode || nRow == nRowStrat)
nVisFrom = m_Selection.GetNormalStart_disp().nCol;
if (m_Selection.bBlockSelectionMode || nRow == nRowEnd)
nVisTo = m_Selection.GetNormalEnd_disp().nCol;
m_pBuffer->ChangeTabification(nRow, nVisFrom, nVisTo, bTabify);
}
m_pBuffer->GetUndoRedoManager()->SetGroupInsertMode(FALSE);
m_pBuffer->GetUndoRedoManager()->SetLastCommandText(bTabify ? XTP_IDS_EDIT_TABIFY : XTP_IDS_EDIT_UNTABIFY);
InvalidateRows(nRowStrat, nRowEnd);
Invalidate(FALSE);
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::TabifySelection()
{
return DoChangeSelectionTabify(TRUE);
}
BOOL CXTPSyntaxEditCtrl::UnTabifySelection()
{
return DoChangeSelectionTabify(FALSE);
}
BOOL CXTPSyntaxEditCtrl::SetLineNumbers(BOOL bLineNumbers, BOOL bUpdateReg/*=FALSE*/)
{
if (!SetValueBool(XTP_EDIT_REG_LINENUMBERS, bLineNumbers, m_bLineNumbers, bUpdateReg))
return FALSE;
CalculateEditbarLength();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, TRUE);
return TRUE;
}
BOOL CXTPSyntaxEditCtrl::GetLineNumbers() const
{
return m_bLineNumbers;
}
void CXTPSyntaxEditCtrl::CalculateEditbarLength(CDC* pDC)
{
int nPrvEditbarLength = m_nEditbarLength;
// gutter
m_nEditbarLength = GetSelMargin() ? m_nMarginLength : 0;
// line numbers
m_nLineNumLength = 0;
if (GetLineNumbers())
{
int nMaxPageRow = GetRowCount();
if (pDC && pDC->IsPrinting())
nMaxPageRow = GetTopRow() + GetRowPerPage();
int nRowNumLen = (int)log10l(nMaxPageRow) + 1;
CWindowDC dc(NULL);
CXTPFontDC fontDC(&dc, GetPaintManager()->GetFontLineNumber());
TEXTMETRIC tm;
VERIFY(dc.GetTextMetrics(&tm));
m_nLineNumLength = (nRowNumLen + 1) * (tm.tmAveCharWidth) + 2;
m_nEditbarLength += m_nLineNumLength;
}
// collapsible nodes area
if (m_bDrawNodes)
{
m_nEditbarLength += m_nNodesWidth;
}
if (GetSelMargin() || GetLineNumbers() || m_bDrawNodes)
m_nEditbarLength += TEXT_LEFT_OFFSET;
// update window if necessary
if (nPrvEditbarLength != m_nEditbarLength && (!pDC || !pDC->IsPrinting()))
{
CRect rcText;
CalcEditRects(NULL, NULL, NULL, &rcText);
m_DrawTextProcessor.SetTextRect(rcText);
_RecalcScrollBars();
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
Invalidate(FALSE);
}
}
void CXTPSyntaxEditCtrl::AddRemoveBookmark(int nRow)
{
if (GetLineMarksManager())
{
GetLineMarksManager()->AddRemoveLineMark(nRow, xtpEditLMT_Bookmark);
}
RedrawLineMarks();
}
void CXTPSyntaxEditCtrl::AddRemoveBreakPoint(int nRow)
{
if (GetLineMarksManager())
{
GetLineMarksManager()->AddRemoveLineMark(nRow, xtpEditLMT_Breakpoint);
}
RedrawLineMarks();
}
void CXTPSyntaxEditCtrl::CollapseExpandBlock(int nRow)
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (!pMgr)
return;
// nLineEnd: adjust also column, for example when collapsing to the string of lower length
int nLineEnd = m_nCurrentCol; //m_nDispCol;
if (pMgr->HasRowMark(nRow, xtpEditLMT_Collapsed))
{
// try expand
pMgr->DeleteLineMark(nRow, xtpEditLMT_Collapsed);
}
else
{
// try collapse
XTP_EDIT_LMPARAM LMCoParam;
CXTPSyntaxEditRowsBlockArray arCoBlocks;
GetCollapsableBlocksInfo(nRow, arCoBlocks);
int nCount = (int)arCoBlocks.GetSize();
for (int i = 0; i < nCount; i++)
{
XTP_EDIT_ROWSBLOCK coBlk = arCoBlocks[i];
if (coBlk.lcStart.nLine == nRow)
{
XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
if (!pCoDrawBlk)
{
pCoDrawBlk = new XTP_EDIT_COLLAPSEDBLOCK;
if (!pCoDrawBlk)
{
return;
}
LMCoParam.SetPtr(pCoDrawBlk, XTPSECollapsedBlockDeleteFn);
}
pCoDrawBlk->collBlock = coBlk;
pMgr->SetLineMark(nRow, xtpEditLMT_Collapsed, &LMCoParam);
m_arCollapsedTextRows.SetAtGrow(m_nCollapsedTextRowsCount, nRow);
nLineEnd = min(nLineEnd, pCoDrawBlk->collBlock.lcEnd.nCol);
m_nCollapsedTextRowsCount++;
}
}
}
SetCurrentDocumentRow(nRow);
m_nDispCol = nLineEnd + 1;
SetCurCaretPos(nRow, m_nDispCol);
Invalidate(FALSE);
RecalcScrollBars();
}
void CXTPSyntaxEditCtrl::DeleteBookmark(int nRow)
{
if (GetLineMarksManager())
{
GetLineMarksManager()->DeleteLineMark(nRow, xtpEditLMT_Bookmark);
}
}
void CXTPSyntaxEditCtrl::PrevBookmark()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (!pMgr)
{
ASSERT(FALSE);
return;
}
int nRow = GetCurRow();
int nVisRow = GetCurrentVisibleRow();
int nPrevRow = nRow;
do {
pMgr->FindPrevLineMark(--nPrevRow, xtpEditLMT_Bookmark);
} while (nPrevRow > 0 && GetVisibleRow(nPrevRow) == nVisRow);
if (nPrevRow < 0)
{
POSITION posLast = pMgr->GetLastLineMark(xtpEditLMT_Bookmark);
XTP_EDIT_LMDATA* pData = pMgr->GetLineMarkAt(posLast, xtpEditLMT_Bookmark);
nPrevRow = pData ? pData->m_nRow : -1;
}
if (GetVisibleRow(nPrevRow) == nVisRow)
{
nPrevRow = -1;
}
if (nPrevRow >= 0)
{
SetCurPos(nPrevRow, 1);
Invalidate(FALSE);
}
}
void CXTPSyntaxEditCtrl::NextBookmark()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (!pMgr)
{
ASSERT(FALSE);
return;
}
int nRow = GetCurRow();
int nVisRow = GetCurrentVisibleRow();
// move down to the next bookmark after the current collapsed block area
int nNextRow = nRow;
do {
pMgr->FindNextLineMark(++nNextRow, xtpEditLMT_Bookmark);
} while (nNextRow > 0 && GetVisibleRow(nNextRow) == nVisRow);
if (nNextRow < 0)
{
// find first line mark
POSITION posFirst = pMgr->GetFirstLineMark(xtpEditLMT_Bookmark);
XTP_EDIT_LMDATA* pData = pMgr->GetNextLineMark(posFirst, xtpEditLMT_Bookmark);
nNextRow = pData ? pData->m_nRow : -1;
}
if (GetVisibleRow(nNextRow) == nVisRow)
{
nNextRow = -1;
}
if (nNextRow >= 0)
{
SetCurPos(nNextRow, 1);
Invalidate(FALSE);
}
}
BOOL CXTPSyntaxEditCtrl::HasRowMark(int nRow, const XTP_EDIT_LINEMARKTYPE& lmType,
XTP_EDIT_LMPARAM* pParam)
{
if (GetLineMarksManager())
{
return GetLineMarksManager()->HasRowMark(nRow, lmType, pParam);
}
return FALSE;
}
void CXTPSyntaxEditCtrl::DeleteBreakpoint(int nRow)
{
if (GetLineMarksManager())
{
GetLineMarksManager()->DeleteLineMark(nRow, xtpEditLMT_Breakpoint);
}
}
void CXTPSyntaxEditCtrl::RefreshLineMarks(XTP_EDIT_NMHDR_EDITCHANGED* pEditChanged)
{
if (!GetLineMarksManager())
{
ASSERT(FALSE);
return ;
}
int eRefreshType = xtpEditLMRefresh_Unknown;
if (pEditChanged->nAction & XTP_EDIT_EDITACTION_DELETEROW)
{
eRefreshType = xtpEditLMRefresh_Delete;
}
else if (pEditChanged->nAction & XTP_EDIT_EDITACTION_INSERTROW)
{
eRefreshType = xtpEditLMRefresh_Insert;
if (pEditChanged->nAction & XTP_EDIT_EDITACTION_INSERTROW_NEW)
eRefreshType |= xtpEditLMRefresh_InsertAt0;
}
else
{
return;
}
GetLineMarksManager()->RefreshLineMarks(pEditChanged->nRowFrom,
pEditChanged->nRowTo, eRefreshType);
RedrawLineMarks();
}
void CXTPSyntaxEditCtrl::RedrawLineMarks()
{
Invalidate(FALSE);
}
BOOL CXTPSyntaxEditCtrl::HasBookmarks()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (pMgr)
{
int nCount = pMgr->GetCount(xtpEditLMT_Bookmark);
return nCount > 0;
}
return FALSE;
}
BOOL CXTPSyntaxEditCtrl::HasBreakpoints()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (pMgr)
{
int nCount = pMgr->GetCount(xtpEditLMT_Breakpoint);
return nCount > 0;
}
return FALSE;
}
CXTPSyntaxEditLineMarksManager* CXTPSyntaxEditCtrl::GetLineMarksManager()
{
ASSERT(m_pBuffer);
return m_pBuffer ? m_pBuffer->GetLineMarksManager() : NULL;
}
CString CXTPSyntaxEditCtrl::GetModulePath()
{
TCHAR zsFileName[_MAX_PATH];
//DWORD dwRes = ::GetModuleFileName(NULL, zsFileName, _MAX_PATH);
DWORD dwRes = ::GetModuleFileName(AfxGetInstanceHandle(), zsFileName, _MAX_PATH);
ASSERT(dwRes);
CString csFilePath = zsFileName;
int nFLs = csFilePath.ReverseFind(_T('\'));
if (nFLs > 0)
{
csFilePath.ReleaseBuffer(nFLs + 1);
}
return csFilePath;
}
CString CXTPSyntaxEditCtrl::GetDefaultCfgFilePath()
{
return m_strDefaultCfgFilePath;
}
void CXTPSyntaxEditCtrl::RefreshColors()
{
m_arOnScreenSchCache.RemoveAll();
if (!m_pBuffer)
{
ASSERT(FALSE);
return;
}
if (GetSyntaxColor())
{
XTP_EDIT_LINECOL pos1_0 = {1,0};
BOOL bParseInThread = m_pBuffer->GetLexParser()->GetSchemaOptions(
m_pBuffer->GetFileExt() )->m_bFirstParseInSeparateThread;
if (bParseInThread)
{
m_pBuffer->GetLexParser()->StartParseInThread(m_pBuffer, &pos1_0, NULL, 0, TRUE);
}
else
{
CXTPSyntaxEditLexTextSchema* ptrTextSch = m_pBuffer->GetLexParser()->GetTextSchema();
if (ptrTextSch)
{
CXTPSyntaxEditTextIterator txtIter(m_pBuffer);
ptrTextSch->RunParseUpdate(TRUE, &txtIter, &pos1_0, NULL);
}
}
}
else
{
GetLineMarksManager()->RemoveAll(xtpEditLMT_Collapsed);
}
// Load data into AC
SetAutoCompleteList();
Invalidate(FALSE);
}
CString CXTPSyntaxEditCtrl::GetConfigFile()
{
if (!m_pBuffer)
return _T("");
return m_pBuffer->GetConfigFile();
}
BOOL CXTPSyntaxEditCtrl::SetConfigFile(LPCTSTR szPath)
{
m_strDefaultCfgFilePath = szPath;
if (!m_pBuffer || !FILEEXISTS_S(szPath))
{
return FALSE;
}
m_pBuffer->SetConfigFile(szPath);
return TRUE;
}
const CString& CXTPSyntaxEditCtrl::GetCurrentTheme()
{
if (!m_pBuffer || !m_pBuffer->GetLexConfigurationManager() || !GetSyntaxColor())
{
static CString strEmpty;
return strEmpty;
}
return m_pBuffer->GetLexConfigurationManager()->GetCurrentTheme();
}
CStringArray& CXTPSyntaxEditCtrl::GetThemes()
{
if (!m_pBuffer || !m_pBuffer->GetLexConfigurationManager())
{
static CStringArray s_ar;
return s_ar;
}
return m_pBuffer->GetLexConfigurationManager()->GetThemeManager().GetThemes();
}
void CXTPSyntaxEditCtrl::ApplyTheme(CString strTheme)
{
if (!m_pBuffer || !m_pBuffer->GetLexConfigurationManager() || !GetSyntaxColor())
{
return;
}
CXTPSyntaxEditLexTextSchema* ptrTextSch = m_pBuffer->GetLexParser()->GetTextSchema();
m_pBuffer->GetLexConfigurationManager()->SetTheme(strTheme, ptrTextSch);
m_arOnScreenSchCache.RemoveAll();
Invalidate(FALSE);
UpdateWindow();
}
void CXTPSyntaxEditCtrl::OnBeforeEditChanged(int nRow, int nCol)
{
UNREFERENCED_PARAMETER(nRow); UNREFERENCED_PARAMETER(nCol);
if (GetSyntaxColor())
{
m_pBuffer->GetLexParser()->OnBeforeEditChanged();
}
}
void CXTPSyntaxEditCtrl::OnEditChanged(const XTP_EDIT_LINECOL& LCFrom,
const XTP_EDIT_LINECOL& LCTo, int eEditAction)
{
OnEditChanged(LCFrom.nLine, LCFrom.nCol, LCTo.nLine, LCTo.nCol, eEditAction);
}
void CXTPSyntaxEditCtrl::OnEditChanged(int nRowFrom, int nColFrom,
int nRowTo, int nColTo, int eEditAction)
{
InvalidateRows(nRowFrom);
if (GetSyntaxColor())
{
XTP_EDIT_LINECOL posFrom = {nRowFrom, max(0, nColFrom-1) };
XTP_EDIT_LINECOL posTo = {nRowTo, max(0, nColTo-1) };
m_pBuffer->GetLexParser()->OnEditChanged(posFrom, posTo, eEditAction, m_pBuffer);
}
}
BOOL CXTPSyntaxEditCtrl::NotifyParseEvent(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam)
{
// Notify the parent class that position has been changed
XTP_EDIT_NMHDR_PARSEEVENT pe;
// NMHDR codes
pe.nmhdr.code = XTP_EDIT_NM_PARSEEVENT;
pe.nmhdr.hwndFrom = m_hWnd;
pe.nmhdr.idFrom = GetDlgCtrlID();
// notification event code.
pe.code = code;
pe.wParam = wParam;
pe.lParam = lParam;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
return (BOOL)m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)pe.nmhdr.idFrom, (LPARAM)&pe);
}
return FALSE;
}
void CXTPSyntaxEditCtrl::OnParseEvent(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam)
{
NotifyParseEvent(code, wParam, lParam);
//-----------------------------------------------------------------------
int nRSFactor = 3;
int nAveRedrawTime = m_aveRedrawScreenTime.GetAverageValue(333);
int nUpdateTimeOut = max(1000, nAveRedrawTime * nRSFactor);
BOOL bRedraw = FALSE;
BOOL bRedrawTimeOut = TRUE;
if (code == xtpEditOnParserStarted)
{
DWORD dwTime = ::GetTickCount();
m_dwLastRedrawTime = dwTime;
}
else if (code == xtpEditOnTextBlockParsed)
{
CXTPSyntaxEditLexTextBlock* pTBended = (CXTPSyntaxEditLexTextBlock*)wParam;
DWORD dwTime = ::GetTickCount();
bRedrawTimeOut = labs(dwTime - m_dwLastRedrawTime) >= nUpdateTimeOut;
if (bRedrawTimeOut)
{
m_dwLastRedrawTime = dwTime;
}
if (pTBended)
{
int nDispMax = GetRowPerPage() - 1;
int nBottomRow = GetDocumentRow(nDispMax+5);
if (!(pTBended->m_PosStartLC.nLine > nBottomRow ||
pTBended->m_PosEndLC.nLine < m_nTopRow) )
{
bRedraw = TRUE;
}
ClearOnScreenSchCache(pTBended->m_PosStartLC.nLine);
}
}
else if (code == xtpEditOnParserEnded)
{
bRedraw = TRUE;
}
//-----------------------------
if (bRedraw)
{
KillTimer(TIMER_REDRAW_WHEN_PARSE);
if (bRedrawTimeOut)
{
Invalidate(FALSE);
UpdateWindow();
}
else
{
SetTimer(TIMER_REDRAW_WHEN_PARSE, nUpdateTimeOut*5, NULL);
}
}
}
//////////////////////////////////////////////////////////////////////////
// Row / col functions
int CXTPSyntaxEditCtrl::GetTopRow()
{
return m_nTopRow;
}
void CXTPSyntaxEditCtrl::SetTopRow(int nRow)
{
if (nRow < 1)
m_nTopRow = 1;
else if (nRow > GetRowCount())
m_nTopRow = max (1, GetRowCount());
else
m_nTopRow = max (1, nRow);
}
int CXTPSyntaxEditCtrl::GetCurRow() const
{
return GetCurrentDocumentRow();
}
int CXTPSyntaxEditCtrl::GetCurCol()
{
return m_nDispCol;
}
int CXTPSyntaxEditCtrl::GetCurAbsCol()
{
return m_nCurrentCol;
}
void CXTPSyntaxEditCtrl::GoToRow(int iRow, BOOL bSelectRow/* = FALSE*/)
{
CString csLineText = GetLineText(iRow);
m_nCurrentCol = 1;
m_nDispCol = 1;
if (bSelectRow)
{
m_Selection.Reset_disp(iRow, 1);
m_Selection.SetEnd_disp(iRow+1, 1);
SetCurrentDocumentRow(iRow);
Invalidate(FALSE);
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, TRUE, TRUE);
//SetTimer(TIMER_SELECTION_ID, TIMER_SELECTION_TIME, NULL);
}
else
{
SetCurrentDocumentRow(iRow);
SetCurPos(iRow, 1);
}
}
int CXTPSyntaxEditCtrl::GetCurrentVisibleRow()
{
return GetVisibleRow(GetCurrentDocumentRow());
}
int CXTPSyntaxEditCtrl::GetCurrentDocumentRow() const
{
return m_nCurrentDocumentRow;
}
void CXTPSyntaxEditCtrl::SetCurrentDocumentRow(int nRow)
{
if (nRow > GetRowCount())
nRow = GetRowCount();
if (nRow < 1)
nRow = 1;
m_nCurrentDocumentRow = nRow;
}
int CXTPSyntaxEditCtrl::GetDocumentRow(int nVisibleRow)
{
return CalculateDocumentRow(m_nTopRow, nVisibleRow);
}
int CXTPSyntaxEditCtrl::CalculateDocumentRow(int nStartDocumentRow, int nRowDelta)
{
int nDocRow = nStartDocumentRow + nRowDelta - 1;
int nNextCollapsedRow = nStartDocumentRow - 1;
POSITION pos = GetLineMarksManager()->FindNextLineMark(nNextCollapsedRow, xtpEditLMT_Collapsed);
while (pos != NULL)
{
XTP_EDIT_LMDATA* pData = GetLineMarksManager()->GetNextLineMark(pos, xtpEditLMT_Collapsed);
if (pData && pData->m_nRow >= nNextCollapsedRow) // mark should be not within previous collapsed block
{
if (pData->m_nRow >= nDocRow) // finish if mark is greater then row to calculate for
break;
XTP_EDIT_COLLAPSEDBLOCK* pCoDBlk = (XTP_EDIT_COLLAPSEDBLOCK*)pData->m_Param.GetPtr();
if (!pCoDBlk)
continue;
int nHiddenRows = pCoDBlk->collBlock.lcEnd.nLine - pCoDBlk->collBlock.lcStart.nLine;
nDocRow += nHiddenRows;
nNextCollapsedRow = pData->m_nRow + nHiddenRows;
}
}
return nDocRow;
}
int CXTPSyntaxEditCtrl::GetVisibleRow(int nDocumentRow)
{
return CalculateVisibleRow(m_nTopRow, nDocumentRow);
}
int CXTPSyntaxEditCtrl::CalculateVisibleRow(int nStartDocumentRow, int nDocumentRow)
{
int nVisRow = nDocumentRow - nStartDocumentRow + 1;
int nNextCollapsedRow = nStartDocumentRow - 1;
const int nRowCount = GetRowCount();
POSITION pos = GetLineMarksManager()->FindNextLineMark(nNextCollapsedRow, xtpEditLMT_Collapsed);
while (pos != NULL)
{
XTP_EDIT_LMDATA* pData = GetLineMarksManager()->GetNextLineMark(pos, xtpEditLMT_Collapsed);
if (pData && pData->m_nRow >= nNextCollapsedRow) // mark should be not within previous collapsed block
{
if (pData->m_nRow >= nDocumentRow) // finish if mark is greater then row to calculate for
break;
XTP_EDIT_COLLAPSEDBLOCK* pCoDBlk = (XTP_EDIT_COLLAPSEDBLOCK*)pData->m_Param.GetPtr();
if (!pCoDBlk)
continue;
int nHiddenRows = min(nRowCount, pCoDBlk->collBlock.lcEnd.nLine) -
pCoDBlk->collBlock.lcStart.nLine;
nVisRow -= nHiddenRows;
nNextCollapsedRow = pData->m_nRow + nHiddenRows;
}
}
return max(nVisRow, 1);
}
int CXTPSyntaxEditCtrl::MoveCurrentVisibleRowUp(int nCount)
{
int nOldVisRow = GetCurrentVisibleRow();
int nOldDocRow = GetCurrentDocumentRow();
int nNewVisRow = nOldVisRow - nCount;
// do not shift a window up
if (nNewVisRow > 0)
{
SetCurrentDocumentRow(GetDocumentRow(nNewVisRow));
return nNewVisRow;
}
// find global visible row index
int nVisRow = CalculateVisibleRow(1, nOldDocRow);
int nTargetDocRow = CalculateDocumentRow(1, max(nVisRow - nCount, 1));
int nDocDiff = nOldDocRow - nTargetDocRow;
nDocDiff = min(nDocDiff, m_nTopRow - 1);
nOldDocRow -= nDocDiff;
m_nCurrentDocumentRow -= nDocDiff;
m_nTopRow -= nDocDiff;
nNewVisRow = nOldVisRow - nDocDiff + GetRowPerPage();
return GetCurrentVisibleRow();
}
int CXTPSyntaxEditCtrl::MoveCurrentVisibleRowDown(int nCount)
{
int nOldRow = GetCurrentVisibleRow();
int nNewDocRow = min(GetDocumentRow(nOldRow + nCount), GetRowCount());
SetCurrentDocumentRow(nNewDocRow);
int nMaxVisRow = GetRowPerPage();
int nMaxDocRow = GetDocumentRow(nMaxVisRow);
if (nNewDocRow > nMaxDocRow)
{
m_nTopRow = max (1, GetDocumentRow(nCount + 1));
}
return GetCurrentVisibleRow();
}
int CXTPSyntaxEditCtrl::GetRowPerPage()
{
return m_DrawTextProcessor.GetRowsCount(FALSE);
}
int CXTPSyntaxEditCtrl::GetVisibleRowsCount(int nMaxDocRow)
{
if (nMaxDocRow < 0)
nMaxDocRow = GetRowCount();
int nVisRow = nMaxDocRow;
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (pMgr)
{
int nNextCollapsedRow = -1;
POSITION pos = pMgr->GetFirstLineMark(xtpEditLMT_Collapsed);
while (pos != NULL)
{
XTP_EDIT_LMDATA* pData = pMgr->GetNextLineMark(pos, xtpEditLMT_Collapsed);
if (pData && pData->m_nRow >= nNextCollapsedRow) // mark should be not within previous collapsed block
{
if (pData->m_nRow >= nMaxDocRow) // finish if mark is greater then row to calculate for
break;
XTP_EDIT_COLLAPSEDBLOCK* pCoDBlk = (XTP_EDIT_COLLAPSEDBLOCK*)pData->m_Param.GetPtr();
if (!pCoDBlk)
continue;
int nHiddenRows = pCoDBlk->collBlock.lcEnd.nLine - pCoDBlk->collBlock.lcStart.nLine;
nVisRow -= nHiddenRows;
nNextCollapsedRow = pData->m_nRow + nHiddenRows;
}
}
}
return nVisRow;
}
BOOL CXTPSyntaxEditCtrl::ShiftCurrentVisibleRowUp(int nCount, BOOL bChangeCaret)
{
BOOL bChanged = FALSE;
if (m_nTopRow > 1)
{
int nOldTopRow = m_nTopRow;
int nDocRow = GetCurrentDocumentRow(); // store old document row
SetCurrentDocumentRow(GetDocumentRow(1)); // move to first visible row
MoveCurrentVisibleRowUp(nCount); // move nCount row up
// move to old document row
int nBottomDocRow = GetDocumentRow(GetRowPerPage());
if (bChangeCaret)
nDocRow = min(nDocRow, nBottomDocRow);
SetCurrentDocumentRow(nDocRow);
if (nDocRow > nBottomDocRow)
CWnd::HideCaret();
if (nOldTopRow != m_nTopRow)
bChanged = TRUE;
}
return bChanged;
}
BOOL CXTPSyntaxEditCtrl::ShiftCurrentVisibleRowDown(int nCount, BOOL bChangeCaret)
{
BOOL bChanged = FALSE;
if (m_nTopRow < GetRowCount())
{
int nOldTopRow = m_nTopRow;
int nDocRow = GetCurrentDocumentRow();
int nLastVisRow = GetRowPerPage();
SetCurrentDocumentRow(GetDocumentRow(nLastVisRow));
MoveCurrentVisibleRowDown(nCount);
int nTopDocRow = GetDocumentRow(1);
if (bChangeCaret)
nDocRow = max(nDocRow, nTopDocRow);
SetCurrentDocumentRow(nDocRow);
if (nDocRow < nTopDocRow)
CWnd::HideCaret();
if (nOldTopRow != m_nTopRow)
bChanged = TRUE;
}
return bChanged;
}
BOOL CXTPSyntaxEditCtrl::GetCollapsedBlockLen(int nStartRow, int& rnLen)
{
rnLen = 0;
XTP_EDIT_LMPARAM LMCoParam;
BOOL bIsCollapsed = HasRowMark(nStartRow, xtpEditLMT_Collapsed, &LMCoParam);
if (!bIsCollapsed)
{
return FALSE;
}
XTP_EDIT_COLLAPSEDBLOCK* pCoDBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
if (!pCoDBlk)
{
ASSERT(FALSE);
return FALSE;
}
rnLen = pCoDBlk->collBlock.lcEnd.nLine - pCoDBlk->collBlock.lcStart.nLine;
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// Line text internal functions
const CString& CXTPSyntaxEditCtrl::GetLineText(int nRow, BOOL bAddCRLF, int iCRLFStyle)
{
GetLineText(nRow, m_strTmpLineTextBuff, bAddCRLF, iCRLFStyle);
return m_strTmpLineTextBuff;
}
void CXTPSyntaxEditCtrl::GetLineText(int nRow, CString& strBuffer, BOOL bAddCRLF, int iCRLFStyle)
{
m_pBuffer->GetLineText(nRow, strBuffer, bAddCRLF, iCRLFStyle);
XTP_EDIT_LMPARAM LMCoParam;
BOOL bIsCollapsed = HasRowMark(nRow, xtpEditLMT_Collapsed, &LMCoParam);
if (bIsCollapsed)
{
XTP_EDIT_COLLAPSEDBLOCK* pCoDBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
if (!pCoDBlk)
{
ASSERT(FALSE);
return;
}
if (strBuffer.GetLength() > pCoDBlk->collBlock.lcStart.nCol)
{
strBuffer.SetAt(pCoDBlk->collBlock.lcStart.nCol, 0);
}
}
}
void CXTPSyntaxEditCtrl::SetAutoCompleteList()
{
CXTPSyntaxEditLexTokensDefArray arTokens;
m_pBuffer->GetLexParser()->GetTokensForAutoCompleate(arTokens, FALSE);
CXTPSyntaxEditACDataArray arrData;
CXTPSyntaxEditLexTokensDef TokenDef;
int nTokensDef = (int)arTokens.GetSize();
if (!nTokensDef)
return;
for (int nTokenDef = 0; nTokenDef < nTokensDef; nTokenDef++)
{
TokenDef = (arTokens.GetAt(nTokenDef));
int nTags = (int)TokenDef.m_arTokens.GetSize();
for (int nTag = 0; nTag < nTags; nTag++)
{
arrData.Add(new XTP_EDIT_ACDATA(0, TokenDef.m_arTokens.GetAt(nTag)));
}
int nDelims = (int)TokenDef.m_arStartSeps.GetSize();
int nDelim;
for (nDelim = 0; nDelim < nDelims; nDelim++)
{
if (m_pAutoComplete->m_strDelims.Find(TokenDef.m_arStartSeps.GetAt(nDelim)) < 0)
m_pAutoComplete->m_strDelims += TokenDef.m_arStartSeps.GetAt(nDelim);
}
nDelims = (int)TokenDef.m_arEndSeps.GetSize();
for (nDelim = 0; nDelim < nDelims; nDelim++)
{
if (m_pAutoComplete->m_strDelims.Find(TokenDef.m_arEndSeps.GetAt(nDelim)) < 0)
m_pAutoComplete->m_strDelims += TokenDef.m_arEndSeps.GetAt(nDelim);
}
}
m_pAutoComplete->SetList(arrData);
}
BOOL CXTPSyntaxEditCtrl::PreTranslateMessage(MSG* pMsg)
{
if (m_pAutoComplete->IsActive())
{
switch (pMsg->message)
{
case WM_KEYDOWN:
case WM_KEYUP:
case WM_CHAR:
case WM_DEADCHAR:
{
m_pAutoComplete->SendMessage(
pMsg->message, pMsg->wParam, pMsg->lParam);
}
break;
}
if (pMsg->message == WM_KEYDOWN)
{
switch (pMsg->wParam)
{
case VK_SPACE:
case VK_PRIOR:
case VK_NEXT:
case VK_END:
case VK_HOME:
case VK_LEFT:
case VK_UP:
case VK_RIGHT:
case VK_DOWN:
case VK_SELECT:
case VK_PRINT:
case VK_EXECUTE:
case VK_SNAPSHOT:
case VK_INSERT:
case VK_DELETE:
case VK_HELP:
case VK_RETURN:
{
return TRUE;
}
}
}
}
else if (m_bEnableEditAccelerators &&
(pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN))
{
BOOL bAltKey = (::GetKeyState(VK_MENU) & KF_UP) != 0;
BOOL bCtrlKey = (::GetKeyState(VK_CONTROL) & KF_UP) != 0;
BOOL bShiftKey = (::GetKeyState(VK_SHIFT) & KF_UP) != 0;
BOOL bAlt = bAltKey && !bCtrlKey && !bShiftKey;
BOOL bCtrl = bCtrlKey && !bAltKey && !bShiftKey;
BOOL bShift = bShiftKey && !bAltKey && !bCtrlKey;
BOOL bCtrlShift = bCtrlKey && bShiftKey && !bAltKey;
BOOL bProcessed = TRUE;
if (bCtrlKey && pMsg->wParam == (BYTE)'X')
{
if (IsSelectionExist() && CanEditDoc())
Cut();
}
else if (bCtrl && pMsg->wParam == (BYTE)'C' ||
bCtrl && pMsg->wParam == VK_INSERT)
{
if (IsSelectionExist())
Copy();
}
else if (bCtrl && pMsg->wParam == (BYTE)'V' ||
bShift && pMsg->wParam == VK_INSERT)
{
if (CanEditDoc())
Paste();
}
else if (bAlt && pMsg->wParam == VK_BACK ||
bCtrl && pMsg->wParam == (BYTE)'Z')
{
if (CanUndo())
Undo();
}
else if (bCtrl && pMsg->wParam == (BYTE)'Y' ||
bCtrlShift && pMsg->wParam == (BYTE)'Z')
{
if (CanRedo())
Redo();
}
else if (bCtrl && pMsg->wParam == (BYTE)'A')
{
SelectAll();
}
else
{
bProcessed = FALSE;
}
if (bProcessed)
return TRUE;
}
return CWnd::PreTranslateMessage(pMsg);
}
BOOL CXTPSyntaxEditCtrl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
if (m_pAutoComplete->IsActive())
{
return (BOOL)m_pAutoComplete->SendMessage(WM_MOUSEWHEEL,
MAKEWPARAM(nFlags, zDelta), MAKELPARAM(pt.x, pt.y));
//CXTPWindowRect rcWndAC(&m_wndAutoComplete);
//if (rcWndAC.PtInRect(pt))
// return (BOOL)m_pAutoComplete->SendMessage(WM_MOUSEWHEEL, MAKEWPARAM(nFlags, zDelta), MAKELPARAM(pt.x, pt.y));
//else
// m_pAutoComplete->Hide();
}
m_pToolTip->Hide();
if (zDelta < 0)
Scroll(0, m_nWheelScroll);
else
Scroll(0, -m_nWheelScroll);
return CWnd::OnMouseWheel(nFlags, zDelta, pt);
}
void CXTPSyntaxEditCtrl::CollapseAll()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (!pMgr)
return;
CWaitCursor _WC;
CXTPSyntaxEditRowsBlockArray arCoBlocks;
GetCollapsableBlocksInfo(-1, arCoBlocks);
for (int nRow = 0; nRow < GetRowCount(); nRow++)
{
XTP_EDIT_LMPARAM LMCoParam;
int toRemove = -1;
int nCount = (int)arCoBlocks.GetSize();
for (int i = 0; i < nCount; i++)
{
XTP_EDIT_ROWSBLOCK coBlk = arCoBlocks[i];
if (coBlk.lcStart.nLine == nRow)
{
XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
if (!pCoDrawBlk)
{
pCoDrawBlk = new XTP_EDIT_COLLAPSEDBLOCK;
if (!pCoDrawBlk)
{
return;
}
LMCoParam.SetPtr(pCoDrawBlk, XTPSECollapsedBlockDeleteFn);
}
pCoDrawBlk->collBlock = coBlk;
pMgr->SetLineMark(nRow, xtpEditLMT_Collapsed, &LMCoParam);
m_arCollapsedTextRows.SetAtGrow(m_nCollapsedTextRowsCount, nRow);
m_nCollapsedTextRowsCount++;
if (toRemove < 0)
toRemove = i;
}
}
if (toRemove >= 0)
arCoBlocks.RemoveAt(0, toRemove+1);
}
// refresh picture
SetCurCaretPos(GetCurrentDocumentRow(), 1);
UpdateWindow();
RecalcScrollBars();
UpdateScrollPos();
}
void CXTPSyntaxEditCtrl::ExpandAll()
{
CXTPSyntaxEditLineMarksManager* pMgr = GetLineMarksManager();
if (!pMgr)
return;
CWaitCursor _WC;
pMgr->RemoveAll(xtpEditLMT_Collapsed);
// refresh picture
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol);
UpdateWindow();
RecalcScrollBars();
UpdateScrollPos();
}
void CXTPSyntaxEditCtrl::GetRowColors(int nTextRow, int nColFrom, int nColTo,
const XTP_EDIT_COLORVALUES& clrDefault,
CXTPSyntaxEditTextBlockList* rBlocks)
{
if (!GetSyntaxColor())
return;
CXTPSyntaxEditLexTextSchema* ptrTxtSch = m_pBuffer->GetLexParser()->GetTextSchema();
if (ptrTxtSch)
{
CXTPSyntaxEditLexTextBlock* pScreenSchFirstTB = GetOnScreenSch(nTextRow);
//CXTPSyntaxEditLexTextBlock* pScreenSchFirstTB = ptrTxtSch->GetBlocks();
if (pScreenSchFirstTB)
{
CXTPSyntaxEditTextIterator txtIter(GetEditBuffer());
ptrTxtSch->GetRowColors(&txtIter, nTextRow, nColFrom, nColTo,
clrDefault, rBlocks, NULL, pScreenSchFirstTB);
}
}
}
void CXTPSyntaxEditCtrl::GetCollapsableBlocksInfo(int nTextRow,
CXTPSyntaxEditRowsBlockArray& rarCoBlocks)
{
rarCoBlocks.RemoveAll();
if (GetSyntaxColor())
{
CXTPSyntaxEditLexTextSchema* ptrTxtSch = m_pBuffer->GetLexParser()->GetTextSchema();
if (ptrTxtSch)
ptrTxtSch->GetCollapsableBlocksInfo(nTextRow, rarCoBlocks, &m_fcCollapsable.ptrTBStart);
}
}
CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditCtrl::GetOnScreenSch(int nForRow)
{
int nLifeTime = m_pBuffer->GetLexParser()->GetSchemaOptions(
m_pBuffer->GetFileExt())->m_dwOnScreenSchCacheLifeTime_sec;
m_arOnScreenSchCache.RemoveOld(nLifeTime);
//========================================================================
int nCount = (int)m_arOnScreenSchCache.GetSize();
int i;
for (i = 0; i < nCount; i++)
{
CScreenSearchBlock& rSchBlk = m_arOnScreenSchCache[i];
if (nForRow >= rSchBlk.nRowStart && nForRow <= rSchBlk.nRowEnd)
{
rSchBlk.dwLastAccessTime = ::GetTickCount();
return rSchBlk.ptrTBFirst;
}
}
//---------------------------------------------------------------------------
CXTPSyntaxEditLexTextSchema* ptrTxtSch = m_pBuffer->GetLexParser()->GetTextSchema();
if (ptrTxtSch)
{
int nRowPerPage = GetRowPerPage()+1;
CScreenSearchBlock schBlkNew;
schBlkNew.nRowStart = nForRow;
schBlkNew.nRowEnd = nForRow + nRowPerPage;
//--------------------------------------------------------------------
int nRowStartMin = 1;
// 1. search next on screen region
nCount = (int)m_arOnScreenSchCache.GetSize();
for (i = 0; i < nCount; i++)
{
const CScreenSearchBlock& rSchBlk = m_arOnScreenSchCache[i];
if (rSchBlk.nRowStart > schBlkNew.nRowStart && rSchBlk.nRowStart <= schBlkNew.nRowEnd)
{
schBlkNew.nRowEnd = rSchBlk.nRowStart-1;
}
if (rSchBlk.nRowEnd+1 > nRowStartMin && rSchBlk.nRowEnd+1 < nForRow)
{
nRowStartMin = rSchBlk.nRowEnd+1;
}
}
//--------------------------------------------------------------------
// 2. search next collapsed block start
for (i = 0; i < m_nCollapsedTextRowsCount; i++)
{
int nCoStartRow = m_arCollapsedTextRows[i];
if (nCoStartRow >= schBlkNew.nRowStart && nCoStartRow < schBlkNew.nRowEnd)
{
schBlkNew.nRowEnd = nCoStartRow;
}
}
//===========================
if (schBlkNew.nRowEnd - schBlkNew.nRowStart < nRowPerPage/2)
{
schBlkNew.nRowStart = max(schBlkNew.nRowStart-nRowPerPage, nRowStartMin);
}
//--------------------------------------------------------------------
CXTPSyntaxEditTextIterator txtIter(m_pBuffer);
BOOL bParseRes = ptrTxtSch->RunParseOnScreen(&txtIter, schBlkNew.nRowStart,
schBlkNew.nRowEnd, schBlkNew.ptrTBFirst);
if (bParseRes)
{
schBlkNew.dwLastAccessTime = ::GetTickCount();
m_arOnScreenSchCache.Add(schBlkNew);
return schBlkNew.ptrTBFirst;
}
}
return NULL;
}
void CXTPSyntaxEditCtrl::InvalidateRows(int nRowFrom, int nRowTo)
{
int nCountVDR = (int)m_arValidDispRows.GetSize();
//-* Invalidate ALL ------------------------------------------------------
if (nRowFrom < 0 && nRowTo < 0)
{
m_arOnScreenSchCache.RemoveAll();
for (int i = 0; i < nCountVDR; i++) {
m_arValidDispRows.SetAtGrow(i, 0);
}
return ;
}
//-* Invalidate Part -----------------------------------------------------
int nRow1 = nRowFrom;
int nRow2 = nRowTo;
if (nRow1 < 0)
{
nRow1 = m_nTopRow;
}
if (nRow2 < nRow1)
{
nRow2 = GetDocumentRow(GetRowPerPage());
}
int nDispRow1= CalculateVisibleRow(m_nTopRow, nRow1);
int nDispRow2 = CalculateVisibleRow(m_nTopRow, nRow2);
int nI1 = max(min(nDispRow1,1000), 0);
int nI2 = max(min(nDispRow2,1000), nCountVDR-1);
for (int i = nI1; i <= nI2; i++)
{
m_arValidDispRows.SetAtGrow(i, 0);
}
//===========================================================================
ClearOnScreenSchCache(nRowFrom);
}
void CXTPSyntaxEditCtrl::ClearOnScreenSchCache(int nRowFrom)
{
//-* clear ALL ------------------------------------------------------
if (nRowFrom < 0)
{
m_arOnScreenSchCache.RemoveAll();
return ;
}
//===========================================================================
int nCountSSC = (int)m_arOnScreenSchCache.GetSize();
for (int i = nCountSSC-1; i >= 0; i--)
{
CScreenSearchBlock& rSchBlk = m_arOnScreenSchCache[i];
BOOL bRemove = FALSE;
if (nRowFrom >= rSchBlk.nRowStart && nRowFrom <= rSchBlk.nRowEnd)
{
rSchBlk.nRowEnd = nRowFrom-1;
bRemove = !(rSchBlk.nRowStart <= rSchBlk.nRowEnd);
}
else if (nRowFrom < rSchBlk.nRowStart)
{
bRemove = TRUE;
}
//-------------------------------------
if (bRemove)
{
m_arOnScreenSchCache.RemoveAt(i);
}
else
{
ASSERT(m_arOnScreenSchCache[i].nRowStart == rSchBlk.nRowStart);
ASSERT(m_arOnScreenSchCache[i].nRowEnd == rSchBlk.nRowEnd);
}
}
}
void CXTPSyntaxEditCtrl::SetRowValid(int nDispRow)
{
ASSERT(nDispRow < 1000);
m_arValidDispRows.SetAtGrow(nDispRow, 1);
}
BOOL CXTPSyntaxEditCtrl::IsRowValid(int nDispRow)
{
int nCount = (int)m_arValidDispRows.GetSize();
if (nDispRow > 0 && nDispRow < nCount)
{
int nValid = m_arValidDispRows[nDispRow];
return (nValid != 0);
}
return FALSE;
}
const CStringList& CXTPSyntaxEditCtrl::GetUndoTextList()
{
return m_pBuffer->GetUndoRedoManager()->GetUndoTextList();
}
const CStringList& CXTPSyntaxEditCtrl::GetRedoTextList()
{
return m_pBuffer->GetUndoRedoManager()->GetRedoTextList();
}
void CXTPSyntaxEditCtrl::OnLexCfgWasChanged(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(wParam); UNREFERENCED_PARAMETER(lParam);
if (code == xtpEditAllConfigWasChanged ||
code == xtpEditClassSchWasChanged ||
code == xtpEditThemeWasChanged)
{
m_arOnScreenSchCache.RemoveAll();
Invalidate(FALSE);
}
else
{
ASSERT(FALSE);
}
}
BOOL CXTPSyntaxEditCtrl::GetRowNodes(int nRow, DWORD& dwType)
{
dwType = XTP_EDIT_ROWNODE_NOTHING;
// retrieve row nodes
CXTPSyntaxEditRowsBlockArray arCoBlocks;
GetCollapsableBlocksInfo(nRow, arCoBlocks);
int nCount = (int)arCoBlocks.GetSize();
for (int i = 0; i < nCount; i++)
{
XTP_EDIT_ROWSBLOCK coBlk = arCoBlocks[i];
if (coBlk.lcStart.nLine == nRow)
{
if (HasRowMark(coBlk.lcStart.nLine, xtpEditLMT_Collapsed))
{
dwType |= XTP_EDIT_ROWNODE_COLLAPSED;
}
else
{
dwType |= XTP_EDIT_ROWNODE_EXPANDED;
}
}
if (coBlk.lcEnd.nLine == nRow)
{
dwType |= XTP_EDIT_ROWNODE_ENDMARK;
}
if (coBlk.lcStart.nLine < nRow)
{
dwType |= XTP_EDIT_ROWNODE_NODEUP;
}
if (coBlk.lcEnd.nLine > nRow && (dwType & XTP_EDIT_ROWNODE_COLLAPSED))
{
dwType |= XTP_EDIT_ROWNODE_NODEDOWN;
}
}
return (dwType != XTP_EDIT_ROWNODE_NOTHING);
}
BOOL CXTPSyntaxEditCtrl::NotifyMarginLBtnClick(int nRow, int nDispRow)
{
// Notify the parent class that position has been changed
XTP_EDIT_NMHDR_MARGINCLICKED somc;
// NMHDR codes
somc.nmhdr.code = XTP_EDIT_NM_MARGINCLICKED;
somc.nmhdr.hwndFrom = m_hWnd;
somc.nmhdr.idFrom = GetDlgCtrlID();
// Row col specific codes
somc.nRow = nRow;
somc.nDispRow = nDispRow;
// Notify the parent window
if (::IsWindow(m_pParentWnd->GetSafeHwnd()))
{
return (BOOL)m_pParentWnd->SendMessage(
WM_NOTIFY, (WPARAM)somc.nmhdr.idFrom, (LPARAM)&somc);
}
return FALSE;
}
UINT CXTPSyntaxEditCtrl::CalcAveDataSize(int nRowStart, int nRowEnd)
{
UINT uSize = m_nAverageLineLen * abs(nRowStart - nRowEnd);
uSize = (uSize / 1024 + 1) * 1024;
return uSize;
}
BOOL CXTPSyntaxEditCtrl::GetWideCaret() const
{
return m_bWideCaret && m_pBuffer && m_pBuffer->GetOverwriteFlag();
}
BOOL CXTPSyntaxEditCtrl::SetWideCaret(BOOL bWideCaret, BOOL bUpdateReg/*=FALSE*/)
{
if (m_bWideCaret != bWideCaret)
{
if (!SetValueBool(XTP_EDIT_REG_WIDECARET, bWideCaret, m_bWideCaret, bUpdateReg))
return FALSE;
SetCurCaretPos(GetCurrentDocumentRow(), m_nDispCol, FALSE, FALSE);
}
return TRUE;
}
void CXTPSyntaxEditCtrl::SetPaintManager(CXTPSyntaxEditPaintManager* pPaintManager)
{
ASSERT(pPaintManager);
if (pPaintManager)
{
CMDTARGET_RELEASE(m_pPaintManeger);
m_pPaintManeger = pPaintManager;
}
}
//===========================================================================
// CXTPSyntaxEditCtrl::CTextSearchCache
//===========================================================================
CXTPSyntaxEditCtrl::CTextSearchCache::CTextSearchCache()
{
nForTopRow = 0;
}
void CXTPSyntaxEditCtrl::CTextSearchCache::Update(int nCurrTopRow)
{
if (nCurrTopRow != nForTopRow)
{
ptrTBStart = NULL;
nForTopRow = nCurrTopRow;
}
}
//===========================================================================
// CXTPSyntaxEditCtrl::CScreenSearchBlock
//===========================================================================
CXTPSyntaxEditCtrl::CScreenSearchBlock::CScreenSearchBlock()
{
nRowStart = nRowEnd = 0;
dwLastAccessTime = 0;
}
CXTPSyntaxEditCtrl::CScreenSearchBlock::CScreenSearchBlock(const CScreenSearchBlock& rSrc)
{
nRowStart = rSrc.nRowStart;
nRowEnd = rSrc.nRowEnd;
ptrTBFirst = rSrc.ptrTBFirst;
dwLastAccessTime = rSrc.dwLastAccessTime;
}
CXTPSyntaxEditCtrl::CScreenSearchBlock::~CScreenSearchBlock()
{
}
//===========================================================================
// CXTPSyntaxEditCtrl::CScreenSearchCache
//===========================================================================
CXTPSyntaxEditCtrl::CScreenSearchCache::CScreenSearchCache()
{
m_dwLastRemoveOldTime = 0;
}
CXTPSyntaxEditCtrl::CScreenSearchCache::~CScreenSearchCache()
{
RemoveAll();
}
void CXTPSyntaxEditCtrl::CScreenSearchCache::RemoveAll()
{
for (int i = 0; i < (int)GetSize(); i++)
{
CScreenSearchBlock& rSchBlk = ElementAt(i);
CXTPSyntaxEditLexTextSchema::Close(rSchBlk.ptrTBFirst);
}
Base::RemoveAll();
}
void CXTPSyntaxEditCtrl::CScreenSearchCache::RemoveAt(int nIndex)
{
CScreenSearchBlock& rSchBlk = ElementAt(nIndex);
CXTPSyntaxEditLexTextSchema::Close(rSchBlk.ptrTBFirst);
Base::RemoveAt(nIndex);
}
void CXTPSyntaxEditCtrl::CScreenSearchCache::RemoveOld(int nTimeOut_sec)
{
int nTimeOut_ms = nTimeOut_sec * 1000;
DWORD dwTime = ::GetTickCount();
int cnCheckTimeOut_ms = min(nTimeOut_sec, 10*1000);
if (nTimeOut_sec == 0 || nTimeOut_sec == -1 ||
labs(dwTime - m_dwLastRemoveOldTime) < cnCheckTimeOut_ms)
{
return;
}
//================================================================
m_dwLastRemoveOldTime = dwTime;
for (int i = (int)GetSize() - 1; i >= 0; i--)
{
CScreenSearchBlock& rSchBlk = ElementAt(i);
if (labs(dwTime - rSchBlk.dwLastAccessTime) >= nTimeOut_ms)
{
CXTPSyntaxEditLexTextSchema::Close(rSchBlk.ptrTBFirst);
Base::RemoveAt(i);
}
}
}
//===========================================================================
// CXTPSyntaxEditCtrl::CAverageVal
//===========================================================================
CXTPSyntaxEditCtrl::CAverageVal::CAverageVal(int nDataSize/* = 100*/)
{
m_nDataSize = max(1, nDataSize);
m_nNextIndex = 0;
}
void CXTPSyntaxEditCtrl::CAverageVal::AddValue(UINT uVal)
{
m_arData.SetAtGrow(m_nNextIndex, uVal);
m_nNextIndex = (m_nNextIndex+1) % m_nDataSize;
}
UINT CXTPSyntaxEditCtrl::CAverageVal::GetAverageValue(UINT uDefaultIfNoData/* = 0*/)
{
int nCount = (int)m_arData.GetSize();
if (nCount <= 0)
{
return uDefaultIfNoData;
}
UINT uSumm = 0;
for (int i = 0; i < nCount; i++) {
uSumm += m_arData[i];
}
UINT uAveVal = uSumm / nCount;
return uAveVal;
}
int CXTPSyntaxEditCtrl::GetRowCount() const
{
return m_pBuffer ? m_pBuffer->GetRowCount() : 0;
}
CXTPSyntaxEditConfigurationManager* CXTPSyntaxEditCtrl::GetLexConfigurationManager() const
{
return m_pBuffer? m_pBuffer->GetLexConfigurationManager(): NULL;
}