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.
Prize winner in Competition "Best C# article of October 2009"
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.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using ICSharpCode.AvalonEdit.Utils;

namespace ICSharpCode.AvalonEdit.Document
{
	/// <summary>
	/// Undo stack implementation.
	/// </summary>
	[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
	public sealed class UndoStack : INotifyPropertyChanged
	{
		/// undo stack is listening for changes
		internal const int StateListen = 0;
		/// undo stack is reverting/repeating a set of changes
		internal const int StatePlayback = 1;
		// undo stack is reverting/repeating a set of changes and modifies the document to do this
		internal const int StatePlaybackModifyDocument = 2;
		/// state is used for checking that noone but the UndoStack performs changes
		/// during Undo events
		internal int state = StateListen;
		
		Deque<IUndoableOperation> undostack = new Deque<IUndoableOperation>();
		Deque<IUndoableOperation> redostack = new Deque<IUndoableOperation>();
		int sizeLimit = int.MaxValue;
		
		int undoGroupDepth;
		int actionCountInUndoGroup;
		int optionalActionCount;
		object lastGroupDescriptor;
		bool allowContinue;
		
		#region IsOriginalFile implementation
		// implements feature request SD2-784 - File still considered dirty after undoing all changes
		
		/// <summary>
		/// Number of times undo must be executed until the original state is reached.
		/// Negative: number of times redo must be executed until the original state is reached.
		/// Special case: int.MinValue == original state is unreachable
		/// </summary>
		int elementsOnUndoUntilOriginalFile;
		
		bool isOriginalFile = true;
		
		/// <summary>
		/// Gets whether the document is currently in its original state (no modifications).
		/// </summary>
		public bool IsOriginalFile {
			get { return isOriginalFile; }
		}
		
		void RecalcIsOriginalFile()
		{
			bool newIsOriginalFile = (elementsOnUndoUntilOriginalFile == 0);
			if (newIsOriginalFile != isOriginalFile) {
				isOriginalFile = newIsOriginalFile;
				NotifyPropertyChanged("IsOriginalFile");
			}
		}
		
		/// <summary>
		/// Marks the current state as original. Discards any previous "original" markers.
		/// </summary>
		public void MarkAsOriginalFile()
		{
			elementsOnUndoUntilOriginalFile = 0;
			RecalcIsOriginalFile();
		}
		
		/// <summary>
		/// Discards the current "original" marker.
		/// </summary>
		public void DiscardOriginalFileMarker()
		{
			elementsOnUndoUntilOriginalFile = int.MinValue;
			RecalcIsOriginalFile();
		}
		
		void FileModified(int newElementsOnUndoStack)
		{
			if (elementsOnUndoUntilOriginalFile == int.MinValue)
				return;
			
			elementsOnUndoUntilOriginalFile += newElementsOnUndoStack;
			if (elementsOnUndoUntilOriginalFile > undostack.Count)
				elementsOnUndoUntilOriginalFile = int.MinValue;
			
			// don't call RecalcIsOriginalFile(): wait until end of undo group
		}
		#endregion
		
		/// <summary>
		/// Gets if the undo stack currently accepts changes.
		/// Is false while an undo action is running.
		/// </summary>
		public bool AcceptChanges {
			get { return state == StateListen; }
		}
		
		/// <summary>
		/// Gets if there are actions on the undo stack.
		/// Use the PropertyChanged event to listen to changes of this property.
		/// </summary>
		public bool CanUndo {
			get { return undostack.Count > 0; }
		}
		
		/// <summary>
		/// Gets if there are actions on the redo stack.
		/// Use the PropertyChanged event to listen to changes of this property.
		/// </summary>
		public bool CanRedo {
			get { return redostack.Count > 0; }
		}
		
		/// <summary>
		/// Gets/Sets the limit on the number of items on the undo stack.
		/// </summary>
		/// <remarks>The size limit is enforced only on the number of stored top-level undo groups.
		/// Elements within undo groups do not count towards the size limit.</remarks>
		public int SizeLimit {
			get { return sizeLimit; }
			set {
				if (value < 0)
					ThrowUtil.CheckNotNegative(value, "value");
				if (sizeLimit != value) {
					sizeLimit = value;
					NotifyPropertyChanged("SizeLimit");
					if (undoGroupDepth == 0)
						EnforceSizeLimit();
				}
			}
		}
		
		void EnforceSizeLimit()
		{
			Debug.Assert(undoGroupDepth == 0);
			while (undostack.Count > sizeLimit)
				undostack.PopFront();
			while (redostack.Count > sizeLimit)
				redostack.PopFront();
		}
		
		/// <summary>
		/// If an undo group is open, gets the group descriptor of the current top-level
		/// undo group.
		/// If no undo group is open, gets the group descriptor from the previous undo group.
		/// </summary>
		/// <remarks>The group descriptor can be used to join adjacent undo groups:
		/// use a group descriptor to mark your changes, and on the second action,
		/// compare LastGroupDescriptor and use <see cref="StartContinuedUndoGroup"/> if you
		/// want to join the undo groups.</remarks>
		public object LastGroupDescriptor {
			get { return lastGroupDescriptor; }
		}
		
		/// <summary>
		/// Starts grouping changes.
		/// Maintains a counter so that nested calls are possible.
		/// </summary>
		public void StartUndoGroup()
		{
			StartUndoGroup(null);
		}
		
		/// <summary>
		/// Starts grouping changes.
		/// Maintains a counter so that nested calls are possible.
		/// </summary>
		/// <param name="groupDescriptor">An object that is stored with the undo group.
		/// If this is not a top-level undo group, the parameter is ignored.</param>
		public void StartUndoGroup(object groupDescriptor)
		{
			if (undoGroupDepth == 0) {
				actionCountInUndoGroup = 0;
				optionalActionCount = 0;
				lastGroupDescriptor = groupDescriptor;
			}
			undoGroupDepth++;
			//Util.LoggingService.Debug("Open undo group (new depth=" + undoGroupDepth + ")");
		}
		
		/// <summary>
		/// Starts grouping changes, continuing with the previously closed undo group if possible.
		/// Maintains a counter so that nested calls are possible.
		/// If the call to StartContinuedUndoGroup is a nested call, it behaves exactly
		/// as <see cref="StartUndoGroup()"/>, only top-level calls can continue existing undo groups.
		/// </summary>
		/// <param name="groupDescriptor">An object that is stored with the undo group.
		/// If this is not a top-level undo group, the parameter is ignored.</param>
		public void StartContinuedUndoGroup(object groupDescriptor)
		{
			if (undoGroupDepth == 0) {
				actionCountInUndoGroup = (allowContinue && undostack.Count > 0) ? 1 : 0;
				optionalActionCount = 0;
				lastGroupDescriptor = groupDescriptor;
			}
			undoGroupDepth++;
			//Util.LoggingService.Debug("Continue undo group (new depth=" + undoGroupDepth + ")");
		}
		
		/// <summary>
		/// Stops grouping changes.
		/// </summary>
		public void EndUndoGroup()
		{
			if (undoGroupDepth == 0) throw new InvalidOperationException("There are no open undo groups");
			undoGroupDepth--;
			//Util.LoggingService.Debug("Close undo group (new depth=" + undoGroupDepth + ")");
			if (undoGroupDepth == 0) {
				Debug.Assert(state == StateListen || actionCountInUndoGroup == 0);
				if (actionCountInUndoGroup == optionalActionCount) {
					// only optional actions: don't store them
					for (int i = 0; i < optionalActionCount; i++) {
						undostack.PopBack();
					}
				} else if (actionCountInUndoGroup > 1) {
					// combine all actions within the group into a single grouped action
					undostack.PushBack(new UndoOperationGroup(undostack, actionCountInUndoGroup));
					FileModified(-actionCountInUndoGroup + 1 + optionalActionCount);
				}
				//if (state == StateListen) {
				EnforceSizeLimit();
				allowContinue = true;
				RecalcIsOriginalFile(); // can raise event
				//}
			}
		}
		
		/// <summary>
		/// Throws an InvalidOperationException if an undo group is current open.
		/// </summary>
		void ThrowIfUndoGroupOpen()
		{
			if (undoGroupDepth != 0) {
				undoGroupDepth = 0;
				throw new InvalidOperationException("No undo group should be open at this point");
			}
			if (state != StateListen) {
				throw new InvalidOperationException("This method cannot be called while an undo operation is being performed");
			}
		}
		
		List<TextDocument> affectedDocuments;
		
		internal void RegisterAffectedDocument(TextDocument document)
		{
			if (affectedDocuments == null)
				affectedDocuments = new List<TextDocument>();
			if (!affectedDocuments.Contains(document)) {
				affectedDocuments.Add(document);
				document.BeginUpdate();
			}
		}
		
		void CallEndUpdateOnAffectedDocuments()
		{
			if (affectedDocuments != null) {
				foreach (TextDocument doc in affectedDocuments) {
					doc.EndUpdate();
				}
				affectedDocuments = null;
			}
		}
		
		/// <summary>
		/// Call this method to undo the last operation on the stack
		/// </summary>
		public void Undo()
		{
			ThrowIfUndoGroupOpen();
			if (undostack.Count > 0) {
				// disallow continuing undo groups after undo operation
				lastGroupDescriptor = null; allowContinue = false;
				// fetch operation to undo and move it to redo stack
				IUndoableOperation uedit = undostack.PopBack();
				redostack.PushBack(uedit);
				state = StatePlayback;
				try {
					RunUndo(uedit);
				} finally {
					state = StateListen;
					FileModified(-1);
					CallEndUpdateOnAffectedDocuments();
				}
				RecalcIsOriginalFile();
				if (undostack.Count == 0)
					NotifyPropertyChanged("CanUndo");
				if (redostack.Count == 1)
					NotifyPropertyChanged("CanRedo");
			}
		}
		
		internal void RunUndo(IUndoableOperation op)
		{
			IUndoableOperationWithContext opWithCtx = op as IUndoableOperationWithContext;
			if (opWithCtx != null)
				opWithCtx.Undo(this);
			else
				op.Undo();
		}
		
		/// <summary>
		/// Call this method to redo the last undone operation
		/// </summary>
		public void Redo()
		{
			ThrowIfUndoGroupOpen();
			if (redostack.Count > 0) {
				lastGroupDescriptor = null; allowContinue = false;
				IUndoableOperation uedit = redostack.PopBack();
				undostack.PushBack(uedit);
				state = StatePlayback;
				try {
					RunRedo(uedit);
				} finally {
					state = StateListen;
					FileModified(1);
					CallEndUpdateOnAffectedDocuments();
				}
				RecalcIsOriginalFile();
				if (redostack.Count == 0)
					NotifyPropertyChanged("CanRedo");
				if (undostack.Count == 1)
					NotifyPropertyChanged("CanUndo");
			}
		}
		
		internal void RunRedo(IUndoableOperation op)
		{
			IUndoableOperationWithContext opWithCtx = op as IUndoableOperationWithContext;
			if (opWithCtx != null)
				opWithCtx.Redo(this);
			else
				op.Redo();
		}
		
		/// <summary>
		/// Call this method to push an UndoableOperation on the undostack.
		/// The redostack will be cleared if you use this method.
		/// </summary>
		public void Push(IUndoableOperation operation)
		{
			Push(operation, false);
		}
		
		/// <summary>
		/// Call this method to push an UndoableOperation on the undostack.
		/// However, the operation will be only stored if the undo group contains a
		/// non-optional operation.
		/// Use this method to store the caret position/selection on the undo stack to
		/// prevent having only actions that affect only the caret and not the document.
		/// </summary>
		public void PushOptional(IUndoableOperation operation)
		{
			if (undoGroupDepth == 0)
				throw new InvalidOperationException("Cannot use PushOptional outside of undo group");
			Push(operation, true);
		}
		
		void Push(IUndoableOperation operation, bool isOptional)
		{
			if (operation == null) {
				throw new ArgumentNullException("operation");
			}
			
			if (state == StateListen && sizeLimit > 0) {
				bool wasEmpty = undostack.Count == 0;
				
				bool needsUndoGroup = undoGroupDepth == 0;
				if (needsUndoGroup) StartUndoGroup();
				undostack.PushBack(operation);
				actionCountInUndoGroup++;
				if (isOptional)
					optionalActionCount++;
				else
					FileModified(1);
				if (needsUndoGroup) EndUndoGroup();
				if (wasEmpty)
					NotifyPropertyChanged("CanUndo");
				ClearRedoStack();
			}
		}
		
		/// <summary>
		/// Call this method, if you want to clear the redo stack
		/// </summary>
		public void ClearRedoStack()
		{
			if (redostack.Count != 0) {
				redostack.Clear();
				NotifyPropertyChanged("CanRedo");
				// if the "original file" marker is on the redo stack: remove it
				if (elementsOnUndoUntilOriginalFile < 0)
					elementsOnUndoUntilOriginalFile = int.MinValue;
			}
		}
		
		/// <summary>
		/// Clears both the undo and redo stack.
		/// </summary>
		public void ClearAll()
		{
			ThrowIfUndoGroupOpen();
			actionCountInUndoGroup = 0;
			optionalActionCount = 0;
			if (undostack.Count != 0) {
				lastGroupDescriptor = null;
				allowContinue = false;
				undostack.Clear();
				NotifyPropertyChanged("CanUndo");
			}
			ClearRedoStack();
		}
		
		internal void Push(TextDocument document, DocumentChangeEventArgs e)
		{
			if (state == StatePlayback)
				throw new InvalidOperationException("Document changes during undo/redo operations are not allowed.");
			if (state == StatePlaybackModifyDocument)
				state = StatePlayback; // allow only 1 change per expected modification
			else
				Push(new DocumentChangeOperation(document, e));
		}
		
		/// <summary>
		/// Is raised when a property (CanUndo, CanRedo) changed.
		/// </summary>
		public event PropertyChangedEventHandler PropertyChanged;
		
		void NotifyPropertyChanged(string propertyName)
		{
			if (PropertyChanged != null)
				PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
		}
	}
}

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)

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
Web01 | 2.8.140721.1 | Last Updated 1 Apr 2013
Article Copyright 2009 by Daniel Grunwald
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid