Code Coverage Statistics for Source File

c:\Tools\SD3\src\Libraries\ICSharpCode.TextEditor\Project\Src\Gui\TextEditorControlBase.cs

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

Sequence Point Coverage

N/A

0 of 0

Branch Coverage

N/A

0 of 0

Lines

757

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: 2739 $</version>
// </file>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Text;
using System.IO;
using System.Text;
using System.Windows.Forms;

using ICSharpCode.TextEditor.Actions;
using ICSharpCode.TextEditor.Document;

namespace ICSharpCode.TextEditor
{
	/// <summary>
	/// This class is used for a basic text area control
	/// </summary>
	[ToolboxItem(false)]
	public abstract class TextEditorControlBase : UserControl
	{
		string    currentFileName = null;
		int       updateLevel     = 0;
		IDocument document;
		
		/// <summary>
		/// This hashtable contains all editor keys, where
		/// the key is the key combination and the value the
		/// action.
		/// </summary>
		protected Dictionary<Keys, IEditAction> editactions = new Dictionary<Keys, IEditAction>();
		
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public ITextEditorProperties TextEditorProperties {
			get {
				return document.TextEditorProperties;
			}
			set {
				document.TextEditorProperties = value;
				OptionsChanged();
			}
		}
		
		Encoding encoding;
		
		/// <value>
		/// Current file's character encoding
		/// </value>
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Encoding Encoding {
			get {
				if (encoding == null)
					return TextEditorProperties.Encoding;
				return encoding;
			}
			set {
				encoding = value;
			}
		}
		
		/// <value>
		/// The current file name
		/// </value>
		[Browsable(false)]
		[ReadOnly(true)]
		public string FileName {
			get {
				return currentFileName;
			}
			set {
				if (currentFileName != value) {
					currentFileName = value;
					OnFileNameChanged(EventArgs.Empty);
				}
			}
		}
		
		/// <value>
		/// The current document
		/// </value>
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public IDocument Document {
			get {
				return document;
			}
			set {
				if (value == null)
					throw new ArgumentNullException("value");
				if (document != null) {
					document.DocumentChanged -= OnDocumentChanged;
				}
				document = value;
				document.UndoStack.TextEditorControl = this;
				document.DocumentChanged += OnDocumentChanged;
			}
		}
		
		void OnDocumentChanged(object sender, EventArgs e)
		{
			OnTextChanged(e);
		}
		
		[EditorBrowsable(EditorBrowsableState.Always), Browsable(true)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
		[Editor("System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(System.Drawing.Design.UITypeEditor))]
		public override string Text {
			get {
				return Document.TextContent;
			}
			set {
				Document.TextContent = value;
			}
		}
		
		[EditorBrowsable(EditorBrowsableState.Always), Browsable(true)]
		public new event EventHandler TextChanged
		{
			add { base.TextChanged += value; }
			remove { base.TextChanged -= value; }
		}
		
		static Font ParseFont(string font)
		{
			string[] descr = font.Split(new char[]{',', '='});
			return new Font(descr[1], Single.Parse(descr[3]));
		}
		
		/// <value>
		/// If set to true the contents can't be altered.
		/// </value>
		[Browsable(false)]
		public bool IsReadOnly {
			get {
				return Document.ReadOnly;
			}
			set {
				Document.ReadOnly = value;
			}
		}
		
		/// <value>
		/// true, if the textarea is updating it's status, while
		/// it updates it status no redraw operation occurs.
		/// </value>
		[Browsable(false)]
		public bool IsInUpdate {
			get {
				return updateLevel > 0;
			}
		}
		
		/// <value>
		/// supposedly this is the way to do it according to .NET docs,
		/// as opposed to setting the size in the constructor
		/// </value>
		protected override Size DefaultSize {
			get {
				return new Size(100, 100);
			}
		}
		
		#region Document Properties
		/// <value>
		/// If true spaces are shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true spaces are shown in the textarea")]
		public bool ShowSpaces {
			get {
				return document.TextEditorProperties.ShowSpaces;
			}
			set {
				document.TextEditorProperties.ShowSpaces = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// Specifies the quality of text rendering (whether to use hinting and/or anti-aliasing).
		/// </value>
		[Category("Appearance")]
		[DefaultValue(TextRenderingHint.SystemDefault)]
		[Description("Specifies the quality of text rendering (whether to use hinting and/or anti-aliasing).")]
		public TextRenderingHint TextRenderingHint {
			get {
				return document.TextEditorProperties.TextRenderingHint;
			}
			set {
				document.TextEditorProperties.TextRenderingHint = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true tabs are shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true tabs are shown in the textarea")]
		public bool ShowTabs {
			get {
				return document.TextEditorProperties.ShowTabs;
			}
			set {
				document.TextEditorProperties.ShowTabs = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true EOL markers are shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true EOL markers are shown in the textarea")]
		public bool ShowEOLMarkers {
			get {
				return document.TextEditorProperties.ShowEOLMarker;
			}
			set {
				document.TextEditorProperties.ShowEOLMarker = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true the horizontal ruler is shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true the horizontal ruler is shown in the textarea")]
		public bool ShowHRuler {
			get {
				return document.TextEditorProperties.ShowHorizontalRuler;
			}
			set {
				document.TextEditorProperties.ShowHorizontalRuler = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true the vertical ruler is shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(true)]
		[Description("If true the vertical ruler is shown in the textarea")]
		public bool ShowVRuler {
			get {
				return document.TextEditorProperties.ShowVerticalRuler;
			}
			set {
				document.TextEditorProperties.ShowVerticalRuler = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// The row in which the vertical ruler is displayed
		/// </value>
		[Category("Appearance")]
		[DefaultValue(80)]
		[Description("The row in which the vertical ruler is displayed")]
		public int VRulerRow {
			get {
				return document.TextEditorProperties.VerticalRulerRow;
			}
			set {
				document.TextEditorProperties.VerticalRulerRow = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true line numbers are shown in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(true)]
		[Description("If true line numbers are shown in the textarea")]
		public bool ShowLineNumbers {
			get {
				return document.TextEditorProperties.ShowLineNumbers;
			}
			set {
				document.TextEditorProperties.ShowLineNumbers = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true invalid lines are marked in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true invalid lines are marked in the textarea")]
		public bool ShowInvalidLines {
			get {
				return document.TextEditorProperties.ShowInvalidLines;
			}
			set {
				document.TextEditorProperties.ShowInvalidLines = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// If true folding is enabled in the textarea
		/// </value>
		[Category("Appearance")]
		[DefaultValue(true)]
		[Description("If true folding is enabled in the textarea")]
		public bool EnableFolding {
			get {
				return document.TextEditorProperties.EnableFolding;
			}
			set {
				document.TextEditorProperties.EnableFolding = value;
				OptionsChanged();
			}
		}
		
		[Category("Appearance")]
		[DefaultValue(true)]
		[Description("If true matching brackets are highlighted")]
		public bool ShowMatchingBracket {
			get {
				return document.TextEditorProperties.ShowMatchingBracket;
			}
			set {
				document.TextEditorProperties.ShowMatchingBracket = value;
				OptionsChanged();
			}
		}
		
		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("If true the icon bar is displayed")]
		public bool IsIconBarVisible {
			get {
				return document.TextEditorProperties.IsIconBarVisible;
			}
			set {
				document.TextEditorProperties.IsIconBarVisible = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// The width in spaces of a tab character
		/// </value>
		[Category("Appearance")]
		[DefaultValue(4)]
		[Description("The width in spaces of a tab character")]
		public int TabIndent {
			get {
				return document.TextEditorProperties.TabIndent;
			}
			set {
				document.TextEditorProperties.TabIndent = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// The line viewer style
		/// </value>
		[Category("Appearance")]
		[DefaultValue(LineViewerStyle.None)]
		[Description("The line viewer style")]
		public LineViewerStyle LineViewerStyle {
			get {
				return document.TextEditorProperties.LineViewerStyle;
			}
			set {
				document.TextEditorProperties.LineViewerStyle = value;
				OptionsChanged();
			}
		}

		/// <value>
		/// The indent style
		/// </value>
		[Category("Behavior")]
		[DefaultValue(IndentStyle.Smart)]
		[Description("The indent style")]
		public IndentStyle IndentStyle {
			get {
				return document.TextEditorProperties.IndentStyle;
			}
			set {
				document.TextEditorProperties.IndentStyle = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// if true spaces are converted to tabs
		/// </value>
		[Category("Behavior")]
		[DefaultValue(false)]
		[Description("Converts tabs to spaces while typing")]
		public bool ConvertTabsToSpaces {
			get {
				return document.TextEditorProperties.ConvertTabsToSpaces;
			}
			set {
				document.TextEditorProperties.ConvertTabsToSpaces = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// if true spaces are converted to tabs
		/// </value>
		[Category("Behavior")]
		[DefaultValue(false)]
		[Description("Hide the mouse cursor while typing")]
		public bool HideMouseCursor {
			get {
				return document.TextEditorProperties.HideMouseCursor;
			}
			set {
				document.TextEditorProperties.HideMouseCursor = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// if true spaces are converted to tabs
		/// </value>
		[Category("Behavior")]
		[DefaultValue(false)]
		[Description("Allows the caret to be placed beyond the end of line")]
		public bool AllowCaretBeyondEOL {
			get {
				return document.TextEditorProperties.AllowCaretBeyondEOL;
			}
			set {
				document.TextEditorProperties.AllowCaretBeyondEOL = value;
				OptionsChanged();
			}
		}
		/// <value>
		/// if true spaces are converted to tabs
		/// </value>
		[Category("Behavior")]
		[DefaultValue(BracketMatchingStyle.After)]
		[Description("Specifies if the bracket matching should match the bracket before or after the caret.")]
		public BracketMatchingStyle BracketMatchingStyle {
			get {
				return document.TextEditorProperties.BracketMatchingStyle;
			}
			set {
				document.TextEditorProperties.BracketMatchingStyle = value;
				OptionsChanged();
			}
		}
		
		/// <value>
		/// The base font of the text area. No bold or italic fonts
		/// can be used because bold/italic is reserved for highlighting
		/// purposes.
		/// </value>
		[Browsable(true)]
		[Description("The base font of the text area. No bold or italic fonts can be used because bold/italic is reserved for highlighting purposes.")]
		public override Font Font {
			get {
				return document.TextEditorProperties.Font;
			}
			set {
				document.TextEditorProperties.Font = value;
				OptionsChanged();
			}
		}
		
		#endregion
		public abstract TextAreaControl ActiveTextAreaControl {
			get;
		}
		
		protected TextEditorControlBase()
		{
			GenerateDefaultActions();
			HighlightingManager.Manager.ReloadSyntaxHighlighting += new EventHandler(OnReloadHighlighting);
		}
		
		protected virtual void OnReloadHighlighting(object sender, EventArgs e)
		{
			if (Document.HighlightingStrategy != null) {
				try {
					Document.HighlightingStrategy = HighlightingStrategyFactory.CreateHighlightingStrategy(Document.HighlightingStrategy.Name);
				} catch (HighlightingDefinitionInvalidException ex) {
					MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
				}
				OptionsChanged();
			}
		}
		
		public bool IsEditAction(Keys keyData)
		{
			return editactions.ContainsKey(keyData);
		}
		
		internal IEditAction GetEditAction(Keys keyData)
		{
			if (!IsEditAction(keyData)) {
				return null;
			}
			return (IEditAction)editactions[keyData];
		}

		void GenerateDefaultActions()
		{
			editactions[Keys.Left] = new CaretLeft();
			editactions[Keys.Left | Keys.Shift] = new ShiftCaretLeft();
			editactions[Keys.Left | Keys.Control] = new WordLeft();
			editactions[Keys.Left | Keys.Control | Keys.Shift] = new ShiftWordLeft();
			editactions[Keys.Right] = new CaretRight();
			editactions[Keys.Right | Keys.Shift] = new ShiftCaretRight();
			editactions[Keys.Right | Keys.Control] = new WordRight();
			editactions[Keys.Right | Keys.Control | Keys.Shift] = new ShiftWordRight();
			editactions[Keys.Up] = new CaretUp();
			editactions[Keys.Up | Keys.Shift] = new ShiftCaretUp();
			editactions[Keys.Up | Keys.Control] = new ScrollLineUp();
			editactions[Keys.Down] = new CaretDown();
			editactions[Keys.Down | Keys.Shift] = new ShiftCaretDown();
			editactions[Keys.Down | Keys.Control] = new ScrollLineDown();
			
			editactions[Keys.Insert] = new ToggleEditMode();
			editactions[Keys.Insert | Keys.Control] = new Copy();
			editactions[Keys.Insert | Keys.Shift] = new Paste();
			editactions[Keys.Delete] = new Delete();
			editactions[Keys.Delete | Keys.Shift] = new Cut();
			editactions[Keys.Home] = new Home();
			editactions[Keys.Home | Keys.Shift] = new ShiftHome();
			editactions[Keys.Home | Keys.Control] = new MoveToStart();
			editactions[Keys.Home | Keys.Control | Keys.Shift] = new ShiftMoveToStart();
			editactions[Keys.End] = new End();
			editactions[Keys.End | Keys.Shift] = new ShiftEnd();
			editactions[Keys.End | Keys.Control] = new MoveToEnd();
			editactions[Keys.End | Keys.Control | Keys.Shift] = new ShiftMoveToEnd();
			editactions[Keys.PageUp] = new MovePageUp();
			editactions[Keys.PageUp | Keys.Shift] = new ShiftMovePageUp();
			editactions[Keys.PageDown] = new MovePageDown();
			editactions[Keys.PageDown | Keys.Shift] = new ShiftMovePageDown();
			
			editactions[Keys.Return] = new Return();
			editactions[Keys.Tab] = new Tab();
			editactions[Keys.Tab | Keys.Shift] = new ShiftTab();
			editactions[Keys.Back] = new Backspace();
			editactions[Keys.Back | Keys.Shift] = new Backspace();
			
			editactions[Keys.X | Keys.Control] = new Cut();
			editactions[Keys.C | Keys.Control] = new Copy();
			editactions[Keys.V | Keys.Control] = new Paste();
			
			editactions[Keys.A | Keys.Control] = new SelectWholeDocument();
			editactions[Keys.Escape] = new ClearAllSelections();
			
			editactions[Keys.Divide | Keys.Control] = new ToggleComment();
			editactions[Keys.OemQuestion | Keys.Control] = new ToggleComment();
			
			editactions[Keys.Back | Keys.Alt]  = new Actions.Undo();
			editactions[Keys.Z | Keys.Control] = new Actions.Undo();
			editactions[Keys.Y | Keys.Control] = new Redo();
			
			editactions[Keys.Delete | Keys.Control] = new DeleteWord();
			editactions[Keys.Back | Keys.Control]   = new WordBackspace();
			editactions[Keys.D | Keys.Control]      = new DeleteLine();
			editactions[Keys.D | Keys.Shift | Keys.Control]      = new DeleteToLineEnd();
			
			editactions[Keys.B | Keys.Control]      = new GotoMatchingBrace();
		}
		
		/// <remarks>
		/// Call this method before a long update operation this
		/// 'locks' the text area so that no screen update occurs.
		/// </remarks>
		public virtual void BeginUpdate()
		{
			++updateLevel;
		}
		
		/// <remarks>
		/// Call this method to 'unlock' the text area. After this call
		/// screen update can occur. But no automatical refresh occurs you
		/// have to commit the updates in the queue.
		/// </remarks>
		public virtual void EndUpdate()
		{
			Debug.Assert(updateLevel > 0);
			updateLevel = Math.Max(0, updateLevel - 1);
		}
		
		public void LoadFile(string fileName)
		{
			LoadFile(fileName, true, true);
		}
		
		/// <remarks>
		/// Loads a file given by fileName
		/// </remarks>
		/// <param name="fileName">The name of the file to open</param>
		/// <param name="autoLoadHighlighting">Automatically load the highlighting for the file</param>
		/// <param name="autodetectEncoding">Automatically detect file encoding and set Encoding property to the detected encoding.</param>
		public void LoadFile(string fileName, bool autoLoadHighlighting, bool autodetectEncoding)
		{
			using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
				LoadFile(fileName, fs, autoLoadHighlighting, autodetectEncoding);
			}
		}
		
		/// <remarks>
		/// Loads a file from the specified stream.
		/// </remarks>
		/// <param name="fileName">The name of the file to open. Used to find the correct highlighting strategy
		/// if autoLoadHighlighting is active, and sets the filename property to this value.</param>
		/// <param name="stream">The stream to actually load the file content from.</param>
		/// <param name="autoLoadHighlighting">Automatically load the highlighting for the file</param>
		/// <param name="autodetectEncoding">Automatically detect file encoding and set Encoding property to the detected encoding.</param>
		public void LoadFile(string fileName, Stream stream, bool autoLoadHighlighting, bool autodetectEncoding)
		{
			if (stream == null)
				throw new ArgumentNullException("stream");
			
			BeginUpdate();
			document.TextContent = String.Empty;
			document.UndoStack.ClearAll();
			document.BookmarkManager.Clear();
			if (autoLoadHighlighting) {
				try {
					document.HighlightingStrategy = HighlightingStrategyFactory.CreateHighlightingStrategyForFile(fileName);
				} catch (HighlightingDefinitionInvalidException ex) {
					MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
				}
			}
			
			if (autodetectEncoding) {
				Encoding encoding = this.Encoding;
				Document.TextContent = Util.FileReader.ReadFileContent(stream, ref encoding);
				this.Encoding = encoding;
			} else {
				using (StreamReader reader = new StreamReader(fileName, this.Encoding)) {
					Document.TextContent = reader.ReadToEnd();
				}
			}
			
			this.FileName = fileName;
			OptionsChanged();
			Document.UpdateQueue.Clear();
			EndUpdate();
			
			Refresh();
		}
		
		/// <summary>
		/// Gets if the document can be saved with the current encoding without losing data.
		/// </summary>
		public bool CanSaveWithCurrentEncoding()
		{
			if (encoding == null || Util.FileReader.IsUnicode(encoding))
				return true;
			// not a unicode codepage
			string text = document.TextContent;
			return encoding.GetString(encoding.GetBytes(text)) == text;
		}
		
		/// <remarks>
		/// Saves the text editor content into the file.
		/// </remarks>
		public void SaveFile(string fileName)
		{
			using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
				SaveFile(fs);
			}
			this.FileName = fileName;
		}
		
		/// <remarks>
		/// Saves the text editor content into the specified stream.
		/// Does not close the stream.
		/// </remarks>
		public void SaveFile(Stream stream)
		{
			StreamWriter streamWriter = new StreamWriter(stream, this.Encoding ?? Encoding.UTF8);
			
			// save line per line to apply the LineTerminator to all lines
			// (otherwise we might save files with mixed-up line endings)
			foreach (LineSegment line in Document.LineSegmentCollection) {
				streamWriter.Write(Document.GetText(line.Offset, line.Length));
				if (line.DelimiterLength > 0) {
					char charAfterLine = Document.GetCharAt(line.Offset + line.Length);
					if (charAfterLine != '\n' && charAfterLine != '\r')
						throw new InvalidOperationException("The document cannot be saved because it is corrupted.");
					// only save line terminator if the line has one
					streamWriter.Write(document.TextEditorProperties.LineTerminator);
				}
			}
			streamWriter.Flush();
		}
		
		public abstract void OptionsChanged();
		
		// Localization ISSUES
		
		// used in insight window
		public virtual string GetRangeDescription(int selectedItem, int itemCount)
		{
			StringBuilder sb=new StringBuilder(selectedItem.ToString());
			sb.Append(" from ");
			sb.Append(itemCount.ToString());
			return sb.ToString();
		}
		
		/// <remarks>
		/// Overwritten refresh method that does nothing if the control is in
		/// an update cycle.
		/// </remarks>
		public override void Refresh()
		{
			if (IsInUpdate) {
				return;
			}
			base.Refresh();
		}
		
		protected override void Dispose(bool disposing)
		{
			if (disposing) {
				HighlightingManager.Manager.ReloadSyntaxHighlighting -= new EventHandler(OnReloadHighlighting);
				document.HighlightingStrategy = null;
				document.UndoStack.TextEditorControl = null;
			}
			base.Dispose(disposing);
		}
		
		protected virtual void OnFileNameChanged(EventArgs e)
		{
			if (FileNameChanged != null) {
				FileNameChanged(this, e);
			}
		}
		
		public event EventHandler FileNameChanged;
	}
}

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: 2739 $</version>
6		// </file>
7
8		using System;
9		using System.Collections.Generic;
10		using System.ComponentModel;
11		using System.Diagnostics;
12		using System.Drawing;
13		using System.Drawing.Text;
14		using System.IO;
15		using System.Text;
16		using System.Windows.Forms;
17
18		using ICSharpCode.TextEditor.Actions;
19		using ICSharpCode.TextEditor.Document;
20
21		namespace ICSharpCode.TextEditor
22		{
23		/// <summary>
24		/// This class is used for a basic text area control
25		/// </summary>
26		[ToolboxItem(false)]
27		public abstract class TextEditorControlBase : UserControl
28		{
29		string currentFileName = null;
30		int updateLevel = 0;
31		IDocument document;
32
33		/// <summary>
34		/// This hashtable contains all editor keys, where
35		/// the key is the key combination and the value the
36		/// action.
37		/// </summary>
38		protected Dictionary<Keys, IEditAction> editactions = new Dictionary<Keys, IEditAction>();
39
40		[Browsable(false)]
41		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
42		public ITextEditorProperties TextEditorProperties {
43		get {
44		return document.TextEditorProperties;
45		}
46		set {
47		document.TextEditorProperties = value;
48		OptionsChanged();
49		}
50		}
51
52		Encoding encoding;
53
54		/// <value>
55		/// Current file's character encoding
56		/// </value>
57		[Browsable(false)]
58		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
59		public Encoding Encoding {
60		get {
61		if (encoding == null)
62		return TextEditorProperties.Encoding;
63		return encoding;
64		}
65		set {
66		encoding = value;
67		}
68		}
69
70		/// <value>
71		/// The current file name
72		/// </value>
73		[Browsable(false)]
74		[ReadOnly(true)]
75		public string FileName {
76		get {
77		return currentFileName;
78		}
79		set {
80		if (currentFileName != value) {
81		currentFileName = value;
82		OnFileNameChanged(EventArgs.Empty);
83		}
84		}
85		}
86
87		/// <value>
88		/// The current document
89		/// </value>
90		[Browsable(false)]
91		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
92		public IDocument Document {
93		get {
94		return document;
95		}
96		set {
97		if (value == null)
98		throw new ArgumentNullException("value");
99		if (document != null) {
100		document.DocumentChanged -= OnDocumentChanged;
101		}
102		document = value;
103		document.UndoStack.TextEditorControl = this;
104		document.DocumentChanged += OnDocumentChanged;
105		}
106		}
107
108		void OnDocumentChanged(object sender, EventArgs e)
109		{
110		OnTextChanged(e);
111		}
112
113		[EditorBrowsable(EditorBrowsableState.Always), Browsable(true)]
114		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
115		[Editor("System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(System.Drawing.Design.UITypeEditor))]
116		public override string Text {
117		get {
118		return Document.TextContent;
119		}
120		set {
121		Document.TextContent = value;
122		}
123		}
124
125		[EditorBrowsable(EditorBrowsableState.Always), Browsable(true)]
126		public new event EventHandler TextChanged
127		{
128		add { base.TextChanged += value; }
129		remove { base.TextChanged -= value; }
130		}
131
132		static Font ParseFont(string font)
133		{
134		string[] descr = font.Split(new char[]{',', '='});
135		return new Font(descr[1], Single.Parse(descr[3]));
136		}
137
138		/// <value>
139		/// If set to true the contents can't be altered.
140		/// </value>
141		[Browsable(false)]
142		public bool IsReadOnly {
143		get {
144		return Document.ReadOnly;
145		}
146		set {
147		Document.ReadOnly = value;
148		}
149		}
150
151		/// <value>
152		/// true, if the textarea is updating it's status, while
153		/// it updates it status no redraw operation occurs.
154		/// </value>
155		[Browsable(false)]
156		public bool IsInUpdate {
157		get {
158		return updateLevel > 0;
159		}
160		}
161
162		/// <value>
163		/// supposedly this is the way to do it according to .NET docs,
164		/// as opposed to setting the size in the constructor
165		/// </value>
166		protected override Size DefaultSize {
167		get {
168		return new Size(100, 100);
169		}
170		}
171
172		#region Document Properties
173		/// <value>
174		/// If true spaces are shown in the textarea
175		/// </value>
176		[Category("Appearance")]
177		[DefaultValue(false)]
178		[Description("If true spaces are shown in the textarea")]
179		public bool ShowSpaces {
180		get {
181		return document.TextEditorProperties.ShowSpaces;
182		}
183		set {
184		document.TextEditorProperties.ShowSpaces = value;
185		OptionsChanged();
186		}
187		}
188
189		/// <value>
190		/// Specifies the quality of text rendering (whether to use hinting and/or anti-aliasing).
191		/// </value>
192		[Category("Appearance")]
193		[DefaultValue(TextRenderingHint.SystemDefault)]
194		[Description("Specifies the quality of text rendering (whether to use hinting and/or anti-aliasing).")]
195		public TextRenderingHint TextRenderingHint {
196		get {
197		return document.TextEditorProperties.TextRenderingHint;
198		}
199		set {
200		document.TextEditorProperties.TextRenderingHint = value;
201		OptionsChanged();
202		}
203		}
204
205		/// <value>
206		/// If true tabs are shown in the textarea
207		/// </value>
208		[Category("Appearance")]
209		[DefaultValue(false)]
210		[Description("If true tabs are shown in the textarea")]
211		public bool ShowTabs {
212		get {
213		return document.TextEditorProperties.ShowTabs;
214		}
215		set {
216		document.TextEditorProperties.ShowTabs = value;
217		OptionsChanged();
218		}
219		}
220
221		/// <value>
222		/// If true EOL markers are shown in the textarea
223		/// </value>
224		[Category("Appearance")]
225		[DefaultValue(false)]
226		[Description("If true EOL markers are shown in the textarea")]
227		public bool ShowEOLMarkers {
228		get {
229		return document.TextEditorProperties.ShowEOLMarker;
230		}
231		set {
232		document.TextEditorProperties.ShowEOLMarker = value;
233		OptionsChanged();
234		}
235		}
236
237		/// <value>
238		/// If true the horizontal ruler is shown in the textarea
239		/// </value>
240		[Category("Appearance")]
241		[DefaultValue(false)]
242		[Description("If true the horizontal ruler is shown in the textarea")]
243		public bool ShowHRuler {
244		get {
245		return document.TextEditorProperties.ShowHorizontalRuler;
246		}
247		set {
248		document.TextEditorProperties.ShowHorizontalRuler = value;
249		OptionsChanged();
250		}
251		}
252
253		/// <value>
254		/// If true the vertical ruler is shown in the textarea
255		/// </value>
256		[Category("Appearance")]
257		[DefaultValue(true)]
258		[Description("If true the vertical ruler is shown in the textarea")]
259		public bool ShowVRuler {
260		get {
261		return document.TextEditorProperties.ShowVerticalRuler;
262		}
263		set {
264		document.TextEditorProperties.ShowVerticalRuler = value;
265		OptionsChanged();
266		}
267		}
268
269		/// <value>
270		/// The row in which the vertical ruler is displayed
271		/// </value>
272		[Category("Appearance")]
273		[DefaultValue(80)]
274		[Description("The row in which the vertical ruler is displayed")]
275		public int VRulerRow {
276		get {
277		return document.TextEditorProperties.VerticalRulerRow;
278		}
279		set {
280		document.TextEditorProperties.VerticalRulerRow = value;
281		OptionsChanged();
282		}
283		}
284
285		/// <value>
286		/// If true line numbers are shown in the textarea
287		/// </value>
288		[Category("Appearance")]
289		[DefaultValue(true)]
290		[Description("If true line numbers are shown in the textarea")]
291		public bool ShowLineNumbers {
292		get {
293		return document.TextEditorProperties.ShowLineNumbers;
294		}
295		set {
296		document.TextEditorProperties.ShowLineNumbers = value;
297		OptionsChanged();
298		}
299		}
300
301		/// <value>
302		/// If true invalid lines are marked in the textarea
303		/// </value>
304		[Category("Appearance")]
305		[DefaultValue(false)]
306		[Description("If true invalid lines are marked in the textarea")]
307		public bool ShowInvalidLines {
308		get {
309		return document.TextEditorProperties.ShowInvalidLines;
310		}
311		set {
312		document.TextEditorProperties.ShowInvalidLines = value;
313		OptionsChanged();
314		}
315		}
316
317		/// <value>
318		/// If true folding is enabled in the textarea
319		/// </value>
320		[Category("Appearance")]
321		[DefaultValue(true)]
322		[Description("If true folding is enabled in the textarea")]
323		public bool EnableFolding {
324		get {
325		return document.TextEditorProperties.EnableFolding;
326		}
327		set {
328		document.TextEditorProperties.EnableFolding = value;
329		OptionsChanged();
330		}
331		}
332
333		[Category("Appearance")]
334		[DefaultValue(true)]
335		[Description("If true matching brackets are highlighted")]
336		public bool ShowMatchingBracket {
337		get {
338		return document.TextEditorProperties.ShowMatchingBracket;
339		}
340		set {
341		document.TextEditorProperties.ShowMatchingBracket = value;
342		OptionsChanged();
343		}
344		}
345
346		[Category("Appearance")]
347		[DefaultValue(false)]
348		[Description("If true the icon bar is displayed")]
349		public bool IsIconBarVisible {
350		get {
351		return document.TextEditorProperties.IsIconBarVisible;
352		}
353		set {
354		document.TextEditorProperties.IsIconBarVisible = value;
355		OptionsChanged();
356		}
357		}
358
359		/// <value>
360		/// The width in spaces of a tab character
361		/// </value>
362		[Category("Appearance")]
363		[DefaultValue(4)]
364		[Description("The width in spaces of a tab character")]
365		public int TabIndent {
366		get {
367		return document.TextEditorProperties.TabIndent;
368		}
369		set {
370		document.TextEditorProperties.TabIndent = value;
371		OptionsChanged();
372		}
373		}
374
375		/// <value>
376		/// The line viewer style
377		/// </value>
378		[Category("Appearance")]
379		[DefaultValue(LineViewerStyle.None)]
380		[Description("The line viewer style")]
381		public LineViewerStyle LineViewerStyle {
382		get {
383		return document.TextEditorProperties.LineViewerStyle;
384		}
385		set {
386		document.TextEditorProperties.LineViewerStyle = value;
387		OptionsChanged();
388		}
389		}
390
391		/// <value>
392		/// The indent style
393		/// </value>
394		[Category("Behavior")]
395		[DefaultValue(IndentStyle.Smart)]
396		[Description("The indent style")]
397		public IndentStyle IndentStyle {
398		get {
399		return document.TextEditorProperties.IndentStyle;
400		}
401		set {
402		document.TextEditorProperties.IndentStyle = value;
403		OptionsChanged();
404		}
405		}
406
407		/// <value>
408		/// if true spaces are converted to tabs
409		/// </value>
410		[Category("Behavior")]
411		[DefaultValue(false)]
412		[Description("Converts tabs to spaces while typing")]
413		public bool ConvertTabsToSpaces {
414		get {
415		return document.TextEditorProperties.ConvertTabsToSpaces;
416		}
417		set {
418		document.TextEditorProperties.ConvertTabsToSpaces = value;
419		OptionsChanged();
420		}
421		}
422
423		/// <value>
424		/// if true spaces are converted to tabs
425		/// </value>
426		[Category("Behavior")]
427		[DefaultValue(false)]
428		[Description("Hide the mouse cursor while typing")]
429		public bool HideMouseCursor {
430		get {
431		return document.TextEditorProperties.HideMouseCursor;
432		}
433		set {
434		document.TextEditorProperties.HideMouseCursor = value;
435		OptionsChanged();
436		}
437		}
438
439		/// <value>
440		/// if true spaces are converted to tabs
441		/// </value>
442		[Category("Behavior")]
443		[DefaultValue(false)]
444		[Description("Allows the caret to be placed beyond the end of line")]
445		public bool AllowCaretBeyondEOL {
446		get {
447		return document.TextEditorProperties.AllowCaretBeyondEOL;
448		}
449		set {
450		document.TextEditorProperties.AllowCaretBeyondEOL = value;
451		OptionsChanged();
452		}
453		}
454		/// <value>
455		/// if true spaces are converted to tabs
456		/// </value>
457		[Category("Behavior")]
458		[DefaultValue(BracketMatchingStyle.After)]
459		[Description("Specifies if the bracket matching should match the bracket before or after the caret.")]
460		public BracketMatchingStyle BracketMatchingStyle {
461		get {
462		return document.TextEditorProperties.BracketMatchingStyle;
463		}
464		set {
465		document.TextEditorProperties.BracketMatchingStyle = value;
466		OptionsChanged();
467		}
468		}
469
470		/// <value>
471		/// The base font of the text area. No bold or italic fonts
472		/// can be used because bold/italic is reserved for highlighting
473		/// purposes.
474		/// </value>
475		[Browsable(true)]
476		[Description("The base font of the text area. No bold or italic fonts can be used because bold/italic is reserved for highlighting purposes.")]
477		public override Font Font {
478		get {
479		return document.TextEditorProperties.Font;
480		}
481		set {
482		document.TextEditorProperties.Font = value;
483		OptionsChanged();
484		}
485		}
486
487		#endregion
488		public abstract TextAreaControl ActiveTextAreaControl {
489		get;
490		}
491
492		protected TextEditorControlBase()
493		{
494		GenerateDefaultActions();
495		HighlightingManager.Manager.ReloadSyntaxHighlighting += new EventHandler(OnReloadHighlighting);
496		}
497
498		protected virtual void OnReloadHighlighting(object sender, EventArgs e)
499		{
500		if (Document.HighlightingStrategy != null) {