Rich Text Editor for WinForms - Implement ISyntaxHighlightService to Highlight C and VB Code Syntax

The Rich Text Editor supports ISyntaxHighlightService that allows you to implement syntax highlighting for a document displayed in the control. This example demonstrates how to highlight its source code (C# and VB). The project uses the DevExpress CodeParser library to parse the code into tokens according to the syntax elements of the programming language.

Rich Text Editor - Highlight Code Syntax

Implementation Details

Declare a custom class that implements ISyntaxHighlightService. In the class constructor, specify colors for different code element categories (keywords, comments, strings, and so on). This example uses colors of the current application skin.
Implement the ISyntaxHighlightService.Execute method. Within the method, use parsers from the DevExpress CodeParser library to parse C# and VB source code into tokens.
Convert tokens to the SyntaxHighlightToken objects and specify format settings for each token.
Pass the list of SyntaxHighlightToken objects to the SubDocument.ApplySyntaxHighlight method to enable syntax highlighting in the document.
Call the RichEditControl.ReplaceService<T> method to register the custom ISyntaxHighlightService implementation.

Files to Look At

Form1.cs (VB: Form1.vb)

Documentation

Highlight Document Syntax

More Examples

How to: Create Syntax Highlight Tokens to Highlight T-SQL Language Syntax

Does this example address your development requirements/objectives?

(you will be redirected to DevExpress.com to submit your response)

Example Code

SyntaxHighlightApp/Form1.cs(vb)

C#
VB.NET

C#
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using DevExpress.CodeParser;
using DevExpress.LookAndFeel;
using DevExpress.Skins;
using DevExpress.XtraRichEdit;
using DevExpress.XtraRichEdit.API.Native;
using DevExpress.XtraRichEdit.Services;

namespace SyntaxHighlightApp
{
    public partial class Form1 : DevExpress.XtraEditors.XtraForm
    {
        public Form1()
        {
            string path = "Form1.cs";
            InitializeComponent();
            richEditControl1.RemoveShortcutKey(System.Windows.Forms.Keys.Enter, System.Windows.Forms.Keys.Shift);

            // Use service substitution to register a custom service that implements syntax highlighting.
            richEditControl1.ReplaceService<ISyntaxHighlightService>(new MySyntaxHighlightService(richEditControl1));
            richEditControl1.LoadDocument(path);
        }
    }
    /// <summary>
    ///  This class implements the Execute method of the ISyntaxHighlightService interface to parse and colorize text.
    /// </summary>
    public class MySyntaxHighlightService : ISyntaxHighlightService
    {
        readonly RichEditControl syntaxEditor;
        SyntaxColors syntaxColors;
        SyntaxHighlightProperties commentProperties;
        SyntaxHighlightProperties keywordProperties;
        SyntaxHighlightProperties stringProperties;
        SyntaxHighlightProperties xmlCommentProperties;
        SyntaxHighlightProperties textProperties;

        public MySyntaxHighlightService(RichEditControl syntaxEditor)
        {
            this.syntaxEditor = syntaxEditor;
            syntaxColors = new SyntaxColors(UserLookAndFeel.Default);
        }

        void HighlightSyntax(TokenCollection tokens)
        {
            commentProperties = new SyntaxHighlightProperties();
            commentProperties.ForeColor = syntaxColors.CommentColor;

            keywordProperties = new SyntaxHighlightProperties();
            keywordProperties.ForeColor = syntaxColors.KeywordColor;

            stringProperties = new SyntaxHighlightProperties();
            stringProperties.ForeColor = syntaxColors.StringColor;

            xmlCommentProperties = new SyntaxHighlightProperties();
            xmlCommentProperties.ForeColor = syntaxColors.XmlCommentColor;

            textProperties = new SyntaxHighlightProperties();
            textProperties.ForeColor = syntaxColors.TextColor;

            Document document = syntaxEditor.Document;
            List<SyntaxHighlightToken> syntaxTokens = new List<SyntaxHighlightToken>(tokens.Count);
            foreach (Token token in tokens)
            {
                var categorizedToken = token as CategorizedToken;
                if (categorizedToken != null)
                    HighlightCategorizedToken(categorizedToken, syntaxTokens);
            }
            if (syntaxTokens.Count > 0) 
            {
                document.ApplySyntaxHighlight(syntaxTokens);
            }
        }
        void HighlightCategorizedToken(CategorizedToken token, List<SyntaxHighlightToken> syntaxTokens)
        {
            Color backColor = syntaxEditor.ActiveView.BackColor;
            TokenCategory category = token.Category;           
            switch (category)
            {
                case TokenCategory.Comment:
                    syntaxTokens.Add(SetTokenColor(token, commentProperties, backColor));
                    break;
                case TokenCategory.Keyword:
                    syntaxTokens.Add(SetTokenColor(token, keywordProperties, backColor));
                    break;
                case TokenCategory.String:
                    syntaxTokens.Add(SetTokenColor(token, stringProperties, backColor));
                    break;
                case TokenCategory.XmlComment:
                    syntaxTokens.Add(SetTokenColor(token, xmlCommentProperties, backColor));
                    break;
                default:
                    syntaxTokens.Add(SetTokenColor(token, textProperties, backColor));
                    break;
            }
        }
        SyntaxHighlightToken SetTokenColor(Token token, SyntaxHighlightProperties foreColor, Color backColor)
        {
            if (syntaxEditor.Document.Paragraphs.Count < token.Range.Start.Line)
                return null;
            int paragraphStart = syntaxEditor.Document.Paragraphs[token.Range.Start.Line - 1].Range.Start.ToInt();
            int tokenStart = paragraphStart + token.Range.Start.Offset - 1;
            if (token.Range.End.Line != token.Range.Start.Line)
                paragraphStart = syntaxEditor.Document.Paragraphs[token.Range.End.Line - 1].Range.Start.ToInt();

            int tokenEnd = paragraphStart + token.Range.End.Offset - 1;
            Debug.Assert(tokenEnd > tokenStart);
            return new SyntaxHighlightToken(tokenStart, tokenEnd - tokenStart, foreColor);
        }

        #region #ISyntaxHighlightServiceMembers
        public void Execute()
        {
            string newText = syntaxEditor.Text;
            // Determine the language by file extension.
            string ext = System.IO.Path.GetExtension(syntaxEditor.Options.DocumentSaveOptions.CurrentFileName);
            ParserLanguageID lang_ID = ParserLanguage.FromFileExtension(ext);
            // Do not parse HTML or XML.
            if (lang_ID == ParserLanguageID.Html ||
                lang_ID == ParserLanguageID.Xml ||
                lang_ID == ParserLanguageID.None) return;
            // Use DevExpress.CodeParser to parse text into tokens.
            ITokenCategoryHelper tokenHelper = TokenCategoryHelperFactory.CreateHelper(lang_ID);
            if (tokenHelper != null) 
            { 
                TokenCollection highlightTokens = tokenHelper.GetTokens(newText);
                if (highlightTokens != null && highlightTokens.Count > 0) 
                {
                    HighlightSyntax(highlightTokens);
                }
                
            }
        }

        public void ForceExecute()
        {
            Execute();
        }
        #endregion #ISyntaxHighlightServiceMembers
    }
    /// <summary>
    ///  This class defines colors to highlight tokens.
    /// </summary>
    public class SyntaxColors
    {
        static Color DefaultCommentColor { get { return Color.Green; } }
        static Color DefaultKeywordColor { get { return Color.Blue; } }
        static Color DefaultStringColor { get { return Color.Brown; } }
        static Color DefaultXmlCommentColor { get { return Color.Gray; } }
        static Color DefaultTextColor { get { return Color.Black; } }
        UserLookAndFeel lookAndFeel;

        public Color CommentColor { get { return GetCommonColorByName(CommonSkins.SkinInformationColor, DefaultCommentColor); } }
        public Color KeywordColor { get { return GetCommonColorByName(CommonSkins.SkinQuestionColor, DefaultKeywordColor); } }
        public Color TextColor { get { return GetCommonColorByName(CommonColors.WindowText, DefaultTextColor); } }
        public Color XmlCommentColor { get { return GetCommonColorByName(CommonColors.DisabledText, DefaultXmlCommentColor); } }
        public Color StringColor { get { return GetCommonColorByName(CommonSkins.SkinWarningColor, DefaultStringColor); } }

        public SyntaxColors(UserLookAndFeel lookAndFeel)
        {
            this.lookAndFeel = lookAndFeel;
        }

        Color GetCommonColorByName(string colorName, Color defaultColor)
        {
            Skin skin = CommonSkins.GetSkin(lookAndFeel);
            if (skin == null)
                return defaultColor;
            return skin.Colors[colorName];
        }
    }
}

Visual Basic
Imports System.Collections.Generic
Imports System.Diagnostics
Imports System.Drawing
Imports DevExpress.CodeParser
Imports DevExpress.LookAndFeel
Imports DevExpress.Skins
Imports DevExpress.XtraRichEdit
Imports DevExpress.XtraRichEdit.API.Native
Imports DevExpress.XtraRichEdit.Services

Namespace SyntaxHighlightApp

    Public Partial Class Form1
        Inherits DevExpress.XtraEditors.XtraForm

        Public Sub New()
            Dim path As String = "Form1.vb"
            InitializeComponent()
            richEditControl1.RemoveShortcutKey(System.Windows.Forms.Keys.Enter, System.Windows.Forms.Keys.Shift)

            ' Use service substitution to register a custom service that implements syntax highlighting.
            richEditControl1.ReplaceService(Of ISyntaxHighlightService)(New MySyntaxHighlightService(richEditControl1))
            richEditControl1.LoadDocument(path)
        End Sub
    End Class

    ''' <summary>
    '''  This class implements the Execute method of the ISyntaxHighlightService interface to parse and colorize text.
    ''' </summary>
    Public Class MySyntaxHighlightService
        Implements ISyntaxHighlightService

        Private ReadOnly syntaxEditor As RichEditControl

        Private syntaxColors As SyntaxColors

        Private commentProperties As SyntaxHighlightProperties

        Private keywordProperties As SyntaxHighlightProperties

        Private stringProperties As SyntaxHighlightProperties

        Private xmlCommentProperties As SyntaxHighlightProperties

        Private textProperties As SyntaxHighlightProperties

        Public Sub New(ByVal syntaxEditor As RichEditControl)
            Me.syntaxEditor = syntaxEditor
            syntaxColors = New SyntaxColors(UserLookAndFeel.Default)
        End Sub

        Private Sub HighlightSyntax(ByVal tokens As TokenCollection)
            commentProperties = New SyntaxHighlightProperties()
            commentProperties.ForeColor = syntaxColors.CommentColor
            keywordProperties = New SyntaxHighlightProperties()
            keywordProperties.ForeColor = syntaxColors.KeywordColor
            stringProperties = New SyntaxHighlightProperties()
            stringProperties.ForeColor = syntaxColors.StringColor
            xmlCommentProperties = New SyntaxHighlightProperties()
            xmlCommentProperties.ForeColor = syntaxColors.XmlCommentColor
            textProperties = New SyntaxHighlightProperties()
            textProperties.ForeColor = syntaxColors.TextColor
            Dim document As Document = syntaxEditor.Document
            Dim syntaxTokens As List(Of SyntaxHighlightToken) = New List(Of SyntaxHighlightToken)(tokens.Count)
            For Each token As Token In tokens
                Dim categorizedToken = TryCast(token, CategorizedToken)
                If categorizedToken IsNot Nothing Then HighlightCategorizedToken(categorizedToken, syntaxTokens)
            Next

            If syntaxTokens.Count > 0 Then
                document.ApplySyntaxHighlight(syntaxTokens)
            End If
        End Sub

        Private Sub HighlightCategorizedToken(ByVal token As CategorizedToken, ByVal syntaxTokens As List(Of SyntaxHighlightToken))
            Dim backColor As Color = syntaxEditor.ActiveView.BackColor
            Dim category As TokenCategory = token.Category
            Select Case category
                Case TokenCategory.Comment
                    syntaxTokens.Add(SetTokenColor(token, commentProperties, backColor))
                Case TokenCategory.Keyword
                    syntaxTokens.Add(SetTokenColor(token, keywordProperties, backColor))
                Case TokenCategory.String
                    syntaxTokens.Add(SetTokenColor(token, stringProperties, backColor))
                Case TokenCategory.XmlComment
                    syntaxTokens.Add(SetTokenColor(token, xmlCommentProperties, backColor))
                Case Else
                    syntaxTokens.Add(SetTokenColor(token, textProperties, backColor))
            End Select
        End Sub

        Private Function SetTokenColor(ByVal token As Token, ByVal foreColor As SyntaxHighlightProperties, ByVal backColor As Color) As SyntaxHighlightToken
            If syntaxEditor.Document.Paragraphs.Count < token.Range.Start.Line Then Return Nothing
            Dim paragraphStart As Integer = syntaxEditor.Document.Paragraphs(token.Range.Start.Line - 1).Range.Start.ToInt()
            Dim tokenStart As Integer = paragraphStart + token.Range.Start.Offset - 1
            If token.Range.End.Line <> token.Range.Start.Line Then paragraphStart = syntaxEditor.Document.Paragraphs(token.Range.End.Line - 1).Range.Start.ToInt()
            Dim tokenEnd As Integer = paragraphStart + token.Range.End.Offset - 1
            Call Debug.Assert(tokenEnd > tokenStart)
            Return New SyntaxHighlightToken(tokenStart, tokenEnd - tokenStart, foreColor)
        End Function

#Region "#ISyntaxHighlightServiceMembers"
        Public Sub Execute() Implements ISyntaxHighlightService.Execute
            Dim newText As String = syntaxEditor.Text
            ' Determine the language by file extension.
            Dim ext As String = System.IO.Path.GetExtension(syntaxEditor.Options.DocumentSaveOptions.CurrentFileName)
            Dim lang_ID As ParserLanguageID = ParserLanguage.FromFileExtension(ext)
            ' Do not parse HTML or XML.
            If lang_ID = ParserLanguageID.Html OrElse lang_ID = ParserLanguageID.Xml OrElse lang_ID = ParserLanguageID.None Then Return
            ' Use DevExpress.CodeParser to parse text into tokens.
            Dim tokenHelper As ITokenCategoryHelper = TokenCategoryHelperFactory.CreateHelper(lang_ID)
            If tokenHelper IsNot Nothing Then
                Dim highlightTokens As TokenCollection = tokenHelper.GetTokens(newText)
                If highlightTokens IsNot Nothing AndAlso highlightTokens.Count > 0 Then
                    HighlightSyntax(highlightTokens)
                End If
            End If
        End Sub

        Public Sub ForceExecute() Implements ISyntaxHighlightService.ForceExecute
            Execute()
        End Sub
#End Region  ' #ISyntaxHighlightServiceMembers
    End Class

    ''' <summary>
    '''  This class defines colors to highlight tokens.
    ''' </summary>
    Public Class SyntaxColors

        Private Shared ReadOnly Property DefaultCommentColor As Color
            Get
                Return Color.Green
            End Get
        End Property

        Private Shared ReadOnly Property DefaultKeywordColor As Color
            Get
                Return Color.Blue
            End Get
        End Property

        Private Shared ReadOnly Property DefaultStringColor As Color
            Get
                Return Color.Brown
            End Get
        End Property

        Private Shared ReadOnly Property DefaultXmlCommentColor As Color
            Get
                Return Color.Gray
            End Get
        End Property

        Private Shared ReadOnly Property DefaultTextColor As Color
            Get
                Return Color.Black
            End Get
        End Property

        Private lookAndFeel As UserLookAndFeel

        Public ReadOnly Property CommentColor As Color
            Get
                Return GetCommonColorByName(CommonSkins.SkinInformationColor, DefaultCommentColor)
            End Get
        End Property

        Public ReadOnly Property KeywordColor As Color
            Get
                Return GetCommonColorByName(CommonSkins.SkinQuestionColor, DefaultKeywordColor)
            End Get
        End Property

        Public ReadOnly Property TextColor As Color
            Get
                Return GetCommonColorByName(CommonColors.WindowText, DefaultTextColor)
            End Get
        End Property

        Public ReadOnly Property XmlCommentColor As Color
            Get
                Return GetCommonColorByName(CommonColors.DisabledText, DefaultXmlCommentColor)
            End Get
        End Property

        Public ReadOnly Property StringColor As Color
            Get
                Return GetCommonColorByName(CommonSkins.SkinWarningColor, DefaultStringColor)
            End Get
        End Property

        Public Sub New(ByVal lookAndFeel As UserLookAndFeel)
            Me.lookAndFeel = lookAndFeel
        End Sub

        Private Function GetCommonColorByName(ByVal colorName As String, ByVal defaultColor As Color) As Color
            Dim skin As Skin = CommonSkins.GetSkin(lookAndFeel)
            If skin Is Nothing Then Return defaultColor
            Return skin.Colors(colorName)
        End Function
    End Class
End Namespace

DevExpress Support Team

last modified 3 years ago

Modified: December 20, 2021 2:18 PM

Platform: WinForms

Product: XtraRichEdit

Disclaimer: The information provided on DevExpress.com and affiliated web properties (including the DevExpress Support Center) is provided "as is" without warranty of any kind. Developer Express Inc disclaims all warranties, either express or implied, including the warranties of merchantability and fitness for a particular purpose. Please refer to the DevExpress.com Website Terms of Use for more information in this regard.

Confidential Information: Developer Express Inc does not wish to receive, will not act to procure, nor will it solicit, confidential or proprietary materials and information from you through the DevExpress Support Center or its web properties. Any and all materials or information divulged during chats, email communications, online discussions, Support Center tickets, or made available to Developer Express Inc in any manner will be deemed NOT to be confidential by Developer Express Inc. Please refer to the DevExpress.com Website Terms of Use for more information in this regard.