Code Coverage Statistics for Source File

c:\Tools\SD3\src\Libraries\ICSharpCode.TextEditor\Project\Src\Actions\MiscActions.cs

Sequence Point Coverage N/A 0 of 0	Branch Coverage N/A 0 of 0	Lines 922

Sequence Point Coverage

N/A

0 of 0

Branch Coverage

N/A

0 of 0

Lines

922

Highlight: Uncovered Code Covered Code


// <file>
//     <copyright see="prj:///doc/copyright.txt"/>
//     <license see="prj:///doc/license.txt"/>
//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
//     <version>$Revision: 2659 $</version>
// </file>

using System;
using System.Drawing;
using System.Text;

using ICSharpCode.TextEditor.Document;

namespace ICSharpCode.TextEditor.Actions
{
	public class Tab : AbstractEditAction
	{
		public static string GetIndentationString(IDocument document)
		{
			return GetIndentationString(document, null);
		}
		
		public static string GetIndentationString(IDocument document, TextArea textArea)
		{
			StringBuilder indent = new StringBuilder();
			
			if (document.TextEditorProperties.ConvertTabsToSpaces) {
				int tabIndent = document.TextEditorProperties.IndentationSize;
				if (textArea != null) {
					int column = textArea.TextView.GetVisualColumn(textArea.Caret.Line, textArea.Caret.Column);
					indent.Append(new String(' ', tabIndent - column % tabIndent));
				} else {
					indent.Append(new String(' ', tabIndent));
				}
			} else {
				indent.Append('\t');
			}
			return indent.ToString();
		}
		
		void InsertTabs(IDocument document, ISelection selection, int y1, int y2)
		{
			string indentationString = GetIndentationString(document);
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (i == y2 && i == selection.EndPosition.Y && selection.EndPosition.X  == 0) {
					continue;
				}
				
				// this bit is optional - but useful if you are using block tabbing to sort out
				// a source file with a mixture of tabs and spaces
//				string newLine = document.GetText(line.Offset,line.Length);
//				document.Replace(line.Offset,line.Length,newLine);
				
				document.Insert(line.Offset, indentationString);
			}
		}
		
		void InsertTabAtCaretPosition(TextArea textArea)
		{
			switch (textArea.Caret.CaretMode) {
				case CaretMode.InsertMode:
					textArea.InsertString(GetIndentationString(textArea.Document, textArea));
					break;
				case CaretMode.OverwriteMode:
					string indentStr = GetIndentationString(textArea.Document, textArea);
					textArea.ReplaceChar(indentStr[0]);
					if (indentStr.Length > 1) {
						textArea.InsertString(indentStr.Substring(1));
					}
					break;
			}
			textArea.SetDesiredColumn();
		}
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			textArea.Document.UndoStack.StartUndoGroup();
			if (textArea.SelectionManager.HasSomethingSelected) {
				foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
					int startLine = selection.StartPosition.Y;
					int endLine   = selection.EndPosition.Y;
					if (startLine != endLine) {
						textArea.BeginUpdate();
						InsertTabs(textArea.Document, selection, startLine, endLine);
						textArea.Document.UpdateQueue.Clear();
						textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, startLine, endLine));
						textArea.EndUpdate();
					} else {
						InsertTabAtCaretPosition(textArea);
						break;
					}
				}
				textArea.Document.CommitUpdate();
				textArea.AutoClearSelection = false;
			} else {
				InsertTabAtCaretPosition(textArea);
			}
			textArea.Document.UndoStack.EndUndoGroup();
		}
	}
	
	public class ShiftTab : AbstractEditAction
	{
		void RemoveTabs(IDocument document, ISelection selection, int y1, int y2)
		{
			document.UndoStack.StartUndoGroup();
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (i == y2 && line.Offset == selection.EndOffset) {
					continue;
				}
				if (line.Length > 0) {
					/**** TextPad Strategy:
					/// first convert leading whitespace to tabs (controversial! - not all editors work like this)
					string newLine = TextUtilities.LeadingWhiteSpaceToTabs(document.GetText(line.Offset,line.Length),document.Properties.Get("TabIndent", 4));
					if(newLine.Length > 0 && newLine[0] == '\t') {
						document.Replace(line.Offset,line.Length,newLine.Substring(1));
						++redocounter;
					}
					else if(newLine.Length > 0 && newLine[0] == ' ') {
						/// there were just some leading spaces but less than TabIndent of them
						int leadingSpaces = 1;
						for(leadingSpaces = 1; leadingSpaces < newLine.Length && newLine[leadingSpaces] == ' '; leadingSpaces++) {
							/// deliberately empty
						}
						document.Replace(line.Offset,line.Length,newLine.Substring(leadingSpaces));
						++redocounter;
					}
					/// else
					/// there were no leading tabs or spaces on this line so do nothing
					/// MS Visual Studio 6 strategy:
					 ****/
//					string temp = document.GetText(line.Offset,line.Length);
					if (line.Length > 0) {
						int charactersToRemove = 0;
						if(document.GetCharAt(line.Offset) == '\t') { // first character is a tab - just remove it
							charactersToRemove = 1;
						} else if(document.GetCharAt(line.Offset) == ' ') {
							int leadingSpaces = 1;
							int tabIndent = document.TextEditorProperties.IndentationSize;
							for (leadingSpaces = 1; leadingSpaces < line.Length && document.GetCharAt(line.Offset + leadingSpaces) == ' '; leadingSpaces++) {
								// deliberately empty
							}
							if(leadingSpaces >= tabIndent) {
								// just remove tabIndent
								charactersToRemove = tabIndent;
							}
							else if(line.Length > leadingSpaces && document.GetCharAt(line.Offset + leadingSpaces) == '\t') {
								// remove the leading spaces and the following tab as they add up
								// to just one tab stop
								charactersToRemove = leadingSpaces+1;
							}
							else {
								// just remove the leading spaces
								charactersToRemove = leadingSpaces;
							}
						}
						if (charactersToRemove > 0) {
							document.Remove(line.Offset,charactersToRemove);
						}
					}
				}
			}
			document.UndoStack.EndUndoGroup();
		}
		
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.SelectionManager.HasSomethingSelected) {
				foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
					int startLine = selection.StartPosition.Y;
					int endLine   = selection.EndPosition.Y;
					textArea.BeginUpdate();
					RemoveTabs(textArea.Document, selection, startLine, endLine);
					textArea.Document.UpdateQueue.Clear();
					textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, startLine, endLine));
					textArea.EndUpdate();
					
				}
				textArea.AutoClearSelection = false;
			} else {
				// Pressing Shift-Tab with nothing selected the cursor will move back to the
				// previous tab stop. It will stop at the beginning of the line. Also, the desired
				// column is updated to that column.
				LineSegment line = textArea.Document.GetLineSegmentForOffset(textArea.Caret.Offset);
				string startOfLine = textArea.Document.GetText(line.Offset,textArea.Caret.Offset - line.Offset);
				int tabIndent = textArea.Document.TextEditorProperties.IndentationSize;
				int currentColumn = textArea.Caret.Column;
				int remainder = currentColumn % tabIndent;
				if (remainder == 0) {
					textArea.Caret.DesiredColumn = Math.Max(0, currentColumn - tabIndent);
				} else {
					textArea.Caret.DesiredColumn = Math.Max(0, currentColumn - remainder);
				}
				textArea.SetCaretToDesiredColumn();
			}
		}
	}
	
	public class ToggleComment : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			
			if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("LineComment")) {
				new ToggleLineComment().Execute(textArea);
			} else if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin") &&
			           textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin")) {
				new ToggleBlockComment().Execute(textArea);
			}
		}
	}
	
	public class ToggleLineComment : AbstractEditAction
	{
		int firstLine;
		int lastLine;
		
		void RemoveCommentAt(IDocument document, string comment, ISelection selection, int y1, int y2)
		{
			firstLine = y1;
			lastLine  = y2;
			
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (selection != null && i == y2 && line.Offset == selection.Offset + selection.Length) {
					--lastLine;
					continue;
				}
				
				string lineText = document.GetText(line.Offset, line.Length);
				if (lineText.Trim().StartsWith(comment)) {
					document.Remove(line.Offset + lineText.IndexOf(comment), comment.Length);
				}
			}
		}
		
		void SetCommentAt(IDocument document, string comment, ISelection selection, int y1, int y2)
		{
			firstLine = y1;
			lastLine  = y2;
			
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (selection != null && i == y2 && line.Offset == selection.Offset + selection.Length) {
					--lastLine;
					continue;
				}
				
				string lineText = document.GetText(line.Offset, line.Length);
				document.Insert(line.Offset, comment);
			}
		}
		
		bool ShouldComment(IDocument document, string comment, ISelection selection, int startLine, int endLine)
		{
			for (int i = endLine; i >= startLine; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (selection != null && i == endLine && line.Offset == selection.Offset + selection.Length) {
					--lastLine;
					continue;
				}
				string lineText = document.GetText(line.Offset, line.Length);
				if (!lineText.Trim().StartsWith(comment)) {
					return true;
				}
			}
			return false;
		}
		
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			
			string comment = null;
			if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("LineComment")) {
				comment = textArea.Document.HighlightingStrategy.Properties["LineComment"].ToString();
			}
			
			if (comment == null || comment.Length == 0) {
				return;
			}
			
			textArea.Document.UndoStack.StartUndoGroup();
			if (textArea.SelectionManager.HasSomethingSelected) {
				bool shouldComment = true;
				foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
					if (!ShouldComment(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y)) {
						shouldComment = false;
						break;
					}
				}
				
				foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
					textArea.BeginUpdate();
					if (shouldComment) {
						SetCommentAt(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y);
					} else {
						RemoveCommentAt(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y);
					}
					textArea.Document.UpdateQueue.Clear();
					textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, firstLine, lastLine));
					textArea.EndUpdate();
				}
				textArea.Document.CommitUpdate();
				textArea.AutoClearSelection = false;
			} else {
				textArea.BeginUpdate();
				int caretLine = textArea.Caret.Line;
				if (ShouldComment(textArea.Document, comment, null, caretLine, caretLine)) {
					SetCommentAt(textArea.Document, comment, null, caretLine, caretLine);
				} else {
					RemoveCommentAt(textArea.Document, comment, null, caretLine, caretLine);
				}
				textArea.Document.UpdateQueue.Clear();
				textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, caretLine));
				textArea.EndUpdate();
			}
			textArea.Document.UndoStack.EndUndoGroup();
		}
	}
	
	public class ToggleBlockComment : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			
			string commentStart = null;
			if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin")) {
				commentStart = textArea.Document.HighlightingStrategy.Properties["BlockCommentBegin"].ToString();
			}
			
			string commentEnd = null;
			if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentEnd")) {
				commentEnd = textArea.Document.HighlightingStrategy.Properties["BlockCommentEnd"].ToString();
			}
			
			if (commentStart == null || commentStart.Length == 0 || commentEnd == null || commentEnd.Length == 0) {
				return;
			}
			
			int selectionStartOffset;
			int selectionEndOffset;
			
			if (textArea.SelectionManager.HasSomethingSelected) {
				selectionStartOffset = textArea.SelectionManager.SelectionCollection[0].Offset;
				selectionEndOffset = textArea.SelectionManager.SelectionCollection[textArea.SelectionManager.SelectionCollection.Count - 1].EndOffset;
			} else {
				selectionStartOffset = textArea.Caret.Offset;
				selectionEndOffset = selectionStartOffset;
			}
			
			BlockCommentRegion commentRegion = FindSelectedCommentRegion(textArea.Document, commentStart, commentEnd, selectionStartOffset, selectionEndOffset);
			
			textArea.Document.UndoStack.StartUndoGroup();
			if (commentRegion != null) {
				RemoveComment(textArea.Document, commentRegion);
			} else if (textArea.SelectionManager.HasSomethingSelected) {
				SetCommentAt(textArea.Document, selectionStartOffset, selectionEndOffset, commentStart, commentEnd);
			}
			textArea.Document.UndoStack.EndUndoGroup();
			
			textArea.Document.CommitUpdate();
			textArea.AutoClearSelection = false;
		}
		
		public static BlockCommentRegion FindSelectedCommentRegion(IDocument document, string commentStart, string commentEnd, int selectionStartOffset, int selectionEndOffset)
		{
			if (document.TextLength == 0) {
				return null;
			}
			
			// Find start of comment in selected text.
			
			int commentEndOffset = -1;
			string selectedText = document.GetText(selectionStartOffset, selectionEndOffset - selectionStartOffset);
			
			int commentStartOffset = selectedText.IndexOf(commentStart);
			if (commentStartOffset >= 0) {
				commentStartOffset += selectionStartOffset;
			}

			// Find end of comment in selected text.
			
			if (commentStartOffset >= 0) {
				commentEndOffset = selectedText.IndexOf(commentEnd, commentStartOffset + commentStart.Length - selectionStartOffset);
			} else {
				commentEndOffset = selectedText.IndexOf(commentEnd);
			}
			
			if (commentEndOffset >= 0) {
				commentEndOffset += selectionStartOffset;
			}
			
			// Find start of comment before or partially inside the
			// selected text.
			
			int commentEndBeforeStartOffset = -1;
			if (commentStartOffset == -1) {
				int offset = selectionEndOffset + commentStart.Length - 1;
				if (offset > document.TextLength) {
					offset = document.TextLength;
				}
				string text = document.GetText(0, offset);
				commentStartOffset = text.LastIndexOf(commentStart);
				if (commentStartOffset >= 0) {
					// Find end of comment before comment start.
					commentEndBeforeStartOffset = text.IndexOf(commentEnd, commentStartOffset, selectionStartOffset - commentStartOffset);
					if (commentEndBeforeStartOffset > commentStartOffset) {
						commentStartOffset = -1;
					}
				}
			}
			
			// Find end of comment after or partially after the
			// selected text.
			
			if (commentEndOffset == -1) {
				int offset = selectionStartOffset + 1 - commentEnd.Length;
				if (offset < 0) {
					offset = selectionStartOffset;
				}
				string text = document.GetText(offset, document.TextLength - offset);
				commentEndOffset = text.IndexOf(commentEnd);
				if (commentEndOffset >= 0) {
					commentEndOffset += offset;
				}
			}
			
			if (commentStartOffset != -1 && commentEndOffset != -1) {
				return new BlockCommentRegion(commentStart, commentEnd, commentStartOffset, commentEndOffset);
			}
			
			return null;
		}
		

		void SetCommentAt(IDocument document, int offsetStart, int offsetEnd, string commentStart, string commentEnd)
		{
			document.Insert(offsetEnd, commentEnd);
			document.Insert(offsetStart, commentStart);
		}
		
		void RemoveComment(IDocument document, BlockCommentRegion commentRegion)
		{
			document.Remove(commentRegion.EndOffset, commentRegion.CommentEnd.Length);
			document.Remove(commentRegion.StartOffset, commentRegion.CommentStart.Length);
		}
	}
	
	public class BlockCommentRegion
	{
		string commentStart = String.Empty;
		string commentEnd = String.Empty;
		int startOffset = -1;
		int endOffset = -1;
		
		/// <summary>
		/// The end offset is the offset where the comment end string starts from.
		/// </summary>
		public BlockCommentRegion(string commentStart, string commentEnd, int startOffset, int endOffset)
		{
			this.commentStart = commentStart;
			this.commentEnd = commentEnd;
			this.startOffset = startOffset;
			this.endOffset = endOffset;
		}
		
		public string CommentStart {
			get {
				return commentStart;
			}
		}
		
		public string CommentEnd {
			get {
				return commentEnd;
			}
		}
		
		public int StartOffset {
			get {
				return startOffset;
			}
		}
		
		public int EndOffset {
			get {
				return endOffset;
			}
		}
		
		public override bool Equals(object obj)
		{
			BlockCommentRegion commentRegion = obj as BlockCommentRegion;
			if (commentRegion != null) {
				if (commentRegion.commentStart == commentStart &&
				    commentRegion.commentEnd == commentEnd &&
				    commentRegion.startOffset == startOffset &&
				    commentRegion.endOffset == endOffset) {
					return true;
				}
			}
			
			return false;
		}
		
		public override int GetHashCode()
		{
			return commentStart.GetHashCode() & commentEnd.GetHashCode() & startOffset.GetHashCode() & endOffset.GetHashCode();
		}
	}
	
	public class IndentSelection : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			textArea.BeginUpdate();
			if (textArea.SelectionManager.HasSomethingSelected) {
				foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
					textArea.Document.FormattingStrategy.IndentLines(textArea, selection.StartPosition.Y, selection.EndPosition.Y);
				}
			} else {
				textArea.Document.FormattingStrategy.IndentLines(textArea, 0, textArea.Document.TotalNumberOfLines - 1);
			}
			textArea.EndUpdate();
			textArea.Refresh();
		}
	}
	
	public class Backspace : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			if (textArea.SelectionManager.HasSomethingSelected) {
				textArea.BeginUpdate();
				textArea.Caret.Position = textArea.SelectionManager.SelectionCollection[0].StartPosition;
				textArea.SelectionManager.RemoveSelectedText();
				textArea.ScrollToCaret();
				textArea.EndUpdate();
			} else {
				if (textArea.Caret.Offset > 0) {
					textArea.BeginUpdate();
					int curLineNr     = textArea.Document.GetLineNumberForOffset(textArea.Caret.Offset);
					int curLineOffset = textArea.Document.GetLineSegment(curLineNr).Offset;
					
					if (curLineOffset == textArea.Caret.Offset) {
						LineSegment line = textArea.Document.GetLineSegment(curLineNr - 1);
						bool lastLine = curLineNr == textArea.Document.TotalNumberOfLines;
						int lineEndOffset = line.Offset + line.Length;
						int lineLength = line.Length;
						textArea.Document.Remove(lineEndOffset, curLineOffset - lineEndOffset);
						textArea.Caret.Position = new TextLocation(lineLength, curLineNr - 1);
						textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, curLineNr - 1)));
						textArea.EndUpdate();
					} else {
						int caretOffset = textArea.Caret.Offset - 1;
						textArea.Caret.Position = textArea.Document.OffsetToPosition(caretOffset);
						textArea.Document.Remove(caretOffset, 1);
						
						textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToLineEnd, new TextLocation(textArea.Caret.Offset - textArea.Document.GetLineSegment(curLineNr).Offset, curLineNr)));
						textArea.EndUpdate();
					}
				}
			}
		}
	}
	
	public class Delete : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			if (textArea.SelectionManager.HasSomethingSelected) {
				textArea.BeginUpdate();
				textArea.Caret.Position = textArea.SelectionManager.SelectionCollection[0].StartPosition;
				textArea.SelectionManager.RemoveSelectedText();
				textArea.ScrollToCaret();
				textArea.EndUpdate();
			} else {
				
				if (textArea.Caret.Offset < textArea.Document.TextLength) {
					textArea.BeginUpdate();
					int curLineNr   = textArea.Document.GetLineNumberForOffset(textArea.Caret.Offset);
					LineSegment curLine = textArea.Document.GetLineSegment(curLineNr);
					
					if (curLine.Offset + curLine.Length == textArea.Caret.Offset) {
						if (curLineNr + 1 < textArea.Document.TotalNumberOfLines) {
							LineSegment nextLine = textArea.Document.GetLineSegment(curLineNr + 1);
							
							textArea.Document.Remove(textArea.Caret.Offset, nextLine.Offset - textArea.Caret.Offset);
							textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, curLineNr)));
						}
					} else {
						textArea.Document.Remove(textArea.Caret.Offset, 1);
//						textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToLineEnd, new TextLocation(textArea.Caret.Offset - textArea.Document.GetLineSegment(curLineNr).Offset, curLineNr)));
					}
					textArea.UpdateMatchingBracket();
					textArea.EndUpdate();
				}
			}
		}
	}
	
	public class MovePageDown : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			int curLineNr           = textArea.Caret.Line;
			int requestedLineNumber = Math.Min(textArea.Document.GetNextVisibleLineAbove(curLineNr, textArea.TextView.VisibleLineCount), textArea.Document.TotalNumberOfLines - 1);
			
			if (curLineNr != requestedLineNumber) {
				textArea.Caret.Position = new TextLocation(textArea.Caret.DesiredColumn, requestedLineNumber);
			}
		}
	}
	
	public class MovePageUp : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			int curLineNr           = textArea.Caret.Line;
			int requestedLineNumber = Math.Max(textArea.Document.GetNextVisibleLineBelow(curLineNr, textArea.TextView.VisibleLineCount), 0);
			
			if (curLineNr != requestedLineNumber) {
				textArea.Caret.Position = new TextLocation(textArea.Caret.DesiredColumn, requestedLineNumber);
			}
		}
	}
	public class Return : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			textArea.BeginUpdate();
			textArea.Document.UndoStack.StartUndoGroup();
			try {
				if (textArea.HandleKeyPress('\n'))
					return;
				
				textArea.InsertString(Environment.NewLine);
				
				int curLineNr = textArea.Caret.Line;
				textArea.Document.FormattingStrategy.FormatLine(textArea, curLineNr, textArea.Caret.Offset, '\n');
				textArea.SetDesiredColumn();
				
				textArea.Document.UpdateQueue.Clear();
				textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, curLineNr - 1)));
			} finally {
				textArea.Document.UndoStack.EndUndoGroup();
				textArea.EndUpdate();
			}
		}
	}
	
	public class ToggleEditMode : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			if (textArea.Document.ReadOnly) {
				return;
			}
			switch (textArea.Caret.CaretMode) {
				case CaretMode.InsertMode:
					textArea.Caret.CaretMode = CaretMode.OverwriteMode;
					break;
				case CaretMode.OverwriteMode:
					textArea.Caret.CaretMode = CaretMode.InsertMode;
					break;
			}
		}
	}
	
	public class Undo : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			textArea.MotherTextEditorControl.Undo();
		}
	}
	
	public class Redo : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			textArea.MotherTextEditorControl.Redo();
		}
	}
	
	/// <summary>
	/// handles the ctrl-backspace key
	/// functionality attempts to roughly mimic MS Developer studio
	/// I will implement this as deleting back to the point that ctrl-leftarrow would
	/// take you to
	/// </summary>
	public class WordBackspace : AbstractEditAction
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			// if anything is selected we will just delete it first
			textArea.BeginUpdate();
			if (textArea.SelectionManager.HasSomethingSelected) {
				textArea.SelectionManager.RemoveSelectedText();
				textArea.ScrollToCaret();
			}
			// now delete from the caret to the beginning of the word
			LineSegment line =
				textArea.Document.GetLineSegmentForOffset(textArea.Caret.Offset);
			// if we are not at the beginning of a line
			if(textArea.Caret.Offset > line.Offset) {
				int prevWordStart = TextUtilities.FindPrevWordStart(textArea.Document,
				                                                    textArea.Caret.Offset);
				if(prevWordStart < textArea.Caret.Offset) {
					textArea.Document.Remove(prevWordStart,textArea.Caret.Offset -
					                         prevWordStart);
					textArea.Caret.Position = textArea.Document.OffsetToPosition(prevWordStart);
				}
			}
			// if we are now at the beginning of a line
			if(textArea.Caret.Offset == line.Offset) {
				// if we are not on the first line
				int curLineNr =
					textArea.Document.GetLineNumberForOffset(textArea.Caret.Offset);
				if(curLineNr > 0) {
					// move to the end of the line above
					LineSegment lineAbove = textArea.Document.GetLineSegment(curLineNr -
					                                                         1);
					int endOfLineAbove = lineAbove.Offset + lineAbove.Length;
					int charsToDelete = textArea.Caret.Offset - endOfLineAbove;
					textArea.Document.Remove(endOfLineAbove,charsToDelete);
					textArea.Caret.Position = textArea.Document.OffsetToPosition(endOfLineAbove);
				}
			}
			textArea.SetDesiredColumn();
			textArea.EndUpdate();
			// if there are now less lines, we need this or there are redraw problems
			textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, textArea.Document.GetLineNumberForOffset(textArea.Caret.Offset))));
			textArea.Document.CommitUpdate();
		}
	}
	
	/// <summary>
	/// handles the ctrl-delete key
	/// functionality attempts to mimic MS Developer studio
	/// I will implement this as deleting forwardto the point that
	/// ctrl-leftarrow would take you to
	/// </summary>
	public class DeleteWord : Delete
	{
		/// <remarks>
		/// Executes this edit action
		/// </remarks>
		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
		public override void Execute(TextArea textArea)
		{
			// if anything is selected we will just delete it first
			textArea.BeginUpdate();
			if (textArea.SelectionManager.HasSomethingSelected) {
				textArea.SelectionManager.RemoveSelectedText();
				textArea.ScrollToCaret();
			}
			// now delete from the caret to the beginning of the word
			LineSegment line =
				textArea.Document.GetLineSegmentForOffset(textArea.Caret.Offset);
			if(textArea.Caret.Offset == line.Offset + line.Length) {
				// if we are at the end of a line
				base.Execute(textArea);
			} else {
				int nextWordStart = TextUtilities.FindNextWordStart(textArea.Document,
				                                                    textArea.Caret.Offset);
				if(nextWordStart > textArea.Caret.Offset) {
					textArea.Document.Remove(textArea.Caret.Offset,nextWordStart -
					                         textArea.Caret.Offset);
					// cursor never moves with this command
				}
			}
			textArea.UpdateMatchingBracket();
			textArea.EndUpdate();
			// if there are now less lines, we need this or there are redraw problems
			textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, textArea.Document.GetLineNumberForOffset(textArea.Caret.Offset))));
			textArea.Document.CommitUpdate();
		}
	}
	
	public class DeleteLine : AbstractEditAction
	{
		public override void Execute(TextArea textArea)
		{
			int lineNr = textArea.Caret.Line;
			LineSegment line = textArea.Document.GetLineSegment(lineNr);
			textArea.Document.Remove(line.Offset, line.TotalLength);
			textArea.Caret.Position = textArea.Document.OffsetToPosition(line.Offset);

			textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.PositionToEnd, new TextLocation(0, lineNr)));
			textArea.UpdateMatchingBracket();
			textArea.Document.CommitUpdate();
		}
	}
	
	public class DeleteToLineEnd : AbstractEditAction
	{
		public override void Execute(TextArea textArea)
		{
			int lineNr = textArea.Caret.Line;
			LineSegment line = textArea.Document.GetLineSegment(lineNr);
			
			int numRemove = (line.Offset + line.Length) - textArea.Caret.Offset;
			if (numRemove > 0) {
				textArea.Document.Remove(textArea.Caret.Offset, numRemove);
				textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, new TextLocation(0, lineNr)));
				textArea.Document.CommitUpdate();
			}
		}
	}
	
	public class GotoMatchingBrace : AbstractEditAction
	{
		public override void Execute(TextArea textArea)
		{
			Highlight highlight = textArea.FindMatchingBracketHighlight();
			if (highlight != null) {
				TextLocation p1 = new TextLocation(highlight.CloseBrace.X + 1, highlight.CloseBrace.Y);
				TextLocation p2 = new TextLocation(highlight.OpenBrace.X + 1, highlight.OpenBrace.Y);
				if (p1 == textArea.Caret.Position) {
					if (textArea.Document.TextEditorProperties.BracketMatchingStyle == BracketMatchingStyle.After) {
						textArea.Caret.Position = p2;
					} else {
						textArea.Caret.Position = new TextLocation(p2.X - 1, p2.Y);
					}
				} else {
					if (textArea.Document.TextEditorProperties.BracketMatchingStyle == BracketMatchingStyle.After) {
						textArea.Caret.Position = p1;
					} else {
						textArea.Caret.Position = new TextLocation(p1.X - 1, p1.Y);
					}
				}
				textArea.SetDesiredColumn();
			}
		}
	}
}

L	V	Source
1		// <file>
2		// <copyright see="prj:///doc/copyright.txt"/>
3		// <license see="prj:///doc/license.txt"/>
4		// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
5		// <version>$Revision: 2659 $</version>
6		// </file>
7
8		using System;
9		using System.Drawing;
10		using System.Text;
11
12		using ICSharpCode.TextEditor.Document;
13
14		namespace ICSharpCode.TextEditor.Actions
15		{
16		public class Tab : AbstractEditAction
17		{
18		public static string GetIndentationString(IDocument document)
19		{
20		return GetIndentationString(document, null);
21		}
22
23		public static string GetIndentationString(IDocument document, TextArea textArea)
24		{
25		StringBuilder indent = new StringBuilder();
26
27		if (document.TextEditorProperties.ConvertTabsToSpaces) {
28		int tabIndent = document.TextEditorProperties.IndentationSize;
29		if (textArea != null) {
30		int column = textArea.TextView.GetVisualColumn(textArea.Caret.Line, textArea.Caret.Column);
31		indent.Append(new String(' ', tabIndent - column % tabIndent));
32		} else {
33		indent.Append(new String(' ', tabIndent));
34		}
35		} else {
36		indent.Append('\t');
37		}
38		return indent.ToString();
39		}
40
41		void InsertTabs(IDocument document, ISelection selection, int y1, int y2)
42		{
43		string indentationString = GetIndentationString(document);
44		for (int i = y2; i >= y1; --i) {
45		LineSegment line = document.GetLineSegment(i);
46		if (i == y2 && i == selection.EndPosition.Y && selection.EndPosition.X == 0) {
47		continue;
48		}
49
50		// this bit is optional - but useful if you are using block tabbing to sort out
51		// a source file with a mixture of tabs and spaces
52		// string newLine = document.GetText(line.Offset,line.Length);
53		// document.Replace(line.Offset,line.Length,newLine);
54
55		document.Insert(line.Offset, indentationString);
56		}
57		}
58
59		void InsertTabAtCaretPosition(TextArea textArea)
60		{
61		switch (textArea.Caret.CaretMode) {
62		case CaretMode.InsertMode:
63		textArea.InsertString(GetIndentationString(textArea.Document, textArea));
64		break;
65		case CaretMode.OverwriteMode:
66		string indentStr = GetIndentationString(textArea.Document, textArea);
67		textArea.ReplaceChar(indentStr[0]);
68		if (indentStr.Length > 1) {
69		textArea.InsertString(indentStr.Substring(1));
70		}
71		break;
72		}
73		textArea.SetDesiredColumn();
74		}
75		/// <remarks>
76		/// Executes this edit action
77		/// </remarks>
78		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
79		public override void Execute(TextArea textArea)
80		{
81		if (textArea.Document.ReadOnly) {
82		return;
83		}
84		textArea.Document.UndoStack.StartUndoGroup();
85		if (textArea.SelectionManager.HasSomethingSelected) {
86		foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
87		int startLine = selection.StartPosition.Y;
88		int endLine = selection.EndPosition.Y;
89		if (startLine != endLine) {
90		textArea.BeginUpdate();
91		InsertTabs(textArea.Document, selection, startLine, endLine);
92		textArea.Document.UpdateQueue.Clear();
93		textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, startLine, endLine));
94		textArea.EndUpdate();
95		} else {
96		InsertTabAtCaretPosition(textArea);
97		break;
98		}
99		}
100		textArea.Document.CommitUpdate();
101		textArea.AutoClearSelection = false;
102		} else {
103		InsertTabAtCaretPosition(textArea);
104		}
105		textArea.Document.UndoStack.EndUndoGroup();
106		}
107		}
108
109		public class ShiftTab : AbstractEditAction
110		{
111		void RemoveTabs(IDocument document, ISelection selection, int y1, int y2)
112		{
113		document.UndoStack.StartUndoGroup();
114		for (int i = y2; i >= y1; --i) {
115		LineSegment line = document.GetLineSegment(i);
116		if (i == y2 && line.Offset == selection.EndOffset) {
117		continue;
118		}
119		if (line.Length > 0) {
120		/**** TextPad Strategy:
121		/// first convert leading whitespace to tabs (controversial! - not all editors work like this)
122		string newLine = TextUtilities.LeadingWhiteSpaceToTabs(document.GetText(line.Offset,line.Length),document.Properties.Get("TabIndent", 4));
123		if(newLine.Length > 0 && newLine[0] == '\t') {
124		document.Replace(line.Offset,line.Length,newLine.Substring(1));
125		++redocounter;
126		}
127		else if(newLine.Length > 0 && newLine[0] == ' ') {
128		/// there were just some leading spaces but less than TabIndent of them
129		int leadingSpaces = 1;
130		for(leadingSpaces = 1; leadingSpaces < newLine.Length && newLine[leadingSpaces] == ' '; leadingSpaces++) {
131		/// deliberately empty
132		}
133		document.Replace(line.Offset,line.Length,newLine.Substring(leadingSpaces));
134		++redocounter;
135		}
136		/// else
137		/// there were no leading tabs or spaces on this line so do nothing
138		/// MS Visual Studio 6 strategy:
139		****/
140		// string temp = document.GetText(line.Offset,line.Length);
141		if (line.Length > 0) {
142		int charactersToRemove = 0;
143		if(document.GetCharAt(line.Offset) == '\t') { // first character is a tab - just remove it
144		charactersToRemove = 1;
145		} else if(document.GetCharAt(line.Offset) == ' ') {
146		int leadingSpaces = 1;
147		int tabIndent = document.TextEditorProperties.IndentationSize;
148		for (leadingSpaces = 1; leadingSpaces < line.Length && document.GetCharAt(line.Offset + leadingSpaces) == ' '; leadingSpaces++) {
149		// deliberately empty
150		}
151		if(leadingSpaces >= tabIndent) {
152		// just remove tabIndent
153		charactersToRemove = tabIndent;
154		}
155		else if(line.Length > leadingSpaces && document.GetCharAt(line.Offset + leadingSpaces) == '\t') {
156		// remove the leading spaces and the following tab as they add up
157		// to just one tab stop
158		charactersToRemove = leadingSpaces+1;
159		}
160		else {
161		// just remove the leading spaces
162		charactersToRemove = leadingSpaces;
163		}
164		}
165		if (charactersToRemove > 0) {
166		document.Remove(line.Offset,charactersToRemove);
167		}
168		}
169		}
170		}
171		document.UndoStack.EndUndoGroup();
172		}
173
174		/// <remarks>
175		/// Executes this edit action
176		/// </remarks>
177		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
178		public override void Execute(TextArea textArea)
179		{
180		if (textArea.SelectionManager.HasSomethingSelected) {
181		foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
182		int startLine = selection.StartPosition.Y;
183		int endLine = selection.EndPosition.Y;
184		textArea.BeginUpdate();
185		RemoveTabs(textArea.Document, selection, startLine, endLine);
186		textArea.Document.UpdateQueue.Clear();
187		textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, startLine, endLine));
188		textArea.EndUpdate();
189
190		}
191		textArea.AutoClearSelection = false;
192		} else {
193		// Pressing Shift-Tab with nothing selected the cursor will move back to the
194		// previous tab stop. It will stop at the beginning of the line. Also, the desired
195		// column is updated to that column.
196		LineSegment line = textArea.Document.GetLineSegmentForOffset(textArea.Caret.Offset);
197		string startOfLine = textArea.Document.GetText(line.Offset,textArea.Caret.Offset - line.Offset);
198		int tabIndent = textArea.Document.TextEditorProperties.IndentationSize;
199		int currentColumn = textArea.Caret.Column;
200		int remainder = currentColumn % tabIndent;
201		if (remainder == 0) {
202		textArea.Caret.DesiredColumn = Math.Max(0, currentColumn - tabIndent);
203		} else {
204		textArea.Caret.DesiredColumn = Math.Max(0, currentColumn - remainder);
205		}
206		textArea.SetCaretToDesiredColumn();
207		}
208		}
209		}
210
211		public class ToggleComment : AbstractEditAction
212		{
213		/// <remarks>
214		/// Executes this edit action
215		/// </remarks>
216		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
217		public override void Execute(TextArea textArea)
218		{
219		if (textArea.Document.ReadOnly) {
220		return;
221		}
222
223		if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("LineComment")) {
224		new ToggleLineComment().Execute(textArea);
225		} else if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin") &&
226		textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin")) {
227		new ToggleBlockComment().Execute(textArea);
228		}
229		}
230		}
231
232		public class ToggleLineComment : AbstractEditAction
233		{
234		int firstLine;
235		int lastLine;
236
237		void RemoveCommentAt(IDocument document, string comment, ISelection selection, int y1, int y2)
238		{
239		firstLine = y1;
240		lastLine = y2;
241
242		for (int i = y2; i >= y1; --i) {
243		LineSegment line = document.GetLineSegment(i);
244		if (selection != null && i == y2 && line.Offset == selection.Offset + selection.Length) {
245		--lastLine;
246		continue;
247		}
248
249		string lineText = document.GetText(line.Offset, line.Length);
250		if (lineText.Trim().StartsWith(comment)) {
251		document.Remove(line.Offset + lineText.IndexOf(comment), comment.Length);
252		}
253		}
254		}
255
256		void SetCommentAt(IDocument document, string comment, ISelection selection, int y1, int y2)
257		{
258		firstLine = y1;
259		lastLine = y2;
260
261		for (int i = y2; i >= y1; --i) {
262		LineSegment line = document.GetLineSegment(i);
263		if (selection != null && i == y2 && line.Offset == selection.Offset + selection.Length) {
264		--lastLine;
265		continue;
266		}
267
268		string lineText = document.GetText(line.Offset, line.Length);
269		document.Insert(line.Offset, comment);
270		}
271		}
272
273		bool ShouldComment(IDocument document, string comment, ISelection selection, int startLine, int endLine)
274		{
275		for (int i = endLine; i >= startLine; --i) {
276		LineSegment line = document.GetLineSegment(i);
277		if (selection != null && i == endLine && line.Offset == selection.Offset + selection.Length) {
278		--lastLine;
279		continue;
280		}
281		string lineText = document.GetText(line.Offset, line.Length);
282		if (!lineText.Trim().StartsWith(comment)) {
283		return true;
284		}
285		}
286		return false;
287		}
288
289		/// <remarks>
290		/// Executes this edit action
291		/// </remarks>
292		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
293		public override void Execute(TextArea textArea)
294		{
295		if (textArea.Document.ReadOnly) {
296		return;
297		}
298
299		string comment = null;
300		if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("LineComment")) {
301		comment = textArea.Document.HighlightingStrategy.Properties["LineComment"].ToString();
302		}
303
304		if (comment == null \|\| comment.Length == 0) {
305		return;
306		}
307
308		textArea.Document.UndoStack.StartUndoGroup();
309		if (textArea.SelectionManager.HasSomethingSelected) {
310		bool shouldComment = true;
311		foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
312		if (!ShouldComment(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y)) {
313		shouldComment = false;
314		break;
315		}
316		}
317
318		foreach (ISelection selection in textArea.SelectionManager.SelectionCollection) {
319		textArea.BeginUpdate();
320		if (shouldComment) {
321		SetCommentAt(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y);
322		} else {
323		RemoveCommentAt(textArea.Document, comment, selection, selection.StartPosition.Y, selection.EndPosition.Y);
324		}
325		textArea.Document.UpdateQueue.Clear();
326		textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, firstLine, lastLine));
327		textArea.EndUpdate();
328		}
329		textArea.Document.CommitUpdate();
330		textArea.AutoClearSelection = false;
331		} else {
332		textArea.BeginUpdate();
333		int caretLine = textArea.Caret.Line;
334		if (ShouldComment(textArea.Document, comment, null, caretLine, caretLine)) {
335		SetCommentAt(textArea.Document, comment, null, caretLine, caretLine);
336		} else {
337		RemoveCommentAt(textArea.Document, comment, null, caretLine, caretLine);
338		}
339		textArea.Document.UpdateQueue.Clear();
340		textArea.Document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, caretLine));
341		textArea.EndUpdate();
342		}
343		textArea.Document.UndoStack.EndUndoGroup();
344		}
345		}
346
347		public class ToggleBlockComment : AbstractEditAction
348		{
349		/// <remarks>
350		/// Executes this edit action
351		/// </remarks>
352		/// <param name="textArea">The <see cref="ItextArea"/> which is used for callback purposes</param>
353		public override void Execute(TextArea textArea)
354		{
355		if (textArea.Document.ReadOnly) {
356		return;
357		}
358
359		string commentStart = null;
360		if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentBegin")) {
361		commentStart = textArea.Document.HighlightingStrategy.Properties["BlockCommentBegin"].ToString();
362		}
363
364		string commentEnd = null;
365		if (textArea.Document.HighlightingStrategy.Properties.ContainsKey("BlockCommentEnd")) {
366		commentEnd = textArea.Document.HighlightingStrategy.Properties["BlockCommentEnd"].ToString();
367		}
368
369		if (commentStart == null \|\| commentStart.Length == 0 \|\| commentEnd == null \|\| commentEnd.Length == 0) {
370		return;
371		}
372
373		int selectionStartOffset;
374		int selectionEndOffset;
375
376		if (textArea.SelectionManager.HasSomethingSelected) {
377		selectionStartOffset = textArea.SelectionManager.SelectionCollection[0].Offset;
378		selectionEndOffset = textArea.SelectionManager.SelectionCollection[textArea.SelectionManager.SelectionCollection.Count - 1].EndOffset;
379		} else {
380		selectionStartOffset = textArea.Caret.Offset;
381		selectionEndOffset = selectionStartOffset;
382		}
383
384		BlockCommentRegion commentRegion = FindSelectedCommentRegion(textArea.Document, commentStart, commentEnd, selectionStartOffset, selectionEndOffset);
385
386		textArea.Document.UndoStack.StartUndoGroup();
387		if (commentRegion != null) {
388		RemoveComment(textArea.Document, commentRegion);
389		} else if (textArea.SelectionManager.HasSomethingSelected) {
390		SetCommentAt(textArea.Document, selectionStartOffset, selectionEndOffset, commentStart, commentEnd);
391		}
392		textArea.Document.UndoStack.EndUndoGroup();
393
394		textArea.Document.CommitUpdate();
395		textArea.AutoClearSelection = false;
396		}
397
398		public static BlockCommentRegion FindSelectedCommentRegion(IDocument document, string commentStart, string commentEnd, int selectionStartOffset, int selectionEndOffset)
399		{
400		if (document.TextLength == 0) {
401		return null;
402		}
403
404		// Find start of comment in selected text.
405
406		int commentEndOffset = -1;
407		string selectedText = document.GetText(selectionStartOffset, selectionEndOffset - selectionStartOffset);
408
409		int commentStartOffset = selectedText.IndexOf(commentStart);
410		if (commentStartOffset >= 0) {
411		commentStartOffset += selectionStartOffset;
412		}
413
414		// Find end of comment in selected text.
415
416		if (commentStartOffset >= 0) {
417		commentEndOffset = selectedText.IndexOf(commentEnd, commentStartOffset + commentStart.Length - selectionStartOffset);
418		} else {
419		commentEndOffset = selectedText.IndexOf(commentEnd);
420		}
421
422		if (commentEndOffset >= 0) {
423		commentEndOffset += selectionStartOffset;
424		}
425
426		// Find start of comment before or partially inside the
427		// selected text.
428
429		int commentEndBeforeStartOffset = -1;
430		if (commentStartOffset == -1) {
431		int offset = selectionEndOffset + commentStart.Length - 1;
432		if (offset > document.TextLength) {
433		offset = document.TextLength;
434		}
435		string text = document.GetText(0, offset);
436		commentStartOffset = text.LastIndexOf(commentStart);
437		if (commentStartOffset >= 0) {
438		// Find end of comment before comment start.
439		commentEndBeforeStartOffset = text.IndexOf(commentEnd, commentStartOffset, selectionStartOffset - commentStartOffset);
440		if (commentEndBeforeStartOffset > commentStartOffset) {
441		commentStartOffset = -1;
442		}
443		}
444		}
445
446		// Find end of comment after or partially after the
447		// selected text.
448
449		if (commentEndOffset == -1) {
450		int offset = selectionStartOffset + 1 - commentEnd.Length;
451		if (offset < 0) {
452		offset = selectionStartOffset;
453		}
454		string text = document.GetText(offset, document.TextLength - offset);
455		commentEndOffset = text.IndexOf(commentEnd);
456		if (commentEndOffset >= 0) {
457		commentEndOffset += offset;
458		}
459		}
460
461		if (commentStartOffset != -1 && commentEndOffset != -1) {
462		return new BlockCommentRegion(commentStart, commentEnd, commentStartOffset, commentEndOffset);
463		}
464
465		return null;
466		}
467
468
469		void SetCommentAt(IDocument document, int offsetStart, int offsetEnd, string commentStart, string commentEnd)
470		{
471		document.Insert(offsetEnd, commentEnd);
472		document.Insert(offsetStart, commentStart);
473		}
474
475		void RemoveComment(IDocument document, BlockCommentRegion commentRegion)
476		{
477		document.Remove(commentRegion.EndOffset, commentRegion.CommentEnd.Length);
478		document.Remove(commentRegion.StartOffset, commentRegion.CommentStart.Length);
479		}
480		}
481
482		public class BlockCommentRegion
483		{
484		string commentStart = String.Empty;
485		string commentEnd = String.Empty;
486		int startOffset = -1;
487		int endOffset = -1;
488
489		/// <summary>
490		/// The end offset is the offset where the comment end string starts from.
491		/// </summary>
492		public BlockCommentRegion(string commentStart, string commentEnd, int startOffset, int endOffset)
493		{
494		this.commentStart = commentStart;
495		this.commentEnd = commentEnd;
496		this.startOffset = startOffset;
497		this.endOffset = endOffset;
498		}
499
500		public string CommentStart {