Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Using AvalonEdit (WPF Text Editor)

, 1 Apr 2013
AvalonEdit is an extensible Open-Source text editor with support for syntax highlighting and folding.
AvalonEdit_4.3.1_Binaries-noexe.zip
AvalonEdit_4.3.1_Binaries.zip
AvalonEdit_4.3.1_Source-noexe.zip
AvalonEdit.Sample
AvalonEdit
dependencies.png
folding.png
renderingPipeline.png
screenshot.png
snoop.png
CustomHighlighting.xshd
Images
Copy.png
Cut.png
Delete.png
Open.png
Paste.png
Redo.png
Save.png
Undo.png
WordWrap.png
Properties
RenderingPipeline.pptx
Documentation
Architecture.aml
Code Completion.aml
Coordinate Systems.aml
Folding.aml
ICSharpCode.AvalonEdit.content
ICSharpCode.AvalonEdit.shfbproj
Media
NamespaceDependencies.png
RenderingPipeline.png
VisualTree.png
WelcomeScreenshot.png
Sample Application.aml
Syntax Highlighting.aml
Text Rendering.aml
Welcome.aml
ICSharpCode.AvalonEdit.Tests
Document
Editing
Highlighting
ICSharpCode.AvalonEdit.Tests.PartCover.Settings
Properties
Search
Utils
ICSharpCode.AvalonEdit
CodeCompletion
Document
Editing
Folding
Highlighting
Resources
ASPX.xshd
Boo.xshd
Coco-Mode.xshd
CPP-Mode.xshd
CSharp-Mode.xshd
CSS-Mode.xshd
HTML-Mode.xshd
Java-Mode.xshd
JavaScript-Mode.xshd
MarkDown-Mode.xshd
Patch-Mode.xshd
PHP-Mode.xshd
PowerShell.xshd
Tex-Mode.xshd
VBNET-Mode.xshd
XML-Mode.xshd
XmlDoc.xshd
Xshd
ICSharpCode.AvalonEdit.snk
Indentation
CSharp
Properties
Rendering
Search
next.png
prev.png
Snippets
themes
RightArrow.cur
Utils
Xml
AvalonEdit_4.3.1_Source.zip
dependencies.png
folding.png
renderingPipeline.png
screenshot.png
snoop.png
CustomHighlighting.xshd
Copy.png
Cut.png
Delete.png
Open.png
Paste.png
Redo.png
Save.png
Undo.png
WordWrap.png
RenderingPipeline.pptx
Architecture.aml
Code Completion.aml
Coordinate Systems.aml
Folding.aml
ICSharpCode.AvalonEdit.content
ICSharpCode.AvalonEdit.shfbproj
NamespaceDependencies.png
RenderingPipeline.png
VisualTree.png
WelcomeScreenshot.png
Sample Application.aml
Syntax Highlighting.aml
Text Rendering.aml
Welcome.aml
ICSharpCode.AvalonEdit.Tests.PartCover.Settings
nunit.framework.dll
ASPX.xshd
Boo.xshd
Coco-Mode.xshd
CPP-Mode.xshd
CSharp-Mode.xshd
CSS-Mode.xshd
HTML-Mode.xshd
Java-Mode.xshd
JavaScript-Mode.xshd
MarkDown-Mode.xshd
Patch-Mode.xshd
PHP-Mode.xshd
PowerShell.xshd
Tex-Mode.xshd
VBNET-Mode.xshd
XML-Mode.xshd
XmlDoc.xshd
ICSharpCode.AvalonEdit.snk
next.png
prev.png
RightArrow.cur
AvalonEdit_Binaries-noexe.zip
AvalonEdit_Binaries.zip
AvalonEdit_CHM_Documentation.zip
AvalonEdit_Source.zip
dependencies.png
folding.png
renderingPipeline.png
screenshot.png
snoop.png
CustomHighlighting.xshd
Copy.png
Cut.png
Delete.png
Open.png
Paste.png
Redo.png
Save.png
Undo.png
WordWrap.png
RenderingPipeline.pptx
Architecture.aml
Code Completion.aml
Coordinate Systems.aml
Folding.aml
Help
ICSharpCode.AvalonEdit.content
ICSharpCode.AvalonEdit.shfbproj
NamespaceDependencies.png
RenderingPipeline.png
VisualTree.png
WelcomeScreenshot.png
Sample Application.aml
Syntax Highlighting.aml
Text Rendering.aml
Welcome.aml
ICSharpCode.AvalonEdit.Tests.PartCover.Settings
nunit.framework.dll
ASPX.xshd
Boo.xshd
Coco-Mode.xshd
CPP-Mode.xshd
CSharp-Mode.xshd
CSS-Mode.xshd
HTML-Mode.xshd
Java-Mode.xshd
JavaScript-Mode.xshd
Patch-Mode.xshd
PHP-Mode.xshd
PowerShell.xshd
Tex-Mode.xshd
VBNET-Mode.xshd
XML-Mode.xshd
XmlDoc.xshd
ICSharpCode.AvalonEdit.snk
next.png
prev.png
RightArrow.cur
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)

using System;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Media;
using System.Xml;
using System.Xml.Schema;

using ICSharpCode.AvalonEdit.Utils;

namespace ICSharpCode.AvalonEdit.Highlighting.Xshd
{
	/// <summary>
	/// Loads .xshd files, version 1.0.
	/// </summary>
	sealed class V1Loader
	{
		static XmlSchemaSet schemaSet;
		
		static XmlSchemaSet SchemaSet {
			get {
				if (schemaSet == null) {
					schemaSet = HighlightingLoader.LoadSchemaSet(new XmlTextReader(
						Resources.OpenStream("ModeV1.xsd")));
				}
				return schemaSet;
			}
		}
		
		public static XshdSyntaxDefinition LoadDefinition(XmlReader reader, bool skipValidation)
		{
			reader = HighlightingLoader.GetValidatingReader(reader, false, skipValidation ? null : SchemaSet);
			XmlDocument document = new XmlDocument();
			document.Load(reader);
			V1Loader loader = new V1Loader();
			return loader.ParseDefinition(document.DocumentElement);
		}
		
		XshdSyntaxDefinition ParseDefinition(XmlElement syntaxDefinition)
		{
			XshdSyntaxDefinition def = new XshdSyntaxDefinition();
			def.Name = syntaxDefinition.GetAttributeOrNull("name");
			if (syntaxDefinition.HasAttribute("extensions")) {
				def.Extensions.AddRange(syntaxDefinition.GetAttribute("extensions").Split(';', '|'));
			}
			
			XshdRuleSet mainRuleSetElement = null;
			foreach (XmlElement element in syntaxDefinition.GetElementsByTagName("RuleSet")) {
				XshdRuleSet ruleSet = ImportRuleSet(element);
				def.Elements.Add(ruleSet);
				if (ruleSet.Name == null)
					mainRuleSetElement = ruleSet;
				
				if (syntaxDefinition["Digits"] != null) {
					// create digit highlighting rule
					
					const string optionalExponent = @"([eE][+-]?[0-9]+)?";
					const string floatingPoint = @"\.[0-9]+";
					ruleSet.Elements.Add(
						new XshdRule {
							ColorReference = GetColorReference(syntaxDefinition["Digits"]),
							RegexType = XshdRegexType.IgnorePatternWhitespace,
							Regex = @"\b0[xX][0-9a-fA-F]+"
								+ @"|"
								+ @"(\b\d+(" + floatingPoint + ")?"
								+ @"|" + floatingPoint + ")"
								+ optionalExponent
						});
				}
			}
			
			if (syntaxDefinition.HasAttribute("extends") && mainRuleSetElement != null) {
				// convert 'extends="HTML"' to '<Import ruleSet="HTML/" />' in main rule set.
				mainRuleSetElement.Elements.Add(
					new XshdImport { RuleSetReference = new XshdReference<XshdRuleSet>(
						syntaxDefinition.GetAttribute("extends"), string.Empty
					) });
			}
			return def;
		}
		
		static XshdColor GetColorFromElement(XmlElement element)
		{
			if (!element.HasAttribute("bold") && !element.HasAttribute("italic") && !element.HasAttribute("color") && !element.HasAttribute("bgcolor"))
				return null;
			XshdColor color = new XshdColor();
			if (element.HasAttribute("bold"))
				color.FontWeight = XmlConvert.ToBoolean(element.GetAttribute("bold")) ? FontWeights.Bold : FontWeights.Normal;
			if (element.HasAttribute("italic"))
				color.FontStyle = XmlConvert.ToBoolean(element.GetAttribute("italic")) ? FontStyles.Italic : FontStyles.Normal;
			if (element.HasAttribute("color"))
				color.Foreground = ParseColor(element.GetAttribute("color"));
			if (element.HasAttribute("bgcolor"))
				color.Background = ParseColor(element.GetAttribute("bgcolor"));
			return color;
		}
		
		static XshdReference<XshdColor> GetColorReference(XmlElement element)
		{
			XshdColor color = GetColorFromElement(element);
			if (color != null)
				return new XshdReference<XshdColor>(color);
			else
				return new XshdReference<XshdColor>();
		}
		
		static HighlightingBrush ParseColor(string c)
		{
			if (c.StartsWith("#", StringComparison.Ordinal)) {
				int a = 255;
				int offset = 0;
				if (c.Length > 7) {
					offset = 2;
					a = Int32.Parse(c.Substring(1,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
				}
				
				int r = Int32.Parse(c.Substring(1 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
				int g = Int32.Parse(c.Substring(3 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
				int b = Int32.Parse(c.Substring(5 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
				return new SimpleHighlightingBrush(Color.FromArgb((byte)a, (byte)r, (byte)g, (byte)b));
			} else if (c.StartsWith("SystemColors.", StringComparison.Ordinal)) {
				return V2Loader.GetSystemColorBrush(null, c);
			} else {
				return new SimpleHighlightingBrush((Color)V2Loader.ColorConverter.ConvertFromInvariantString(c));
			}
		}
		
		char ruleSetEscapeCharacter;
		
		XshdRuleSet ImportRuleSet(XmlElement element)
		{
			XshdRuleSet ruleSet = new XshdRuleSet();
			ruleSet.Name = element.GetAttributeOrNull("name");
			
			if (element.HasAttribute("escapecharacter")) {
				ruleSetEscapeCharacter = element.GetAttribute("escapecharacter")[0];
			} else {
				ruleSetEscapeCharacter = '\0';
			}
			
			if (element.HasAttribute("reference")) {
				ruleSet.Elements.Add(
					new XshdImport { RuleSetReference = new XshdReference<XshdRuleSet>(
						element.GetAttribute("reference"), string.Empty
					) });
			}
			ruleSet.IgnoreCase = element.GetBoolAttribute("ignorecase");
			
			foreach (XmlElement el in element.GetElementsByTagName("KeyWords")) {
				XshdKeywords keywords = new XshdKeywords();
				keywords.ColorReference = GetColorReference(el);
				// we have to handle old syntax highlighting definitions that contain
				// empty keywords or empty keyword groups
				foreach (XmlElement node in el.GetElementsByTagName("Key")) {
					string word = node.GetAttribute("word");
					if (!string.IsNullOrEmpty(word))
						keywords.Words.Add(word);
				}
				if (keywords.Words.Count > 0) {
					ruleSet.Elements.Add(keywords);
				}
			}
			
			foreach (XmlElement el in element.GetElementsByTagName("Span")) {
				ruleSet.Elements.Add(ImportSpan(el));
			}
			
			foreach (XmlElement el in element.GetElementsByTagName("MarkPrevious")) {
				ruleSet.Elements.Add(ImportMarkPrevNext(el, false));
			}
			foreach (XmlElement el in element.GetElementsByTagName("MarkFollowing")) {
				ruleSet.Elements.Add(ImportMarkPrevNext(el, true));
			}
			
			return ruleSet;
		}
		
		static XshdRule ImportMarkPrevNext(XmlElement el, bool markFollowing)
		{
			bool markMarker = el.GetBoolAttribute("markmarker") ?? false;
			string what = Regex.Escape(el.InnerText);
			const string identifier = @"[\d\w_]+";
			const string whitespace = @"\s*";
			
			string regex;
			if (markFollowing) {
				if (markMarker) {
					regex = what + whitespace + identifier;
				} else {
					regex = "(?<=(" + what + whitespace + "))" + identifier;
				}
			} else {
				if (markMarker) {
					regex = identifier + whitespace + what;
				} else {
					regex = identifier + "(?=(" + whitespace + what + "))";
				}
			}
			return new XshdRule {
				ColorReference = GetColorReference(el),
				Regex = regex,
				RegexType = XshdRegexType.IgnorePatternWhitespace
			};
		}
		
		XshdSpan ImportSpan(XmlElement element)
		{
			XshdSpan span = new XshdSpan();
			if (element.HasAttribute("rule")) {
				span.RuleSetReference = new XshdReference<XshdRuleSet>(null, element.GetAttribute("rule"));
			}
			char escapeCharacter = ruleSetEscapeCharacter;
			if (element.HasAttribute("escapecharacter")) {
				escapeCharacter = element.GetAttribute("escapecharacter")[0];
			}
			span.Multiline = !(element.GetBoolAttribute("stopateol") ?? false);
			
			span.SpanColorReference = GetColorReference(element);
			
			span.BeginRegexType = XshdRegexType.IgnorePatternWhitespace;
			span.BeginRegex = ImportRegex(element["Begin"].InnerText,
			                              element["Begin"].GetBoolAttribute("singleword") ?? false,
			                              element["Begin"].GetBoolAttribute("startofline"));
			span.BeginColorReference = GetColorReference(element["Begin"]);
			
			string endElementText = string.Empty;
			if (element["End"] != null) {
				span.EndRegexType = XshdRegexType.IgnorePatternWhitespace;
				endElementText = element["End"].InnerText;
				span.EndRegex = ImportRegex(endElementText,
				                            element["End"].GetBoolAttribute("singleword") ?? false,
				                            null);
				span.EndColorReference = GetColorReference(element["End"]);
			}
			
			if (escapeCharacter != '\0') {
				XshdRuleSet ruleSet = new XshdRuleSet();
				if (endElementText.Length == 1 && endElementText[0] == escapeCharacter) {
					// ""-style escape
					ruleSet.Elements.Add(new XshdSpan {
					                     	BeginRegex = Regex.Escape(endElementText + endElementText),
					                     	EndRegex = ""
					                     });
				} else {
					// \"-style escape
					ruleSet.Elements.Add(new XshdSpan {
					                     	BeginRegex = Regex.Escape(escapeCharacter.ToString()),
					                     	EndRegex = "."
					                     });
				}
				if (span.RuleSetReference.ReferencedElement != null) {
					ruleSet.Elements.Add(new XshdImport { RuleSetReference = span.RuleSetReference });
				}
				span.RuleSetReference = new XshdReference<XshdRuleSet>(ruleSet);
			}
			return span;
		}
		
		static string ImportRegex(string expr, bool singleWord, bool? startOfLine)
		{
			StringBuilder b = new StringBuilder();
			if (startOfLine != null) {
				if (startOfLine.Value) {
					b.Append(@"(?<=(^\s*))");
				} else {
					b.Append(@"(?<!(^\s*))");
				}
			} else {
				if (singleWord)
					b.Append(@"\b");
			}
			for (int i = 0; i < expr.Length; i++) {
				char c = expr[i];
				if (c == '@') {
					++i;
					if (i == expr.Length)
						throw new HighlightingDefinitionInvalidException("Unexpected end of @ sequence, use @@ to look for a single @.");
					switch (expr[i]) {
						case 'C': // match whitespace or punctuation
							b.Append(@"[^\w\d_]");
							break;
						case '!': // negative lookahead
							{
								StringBuilder whatmatch = new StringBuilder();
								++i;
								while (i < expr.Length && expr[i] != '@') {
									whatmatch.Append(expr[i++]);
								}
								b.Append("(?!(");
								b.Append(Regex.Escape(whatmatch.ToString()));
								b.Append("))");
							}
							break;
						case '-': // negative lookbehind
							{
								StringBuilder whatmatch = new StringBuilder();
								++i;
								while (i < expr.Length && expr[i] != '@') {
									whatmatch.Append(expr[i++]);
								}
								b.Append("(?<!(");
								b.Append(Regex.Escape(whatmatch.ToString()));
								b.Append("))");
							}
							break;
						case '@':
							b.Append("@");
							break;
						default:
							throw new HighlightingDefinitionInvalidException("Unknown character in @ sequence.");
					}
				} else {
					b.Append(Regex.Escape(c.ToString()));
				}
			}
			if (singleWord)
				b.Append(@"\b");
			return b.ToString();
		}
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)

Share

About the Author

Daniel Grunwald

Germany Germany
I am the lead developer on the SharpDevelop open source project.
Follow on   Twitter   Google+   LinkedIn

| Advertise | Privacy | Mobile
Web03 | 2.8.140827.1 | Last Updated 1 Apr 2013
Article Copyright 2009 by Daniel Grunwald
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid