// XTPSyntaxEditCtrl.h : header file
//
// This file is a part of the XTREME TOOLKIT PRO MFC class library.
// (c)1998-2012 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME SYNTAX EDIT LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////
//{{AFX_CODEJOCK_PRIVATE
#if !defined(__XTPSYNTAXEDITSYNTAXEDITCTRL_H__)
#define __XTPSYNTAXEDITSYNTAXEDITCTRL_H__
//}}AFX_CODEJOCK_PRIVATE
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
//{{AFX_CODEJOCK_PRIVATE
typedef CMap<int, int, COLORREF, COLORREF> CXTPSyntaxEditRowColorMap;
//}}AFX_CODEJOCK_PRIVATE
// forwards
class CXTPNotifySink;
class CXTPSyntaxEditBufferManager;
class CXTPSyntaxEditConfigurationManager;
class CXTPSyntaxEditToolTipCtrl;
class CXTPSyntaxEditAutoCompleteWnd;
class CXTPSyntaxEditLineMarksManager;
class CXTPSyntaxEditDrawTextProcessor;
class CXTPSyntaxEditSelection;
typedef CList<XTP_EDIT_TEXTBLOCK, XTP_EDIT_TEXTBLOCK> CXTPSyntaxEditTextBlockList;
typedef LPCTSTR XTP_EDIT_LINEMARKTYPE;
struct XTP_EDIT_LMPARAM;
//===========================================================================
// Shared Options of SyntaxEdit.
class CXTPSyntaxEditOptions : public CCmdTarget
{
public:
CXTPSyntaxEditOptions();
protected:
BOOL m_bSyntaxColor; // Enables or disables syntax colorization
BOOL m_bAutoIndent; // Auto indentation is enabled or not
BOOL m_bSelMargin; // TRUE if selection margin is to be enabled or not
BOOL m_bLineNumbers; // TRUE if line number is to be printed
BOOL m_bWideCaret; // Stored Overwrite Caret Style: Thin or Thick.
BOOL m_bTabWithSpace; // Store tabulation width.
BOOL m_bVirtualSpace; // TRUE if virtual space is enabled (cursor can be paced in any place after line end).
BOOL m_bDrawNodes; // TRUE if Collapsible nodes signs are to be printed
BOOL m_bEnableWhiteSpace; // Show white space
BOOL m_bReadOnly; // Store ReadOnly mode.
BOOL m_bViewOnly; // Store ViewOnly mode (as ViewOnly but with normal background.
BOOL m_bHideCaret; // Store is caret visible.
BOOL m_bEnableEditAccelerators; // Enable/disable accelerators for Cut, Copy, Paste, Undo, Redoo and Select All operations.
CXTPSyntaxEditRowColorMap m_mapRowBkColor; // The map for row back colors
CXTPSyntaxEditRowColorMap m_mapRowForeColor; // The map for row colors
friend class CXTPSyntaxEditCtrl;
};
//===========================================================================
// Summary: This class is the main CWnd - based editor class. It is a rectangular
// child window in which the user can enter and edit text.
//
// The control is also capable of enhance text coloring for a number
// of specific input file types, e.c. C/C++ source files, HTML files, etc.
// User can create and customize his own text files schemes - they are
// independent of source files.
// The control contains the main configuration file, which can contain
// references to any specific configuration files. By default, this
// file is placed in the same folder as the application executable and
// is called <i>EditControl.ini</i>.
// The main configuration file contains 2 blocks with references to
// input file lexicographic schemes in the specific format (see below)
// and color themes for the editor, which could be applied to the
// control editing any file type. The format of the main configuration
// file is the following:
//<code>
//[Schemas]
//FileType1=SchemaFileName1.schclass
//FileType2=SchemaFileName2.schclass
//...
//
//[Themes]
//ThemeName1=ThemeFileName1.ini
//ThemeName2=ThemeFileName2.ini
//...
//</code>
//
//===========================================================================
class _XTP_EXT_CLASS CXTPSyntaxEditCtrl : public CWnd
{
DECLARE_DYNAMIC(CXTPSyntaxEditCtrl)
friend class CXTPSyntaxEditAutoCompleteWnd;
friend class CXTPSyntaxEditView;
friend class CXTPSyntaxEditCommand;
friend class CXTPSyntaxEditPaintManager;
friend class CXTPSyntaxEditSelection;
friend class CSyntaxEditCtrl; // for AciveX implementation
friend class CSyntaxEditBaseCtrl;
class CImmWrapper;
public:
//-----------------------------------------------------------------------
// Summary:
// Default object constructor.
//-----------------------------------------------------------------------
CXTPSyntaxEditCtrl();
//-----------------------------------------------------------------------
// Summary:
// Destroys a CXTPSyntaxEditCtrl object, handles cleanup and de- allocation
//-----------------------------------------------------------------------
virtual ~CXTPSyntaxEditCtrl();
public:
//-----------------------------------------------------------------------
// Summary:
// Determines if line numbering is enabled or not.
// Returns:
// TRUE if line numbering is enabled, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetLineNumbers() const;
//-----------------------------------------------------------------------
// Summary:
// Enables or disables line numbering.
// Parameters:
// bLineNumbers : [in] Pass TRUE to enable line numbering.
// bUpdateReg : [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
//-----------------------------------------------------------------------
BOOL SetLineNumbers(BOOL bLineNumbers, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Determines if Collapsible Nodes is enabled or not.
// Returns:
// TRUE if Collapsible Nodes area is enabled, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetCollapsibleNodes() const;
//-----------------------------------------------------------------------
// Summary:
// Enables or disables Collapsible Nodes area.
// Parameters:
// bDrawNodes : [in] Pass TRUE to show Collapsible Nodes area.
// bUpdateReg : [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
//-----------------------------------------------------------------------
void SetCollapsibleNodes(BOOL bDrawNodes, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Replaces all the tabs with blank spaces.
// Returns:
// TRUE if Untabify done successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL UnTabifySelection();
//-----------------------------------------------------------------------
// Summary:
// Replaces all the blank spaces with tabs.
// Returns:
// TRUE if Tabify done successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL TabifySelection();
//-----------------------------------------------------------------------
// Summary:
// Turns selected text to the lowercase.
// Returns:
// TRUE if performs successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL LowercaseSelection();
//-----------------------------------------------------------------------
// Summary:
// Turns selected text to the uppercase.
// Returns:
// TRUE if performs successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL UppercaseSelection();
//-----------------------------------------------------------------------
// Summary:
// This method used to get current selection.
// Returns:
// A reference to CXTPSyntaxEditSelection object.
// See Also: CXTPSyntaxEditSelection
//-----------------------------------------------------------------------
CXTPSyntaxEditSelection& GetSelection();
//-----------------------------------------------------------------------
// Summary:
// This method used to get Auto-Complete window.
// Returns:
// A pointer to CXTPSyntaxEditAutoCompleteWnd object.
// See Also:
// CXTPSyntaxEditAutoCompleteWnd
//-----------------------------------------------------------------------
CXTPSyntaxEditAutoCompleteWnd* GetAutoCompleteWnd() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the number of rows can be printed per page.
// Returns:
// int value determines the number of rows can be printed in current
// settings.
//-----------------------------------------------------------------------
int GetRowPerPage() const;
//-----------------------------------------------------------------------
// Summary:
// Returns visibility status for given row.
// Parameters:
// iRow: [in] The document row number to be tested.
// Remarks:
// Call this member function to determine if a row of the document is
// visible or not.
// Returns:
// TRUE if the row is visible, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsRowVisible(int iRow) const;
//-----------------------------------------------------------------------
// Summary:
// Sets right mouse button for dragging.
// Parameters:
// bRightButtonDrag: [in] Boolean state flag of right button drag mode.
// Remarks:
// Mainly used by <b>CXTPSyntaxEditView</b> for setting right button
// drag mode. If parameter is TRUE function sets right button for
// dragging, otherwise dragging mode is disabled for right mouse
// button.
// See also:
// void CancelRightButtonDrag(), BOOL IsRightButtonDrag()
//-----------------------------------------------------------------------
void SetRightButtonDrag(BOOL bRightButtonDrag = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Sets scroll bars to enable/disable state.
// Parameters:
// bHorzSBar: [in] TRUE enables horizontal scroll bar; otherwise disables.
// bVertSBar: [in] TRUE enables vertical scroll bar; otherwise disables.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Summary:
// Call this member function to change state for scroll bars. This
// function operates on either vertical and horizontal scroll bars
// simultaneously. Disabled scroll bar is not visible.
// Returns:
// TRUE if scrollbars were updated, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL SetScrollBars(BOOL bHorzSBar, BOOL bVertSBar, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Returns the if horizontal scrollbar is enabled.
// Returns:
// TRUE if horizontal scrollbar is enabled, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetHorzScrollBar() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the if vertical scrollbar is enabled.
// Returns:
// TRUE if vertical scrollbar is enabled, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetVertScrollBar() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to change state for gutter. Passing TRUE
// you enable gutter. Otherwise gutter is disabled. Disabled gutter is
// not visible.
// Parameters:
// bSelMargin: [in] Boolean state flag of gutter.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// TRUE if the operation is successful, FLASE else.
// See also:
// BOOL GetSelMargin()
//-----------------------------------------------------------------------
BOOL SetSelMargin(BOOL bSelMargin, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Returns gutter state.
// Remarks:
// Call this member function to determine current state of gutter.
// It may be enabled or disabled. Disabled gutter is not visible and
// inactive.
// Returns:
// TRUE if gutter is enabled, FALSE otherwise
// See also:
// void SetSelMargin(BOOL bEnabled = TRUE)
//-----------------------------------------------------------------------
BOOL GetSelMargin() const;
//-----------------------------------------------------------------------
// Summary:
// Sets syntax colorization state.
// Parameters:
// bSyntaxColor: [in] Boolean flag determines if colorization is enabled
// or disabled.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// Call this member function to change state syntax colorization.
// Passing TRUE you enable syntax colorization, otherwise it is
// disabled.
// See also:
// BOOL GetSyntaxColor()
//-----------------------------------------------------------------------
BOOL SetSyntaxColor(BOOL bSyntaxColor, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine current syntax colorization
// state.
// Returns:
// TRUE if syntax colorization is enabled, FALSE otherwise.
// See also:
// void SetSyntaxColor(BOOL bEnable = TRUE)
//-----------------------------------------------------------------------
BOOL GetSyntaxColor() const;
//-----------------------------------------------------------------------
// Summary:
// Sets auto indentation state.
// Parameters:
// bAutoIndent: [in] boolean flag determines state auto indent.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// TRUE if the operation is successful, FLASE else.
// Remarks:
// Call this member function change state of auto indentation. Passing
// TRUE you enable it, disable otherwise.
// See also:
// BOOL GetAutoIndent()
//-----------------------------------------------------------------------
BOOL SetAutoIndent(BOOL bAutoIndent, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Returns state of auto intend.
// Remarks:
// Call this member function to determine current auto intend state.
// Returns:
// TRUE if syntax auto indent is enabled, FALSE otherwise.
// See also:
// void SetAutoIndent(BOOL bEnable = TRUE)
//-----------------------------------------------------------------------
BOOL GetAutoIndent() const;
//-----------------------------------------------------------------------
// Summary:
// Sets the tab size.
// Parameters:
// nTabSize: [in] The tab size to set should be between 2 to 10.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// TRUE if the operation is successful, FLASE else.
// Remarks:
// Call this member function to set tab size. Size is measured in
// space character and should be between 2 to 10.
// See also:
// int GetTabSize()
//-----------------------------------------------------------------------
BOOL SetTabSize(int nTabSize, BOOL bUpdateReg = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Returns the tab size.
// Returns:
// Actual tab size is number of character.
// See also:
// void SetTabSize(int iTabSize)
//-----------------------------------------------------------------------
int GetTabSize() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the status if tab should be replaced by space.
// Returns:
// Returns TRUE if tab is enabled, FALSE otherwise.
// See also:
// void SetTabWithSpace(BOOL bReplace = TRUE);
//-----------------------------------------------------------------------
BOOL GetTabWithSpace() const;
//-----------------------------------------------------------------------
// Summary:
// Enables/disables replacing tabs with spaces.
// Parameters:
// bTabWithSpace: [in] Boolean flag determines enable/disable state.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// TRUE if the operation is successful, FLASE else.
// Remarks:
// Call this member function to enable/disable replacing tabs with space
// Pass TRUE if tab should be replaced with space, FALSE otherwise.
// See also:
// BOOL GetTabWithSpace()
//-----------------------------------------------------------------------
BOOL SetTabWithSpace(BOOL bTabWithSpace, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Set the text color of the specified row in the colors cache.
// Parameters:
// nRow : [in] A row identifier for changing the foreground color.
// clrFront : [in] An actual text color foreground.
// See also:
// GetRowColor(int nRow);
//-----------------------------------------------------------------------
void SetRowColor(int nRow, COLORREF clrFront);
//-----------------------------------------------------------------------
// Summary:
// Gets the text color of the specified row in the colors cache.
// Parameters:
// nRow : [in] A row identifier for getting the foreground color.
// Returns:
// The actual text color foreground as a COLORREF value.
// See also:
// SetRowColor(int nRow);
//-----------------------------------------------------------------------
virtual COLORREF GetRowColor(int nRow) const;
//-----------------------------------------------------------------------
// Summary:
// Sets the background color of a specified row in the colors cache.
// Parameters:
// nRow : [in] A row identifier to set the background color.
// crBack : [in] A background color
// See also:
// COLORREF GetRowBkColor(int nRow);
//-----------------------------------------------------------------------
void SetRowBkColor(int nRow, COLORREF crBack);
//-----------------------------------------------------------------------
// Summary:
// Returns the background color of the specified row in the colors cache.
// Parameters:
// nRow - Specifies the document row.
// Returns:
// COLORREF value of the current background color
// See also:
// void SetRowBkColor(int nRow, COLORREF crBack);
//-----------------------------------------------------------------------
virtual COLORREF GetRowBkColor(int nRow) const;
//-----------------------------------------------------------------------
// Summary:
// Returns the status if white space should be shown or not.
// Remarks:
// Call this member function to determine if currently white space
// should be shown or not.
// Returns:
// TRUE if white space should be shown, FALSE otherwise.
// See also:
// void EnableWhiteSpace(BOOL bShow = TRUE)
//-----------------------------------------------------------------------
BOOL IsEnabledWhiteSpace() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to enable or disable showing white spaces
// facility. Pass TRUE if white space should be shown, FALSE otherwise.
// Parameters:
// bShow: [in] Boolean flag determines if white space should be shown
// or not
// See also:
// BOOL IsEnabledWhiteSpace()
//-----------------------------------------------------------------------
void EnableWhiteSpace(BOOL bShow = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Returns the status of Virtual Space mode.
// Returns:
// TRUE if Virtual Space mode enabled, FALSE otherwise.
// See also:
// EnableVirtualSpace
//-----------------------------------------------------------------------
BOOL IsEnabledVirtualSpace() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to enable or disable showing white spaces
// facility. Pass TRUE if white space should be shown, FALSE otherwise.
// Parameters:
// bEnable : [in] Set as TRUE to enable Virtual Space mode and as FALSE
// to disable.
// bUpdateReg : [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// See also:
// BOOL IsEnabledWhiteSpace()
//-----------------------------------------------------------------------
void EnableVirtualSpace(BOOL bEnable, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Returns state flag of mouse right button for drag or not.
// Remarks:
// Call this member function to determine if mouse right button is
// currently enabled for dragging.
// Returns:
// TRUE if right button drag is enabled, FALSE otherwise.
// See also:
// void SetRightButtonDrag(BOOL bRightButtonDrag = TRUE)
// void CancelRightButtonDrag();
//-----------------------------------------------------------------------
BOOL IsRightButtonDrag() const;
//-----------------------------------------------------------------------
// Summary:
// Cancels right button drag.
// Remarks:
// Call this member function to cancel right button drag. It is mainly
// by by CXTPSyntaxEditView class.
// See also:
// void SetRightButtonDrag(BOOL bRightButtonDrag = TRUE),
// IsRightButtonDrag()
// CXTPSyntaxEditView
//-----------------------------------------------------------------------
void CancelRightButtonDrag();
//-----------------------------------------------------------------------
// Summary:
// Displays the default context menu.
// Remarks:
// This member function calls OnContextMenu().
// See also:
// OnContextMenu()
//-----------------------------------------------------------------------
void ShowDefaultContextMenu();
//-----------------------------------------------------------------------
// Summary:
// Handle the drop operation within the same edit buffer.
// Parameters:
// bCopy: [in] TRUE if drag is to copy, FALSE to specify a move.
//-----------------------------------------------------------------------
void HandleDrop(BOOL bCopy);
//-----------------------------------------------------------------------
// Summary: Call this method to move to the row
// Parameters:
// iRow - [in] row index.
// bSelectRow - [in] select row if TRUE.
//-----------------------------------------------------------------------
void GoToRow(int iRow, BOOL bSelectRow = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Replaces a selection with the supplied text.
// Parameters:
// szNewText: [in] The text to be pasted into the selected part.
// Returns:
// TRUE if replaced, FALSE otherwise
//-----------------------------------------------------------------------
BOOL ReplaceSel(LPCTSTR szNewText);
//-----------------------------------------------------------------------
// Summary:
// Replaces all occurrences of szFindText to szReplaceText.
// Parameters:
// szFindText : [in] Pointer to text to find.
// szReplaceText: [in] Pointer to text which will replace.
// bMatchWholeWord: [in] Boolean flag to match whole word.
// bMatchCase: [in] Boolean flag to match case.
// Returns:
// The number of founded matches.
//-----------------------------------------------------------------------
int ReplaceAll(LPCTSTR szFindText, LPCTSTR szReplaceText, BOOL bMatchWholeWord, BOOL bMatchCase);
//-----------------------------------------------------------------------
// Summary:
// Returns the selected text.
// Parameters:
// strText: [out] Reference to a CString object where returned text
// will be placed.
// Returns:
// Number of character in the returned text.
//-----------------------------------------------------------------------
int GetSelectionText(CString& strText);
//-----------------------------------------------------------------------
// Summary:
// Sets the drop position.
// Parameters:
// iRow: [in] Row of the drop position.
// iCol: [in] Col of the drop position.
// Remarks:
// Call this member function to set the drop position. Mainly used by
// CXTPSyntaxEditView during OLE drag drop operation.
// See also:
// CXTPSyntaxEditView class
//-----------------------------------------------------------------------
void SetDropPos(int iRow, int iCol);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine the current absolute text
// position, mainly used in text insert or delete operations.
// Treats tabs as one character.
// Returns:
// Return absolute column position.
//-----------------------------------------------------------------------
int GetCurAbsCol() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function get a handle of a selection buffer in the
// global memory in one of the clipboard format of CF_TEXT or
// CF_UNICODETEXT. Mainly used in OLE drag drop operation.
// Parameters:
// nFormat: [in] Determines clipboard format to be returned
// (CF_TEXT or CF_UNICODETEXT)
// Returns:
// Handle of a globally allocated memory.
//-----------------------------------------------------------------------
HGLOBAL GetSelectionBuffer(UINT nFormat);
//-----------------------------------------------------------------------
// Summary:
// Enables or disables OLE drag drop mode.
// Parameters:
// bEnableDrag: [in] Determines state of OLE drag drop.
// Remarks:
// CAll this member function toenablr/disable OLE drag drop. Pass TRUE
// to enable OLE drag drop, otherwise pass FALSE.
//-----------------------------------------------------------------------
void EnableOleDrag(BOOL bEnableDrag = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Validates and set the row column to a valid one.
// Parameters:
// nRow: [in] Document row to be validated.
// nCol: [in out] Col to be validated.
// nAbsCol: [in out] Absolute col to be validated.
//-----------------------------------------------------------------------
void ValidateCol(const int nRow, int& nCol, int& nAbsCol);
//-----------------------------------------------------------------------
// Summary:
// Returns the row and col (Not validated) for a specific point. Use
// CalcValidDispCol for validation.
// Parameters:
// pt : [in] The point in client co-ordinate.
// pRow : [out] The out parameter contains the calculated
// document row.
// pCol : [out] The out parameter contains the calculated col.
// pDispRow : [out] The out parameter contains the calculated
// visible row.
// pDispCol : [out] The out parameter contains the calculated
// visible col.
// bVirtualSpace : [in] Set TRUE if virtual space is enabled
// (cursor can be paced in any place after line end).
// Returns:
// BOOL : True if point was out of bound and index was corrected
//-----------------------------------------------------------------------
BOOL RowColFromPoint(CPoint pt, int *pRow, int *pCol, int *pDispRow = NULL,
int *pDispCol = NULL, BOOL bVirtualSpace = -1);
//-----------------------------------------------------------------------
// Summary:
// Deletes tab from the front of a selection.
// Returns:
// BOOL : True if successful, false if not.
//-----------------------------------------------------------------------
BOOL DecreaseIndent();
//-----------------------------------------------------------------------
// Summary:
// Inserts tab in front of a selection.
// Returns:
// BOOL - True if successful, false if not.
//-----------------------------------------------------------------------
BOOL IncreaseIndent();
//-----------------------------------------------------------------------
// Summary:
// Deletes all the lines in a selection or a specific line in the case
// if no selection exists.
// Parameters:
// iForceDeleteRow : [in] The document row to delete.
//-----------------------------------------------------------------------
void DeleteSelectedLines(int iForceDeleteRow);
//-----------------------------------------------------------------------
// Summary:
// Shows or hides the scroll bar.
// Parameters:
// bShow : [in] Determines if a horizontal scrollbar should be shown.
// Pass TRUE to show FALSE otherwise. Default value is
// TRUE.
//-----------------------------------------------------------------------
void ShowHScrollBar(BOOL bShow = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Copy or move text after dragging.
// Parameters:
// bCopy: [in] Set as TRUE to copy text, FALSE to move text.
//-----------------------------------------------------------------------
void CopyOrMoveText(BOOL bCopy);
//-----------------------------------------------------------------------
// Summary:
// Finds a certain text with some parameters for find.
// Parameters:
// szText : [in] Pointer to a text string to be found.
// bMatchWholeWord : [in] Find text matching the whole word.
// bMatchCase : [in] Try to match case.
// bSearchDown : [in] TRUE for searching downward.
// bRedraw : [in] TRUE for redraw control after search.
// nStartRow : [in] The row number to start search. Value -1 means start from current row.
// nStartCol : [in] The column number to start search. Value -1 means start from current column.
// Returns:
// TRUE if found, FALSE if not
//-----------------------------------------------------------------------
BOOL Find(LPCTSTR szText, BOOL bMatchWholeWord, BOOL bMatchCase, BOOL bSearchDown,BOOL bRedraw = TRUE,
int nStartRow = -1, int nStartCol = -1);
//-----------------------------------------------------------------------
// Summary:
// Selects a text bounded by given coordinates.
// Parameters:
// nRow1 - Start row of the text.
// nDispCol1 - Start visible column (character) of the text.
// nRow2 - End row of the text.
// nDispCol2 - End visible column (character) of the text.
// bRedraw - TRUE for redraw control after search.
// Returns:
// TRUE if found, FALSE if not.
//-----------------------------------------------------------------------
BOOL Select(int nRow1, int nDispCol1, int nRow2, int nDispCol2, BOOL bRedraw = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Cancels the previously selected rectangle area.
// See also:
// void SetCurSel(int iRow1, int iCol1, int iRow2, int iCol2)
//-----------------------------------------------------------------------
void Unselect();
//-----------------------------------------------------------------------
// Summary:
// Use this operator to copy control settings from other control.
// Parameters:
// src - A source syntax edit control.
// Returns:
// A reference to this object.
//-----------------------------------------------------------------------
const CXTPSyntaxEditCtrl& operator=(const CXTPSyntaxEditCtrl& src);
//-----------------------------------------------------------------------
// Summary:
// Restores cursor, used mainly while changing font.
//-----------------------------------------------------------------------
void RestoreCursor();
//-----------------------------------------------------------------------
// Summary:
// Turns on/off overwrite mode.
// Parameters:
// bOverwriteMode : [in] TRUE if INS is off, FALSE otherwise.
//-----------------------------------------------------------------------
void SetOverwriteMode(BOOL bOverwriteMode);
//-----------------------------------------------------------------------
// Summary:
// Sets caret for overwrite mode.
// Parameters:
// bWideCaret: [in] TRUE if thin caret, FALSE otherwise.
// bUpdateReg: [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
// Returns:
// TRUE if the operation is successful, FALSE else.
//-----------------------------------------------------------------------
BOOL SetWideCaret(BOOL bWideCaret, BOOL bUpdateReg = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Determines if thin caret is set for overwrite mode.
// Returns:
// Boolean flag. TRUE if set, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetWideCaret() const;
//-----------------------------------------------------------------------
// Summary:
// Determines is the caret visible or not.
// Returns:
// TRUE if caret is hidden, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsHideCaret() const;
//-----------------------------------------------------------------------
// Summary:
// Used to hide or show caret.
// Parameters:
// bHide : BOOL - TRUE to Hide
// Remarks:
// May be useful to hide caret in the read-only mode.
//-----------------------------------------------------------------------
void SetHideCaret(BOOL bHide);
//-----------------------------------------------------------------------
// Summary:
// Selects the surrounding word of the point specified.
// Parameters:
// point : [in] A point about which a word will be searched.
//-----------------------------------------------------------------------
void SelectWord(CPoint point);
//-----------------------------------------------------------------------
// Summary:
// Sets the current caret position to the specified row and col.
// Parameters:
// nTextRow : [in] The text row number for the current
// caret position.
// nDispCol : [in] The col for the current caret position.
// bRowColNotify : [in] Pass TRUE to send XTP_EDIT_NM_ROWCOLCHANGED
// notification, FALSE otherwise.
// bEnsureVisible : [in] Pass true if the set row col should be
// forcefully made visible.
//-----------------------------------------------------------------------
void SetCurCaretPos(int nTextRow, int nDispCol, BOOL bRowColNotify = TRUE, BOOL bEnsureVisible = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Returns a buffer manager which maintains a buffer of a smart edit
// control.
// Returns:
// Pointer to the CXTPSyntaxEditBufferManager object.
//-----------------------------------------------------------------------
CXTPSyntaxEditBufferManager* GetEditBuffer() const;
//-----------------------------------------------------------------------
// Summary:
// Use this method to get associated configuration manager.
// Returns:
// Returns pointer to configuration manager.
//-----------------------------------------------------------------------
CXTPSyntaxEditConfigurationManager* GetLexConfigurationManager() const;
//-----------------------------------------------------------------------
// Summary:
// Use this method to get paint manager object.
// Returns:
// Returns pointer to associated CXTPSyntaxEditPaintManager object.
//-----------------------------------------------------------------------
CXTPSyntaxEditPaintManager* GetPaintManager() const;
//-----------------------------------------------------------------------
// Summary:
// Use this method to sett paint manager object.
// Parameters:
// pPaintManager : [in] A pointer CXTPSyntaxEditPaintManager object.
//-----------------------------------------------------------------------
virtual void SetPaintManager(CXTPSyntaxEditPaintManager* pPaintManager);
//-----------------------------------------------------------------------
// Summary:
// Use this method to get draw text processor object.
// Returns:
// Returns pointer to CXTPSyntaxEditDrawTextProcessor object.
//-----------------------------------------------------------------------
CXTPSyntaxEditDrawTextProcessor& GetDrawTextProcessor();
//-----------------------------------------------------------------------
// Summary:
// Inserts a string at specified row and col.
// Parameters:
// szText : [in] A pointer to a text string to be inserted.
// iRow : [in] A row identifier where text will be inserted.
// iCol : [in] A column identifier where text will be inserted.
// bDeleteSelection : [in] If TRUE selected text will be deleted at insertion.
// Default is TRUE.
//-----------------------------------------------------------------------
void InsertString(LPCTSTR szText, int iRow, int iCol, BOOL bDeleteSelection = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Inserts a vertical text block at specified row and col.
// Parameters:
// szText : [in] A pointer to a text string to be inserted.
// iRow : [in] A row identifier where text will be inserted.
// iCol : [in] A column identifier where text will be inserted.
// bDeleteSelection : [in] If TRUE selected text will be deleted at insertion.
// Default is TRUE.
//-----------------------------------------------------------------------
void InsertTextBlock(LPCTSTR szText, int iRow, int iCol, BOOL bDeleteSelection = TRUE);
//--------------------------------------------------------------------
// Summary:
// Returns main configuration file name.
// Remarks:
// Return configuration file name previously stored by SetConfigFile().
// Returns:
// CString object contains main configuration file name.
// See also:
// CXTPSyntaxEditCtrl::SetConfigFile().
//--------------------------------------------------------------------
CString GetConfigFile() const;
//-----------------------------------------------------------------------
// Summary:
// Returns a path of the executable file module.
// Returns:
// CString objects with path.
//-----------------------------------------------------------------------
static CString AFX_CDECL GetModulePath();
//-----------------------------------------------------------------------
// Summary:
// Sets the path to the main configuration file.
// Parameters:
// szPath : [in] A pointer to a string containing a valid path for
// searching the control's .ini files.
// bConfigFileMode : [in] flag for mode
// Remarks:
// Configuration will be reloaded.
// Returns:
// TRUE if path is found, FALSE otherwise
// See also:
// CXTPSyntaxEditCtrl::GetConfigFile().
//-----------------------------------------------------------------------
BOOL SetConfigFile(LPCTSTR szPath, BOOL bConfigFileMode = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Creates and applies the font for the edit control
// Parameters:
// pLogfont : [in] A pointer to LOGFONT structure.
// bUpdateReg : [in] Set this parameter as TRUE to update this setting
// in the registry. It is FALSE by default.
//-----------------------------------------------------------------------
void SetFontIndirect(LPLOGFONT pLogfont, BOOL bUpdateReg=FALSE);
//-----------------------------------------------------------------------
// Summary:
// Sets the current cursor position to the specified row and col.
// Parameters:
// nTextRow : [in] A Row to set as the current cursor position document
// coordinates.
// nDispCol : [in] A Col to set as the current cursor position in
// document coordinates.
// bRemainSelected : [in] FALSE determines to unselect the selected text.
// bForceVisible : [in] Set TRUE to make current pos visible.
// See also:
// int GetCurCol(), int GetCurRow()
//-----------------------------------------------------------------------
void SetCurPos(int nTextRow, int nDispCol, BOOL bRemainSelected = FALSE, BOOL bForceVisible = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Returns the current column.
// Returns:
// An integer value of current document column identifier.
//-----------------------------------------------------------------------
int GetCurCol() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the current document row
// Returns:
// An integer value of current document row identifier.
//-----------------------------------------------------------------------
int GetCurRow() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the number of rows in the current document.
// Returns:
// Number of rows in the document.
//-----------------------------------------------------------------------
int GetRowCount() const;
//-----------------------------------------------------------------------
// Summary:
// Selects all the text.
//-----------------------------------------------------------------------
void SelectAll();
//-----------------------------------------------------------------------
// Summary:
// This method used to draw the edit control client area.
// Parameters:
// pDC : [in] A pointer to device context to print.
// rcRect : [in] A rectangle to draw control.
// See Also: PrintPage
//-----------------------------------------------------------------------
virtual void Draw(CDC *pDC, const CRect& rcRect);
//-----------------------------------------------------------------------
// Summary:
// This method used to print the edit control page.
// Parameters:
// pDC : [in] A pointer to device context to print.
// rcRect : [in] A rectangle to draw control.
// nFlags : [in] Additional printing options. The folowing are supported:
// DT_CALCRECT, DT_SINGLELINE, DT_WORDBREAK
// Remarks:
// The TopRow is used as the first page line.
// Returns:
// Returns count of the printed rows.
// See Also: Draw
//-----------------------------------------------------------------------
virtual int PrintPage(CDC *pDC, const CRect& rcRect, int nFlags = 0);
//-----------------------------------------------------------------------
// Summary:
// This method used to calculate the edit control regions.
// Parameters:
// prcBookMarks : [out] A pointer to CRect object to receive a Bookmarks
// area rectangle. May be NULL.
// prcLineNum : [out] A pointer to CRect object to receive a Line Numbers
// area rectangle. May be NULL.
// prcNodes : [out] A pointer to CRect object to receive a Line Nodes
// area rectangle. May be NULL.
// prcText : [out] A pointer to CRect object to receive a Text
// area rectangle. May be NULL.
// prcClient : [in] A pointer to CRect object which contains a base edit
// control rectangle to calculate other rectangles.
// Pass NULL to use edit control's window client rect.
// Remarks:
// For invisible(diabled) areas - the empty rectangles returned.
// Returns:
// Returns a base rectangle for which other rectangless where calculated
// (this is a window client rect or value from prcClient parameter).
//-----------------------------------------------------------------------
virtual CRect CalcEditRects(CRect* prcBookMarks = NULL, CRect* prcLineNum = NULL,
CRect* prcNodes = NULL, CRect* prcText = NULL,
const CRect* prcClient = NULL) const;
//-----------------------------------------------------------------------
// Summary:
// Returns boolean selection existence flag.
// Returns:
// TRUE if selection exist, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsSelectionExist() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to paste from clipboard to the current
// document.
//-----------------------------------------------------------------------
void Paste();
//-----------------------------------------------------------------------
// Summary:
// Copies the selected text to clipboard.
//-----------------------------------------------------------------------
void Copy();
//-----------------------------------------------------------------------
// Summary:
// Copies the selected text to clipboard and deletes it from document.
//-----------------------------------------------------------------------
void Cut();
//-----------------------------------------------------------------------
// Summary:
// Returns flag which determines if Redo can be made.
// Remarks:
// Call this member function to determine if redo can be made.
// Returns:
// TRUE if redo can be made, FALSE otherwise.
// See also:
// BOOL Redo(int nActionsCount = 1);
//-----------------------------------------------------------------------
BOOL CanRedo() const;
//-----------------------------------------------------------------------
// Summary:
// Returns flag which determines if Undo can be made.
// Remarks:
// Call this member function to determine if undo can be made.
// Returns:
// TRUE if any undo action pending, FALSE otherwise
// See also:
// BOOL Undo(int nActionsCount = 1);
//-----------------------------------------------------------------------
BOOL CanUndo() const;
//-----------------------------------------------------------------------
// Summary:
// Re-does the last undone operation.
// Parameters:
// nActionsCount : [in] Specifies the number of actions to be redone
// simultaneously.
// Returns:
// TRUE if success, FALSE otherwise.
// See also:
// BOOL CanRedo();
//-----------------------------------------------------------------------
BOOL Redo(int nActionsCount = 1);
//-----------------------------------------------------------------------
// Summary:
// Un-does the current action.
// Parameters:
// nActionsCount : [in] Specifies the number of actions to be undone
// simultaneously.
// Returns:
// TRUE if success, FALSE otherwise.
// See also:
// BOOL CanUndo();
//-----------------------------------------------------------------------
BOOL Undo(int nActionsCount = 1);
//-----------------------------------------------------------------------
// Summary:
// Returns the list of text for undo operations.
// Returns:
// A reference to CStringList with strings of text for undo.
//-----------------------------------------------------------------------
const CStringList& GetUndoTextList();
//-----------------------------------------------------------------------
// Summary:
// Returns the list of text for redo operations.
// Returns:
// A reference to CStringList with strings of text for redo.
//-----------------------------------------------------------------------
const CStringList& GetRedoTextList();
//-----------------------------------------------------------------------
// Summary:
// Deletes a character at specified location.
// Parameters:
// iRow : [in] A row identifier in document coordinates.
// iCol : [in] A column identifier in document coordinates.
// pos : [in] A position qualifier.
// Returns:
// TRUE if deleted, FALSE otherwise;
// See also:
// XTPSyntaxEditDeletePos enum.
//-----------------------------------------------------------------------
BOOL DeleteChar(int iRow, int iCol, XTPSyntaxEditDeletePos pos);
//-----------------------------------------------------------------------
// Summary:
// Deletes a given range of text.
// Parameters:
// iRowFrom : [in] Specifies start row in document coordinates.
// iColFrom : [in] Specifies start col in document coordinates.
// iRowTo : [in] Specifies end row in document coordinates.
// iColTo : [in] Specifies end col in document coordinates.
// nFlags : [in] mode flag, possible values : smfRedraw,
// smfForceRedraw, smfTextAsBlock.
// Returns:
// TRUE if deleted, FALSE otherwise.
// See also:
// enum XTPSyntaxEditFlags.
//-----------------------------------------------------------------------
BOOL DeleteBuffer(int iRowFrom, int iColFrom, int iRowTo, int iColTo, int nFlags = 0);
//-----------------------------------------------------------------------
// Summary:
// Deletes the currently selected text.
// Parameters:
// bRedraw : [in] If TRUE document should be redrawn. Default value
// is TRUE.
// Returns:
// TRUE if deleted, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL DeleteSelection();
//-----------------------------------------------------------------------
// Summary:
// Use this method to get editor text.
// Parameters:
// nMaxLen : [in] The maximum text length to get (in TCHARs). Set as -1
// to get all text. Default value -1.
// Remarks:
// Also CWnd::GetWindowText can be used to get editor text.
// Returns:
// First function returns a CString object wich contains an editor text
// (or empty string).
// Second function returns TRUE if succeeded, FALSE otherwise.
// See Also: SetText, CWnd::SetWindowText
//-----------------------------------------------------------------------
CString GetText(int nMaxLen = -1) const;
//-----------------------------------------------------------------------
// Summary:
// Use this method to get editor text.
// Parameters:
// nMaxLen : [in] The maximum text length to get (in TCHARs). Set as -1
// to get all text. Default value -1.
// memFile : [out] A reference to CMemFile object to receive a text.
// Remarks:
// Also CWnd::GetWindowText can be used to get editor text.
// Returns:
// First function returns a CString object wich contains an editor text
// (or empty string).
// Second function returns TRUE if succeeded, FALSE otherwise.
// See Also: SetText, CWnd::SetWindowText
//-----------------------------------------------------------------------
BOOL GetText(CMemFile& memFile, int nMaxLen = -1) const;
//-----------------------------------------------------------------------
// Summary:
// Use this method to set editor text.
// Parameters:
// pcszText : [in] Pointer to a text string.
// Remarks:
// Also CWnd::SetWindowText can be used to set editor text.
// See Also: GetText, CWnd::GetWindowText
//-----------------------------------------------------------------------
void SetText(LPCTSTR pcszText);
//-----------------------------------------------------------------------
// Summary:
// Set the top row of the visible window.
// Parameters:
// iRow : [in] An identifier of the top visible row in document
// coordinates.
// See also:
// int GetTopRow();
//-----------------------------------------------------------------------
void SetTopRow(int iRow);
//-----------------------------------------------------------------------
// Summary:
// Returns top row identifier.
// Returns:
// An integer value of the current top row identifier.
// See also:
// SetTopRow(int iRow);
//-----------------------------------------------------------------------
int GetTopRow() const;
//-----------------------------------------------------------------------
// Summary:
// Recalculates and set the scroll bars and other related areas
// depending on the text size and current position.
//-----------------------------------------------------------------------
void RecalcScrollBars();
//-----------------------------------------------------------------------
// Summary: Repositions and resizes control bars in the client area of a
// window.
// Parameters:
// nIDFirst : [in] The ID of the first in a range of control bars
// to reposition and resize.
// nIDLast : [in] The ID of the last in a range of control bars
// to reposition and resize.
// nIDLeftOver : [in] Specifies ID of pane that fills the rest of the
// client area.
// nFlag : [in] Can have one of the following values:
// [ul]
// [li]CWnd::reposDefault - Performs the layout of
// the control bars. lpRectParam is not used and
// can be NULL.[/li]
// [li]CWnd::reposQuery - The layout of the control
// bars is not done; instead lpRectParam is
// initialized with the size of the client area,
// as if the layout had actually been done.[/li]
// [li]CWnd::reposExtra Adds the values of lpRectParam
// to the client area of nIDLast and also performs
// the layout.[/li]
// [/ul]
// lpRectParam : [in] Points to a RECT structure; the usage of which
// depends on the value of nFlag.
// lpRectClient : [in] Points to a RECT structure containing the available
// client area. If NULL, the window's client area will
// be used.
// bStretch : [in] Indicates whether the bar should be stretched to
// the size of the frame.
// Remarks: The nIDFirst and nIDLast parameters define a range of control-bar
// IDs to be repositioned in the client area. The nIDLeftOver parameter
// specifies the ID of the child window (normally the view) which
// is repositioned and resized to fill the rest of the client area
// not filled by control bars.
//-----------------------------------------------------------------------
void RepositionBars(UINT nIDFirst, UINT nIDLast, UINT nIDLeftOver, UINT nFlag = CWnd::reposDefault, LPRECT lpRectParam = NULL, LPCRECT lpRectClient = NULL, BOOL bStretch = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Return pointer to the specified CScrollBar object.
// Parameters:
// nBar : [in] Specifies the type of scroll bar. The parameter can take
// one of the following values:
// [ul]
// [li]SB_HORZ - Retrieves the position of the horizontal scroll bar[/li]
// [li]SB_VERT - Retrieves the position of the vertical scroll bar[/li]
// [/ul]
// Remarks:
// Call this member function to obtain a pointer to the specified sibling
// scroll bar. This member function does not operate on scroll bars created
// when the WS_HSCROLL or WS_VSCROLL bits are set during the creation
// of a window. The CWnd implementation of this function simply returns
// NULL. Derived classes, such as CView, implement the described
// functionality.
// Returns:
// A pointer to sibling scroll-bar control, or NULL if none.
//-----------------------------------------------------------------------
virtual CScrollBar* GetScrollBarCtrl( int nBar ) const;
//-----------------------------------------------------------------------
// Summary:
// Enables or disables the scroll bar.
// Parameters:
// nBar : [in] The scroll-bar identifier.
// bEnable : [in] Specifies whether the scroll bar is to be enabled
// or disabled.
// Remarks:
// If the window has a sibling scroll-bar control, that scroll bar
// is used; otherwise the window's own scroll bar is used.
// See also:
// void ShowScrollBar(UINT nBar, BOOL bShow = TRUE );
//-----------------------------------------------------------------------
void EnableScrollBarCtrl(int nBar, BOOL bEnable = TRUE );
//-----------------------------------------------------------------------
// Summary:
// Shows or hides a scroll bar.
// Parameters:
// nBar : [in] Specifies whether the scroll bar is a control or part
// of a window's non-client area. If it is part of the
// non-client area, nBar also indicates whether the scroll
// bar is positioned horizontally, vertically, or both.
// It must be one of the following:
// [ul]
// [li]SB_BOTH - Specifies the horizontal and vertical
// scroll bars of the window.[/li]
// [li]SB_HORZ - Specifies that the window is a horizontal
// scroll bar.[/li]
// [li]SB_VERT - Specifies that the window is a vertical
// scroll bar.[/li]
// bShow: [in] Specifies whether Windows shows or hides the scroll bar.
// If this parameter is TRUE, the scroll bar is shown;
// otherwise the scroll bar is hidden.
// Remarks:
// An application should not call ShowScrollBar to hide a scroll
// bar while processing a scroll-bar notification message.
// See also:
// void EnableScrollBarCtrl( int nBar, BOOL bEnable = TRUE );
//-----------------------------------------------------------------------
void ShowScrollBar(UINT nBar, BOOL bShow = TRUE );
//-----------------------------------------------------------------------
// Summary:
// Sets minimum and maximum position values for the given scroll bar.
// Parameters:
// nBar : [in] Specifies the scroll bar to be set. This parameter
// can be either of the following values:
// [ul]
// [li]SB_HORZ - Sets the range of the horizontal scroll
// bar of the window.[/li]
// [li]SB_VERT - Sets the range of the vertical scroll
// bar of the window.[/li]
// [/ul]
// nMinPos : [in] Specifies the minimum scrolling position.
// nMaxPos : [in] Specifies the maximum scrolling position.
// bRedraw : [in] Specifies whether the scroll bar should be redrawn to
// reflect the change. If bRedraw is TRUE, the scroll bar
// is redrawn; if FALSE, the scroll bar is not redrawn.
// Remarks: It can also be used to hide or show standard scroll bars.
//
// An application should not call this function to hide a scroll
// bar while processing a scroll-bar notification message.
//
// If the call to SetScrollRange immediately follows a call to
// the SetScrollPos member function, the bRedraw parameter in the
// SetScrollPos member function should be 0 to prevent the scroll
// bar from being drawn twice.
//
// The default range for a standard scroll bar is 0 through 100.
// The default range for a scroll bar control is empty (both the
// nMinPos and nMaxPos values are 0). The difference between the
// values specified by nMinPos and nMaxPos must not be greater
// than INT_MAX.
//-----------------------------------------------------------------------
void SetScrollRange( int nBar, int nMinPos, int nMaxPos, BOOL bRedraw = TRUE );
//-----------------------------------------------------------------------
// Summary:
// Sets the current position of a scroll box and, if requested, redraws
// the scroll bar to reflect the new position of the scroll box
// Parameters:
// nBar : [in] Specifies the scroll bar to be set. This parameter
// can be either of the following:
// [ul]
// [li]SB_HORZ - Sets the position of the scroll box
// in the horizontal scroll bar of the
// window.[/li]
// [li]SB_VERT - Sets the position of the scroll box in
// the vertical scroll bar of the
// window.[/li]
// [/ul]
// nPos : [in] Specifies the new position of the scroll box. It must
// be within the scrolling range.
// bRedraw : [in] Specifies whether the scroll bar should be repainted
// to reflect the new scroll-box position. If this parameter
// is TRUE, the scroll bar is repainted; if FALSE, the
// scroll bar is not repainted.
// Remarks:
// Setting bRedraw to FALSE is useful whenever the scroll bar will
// be redrawn by a subsequent call to another function.
// Returns:
// The previous position of the scroll box.
//-----------------------------------------------------------------------
int SetScrollPos( int nBar, int nPos, BOOL bRedraw = TRUE );
//-----------------------------------------------------------------------
// Summary:
// Sets the information that the SCROLLINFO structure maintains about
// a scroll bar.
// Parameters:
// nBar : [in] Specifies the scroll bar to be set. This parameter
// can be either of the following:
// [ul]
// [li]SB_HORZ - Sets the position of the scroll box
// in the horizontal scroll bar of the window.[/li]
// [li]SB_VERT Sets the position of the scroll box in
// the vertical scroll bar of the window.[/li]
// [/ul]
// lpScrollInfo : [in] A pointer to a SCROLLINFO structure.
// bRedraw : [in] Specifies whether the scroll bar should be redrawn
// to reflect the new information. If bRedraw is TRUE,
// the scroll bar is redrawn. If it is FALSE, it is
// not redrawn. The scroll bar is redrawn by default.
// Remarks:
// You must provide the values required by the SCROLLINFO structure
// parameters, including the flag values.
//
// The SCROLLINFO structure contains information about a scroll bar,
// including the minimum and maximum scrolling positions, the page
// size, and the position of the scroll box (the thumb). See the
// SCROLLINFO structure topic in the Platform SDK for more information
// about changing the structure defaults.
// Returns:
// If successful, the return is TRUE. Otherwise, it is FALSE.
// See also:
// BOOL GetScrollInfo( int nBar, LPSCROLLINFO lpScrollInfo, UINT nMask = SIF_ALL )
// int GetScrollLimit( int nBar )
//-----------------------------------------------------------------------
BOOL SetScrollInfo( int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE );
//-----------------------------------------------------------------------
// Summary:
// Returns max scroll position identifier.
// Parameters:
// nBar : [in] Specifies the type of scroll bar. The parameter can take
// one of the following values:
// [ul]
// [li]SB_HORZ - Retrieves the scroll limit of the horizontal
// scroll bar.[/li]
// [li]SB_VERT Retrieves the scroll limit of the vertical
// scroll bar.[/li]
// [/ul]
// Remarks:
// Call this member function to retrieve the maximum scrolling
// position of the scroll bar.
// Returns:
// An integer value which specifies the maximum position of a scroll
// bar if successful; otherwise 0.
//-----------------------------------------------------------------------
int GetScrollLimit(int nBar);
//-----------------------------------------------------------------------
// Summary: Retrieves the scrollbar information
// Parameters:
// nBar : [in] Specifies whether the scroll bar is a control
// or part of a window's non-client area. If it is
// part of the non-client area, nBar also indicates
// whether the scroll bar is positioned horizontally,
// vertically, or both. It must be one of the following:
// [ul]
// [li]SB_CTL - Contains the parameters for a scroll
// bar control. The m_hWnd data member must be
// the handle of the scroll bar control.[/li]
// [li]SB_HORZ - Specifies that the window is a
// horizontal scroll bar.[/li]
// [li]SB_VERT Specifies that the window is a
// vertical scroll bar.
// lpScrollInfo : [out] A pointer to a SCROLLINFO structure. See the
// Platform SDK for more information about this
// structure.
// nMask : [in] Specifies the scroll bar parameters to retrieve.
// The default specifies a combination of SIF_PAGE,
// SIF_POS, SIF_TRACKPOS, and SIF_RANGE. See SCROLLINFO
// for more information on the nMask values.
// Remarks:
// Call this member function to retrieve the information that the
// SCROLLINFO structure maintains about a scroll bar.
// GetScrollInfo enables applications to use 32-bit scroll positions.
//
// The SCROLLINFO structure contains information about a scroll bar,
// including the minimum and maximum scrolling positions, the page
// size, and the position of the scroll box (the thumb). See the
// SCROLLINFO structure topic in the Platform SDK for more information
// about changing the structure defaults.
//
// The MFC Windows message handlers that indicate scroll-bar position,
// CWnd::OnHScroll and CWnd::OnVScroll, provide only 16 bits of position
// data. GetScrollInfo and SetScrollInfo provide 32 bits of scroll-bar
// position data. Thus, an application can call GetScrollInfo while
// processing either CWnd::OnHScroll or CWnd::OnVScroll to obtain 32-bit
// scroll-bar position data.
// Returns:
// If the message retrieved any values, the return is TRUE. Otherwise,
// it is FALSE.
// See also:
// BOOL SetScrollInfo( int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE );
//-----------------------------------------------------------------------
BOOL GetScrollInfo( int nBar, LPSCROLLINFO lpScrollInfo, UINT nMask = SIF_ALL );
//-----------------------------------------------------------------------
// Summary:
// Scrolls the specified client area with additional features.
// Parameters:
// dx : [in] Specifies the amount, in device units, of horizontal scrolling.
// This parameter must have a negative value to scroll to the left.
// dy : [in] Specifies the amount, in device units, of vertical scrolling.
// This parameter must have a negative value to scroll up.
// lpRectScroll : [in] Points to a RECT structure that specifies the portion
// of the client area to be scrolled. If this parameter
// is NULL, the entire client area is scrolled.
// lpRectClip : [in] Points to a RECT structure that specifies the clipping
// rectangle to scroll. This structure takes precedence
// over the rectangle pointed to by lpRectScroll. Only
// bits inside this rectangle are scrolled. Bits outside
// this rectangle are not affected even if they are in
// the lpRectScroll rectangle. If this parameter is NULL,
// no clipping is performed on the scroll rectangle.
// prgnUpdate : [in] Identifies the region that is modified to hold the
// region invalidated by scrolling. This parameter
// may be NULL.
// lpRectUpdate : [out] Points to a RECT structure that will receive the
// boundaries of the rectangle invalidated by scrolling.
// This parameter may be NULL.
// flags : [in] Can have one of the following values:
// [ul]
// [li]SW_ERASE When specified with SW_INVALIDATE,
// erases the newly invalidated region by sending
// a WM_ERASEBKGND message to the window. [/li]
// [li]SW_INVALIDATE Invalidates the region identified
// by prgnUpdate after scrolling.[/li]
// [li]SW_SCROLLCHILDREN Scrolls all child windows that
// intersect the rectangle pointed to by lpRectScroll
// by the number of pixels specified in dx and dy.
// Windows sends a WM_MOVE message to all child windows
// that intersect lpRectScroll, even if they do not move.
// The caret is repositioned when a child window is
// scrolled and the cursor rectangle intersects the
// scroll rectangle.[/li]
// [/ul]
//-----------------------------------------------------------------------
int ScrollWindowEx( int dx, int dy, LPCRECT lpRectScroll, LPCRECT lpRectClip, CRgn* prgnUpdate, LPRECT lpRectUpdate, UINT flags );
//-----------------------------------------------------------------------
// Summary:
// Scrolls the specified client area.
// Parameters:
// xAmount : [in] Specifies the amount, in device units, of horizontal
// scrolling. This parameter must be a negative value
// to scroll to the left.
// yAmount : [in] Specifies the amount, in device units, of vertical
// scrolling. This parameter must be a negative value
// to scroll up.
// lpRect : [in] Points to a CRect object or RECT structure that
// specifies the portion of the client area to be scrolled.
// If lpRect is NULL, the entire client area is scrolled.
// The caret is repositioned if the cursor rectangle
// intersects the scroll rectangle.
// lpClipRect : [in] Points to a CRect object or RECT structure that
// specifies the clipping rectangle to scroll.
// Only bits inside this rectangle are scrolled.
// Bits outside this rectangle are not affected
// even if they are in the lpRect rectangle.
// If lpClipRect is NULL, no clipping is performed
// on the scroll rectangle.
//-----------------------------------------------------------------------
void ScrollWindow( int xAmount, int yAmount, LPCRECT lpRect = NULL, LPCRECT lpClipRect = NULL );
//-----------------------------------------------------------------------
// Summary:
// Retrieves the scroll bar range.
// Parameters:
// nBar : [in] Specifies the scroll bar to examine. The parameter can
// take one of the following values:
// [ul]
// [li]SB_HORZ - Retrieves the position of the horizontal
// scroll bar.[/li]
// [li]SB_VERT - Retrieves the position of the vertical
// scroll bar.[/li]
// [/ul]
// lpMinPos : [out] Points to the integer variable that is to receive
// the minimum position.
// lpMaxPos : [out] Points to the integer variable that is to receive
// the maximum position.
//-----------------------------------------------------------------------
void GetScrollRange( int nBar, LPINT lpMinPos, LPINT lpMaxPos ) const;
//-----------------------------------------------------------------------
// Summary:
// Retrieves the position of the scroll box.
// Parameters:
// nBar : [in] Specifies the scroll bar to examine. The parameter can
// take one of the following values:
// [ul]
// [li]SB_HORZ - Retrieves the position of the horizontal
// scroll bar.[/li]
// [li]SB_VERT - Retrieves the position of the vertical
// scroll bar.[/li]
// [/ul]
// Returns:
// The current position of the scroll box in the scroll bar if it is
// successful; otherwise, it is zero.
//-----------------------------------------------------------------------
int GetScrollPos(int nBar) const;
// ----------------------------------------------------------------------
// Summary:
// Scrolls the window along with the contents for the specified x and
// y
// Parameters:
// yPos : [in] Scroll vertically in rows.
// xPos : [in] Scroll Horizontally in columns.
//
// ----------------------------------------------------------------------
void Scroll(int xPos, int yPos);
//-----------------------------------------------------------------------
// Summary:
// Scrolls the window to a specific location where the specified row
// Parameters:
// nTextRow : [in] Row for lookup in document coordinates.
// Returns: TRUE or FALSE
//-----------------------------------------------------------------------
BOOL EnsureVisibleRow(int nTextRow);
//-----------------------------------------------------------------------
// Summary:
// Scrolls the window to a specific location where the specified row
// or col are visible.
// Parameters:
// nDispRow : [in] Row for lookup in display coordinates.
// nDispCol : [in] Column for lookup in display coordinates.
// Returns: TRUE or FALSE
//-----------------------------------------------------------------------
BOOL EnsureVisibleCol(int nDispRow, int nDispCol);
//-----------------------------------------------------------------------
// Summary:
// Creates the window
// Parameters:
// pParent : [in] Parent window (Must not be NULL)
// bHorzScroll : [in] TRUE if horizontal scroll bar is needed
// bVertScroll : [in] TRUE if vertical scroll bar is needed
// pBuffer : [in] A pointer to The buffer for the control (Used by splitter)
// lpCS : [in] Specifies the create context of the window.
// nID : [in] Specifies the control identifier.
// Returns: TRUE if created, FALSE otherwise
//-----------------------------------------------------------------------
BOOL Create(CWnd *pParent, BOOL bHorzScroll, BOOL bVertScroll,
CXTPSyntaxEditBufferManager *pBuffer = NULL,
CCreateContext *lpCS = NULL, UINT nID = 0);
//-----------------------------------------------------------------------
// Summary:
// Sets Breakpoint shape at specified row.
// Parameters:
// nRow : [in] A row identifier in document coordinates.
//-----------------------------------------------------------------------
void AddRemoveBreakPoint(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Sets Bookmark shape at specified row.
// Parameters:
// nRow : [in] A row identifier in document coordinates.
//-----------------------------------------------------------------------
void AddRemoveBookmark(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Expands/Collapses block at specified row.
// Parameters:
// nRow : [in] A row identifier in document coordinates.
//-----------------------------------------------------------------------
void CollapseExpandBlock(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Removes Breakpoint shape at specified row.
// Parameters:
// nRow : [in] A row identifier in document coordinates.
//-----------------------------------------------------------------------
void DeleteBreakpoint(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Removes Breakpoint shape at specified row.
// Parameters:
// nRow : [in] A row identifier in document coordinates.
//-----------------------------------------------------------------------
void DeleteBookmark(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Moves the current position to the previous bookmark.
//-----------------------------------------------------------------------
void PrevBookmark();
//-----------------------------------------------------------------------
// Summary:
// Moves the current position to the next bookmark.
//-----------------------------------------------------------------------
void NextBookmark();
//-----------------------------------------------------------------------
// Summary:
// Determines if the current document has breakpoints.
// Returns:
// TRUE if breakpoints were set; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL HasBreakpoints() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if the current document has bookmarks.
// Returns:
// TRUE if bookmarks were set; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL HasBookmarks() const;
//-----------------------------------------------------------------------
// Summary:
// Retrieves a row mark for the specified row.
// Parameters:
// nRow : [in] row identifier in document coordinates.
// lmType : [in] type of line mark.
// pParam : [in] a pointer to a parameter structure.
// Returns:
// TRUE if specified row mark exists at the specified row, FALSE otherwise.
// See also:
// XTP_EDIT_LINEMARKTYPE, XTP_EDIT_LMPARAM
//-----------------------------------------------------------------------
BOOL HasRowMark(int nRow, const XTP_EDIT_LINEMARKTYPE& lmType, XTP_EDIT_LMPARAM* pParam = NULL) const;
//-----------------------------------------------------------------------
// Summary:
// Collapses all expanded collapsible nodes.
// See Also:
// void ExpandAll();
//-----------------------------------------------------------------------
void CollapseAll();
//-----------------------------------------------------------------------
// Summary:
// Expands all collapsed nodes.
// See Also:
// void CollapseAll();
//-----------------------------------------------------------------------
void ExpandAll();
//-----------------------------------------------------------------------
// Summary:
// Returns an array of available theme names from the configuration
// manager.
// Returns:
// A reference to CStringArray object containing available theme names.
//-----------------------------------------------------------------------
CStringArray& GetThemes();
//-----------------------------------------------------------------------
// Summary:
// Applies the theme with the specified name onto the editor.
// Parameters:
// strTheme : [in] theme name.
//-----------------------------------------------------------------------
void ApplyTheme(CString strTheme);
//-----------------------------------------------------------------------
// Summary:
// Returns current theme name.
// Returns:
// A reference to CString object with active theme name.
//-----------------------------------------------------------------------
CString GetCurrentTheme() const;
//-----------------------------------------------------------------------
// Summary:
// Refreshes colors for the current document.
// Remarks:
// Refreshing colors causes reread configuration files and reparsing
// the current document.
//-----------------------------------------------------------------------
virtual void RefreshColors();
//-----------------------------------------------------------------------
// Summary:
// Invalidates required row.
// Parameters:
// nRow : [in] row identifier in document coordinates.
//-----------------------------------------------------------------------
void InvalidateRow(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Invalidates given set of rows
// Parameters:
// nRowFrom : [in] first row identifier in document coordinates.
// nRowTo : [in] last row identifier in document coordinates.
//-----------------------------------------------------------------------
void InvalidateRows(int nRowFrom = -1, int nRowTo = -1);
//-----------------------------------------------------------------------
// Summary:
// Returns valid row flag.
// Parameters:
// nDispRow : [in] row identifier in document coordinates.
// Returns:
// TRUE if row valid; FALSE otherwise.
// See also:
// void SetRowValid(int nDispRow);
//-----------------------------------------------------------------------
BOOL IsRowValid(int nDispRow) const;
//-----------------------------------------------------------------------
// Summary:
// Sets valid flag for the row.
// Parameters:
// nDispRow : [in] row identifier in document coordinates.
// See also:
// BOOL IsRowValid(int nDispRow);
//-----------------------------------------------------------------------
void SetRowValid(int nDispRow);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the edit control has been activated
// or deactivated.
// Returns:
// TRUE if the edit control has been activated, otherwise FALSE.
//-----------------------------------------------------------------------
BOOL IsActive() const;
//-----------------------------------------------------------------------
// Summary:
// This member function is called the the edit control is being activated
// or deactivated.
// Parameters:
// bIsActive - TRUE if the edit control has been activated, otherwise FALSE.
//-----------------------------------------------------------------------
virtual void SetActive(BOOL bIsActive);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the edit control create and use
// scroll bars on parent window.
// Returns:
// TRUE if parent window scroll bars are used, otherwise FALSE.
//-----------------------------------------------------------------------
BOOL IsCreateScrollbarOnParent() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to define where scrollbars are created -
// in SyntaxEdit control window or in parent window.
// Parameters:
// nSet - TRUE if parent window scroll bars should be used, otherwise FALSE.
//-----------------------------------------------------------------------
void SetCreateScrollbarOnParent(BOOL nSet);
//-----------------------------------------------------------------------
// Summary:
// Determines if a document can be modified by checking ReadOnly
// property value and sending XTP_EDIT_NM_EDITCHANGING notification
// to parent.
// Returns:
// TRUE if the document can be edited, FALSE otherwise.
//-----------------------------------------------------------------------
virtual BOOL CanEditDoc() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if editor in read-only mode.
// Returns:
// TRUE if the editor in read-only mode, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsReadOnly() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to set editor read-only mode.
// Parameters:
// bReadOnly - Set as TRUE to switch editor in read-only mode, FALSE otherwise.
//-----------------------------------------------------------------------
virtual void SetReadOnly(BOOL bReadOnly = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Determines if editor in view-only mode.
// Comment:
// ViewOnly mode - same as ReadOnly but with normal background
// no cursor (carret), no selectable text, no copy\paste.
// Returns:
// TRUE if the editor in read-only mode, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsViewOnly() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to set editor view-only mode.
// Comment:
// ViewOnly mode - same as ReadOnly but with normal background
// no cursor (carret), no selectable text, no copy\paste.
// Parameters:
// bViewOnly - Set as TRUE to switch editor in view-only mode, FALSE otherwise.
//-----------------------------------------------------------------------
void SetViewOnly(BOOL bViewOnly);
//-----------------------------------------------------------------------
// Summary:
// Determines if editor internally catch standard editor accelerators:
// Ctrl+C, Ctrl+V, Ctrl+X, Ctrl+Y, Ctrl+Z, Ctrl+Shift+Z, Ctrl+A,
// Ctrl+Ins, Shift+Ins, Alt+Backspace.
// Remarks:
// You can support any of these editing operations externally, by call
// of member functions. By default this feature is off.
// Returns:
// TRUE if accelerators internally supported, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsEnabledEditAccelerators() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to enable or disable standard editor accelerators
// processing. By default this feature is off.
// Parameters:
// bEnable - Set as TRUE to enable accelerators, FALSE otherwise.
//-----------------------------------------------------------------------
void EnableEditAccelerators(BOOL bEnable);
BOOL HasFocus() const;
//{{AFX_CODEJOCK_PRIVATE
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
virtual void PreSubclassWindow();
virtual void OnFinalRelease();
virtual BOOL _InitEditControl();
virtual DWORD ProcessCollapsedRowsBeroreDraw(int nTextRow,
int& rnSkipRowsCount);
virtual BOOL _IsVirtualSpaceActive() const;
virtual void _EnsureVisible(int nTextRow, int nDispCol);
virtual BOOL SetValueInt(LPCTSTR lpszValue, int nNewValue, int& nRefValue, BOOL bUpdateReg);
virtual BOOL SetValueBool(LPCTSTR lpszValue, BOOL bNewValue, BOOL& bRefValue, BOOL bUpdateReg);
void SetInternalRowBkColor(int nRow, COLORREF crBack);
void SetInternalRowColor(int nRow, COLORREF crText);
protected:
afx_msg void OnPaint();
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnDestroy();
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnSetFocus(CWnd* pOldWnd);
afx_msg BOOL OnNcActivate(BOOL bActive);
afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
afx_msg void OnTimer(UINT_PTR nIDEvent);
afx_msg void OnKillFocus(CWnd* pNewWnd);
afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
afx_msg void OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized);
afx_msg LRESULT OnSetText(WPARAM wParam, LPARAM lParam);
afx_msg LRESULT OnGetText(WPARAM wBufferSize, LPARAM lpBuffer);
afx_msg LRESULT OnGetTextLen(WPARAM wParam, LPARAM lParam);
afx_msg LRESULT OnGetFont(WPARAM wParam, LPARAM lParam);
afx_msg LRESULT OnSetFont(WPARAM wParam, LPARAM lParam);
afx_msg LRESULT OnInputLanguage(WPARAM wParam, LPARAM lParam);
afx_msg void OnDragCopy();
afx_msg void OnDragMove();
afx_msg UINT OnGetDlgCode();
DECLARE_MESSAGE_MAP()
//}}AFX_CODEJOCK_PRIVATE
/////////////////////////////////////////////////////////////////
// Methods
/////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------
// Summary:
// Calculates rect(s) for Collapsible node icon
// Parameters:
// nDispRow : [in] The window row number for which to print
// rcNode : [out] Reference to CRect variable to receive node
// icon rect
// prcNodeFull : [out] Pointer to CRect variable to receive full
// node area rect
//-----------------------------------------------------------------------
void GetLineNodeRect(int nDispRow, CRect& rcNode, CRect* prcNodeFull = NULL) const;
//-----------------------------------------------------------------------
// Summary:
// Calculates the edit bar length and stores it into m_nEditbarLength
// member variable depending upon the gutter length and visibility and
// line number length and visibility.
// Parameters:
// pDC : [in] A pointer to device context to draw.
//-----------------------------------------------------------------------
void CalculateEditbarLength(CDC* pDC= NULL);
//-----------------------------------------------------------------------
// Summary:
// Recalculates and set the scroll bars depending on the text size
// and current position.
//-----------------------------------------------------------------------
void _RecalcScrollBars();
//-----------------------------------------------------------------------
// Summary:
// Recalculates and set m_nHScrollMaxWidth member depending on the visible
// text size.
//-----------------------------------------------------------------------
void _RecalcHScrollMaxWidth();
//-----------------------------------------------------------------------
// Summary:
// This member function is called to update Is IME mode supported at
// the current time.
//-----------------------------------------------------------------------
void _UpdateIMEStatus();
//-----------------------------------------------------------------------
// Summary:
// Add number of tabs and spaces required to reach nDispColl.
// Parameters:
// rstrTextToIns : [in out] Text to be inserted
// nDispColl : [in] A display column number to reach to.
//-----------------------------------------------------------------------
void FillTabs(CString &rstrTextToIns, int nDispColl);
//-----------------------------------------------------------------------
// Summary:
// Fills and/or calculates number of tabs or blank spaces required.
// Parameters:
// szText : [in] Text to be inserted
// strTextToIns : [out] Return string with all the indentation
// iNewRow : [out] New row
// iNewCol : [out] New col (absolute)
// iNewDispCol : [out] New display col
// iEditRowFrom : [out] Start row for XTP_EDIT_NM_EDITCHANGED
// iEditRowTo : [out] End row for XTP_EDIT_NM_EDITCHANGED
// iChainActionCount : [out] Chain action count for undo
// Returns:
// TRUE if the operation is successful, FALSE else.
//-----------------------------------------------------------------------
BOOL CreateInsertText(LPTSTR szText, CString& strTextToIns,int& iNewRow,int& iNewCol,
int& iNewDispCol, int& iEditRowFrom, int& iEditRowTo,int& iChainActionCount);
//-----------------------------------------------------------------------
// Summary:
// Send XTP_EDIT_NM_EDITCHANGED notification with specified parameters.
// Parameters:
// iRowFrom : [in] Start row identifier.
// iRowTo : [in] End row identifier.
// nActions : [in] Action mask.
//-----------------------------------------------------------------------
void NotifyEditChanged(int iRowFrom, int iRowTo, UINT nActions);
//-----------------------------------------------------------------------
// Summary:
// Sends notification when current text position was changed.
// Parameters:
// nRow: [in] Row to be notified in document coordinates.
// nCol: [in] Column to be notified.
// Remarks:
// Call this member function to send notification to the parent class
// about the row col changes.
//-----------------------------------------------------------------------
void NotifyCurRowCol(int nRow, int nCol) const;
//-----------------------------------------------------------------------
// Summary:
// Send any notification to parent.
// Parameters:
// uCode : [in] The notification code to send.
//-----------------------------------------------------------------------
virtual LRESULT NotifyParent(UINT uCode) const;
//-----------------------------------------------------------------------
// Summary:
// Send any mouse notification to parent.
// Parameters:
// uCode : [in] A mouse event notify code (like XTP_EDIT_NM_LBUTTONDOWN or other).
// nFlags : [in] A mouse event flags.
// point : [in] A mouse event cursor position.
// See Also:
// XTP_EDIT_NM_LBUTTONDOWN, XTP_EDIT_NM_LBUTTONDBLCLICK, XTP_EDIT_NM_LBUTTONUP,
// XTP_EDIT_NM_RBUTTONDOWN, XTP_EDIT_NM_RBUTTONUP, XTP_EDIT_NM_MOUSEMOVE.
//-----------------------------------------------------------------------
virtual LRESULT NotifyMouseEvent(UINT uCode, UINT nFlags, const CPoint& point) const;
//-----------------------------------------------------------------------
// Summary:
// Send any notification to parent that user click in the bookmark area.
// Parameters:
// nRow : [in] Document row.
// nDispRow : [in] Visible row.
// Returns:
// TRUE if action was handled, FALSE otherwise.
//-----------------------------------------------------------------------
virtual BOOL NotifyMarginLBtnClick(int nRow, int nDispRow) const;
//-----------------------------------------------------------------------
// Summary:
// Initialize selection of all the sibling views.
//-----------------------------------------------------------------------
virtual void NotifySelInit() const;
//-----------------------------------------------------------------------
// Summary:
// Recalculates horizontal scroll bar
//-----------------------------------------------------------------------
void RecalcHorzScrollPos();
//-----------------------------------------------------------------------
// Summary:
// Recalculates vertical scroll bar
//-----------------------------------------------------------------------
void RecalcVertScrollPos();
//-----------------------------------------------------------------------
// Summary:
// Find the next(or previouse) word position depending on the
// parameter supplied.
// Parameters:
// nFindWhat : [in] XTP_EDIT_FINDWORD_PREV to find previous and
// XTP_EDIT_FINDWORD_NEXT to find next word.
//-----------------------------------------------------------------------
void FindWord(UINT nFindWhat);
//-----------------------------------------------------------------------
// Summary:
// Find the next(or previouse) word position depending on the
// parameter supplied.
// Parameters:
// nFindWhat : [in] XTP_EDIT_FINDWORD_PREV to find previous and
// XTP_EDIT_FINDWORD_NEXT to find next word.
// nTextRow : [in] A text row number to start finding.
// nCol : [in] A column number to start finding (1 based value).
// rlcWordStart : [out] A reference to XTP_EDIT_LINECOL object
// to receive word start position.
// rlcWordEnd : [out] A reference to XTP_EDIT_LINECOL object
// to receive word end position.
// rbOverSpace : [out] A reference to BOOL variable to receive
// if finding started from space or tab character.
// Returns:
// TRUE if the word is found, FALSE else.
//-----------------------------------------------------------------------
BOOL FindWordEx(UINT nFindWhat, int nTextRow, int nCol,
XTP_EDIT_LINECOL& rlcWordStart, XTP_EDIT_LINECOL& rlcWordEnd,
BOOL& rbOverSpace);
//-----------------------------------------------------------------------
// Summary:
// Find the next(or previouse) word position depending on the
// parameter supplied.
// Parameters:
// nFindWhat : [in] XTP_EDIT_FINDWORD_PREV to find previous and
// XTP_EDIT_FINDWORD_NEXT to find next word.
// nTextRow : [in] A text row number to start finding.
// lcPos_str : [in] A text position to start finding (column
// is a 0 based value).
// rlcWordStart : [out] A reference to XTP_EDIT_LINECOL object
// to receive word start position.
// rlcWordEnd : [out] A reference to XTP_EDIT_LINECOL object
// to receive word end position.
// rbOverSpace : [out] A reference to BOOL variable to receive
// if finding started from space or tab character.
//-----------------------------------------------------------------------
BOOL FindWordEx_str(UINT nFindWhat, XTP_EDIT_LINECOL lcPos_str,
XTP_EDIT_LINECOL& rlcWordStart, XTP_EDIT_LINECOL& rlcWordEnd,
BOOL& rbOverSpace);
//-----------------------------------------------------------------------
// Summary:
// Try to match text on the supplied parameters.
// Parameters:
// nRow : [in] Row to match for.
// szLineText : [in] Line text.
// szMatchText : [in] Text to be matched.
// nStartPos : [in] Start position.
// bMatchWholeWord : [in] Has to match whole word or not.
// bMatchCase : [in] Case to be matched or not.
// bSearchForward : [in] TRUE if it is to search forward.
// bRedraw : [in] TRUE for redraw control after search.
// Returns:
// TRUE if the operation is successful, FALSE else.
//-----------------------------------------------------------------------
BOOL MatchText(int nRow, LPCTSTR szLineText, LPCTSTR szMatchText, int nStartPos,
BOOL bMatchWholeWord, BOOL bMatchCase, BOOL bSearchForward,
BOOL bRedraw = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Returns the effective parent.
// Returns:
// The parent window in form of CWnd*.
//-----------------------------------------------------------------------
CWnd* GetEffectiveParent() const;
//-----------------------------------------------------------------------
// Summary:
// Calculate and returns the display column for another display column
// specified in the iCol parameter.
// Parameters:
// szText : [in] The text on which the calculation should be made.
// iCol : [in] The display column for which calculation is needed.
// Returns:
// The display column as integer value.
//-----------------------------------------------------------------------
int CalcValidDispCol(LPCTSTR szText, int iCol) const;
//-----------------------------------------------------------------------
// Summary:
// Returns the absolute column for a display column.
// Parameters:
// szText : [in] The text for which calculation is needed.
// nDispCol : [in] The valid display column.
// Returns:
// The absolute column.
//-----------------------------------------------------------------------
int CalcAbsCol(LPCTSTR szText, int nDispCol) const;
//-----------------------------------------------------------------------
// Summary:
// Calculates and returns the display column for the specified
// absolute column.
// Parameters:
// szText : [in] The text for calculation.
// nActualCol : [in] The actual (absolute) column position.
// Returns:
// The calculated display column.
//-----------------------------------------------------------------------
int CalcDispCol(LPCTSTR szText, int nActualCol) const;
public:
//-----------------------------------------------------------------------
// Summary:
// Calculates and returns the display column for the specified
// displayed column.
// Parameters:
// szText : [in] The text for calculation.
// nDispCol : [in] The displayed column position.
// nTextRow : [in] The text row number.
// Returns:
// The calculated display column.
//-----------------------------------------------------------------------
int CalcAbsCol(int nTextRow, int nDispCol) const;
//-----------------------------------------------------------------------
// Summary:
// Calculates and returns the display column for the specified
// absolute column.
// Parameters:
// nActualCol : [in] The actual (absolute) column position.
// nTextRow : [in] The text row number.
// Returns:
// The calculated display column.
//-----------------------------------------------------------------------
int CalcDispCol(int nTextRow, int nActualCol) const;
//-----------------------------------------------------------------------
// Summary:
// Returns a pointer to the line marks manager associated with the
// current text buffer.
// Returns:
// Pointer to CXTPSyntaxEditLineMarksManager
//-----------------------------------------------------------------------
CXTPSyntaxEditLineMarksManager* GetLineMarksManager() const;
//-----------------------------------------------------------------------
// Summary:
// Use this member function to set new text value for specified row.
// Parameters:
// nRow : [in] The text row number.
// pcszText : [in] The row text new value.
// bCanUndo : [in] Pass TRUE if this can be undone.
// Remarks:
// The parser is notified to reparse changed text.
//-----------------------------------------------------------------------
void SetRowText(int nRow, LPCTSTR pcszText, BOOL bCanUndo);
//-----------------------------------------------------------------------
// Summary:
// Use this member function to insert new row.
// Parameters:
// nRow : [in] The row number to insert at.
// pcszText : [in] The new row text.
// bCanUndo : [in] Pass TRUE if this can be undone.
// Remarks:
// The parser is notified to reparse changed text.
//-----------------------------------------------------------------------
void InsertRow(int nRow, LPCTSTR pcszText, BOOL bCanUndo);
//-----------------------------------------------------------------------
// Summary:
// Use this member function to remove row.
// Parameters:
// nRow : [in] The row number to remove.
// bCanUndo : [in] Pass TRUE if this can be undone.
// Remarks:
// The parser is notified to reparse changed text.
//-----------------------------------------------------------------------
void RemoveRow(int nRow, BOOL bCanUndo);
//-----------------------------------------------------------------------
// Summary:
// This member function is used to retrieve text colors for the
// specified row. It is called by the edit control from drawing procedure.
// Parameters:
// nTextRow : [in] The row number to retrieve text colors.
// nColFrom : [in] The start column number (zero based).
// nColTo : [in] The end column number (zero based). Value -1 means
// line end.
// clrDefault : [in] A const reference to structure which contains
// default text colors. CXTPSyntaxEditPaintManager::m_clrValues
// passed by default.
// rBlocks : [out] A pointer to CXTPSyntaxEditTextBlockList object
// to return text colors.
// Remarks:
// The default implementation call CXTPSyntaxEditLexTextSchema::GetRowColors.
// You may override this method and create own fast implementation
// for the simple colors schemas.
//-----------------------------------------------------------------------
virtual void GetRowColors(int nTextRow, int nColFrom, int nColTo,
const XTP_EDIT_COLORVALUES& clrDefault,
CXTPSyntaxEditTextBlockList* rBlocks);
//-----------------------------------------------------------------------
// Summary:
// This member function is used to retrieve collapsable text blocks
// for the specified row. It is called by the edit control.
// Parameters:
// nTextRow : [in] The row number to retrieve text colors.
// rArBlocks : [out] A reference to CXTPSyntaxEditRowsBlockArray object
// to return collapsable text blocks.
// Remarks:
// The default implementation call CXTPSyntaxEditLexTextSchema::GetCollapsableBlocksInfo.
// You may override this method and create own fast implementation.
//-----------------------------------------------------------------------
virtual void GetCollapsableBlocksInfo(int nTextRow,
CXTPSyntaxEditRowsBlockArray& rArBlocks) const;
public:
//-----------------------------------------------------------------------
// Summary:
// Returns a text for the specified line.
// Parameters:
// nRow : [in] Row identifier.
// bAddCRLF : [in] Boolean flag how to process end of text lines.
// Default is FALSE.
// iCRLFStyle : [in] Style of end of text lines. Default is -1.
// Returns:
// Reference to CString with text.
// See Also: CXTPSyntaxEditBufferManager::GetLineText
//-----------------------------------------------------------------------
CString GetLineText(int nRow, BOOL bAddCRLF = FALSE, int iCRLFStyle = -1) const;
//-----------------------------------------------------------------------
// Summary:
// Gets a text for the specified line.
// Parameters:
// nRow : [in] Row identifier.
// strBuffer : [out] Reference to text buffer to put returned text.
// bAddCRLF : [in] Boolean flag how to process end of text lines.
// Default is FALSE.
// iCRLFStyle : [in] Style of end of text lines. Default is -1.
// See Also: CXTPSyntaxEditBufferManager::GetLineText
//-----------------------------------------------------------------------
void GetLineText(int nRow, CString& strBuffer, BOOL bAddCRLF = FALSE, int iCRLFStyle = -1) const;
protected:
//-----------------------------------------------------------------------
// Summary:
// Expands the character set by putting space in the position of tab.
// Parameters:
// pDC : [in] A pointer to CDC object.
// pszChars : [in] The text to be processed.
// strBufer : [in] Buffer for text to be created after expansion.
// nCurPos : [in] The current position in the line.
// Returns:
// The length of processed text after expansion.
//-----------------------------------------------------------------------
int ExpandChars(CDC* pDC, LPCTSTR pszChars, int nCurPos, CString& strBufer);
//-----------------------------------------------------------------------
// Summary:
// Calculate collapsed text sign rect (like for [..])
// Parameters:
// pDC : [in] A pointer to CDC object.
// pCoDrawBlk : [in] Pointer to XTP_EDIT_COLLAPSEDBLOCK structure.
// rcCoBlk : [in, out] A reference to rectangle with collapced
// block text area. The right border is updated by this function.
// See also:
// struct XTP_EDIT_COLLAPSEDBLOCK
//-----------------------------------------------------------------------
void ProcessCollapsedText(CDC* pDC, XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk, CRect& rcCoBlk);
//-----------------------------------------------------------------------
// Summary:
// The same functionality as for ProcessCollapsedText but performs some
// additional checks for input parameters.
// Parameters:
// pDC : [in] A pointer to CDC object.
// pCoDrawBlk : [in] Pointer to XTP_EDIT_COLLAPSEDBLOCK structure.
// txtBlk : [in] Pointer to XTP_EDIT_TEXTBLOCK structure.
// rcCoBlk : [in, out] A reference to rectangle with collapsed
// block text area. The right border is updated by this function.
// Returns:
// TRUE if the operation is successful, FALSE else.
// See also:
// struct XTP_EDIT_COLLAPSEDBLOCK, struct XTP_EDIT_TEXTBLOCK
//-----------------------------------------------------------------------
BOOL ProcessCollapsedTextEx(CDC* pDC, XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk,
const XTP_EDIT_TEXTBLOCK& txtBlk, CRect& rcCoBlk);
//-----------------------------------------------------------------------
// Summary:
// Returns a collapsed text for the specified collapsed block.
// Parameters:
// pCoDrawBlk : [in] XTP_EDIT_COLLAPSEDBLOCK structure.
// nMaxLinesCount : [in] Max lines of text. Default is 150.
// Returns:
// CString object with text for collapsed block.
// See also:
// struct XTP_EDIT_COLLAPSEDBLOCK
//-----------------------------------------------------------------------
CString GetCollapsedText(XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk, int nMaxLinesCount = 150) const;
//-----------------------------------------------------------------------
// Summary:
// Finds collapsed block on the specified point if exist.
// Parameters:
// ptMouse : [in] Mouse coordinates where to check for collapsed block.
// Returns:
// Pointer to the XTP_EDIT_COLLAPSEDBLOCK structure with collapsed block
// parameters if it found, NULL otherwise.
// See also:
// struct XTP_EDIT_COLLAPSEDBLOCK.
//-----------------------------------------------------------------------
XTP_EDIT_COLLAPSEDBLOCK* GetBlockFromPt(const CPoint& ptMouse) const;
//-----------------------------------------------------------------------
// Summary:
// Shows tool tip with the text of the collapsed block on the specified
// point.
// Parameters:
// ptMouse : [in] Mouse coordinates where to check for tooltip.
// See also:
// CXTPSyntaxEditToolTipCtrl, m_wndToolTip
//-----------------------------------------------------------------------
void ShowCollapsedToolTip(const CPoint& ptMouse);
//-----------------------------------------------------------------------
// Summary:
// Expand collapsed block if double clicked on it.
// Parameters:
// ptMouse : [in] Mouse coordinates where to check for collapsed block.
// Returns:
// A number of row where collapsed block was expanded, 0 if collapsed
// block was not expanded.
// See also:
// CXTPSyntaxEditToolTipCtrl
//-----------------------------------------------------------------------
int ProcessCollapsedBlockDblClick(const CPoint& ptMouse);
//-----------------------------------------------------------------------
// Summary:
// Updates the sibling views while in split mode.
// Parameters:
// dwUpdate : [in] Specifies the view update flags.
//-----------------------------------------------------------------------
void UpdateScrollPos(DWORD dwUpdate = XTP_EDIT_UPDATE_ALL);
//-----------------------------------------------------------------------
// Summary:
// Sets or clears the modification flag for the currently opened
// document.
// Parameters:
// bModified : [in] TRUE if want to set the document modified.
// Default is TRUE.
//-----------------------------------------------------------------------
void SetDocModified(BOOL bModified = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Calculates the maximum width for a text.
// Parameters:
// szText : [in] The text for calculation.
// Returns:
// The maximum width.
//-----------------------------------------------------------------------
int CalcMaximumWidth(LPCTSTR szText);
//-----------------------------------------------------------------------
// Summary:
// Returns a filename of the default ini configuration file.
// Returns:
// CString objects with filename.
//-----------------------------------------------------------------------
CString GetDefaultCfgFilePath();
//-----------------------------------------------------------------------
// Summary:
// Internal editing event handler.
// Parameters:
// nRow : [in] Row identifier.
// nCol : [in] Column identifier.
//-----------------------------------------------------------------------
void OnBeforeEditChanged(int nRow, int nCol);
//-----------------------------------------------------------------------
// Summary:
// Internal editing event handler.
// Parameters:
// nRowFrom : [in] Start row identifier.
// nColFrom : [in] Start column identifier.
// nRowTo : [in] End row identifier.
// nColTo : [in] End column identifier.
// eEditAction : [in] Action identifier.
//-----------------------------------------------------------------------
void OnEditChanged(int nRowFrom, int nColFrom, int nRowTo, int nColTo, int eEditAction);
//-----------------------------------------------------------------------
// Summary:
// Internal editing event handler.
// Parameters:
// LCFrom : [in] Start coordinates.
// LCTo : [in] End coordinates.
// eEditAction : [in] Action identifier.
// See also:
// struct XTP_EDIT_LINECOL
//-----------------------------------------------------------------------
void OnEditChanged(const XTP_EDIT_LINECOL& LCFrom, const XTP_EDIT_LINECOL& LCTo, int eEditAction);
//-----------------------------------------------------------------------
// Summary:
// Internal editing event handler.
// Parameters:
// code : [in] Event code.
// wParam : [in] Event parameter 1.
// lParam : [in] Event parameter 2.
// See also:
// XTP_NOTIFY_CODE
//-----------------------------------------------------------------------
void OnParseEvent(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam);
//-----------------------------------------------------------------------
// Summary:
// Send WM_NOTIFY with XTP_EDIT_NM_PARSEEVENT code to parent window.
// Parameters:
// code : [in] Event code from XTPSyntaxEditOnParseEvent enum.
// wParam : [in] Event parameter 1.
// lParam : [in] Event parameter 2.
// Returns:
// TRUE if the operation is successful, FALSE else.
// See Also:
// XTPSyntaxEditOnParseEvent
//-----------------------------------------------------------------------
BOOL NotifyParseEvent(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam);
//-----------------------------------------------------------------------
// Summary:
// Internal editing event handler.
// Parameters:
// code : [in] Event code from XTPSyntaxEditOnCfgChangedEvent enum.
// wParam : [in] Event parameter 1.
// lParam : [in] Event parameter 2.
// See also:
// XTPSyntaxEditOnCfgChangedEvent
//-----------------------------------------------------------------------
void OnLexCfgWasChanged(XTP_NOTIFY_CODE code, WPARAM wParam, LPARAM lParam);
//-----------------------------------------------------------------------
// Summary:
// Returns current document row number.
// Returns:
// Current document row integer value.
// See also:
// void SetCurrentDocumentRow(int nRow);
//-----------------------------------------------------------------------
int GetCurrentDocumentRow() const;
//-----------------------------------------------------------------------
// Summary:
// Set row number as current document row.
// Parameters:
// nRow : [in] row number.
// See also:
// int GetCurrentDocumentRow();
//-----------------------------------------------------------------------
void SetCurrentDocumentRow(int nRow);
//-----------------------------------------------------------------------
// Summary:
// Returns current visible row number.
// Returns:
// Integer value of current visible row.
//-----------------------------------------------------------------------
int GetCurrentVisibleRow();
//-----------------------------------------------------------------------
// Summary:
// Calculates document row basing in visible row.
// Parameters:
// nVisibleRow : [in] Visible row.
// Returns:
// Integer value of document row.
// See also:
// int GetCurrentVisibleRow();
//-----------------------------------------------------------------------
int GetDocumentRow(int nVisibleRow);
//-----------------------------------------------------------------------
// Summary:
// Calculates document row basing in global visible row.
// Parameters:
// nStartDocumentRow : [in] Start document row.
// nRowDelta : [in] Visible rows count.
// Returns:
// Integer value of document row.
//-----------------------------------------------------------------------
int CalculateDocumentRow(int nStartDocumentRow, int nRowDelta);
//-----------------------------------------------------------------------
// Summary:
// Calculates visible row basing in document row.
// Parameters:
// nDocumentRow : [in] Document row.
// Returns:
// Integer value of visible row.
//-----------------------------------------------------------------------
int GetVisibleRow(int nDocumentRow);
//-----------------------------------------------------------------------
// Summary:
// Calculates global visible row basing in document row.
// Parameters:
// nStartDocumentRow : [in] Start row.
// nDocumentRow : [in] Count of document rows.
// Returns:
// Integer value of global visible row.
//-----------------------------------------------------------------------
int CalculateVisibleRow(int nStartDocumentRow, int nDocumentRow);
//-----------------------------------------------------------------------
// Summary:
// Returns maximum visible rows count.
// Parameters:
// nMaxDocRow : [in] Max document row up to which calculate visible
// rows. If you pass -1 then calculate up to the
// end of the document. -1 is default value.
// Returns:
// Integer value of maximum visible rows count.
//-----------------------------------------------------------------------
int GetVisibleRowsCount(int nMaxDocRow = -1);
//-----------------------------------------------------------------------
// Summary:
// Moves current row up on a number of rows.
// Parameters:
// nCount : [in] Count of rows.
// Returns:
// Integer value of current visible row.
//-----------------------------------------------------------------------
int MoveCurrentVisibleRowUp(int nCount);
//-----------------------------------------------------------------------
// Summary:
// Moves current row down on a number of rows.
// Parameters:
// nCount : [in] Count of rows.
// Returns:
// Integer value of current visible row.
//-----------------------------------------------------------------------
int MoveCurrentVisibleRowDown(int nCount);
//-----------------------------------------------------------------------
// Summary:
// Shifts current row up on a number of rows.
// Parameters:
// nCount : [in] Count of rows.
// bChangeCaret : [in] Caret movement flag, default is FALSE.
// Returns:
// TRUE if screen is changed; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL ShiftCurrentVisibleRowUp(int nCount, BOOL bChangeCaret = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Shifts current row down on a number of rows.
// Parameters:
// nCount : [in] Count of rows.
// bChangeCaret : [in] Caret movement flag, default is FALSE.
// Returns:
// TRUE if screen is changed; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL ShiftCurrentVisibleRowDown(int nCount, BOOL bChangeCaret = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Gets length of collapsed block.
// Parameters:
// nStartRow : [in] Start row of collapsed block.
// rnLen : [out] Reference to store length value.
// Returns:
// TRUE if success; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetCollapsedBlockLen(int nStartRow, int& rnLen) const;
//-----------------------------------------------------------------------
// Summary:
// Gets the type of row node.
// Parameters:
// nRow : [in] Row identifier.
// dwType : [out] Reference to store row node type.
// Returns:
// TRUE if success; FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetRowNodes(int nRow, DWORD& dwType) const;
//-----------------------------------------------------------------------
// Summary:
// Loads data into auto complete list.
//-----------------------------------------------------------------------
virtual void SetAutoCompleteList();
//-----------------------------------------------------------------------
// Summary:
// Refreshes line marks depending on change type.
// Parameters:
// pEditChanged : [in] Pointer to XTP_EDIT_NMHDR_EDITCHANGED structure.
// See also:
// LPXTP_EDIT_NMHDR_EDITCHANGED
//-----------------------------------------------------------------------
virtual void RefreshLineMarks(XTP_EDIT_NMHDR_EDITCHANGED* pEditChanged);
//-----------------------------------------------------------------------
// Summary:
// Redraws line marks.
//-----------------------------------------------------------------------
virtual void RedrawLineMarks();
//-----------------------------------------------------------------------
// Summary:
// Performs Undo/Redo operations and common control properties
// adjustment.
// Parameters:
// nActionsCount : [in] A number of actions to undo/redo.
// bUndoRedo : [in] TRUE for performing Undo operations, FALSE for
// performing Redo operations.
// Returns:
// TRUE if success, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL DoUndoRedo(int nActionsCount, BOOL bUndoRedo);
//-----------------------------------------------------------------------
// Summary:
// Changes the case of the selection.
// Parameters:
// bUpper : [in] TRUE when changing selection case to Upper,
// FALSE when changing selection case to Lower.
// Returns:
// TRUE if performs successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL DoChangeSelectionCase(BOOL bUpper);
//-----------------------------------------------------------------------
// Summary:
// Changes the tabification of the selection.
// Parameters:
// bTabify : [in] TRUE when changing spaces to tabs,
// FALSE when changing tabs to spaces.
// Returns:
// TRUE if performs successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL DoChangeSelectionTabify(BOOL bTabify);
//-----------------------------------------------------------------------
// Summary:
// Use this method to read options from the registry.
// Returns:
// TRUE if performs successfully, FALSE otherwise.
//-----------------------------------------------------------------------
BOOL GetRegValues();
//-----------------------------------------------------------------------
// Summary:
// Use this method to internally update drawing information (like
// each character position) in the draw text processor.
// Parameters:
// nTextRow : Text Row
// Remarks:
// It just draw specified row on the memory device context.
//-----------------------------------------------------------------------
void UpdateRowInfoInternally(int nTextRow);
//-----------------------------------------------------------------------
// Summary:
// This method used to determine scroll direction for automatic
// scrolling (when selecting by mouse).
// Parameters:
// pnCols : [out] A pointer to int variable to receive columns count
// to scroll. May be NULL.
// pnRows : [out] A pointer to int variable to receive rows count
// to scroll. May be NULL.
// Returns:
// A flags from enum CXTPSyntaxEditCtrl::XTPScrolDirection.
//-----------------------------------------------------------------------
virtual DWORD GetAutoscrollDirection(int* pnCols = NULL, int* pnRows = NULL);
//-----------------------------------------------------------------------
// Summary:
// This method used to subtract selection size from the specified position.
// Parameters:
// lcDispPos : XTP_EDIT_LINECOL
// Returns:
// A subtracted position.
//-----------------------------------------------------------------------
XTP_EDIT_LINECOL _SubtractSelSizeFromPos(XTP_EDIT_LINECOL lcDispPos);
//-----------------------------------------------------------------------
// Summary:
// This method used to set variables for autoindent.
// Parameters:
// nBaseDocRow : [in] A text row to calculate autoindentstart.
// nDispCol_prev : [in] A previouse display column (before enter pressed).
//-----------------------------------------------------------------------
virtual void DoAutoIndentIfNeed(int nBaseDocRow, int nDispCol_prev);
//-----------------------------------------------------------------------
// Summary:
// This method used to notify parent window that scrollbar state changed.
// Parameters:
// dwScrollBar : [in] Define the scroll bar(s) to change state as
// WS_HSCROLL and WS_VSCROLL flags.
// dwState : [in] Define the scroll bar(s) state as WS_HSCROLL and
// WS_VSCROLL flags.
// Remarks:
// Default implementation send XTP_EDIT_NM_ENABLESCROLLBAR notification
// to the parent.
//-----------------------------------------------------------------------
virtual void _EnableScrollBarNotify(DWORD dwScrollBar, DWORD dwState);
private:
void RedrawScrollBar(int nBar);
void InvalidateAll();
protected:
CXTPSyntaxEditOptions* m_pOptions;
/////////////////////////////////////////////////////////////////////////
// Variables
/////////////////////////////////////////////////////////////////////////
BOOL m_bVertScrollBarEnabled;
BOOL m_bHorzScrollBarEnabled;
CXTPSyntaxEditRowColorMap m_mapInternalRowBkColor; // The map for row back colors
CXTPSyntaxEditRowColorMap m_mapInternalRowForeColor; // The map for row colors
CXTPNotifySink* m_pSink;
BOOL m_bVertScrollBar; // TRUE if horizontal scrollbar is to be enabled
BOOL m_bHorzScrollBar; // TRUE if vertical scrollbar is to be enabled
BOOL m_bScrolling; // Temporary variable to specify if scrolling by mouse wheel
BOOL m_bCaseSensitive; // Case sensitive
BOOL m_bEnableOleDrag; // Enables or disables OLE drag drop
BOOL m_bIsSmartIndent; // Smart indentation is enabled or not
BOOL m_bRightButtonDrag; // TRUE if user is dragging through right button
BOOL m_bIsScrollingEndRow; // Maintains a internal logic to draw the last row which is partly visible
BOOL m_bTokensLoaded; // Specifies if tokens are loaded or not
BOOL m_bDroppable; // TRUE if the current position is droppable
BOOL m_bDragging; // TRUE if in dragging mode
BOOL m_bIsDragging; // TRUE if dragging, FALSE otherwise
BOOL m_bPageDirty; // TRUE if the whole page is dirty
BOOL m_bIsActive; // TRUE if application is active.
BOOL m_bFocused; // States if focused or not
BOOL m_bCreateScrollbarOnParent; // TRUE if parent window scroll bars are used, otherwise FALSE.
BOOL m_bAllowExpandCollapse;
BOOL m_bActivateOnFocus; //Flag to activate control on focus set (like CXTPSyntaxEditView do)
int m_nTopCalculatedRow; // Top row of the last range of rows that have scrollbars properly calculated
int m_nBottomCalculatedRow; // Bottom row of the last range of rows that have scrollbars properly calculated
int m_nEditbarLength; // Edit bar length including gutter and line number
int m_nMarginLength; // Margin length
int m_nLineNumLength; // Line numbers length
int m_nNodesWidth; // The width of the nodes signs
int m_nInsertTabCount; // Temporarily stores the no of tabs to be inserted for auto indentation
int m_nInsertSpaceCount; // Temporarily stores the no of space to be inserted for auto indentation
int m_nAutoIndentCol; // Contains the column for auto indentation
int m_nTopRow; // Top row for display
int m_nCurrentDocumentRow; // Current row in the document
int m_nCurrentCol; // Current absolute column
int m_nDispCol; // Current display column
int m_nWheelScroll; // Lines to scroll on mouse wheel
int m_nAverageLineLen; // Average length of line
int m_nCollapsedTextRowsCount; // The total amount of collapsed blocks in the document,
DWORD m_dwInsertPos; // Current insert position
DWORD m_dwLastRedrawTime; // Stores last redrawing time
#ifndef _UNICODE
// DBCS Support (specially for IME)
BYTE m_chPrevLeadByte; // For none-UNICODE version IME sends double byte chars as 2 WM_CHAR messages. This member keep a lead byte until second byte receive to process them together.
#endif
CPoint m_ptDropPos; // Specifies the drop position
CPoint m_ptPrevMouse; // Stored mouse position of the previous tip showing.
CBitmap m_bmpCache; // Current view cached picture
CXTPSyntaxEditSelection* m_pSelection; // Current selection
//-----------------------------------------------------------------------
// Summary:
// This enum defines flags for autoscroll direction.
//-----------------------------------------------------------------------
enum XTPScrolDirection
{
xtpLeft = 0x0001, // Defines left direction.
xtpRight = 0x0010, // Defines right direction.
xtpTop = 0x0100, // Defines top direction.
xtpBottom = 0x1000, // Defines bottom direction.
};
DWORD m_dwAutoScrollDirection; // Store active auto scroll direction.
CXTPSyntaxEditBufferManager* m_pBuffer; // The buffer manager
CXTPSyntaxEditPaintManager* m_pPaintManeger;// The paint manager
CWnd* m_pParentWnd; // Points to parent window.
CUIntArray m_arCollapsedTextRows; // The array of rows with beginning of collapsed blocks.
CXTPSyntaxEditToolTipCtrl* m_pToolTip; // Tool tip window for collapsed blocks text.
CXTPSyntaxEditAutoCompleteWnd* m_pAutoComplete; // Auto complete popup window.
CString m_strDefaultCfgFilePath; // Store configuration file full name.
CString m_strSyntaxScheme; //The syntax scheme.
CString m_strColorScheme; //The color scheme.
int m_nHScrollMaxWidth; // Maximum horizontal scrollbar position.
BOOL m_bWndCreateInProgress; // Internal flag to indicate that windows creating is in progress.
//-----------------------------------------------------------------------
// Summary:
// Parameters:
// nForRow : ROW
// Returns:
// a pointer to the screen schema cache.
//-----------------------------------------------------------------------
XTPSyntaxEditLexAnalyser::CXTPSyntaxEditLexTextBlock* GetOnScreenSch(int nForRow);
//-----------------------------------------------------------------------
// Summary:
// Clears a screen schema cache.
// Parameters:
// nRowFrom : [in] An integer index of a row where to clear cache from.
//-----------------------------------------------------------------------
void ClearOnScreenSchCache(int nRowFrom);
//-----------------------------------------------------------------------
// Summary:
// Calculates an average line length from start row to end row.
// Parameters:
// nRowStart : [in] An integer index of a row where to calculate from.
// nRowEnd : [in] An integer index of a row where to calculate to.
// Returns:
// An average line length.
//-----------------------------------------------------------------------
virtual UINT CalcAveDataSize(int nRowStart, int nRowEnd);
// -----------------------------------------------------------------
// Summary:
// This member function registers the window class if it has not
// already been registered.
// Parameters:
// hInstance - Instance of resource where control is located
// Returns:
// A boolean value that specifies if the window is successfully
// registered.<p/>
// TRUE if the window class is successfully registered.<p/>
// Otherwise FALSE.
// -----------------------------------------------------------------
BOOL RegisterWindowClass(HINSTANCE hInstance = NULL);
//===========================================================================
// CXTPSyntaxEditCtrl::CTextSearchCache
//===========================================================================
class CTextSearchCache;
CTextSearchCache* m_fcCollapsable; // Collapsible rows cache
CTextSearchCache* m_fcRowColors; // Row colors cache
class CScreenSearchBlock;
class CScreenSearchCache;
CScreenSearchCache* m_arOnScreenSchCache; // On-screen schema cache for this control.
CByteArray m_arValidDispRows; // An array with indexes of valid displayed rows.
//===========================================================================
// CXTPSyntaxEditCtrl::CAverageVal
//===========================================================================
class CAverageVal
{
public:
// -----------------------------------------------------------------
// Summary:
// Constructs a average value object.
// Parameter:
// nDataSize - The data size.
// -----------------------------------------------------------------
CAverageVal(int nDataSize = 100);
// -----------------------------------------------------------------
// Summary:
// Add a vlue to the data collection.
// Parameter:
// uVal - value.
// -----------------------------------------------------------------
void AddValue(UINT uVal);
// -----------------------------------------------------------------
// Summary:
// Call this function to get the average value.
// Parameter:
// uDefaultIfNoData - the default value.
// Returns:
// A UINT value denoting the average of all data in the object.
// -----------------------------------------------------------------
UINT GetAverageValue(UINT uDefaultIfNoData = 0);
protected:
int m_nDataSize; //The data size.
int m_nNextIndex; //The next index.
CUIntArray m_arData; //The data collection.
};
CAverageVal m_aveRedrawScreenTime; //The redraw screen time.
//===========================================================================
CXTPSyntaxEditDrawTextProcessor* m_pDrawTextProcessor; //The draw text processor.
CImmWrapper* m_pImmWrapper; //The Imm wrapper.
BOOL m_bIMEsupported; //Tells whether the IME supported or not.
//for direct assignment (without SynaxEditControl files to read!)
CString m_sIniSet;
// String with default or passed type of rules,
// e.g. _T("[Schemes]\r\nCPP\r\n[Themes]\r\nDefault\r\nAlternative\r\n")
BOOL m_bConfigFileMode;
// TRUE if control read Config file with links to detailed setting (Syntax and Color schemes)
// FALSE if Syntax and Color schemes passed as strings using special functions
CString m_sPassedIniSet;
// String with passed type of rules,
// e.g. _T("[Schemes]\r\nVBS\r\n[Themes]\r\nDefault\r\nAlternative\r\n")
public:
BOOL m_bDisableRedraw;
// If TRUE - control window is not redraw, it is draw last window content (draw cached bitmap). FALSE by default.
BOOL m_bUseMonitor;
// TRUE if control use special thread to synchronize syntax rules with files with Syntax and Color schemes
// FALSE if control works "off-line"
// -----------------------------------------------------------------
// Summary:
// access function (also used in ActiveX)
//
// Returns:
// A boolean value that specifies current cofig file mode
//
// -----------------------------------------------------------------
BOOL IsConfigFileMode() { return m_bConfigFileMode; }
// -----------------------------------------------------------------
// Summary:
// access function (also used in ActiveX)
//
// Returns:
// String with current Syntax Scheme
// -----------------------------------------------------------------
CString GetSyntaxScheme() { return m_strSyntaxScheme; }
// -----------------------------------------------------------------
// Summary:
// access function (also used in ActiveX)
//
// Returns:
// String with current Color Scheme
// -----------------------------------------------------------------
CString GetColorScheme() { return m_strColorScheme; }
CString m_sCustomTitle;
//user-defined app title - can be used also in Print Job as unique identifier
// -----------------------------------------------------------------
// Summary:
// set functional params for non file-based mode
// Parameters:
// sPassedIniSet - passed string
//
// -----------------------------------------------------------------
void SetPassedIniSet(CString sPassedIniSet) { m_sPassedIniSet = sPassedIniSet; }
// -----------------------------------------------------------------
// Summary:
// set functional params for non file-based mode
// Parameters:
// sSyntaxScheme : syntax scheme as a string
// sColorScheme : color scheme as a string
// bScheme : additional flag to call in-place editor
// bColors : additional flag to call in-place editor
//
// -----------------------------------------------------------------
void SetSyntaxAndColorScheme(CString sSyntaxScheme, CString sColorScheme, BOOL bScheme = FALSE, BOOL bColors = FALSE);
// -----------------------------------------------------------------
// Summary:
// function to Reload Syntax String Mode
//
// -----------------------------------------------------------------
void ReloadSyntaxStringMode();
// -----------------------------------------------------------------
// Summary:
// function to Reload Syntax ConfigFile Mode
//
// -----------------------------------------------------------------
void ReloadSyntaxConfigFileMode();
};
/////////////////////////////////////////////////////////////////////////////
AFX_INLINE void CXTPSyntaxEditCtrl::InvalidateRow(int nDispRow) {
InvalidateRows(nDispRow, nDispRow);
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetAutoIndent() const {
return m_pOptions->m_bAutoIndent;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetSyntaxColor() const {
return m_pOptions->m_bSyntaxColor;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetSelMargin() const {
return m_pOptions->m_bSelMargin;
}
AFX_INLINE CXTPSyntaxEditBufferManager* CXTPSyntaxEditCtrl::GetEditBuffer() const {
return m_pBuffer;
}
AFX_INLINE CXTPSyntaxEditPaintManager* CXTPSyntaxEditCtrl::GetPaintManager() const {
return m_pPaintManeger;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetHorzScrollBar() const {
return m_bHorzScrollBar;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetVertScrollBar() const {
return m_bVertScrollBar;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsActive() const {
return m_bIsActive;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsCreateScrollbarOnParent() const {
return m_bCreateScrollbarOnParent;
}
AFX_INLINE void CXTPSyntaxEditCtrl::SetCreateScrollbarOnParent(BOOL bSet) {
m_bCreateScrollbarOnParent = bSet;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsEnabledVirtualSpace() const {
return m_pOptions->m_bVirtualSpace;
}
AFX_INLINE CXTPSyntaxEditAutoCompleteWnd* CXTPSyntaxEditCtrl::GetAutoCompleteWnd() const {
return m_pAutoComplete;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsReadOnly() const {
return m_pOptions->m_bReadOnly;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetLineNumbers() const {
return m_pOptions->m_bLineNumbers;
}
AFX_INLINE void CXTPSyntaxEditCtrl::SetReadOnly(BOOL bReadOnly) {
m_pOptions->m_bReadOnly = bReadOnly;
InvalidateAll();
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsViewOnly() const {
return m_pOptions->m_bViewOnly;
}
AFX_INLINE void CXTPSyntaxEditCtrl::SetViewOnly(BOOL bViewOnly) {
m_pOptions->m_bViewOnly = bViewOnly;
m_pOptions->m_bReadOnly = bViewOnly;
m_pOptions->m_bHideCaret = bViewOnly;
InvalidateAll();
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::HasFocus() const {
return m_bFocused;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsHideCaret() const {
return m_pOptions->m_bHideCaret;
}
AFX_INLINE void CXTPSyntaxEditCtrl::SetHideCaret(BOOL bHide) {
m_pOptions->m_bHideCaret = bHide;
if (m_hWnd)
Invalidate(FALSE);
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetCollapsibleNodes() const {
return m_pOptions->m_bDrawNodes;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsEnabledEditAccelerators() const {
return m_pOptions->m_bEnableEditAccelerators;
}
AFX_INLINE void CXTPSyntaxEditCtrl::EnableEditAccelerators(BOOL bEnable) {
m_pOptions->m_bEnableEditAccelerators = bEnable;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::_IsVirtualSpaceActive() const
{
BOOL bVirtualSpace = IsEnabledVirtualSpace();
return bVirtualSpace;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsEnabledWhiteSpace() const
{
return m_pOptions->m_bEnableWhiteSpace;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::GetTabWithSpace() const
{
return m_pOptions->m_bTabWithSpace;
}
AFX_INLINE int CXTPSyntaxEditCtrl::GetTopRow() const {
return m_nTopRow;
}
AFX_INLINE BOOL CXTPSyntaxEditCtrl::IsRightButtonDrag() const {
return m_bRightButtonDrag;
}
AFX_INLINE void CXTPSyntaxEditCtrl::CancelRightButtonDrag() {
m_bRightButtonDrag = FALSE;
}
AFX_INLINE void CXTPSyntaxEditCtrl::SetRightButtonDrag(BOOL bRightButtonDrag) {
m_bRightButtonDrag = bRightButtonDrag;
}
AFX_INLINE int CXTPSyntaxEditCtrl::GetCurCol() const{
return m_nDispCol;
}
AFX_INLINE int CXTPSyntaxEditCtrl::GetCurAbsCol() const {
return m_nCurrentCol;
}
/////////////////////////////////////////////////////////////////////////////
// CXTPSyntaxEditStringDlg dialog
class _XTP_EXT_CLASS CXTPSyntaxEditStringDlg : public CDialog
{
DECLARE_DYNAMIC(CXTPSyntaxEditStringDlg)
public:
CXTPSyntaxEditStringDlg(CWnd* pParent = NULL); // standard constructor
virtual ~CXTPSyntaxEditStringDlg();
CString m_Syntax;
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
DECLARE_MESSAGE_MAP()
virtual void OnOK();
public:
virtual INT_PTR DoModal();
virtual BOOL OnInitDialog();
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnEditCut();
afx_msg void OnEditCopy();
afx_msg void OnEditClear();
afx_msg void OnEditPaste();
afx_msg void OnEditUndo();
afx_msg void OnEditSelectAll();
CEdit m_edit;
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(__XTPSYNTAXEDITSYNTAXEDITCTRL_H__)