Code Coverage Statistics for Source File

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

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

Sequence Point Coverage

N/A

0 of 0

Branch Coverage

N/A

0 of 0

Lines

948

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

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

using ICSharpCode.TextEditor.Actions;
using ICSharpCode.TextEditor.Document;
using ICSharpCode.TextEditor.Gui.CompletionWindow;

namespace ICSharpCode.TextEditor
{
	public delegate bool KeyEventHandler(char ch);
	public delegate bool DialogKeyProcessor(Keys keyData);
	
	/// <summary>
	/// This class paints the textarea.
	/// </summary>
	[ToolboxItem(false)]
	public class TextArea : Control
	{
		bool hiddenMouseCursor = false;
		/// <summary>
		/// The position where the mouse cursor was when it was hidden. Sometimes the text editor gets MouseMove
		/// events when typing text even if the mouse is not moved.
		/// </summary>
		Point mouseCursorHidePosition;
		
		Point virtualTop        = new Point(0, 0);
		TextAreaControl         motherTextAreaControl;
		TextEditorControl       motherTextEditorControl;
		
		List<BracketHighlightingSheme> bracketshemes  = new List<BracketHighlightingSheme>();
		TextAreaClipboardHandler  textAreaClipboardHandler;
		bool autoClearSelection = false;
		
		List<AbstractMargin> leftMargins = new List<AbstractMargin>();
		
		TextView      textView;
		GutterMargin  gutterMargin;
		FoldMargin    foldMargin;
		IconBarMargin iconBarMargin;
		
		SelectionManager selectionManager;
		Caret            caret;

		internal Point mousepos = new Point(0, 0);
		//public Point selectionStartPos = new Point(0,0);

		bool disposed;
		
		[Browsable(false)]
		public IList<AbstractMargin> LeftMargins {
			get {
				return leftMargins.AsReadOnly();
			}
		}
		
		public void InsertLeftMargin(int index, AbstractMargin margin)
		{
			leftMargins.Insert(index, margin);
			Refresh();
		}
		
		public TextEditorControl MotherTextEditorControl {
			get {
				return motherTextEditorControl;
			}
		}
		
		public TextAreaControl MotherTextAreaControl {
			get {
				return motherTextAreaControl;
			}
		}
		
		public SelectionManager SelectionManager {
			get {
				return selectionManager;
			}
		}
		
		public Caret Caret {
			get {
				return caret;
			}
		}
		
		public TextView TextView {
			get {
				return textView;
			}
		}
		
		public GutterMargin GutterMargin {
			get {
				return gutterMargin;
			}
		}
		
		public FoldMargin FoldMargin {
			get {
				return foldMargin;
			}
		}
		
		public IconBarMargin IconBarMargin {
			get {
				return iconBarMargin;
			}
		}
		
		public Encoding Encoding {
			get {
				return motherTextEditorControl.Encoding;
			}
		}
		public int MaxVScrollValue {
			get {
				return (Document.GetVisibleLine(Document.TotalNumberOfLines - 1) + 1 + TextView.VisibleLineCount * 2 / 3) * TextView.FontHeight;
			}
		}
		
		public Point VirtualTop {
			get {
				return virtualTop;
			}
			set {
				Point newVirtualTop = new Point(value.X, Math.Min(MaxVScrollValue, Math.Max(0, value.Y)));
				if (virtualTop != newVirtualTop) {
					virtualTop = newVirtualTop;
					motherTextAreaControl.VScrollBar.Value = virtualTop.Y;
					Invalidate();
				}
			}
		}
		
		public bool AutoClearSelection {
			get {
				return autoClearSelection;
			}
			set {
				autoClearSelection = value;
			}
		}
		
		[Browsable(false)]
		public IDocument Document {
			get {
				return motherTextEditorControl.Document;
			}
		}
		
		public TextAreaClipboardHandler ClipboardHandler {
			get {
				return textAreaClipboardHandler;
			}
		}
		
		
		public ITextEditorProperties TextEditorProperties {
			get {
				return motherTextEditorControl.TextEditorProperties;
			}
		}
		
		public TextArea(TextEditorControl motherTextEditorControl, TextAreaControl motherTextAreaControl)
		{
			this.motherTextAreaControl      = motherTextAreaControl;
			this.motherTextEditorControl    = motherTextEditorControl;
			
			caret            = new Caret(this);
			selectionManager = new SelectionManager(Document, this);
			
			this.textAreaClipboardHandler = new TextAreaClipboardHandler(this);
			
			ResizeRedraw = true;
			
			SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
//			SetStyle(ControlStyles.AllPaintingInWmPaint, true);
//			SetStyle(ControlStyles.UserPaint, true);
			SetStyle(ControlStyles.Opaque, false);
			SetStyle(ControlStyles.ResizeRedraw, true);
			SetStyle(ControlStyles.Selectable, true);
			
			textView = new TextView(this);
			
			gutterMargin = new GutterMargin(this);
			foldMargin   = new FoldMargin(this);
			iconBarMargin = new IconBarMargin(this);
			leftMargins.AddRange(new AbstractMargin[] { iconBarMargin, gutterMargin, foldMargin });
			OptionsChanged();
			
			
			new TextAreaMouseHandler(this).Attach();
			new TextAreaDragDropHandler().Attach(this);
			
			bracketshemes.Add(new BracketHighlightingSheme('{', '}'));
			bracketshemes.Add(new BracketHighlightingSheme('(', ')'));
			bracketshemes.Add(new BracketHighlightingSheme('[', ']'));
			
			caret.PositionChanged += new EventHandler(SearchMatchingBracket);
			Document.TextContentChanged += new EventHandler(TextContentChanged);
			Document.FoldingManager.FoldingsChanged += new EventHandler(DocumentFoldingsChanged);
		}
		
		public void UpdateMatchingBracket()
		{
			SearchMatchingBracket(null, null);
		}
		
		void TextContentChanged(object sender, EventArgs e)
		{
			Caret.Position = new TextLocation(0, 0);
			SelectionManager.SelectionCollection.Clear();
		}
		void SearchMatchingBracket(object sender, EventArgs e)
		{
			if (!TextEditorProperties.ShowMatchingBracket) {
				textView.Highlight = null;
				return;
			}
			int oldLine1 = -1, oldLine2 = -1;
			if (textView.Highlight != null && textView.Highlight.OpenBrace.Y >=0 && textView.Highlight.OpenBrace.Y < Document.TotalNumberOfLines) {
				oldLine1 = textView.Highlight.OpenBrace.Y;
			}
			if (textView.Highlight != null && textView.Highlight.CloseBrace.Y >=0 && textView.Highlight.CloseBrace.Y < Document.TotalNumberOfLines) {
				oldLine2 = textView.Highlight.CloseBrace.Y;
			}
			textView.Highlight = FindMatchingBracketHighlight();
			if (oldLine1 >= 0)
				UpdateLine(oldLine1);
			if (oldLine2 >= 0 && oldLine2 != oldLine1)
				UpdateLine(oldLine2);
			if (textView.Highlight != null) {
				int newLine1 = textView.Highlight.OpenBrace.Y;
				int newLine2 = textView.Highlight.CloseBrace.Y;
				if (newLine1 != oldLine1 && newLine1 != oldLine2)
					UpdateLine(newLine1);
				if (newLine2 != oldLine1 && newLine2 != oldLine2 && newLine2 != newLine1)
					UpdateLine(newLine2);
			}
		}
		
		public Highlight FindMatchingBracketHighlight()
		{
			if (Caret.Offset == 0)
				return null;
			foreach (BracketHighlightingSheme bracketsheme in bracketshemes) {
				Highlight highlight = bracketsheme.GetHighlight(Document, Caret.Offset - 1);
				if (highlight != null) {
					return highlight;
				}
			}
			return null;
		}
		
		public void SetDesiredColumn()
		{
			Caret.DesiredColumn = TextView.GetDrawingXPos(Caret.Line, Caret.Column) + VirtualTop.X;
		}
		
		public void SetCaretToDesiredColumn()
		{
			FoldMarker dummy;
			Caret.Position = textView.GetLogicalColumn(Caret.Line, Caret.DesiredColumn + VirtualTop.X, out dummy);
		}
		
		public void OptionsChanged()
		{
			UpdateMatchingBracket();
			textView.OptionsChanged();
			caret.RecreateCaret();
			caret.UpdateCaretPosition();
			Refresh();
		}
		
		AbstractMargin lastMouseInMargin;
		
		protected override void OnMouseLeave(System.EventArgs e)
		{
			base.OnMouseLeave(e);
			this.Cursor = Cursors.Default;
			if (lastMouseInMargin != null) {
				lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
				lastMouseInMargin = null;
			}
			CloseToolTip();
		}
		
		protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
		{
			// this corrects weird problems when text is selected,
			// then a menu item is selected, then the text is
			// clicked again - it correctly synchronises the
			// click position
			mousepos = new Point(e.X, e.Y);

			base.OnMouseDown(e);
			CloseToolTip();
			
			foreach (AbstractMargin margin in leftMargins) {
				if (margin.DrawingPosition.Contains(e.X, e.Y)) {
					margin.HandleMouseDown(new Point(e.X, e.Y), e.Button);
				}
			}
		}
		
		/// <summary>
		/// Shows the mouse cursor if it has been hidden.
		/// </summary>
		/// <param name="forceShow"><c>true</c> to always show the cursor or <c>false</c> to show it only if it has been moved since it was hidden.</param>
		internal void ShowHiddenCursor(bool forceShow)
		{
			if (hiddenMouseCursor) {
				if (mouseCursorHidePosition != Cursor.Position || forceShow) {
					Cursor.Show();
					hiddenMouseCursor = false;
				}
			}
		}
		
		
		// static because the mouse can only be in one text area and we don't want to have
		// tooltips of text areas from inactive tabs floating around.
		static DeclarationViewWindow toolTip;
		static string oldToolTip;
		
		void SetToolTip(string text, int lineNumber)
		{
			if (toolTip == null || toolTip.IsDisposed)
				toolTip = new DeclarationViewWindow(this.FindForm());
			if (oldToolTip == text)
				return;
			if (text == null) {
				toolTip.Hide();
			} else {
				Point p = Control.MousePosition;
				Point cp = PointToClient(p);
				if (lineNumber >= 0) {
					lineNumber = this.Document.GetVisibleLine(lineNumber);
					p.Y = (p.Y - cp.Y) + (lineNumber * this.TextView.FontHeight) - this.virtualTop.Y;
				}
				p.Offset(3, 3);
				toolTip.Location = p;
				toolTip.Description = text;
				toolTip.HideOnClick = true;
				toolTip.Show();
			}
			oldToolTip = text;
		}
		
		public event ToolTipRequestEventHandler ToolTipRequest;
		
		protected virtual void OnToolTipRequest(ToolTipRequestEventArgs e)
		{
			if (ToolTipRequest != null) {
				ToolTipRequest(this, e);
			}
		}
		
		bool toolTipActive;
		/// <summary>
		/// Rectangle in text area that caused the current tool tip.
		/// Prevents tooltip from re-showing when it was closed because of a click or keyboard
		/// input and the mouse was not used.
		/// </summary>
		Rectangle toolTipRectangle;
		
		void CloseToolTip()
		{
			if (toolTipActive) {
				//Console.WriteLine("Closing tooltip");
				toolTipActive = false;
				SetToolTip(null, -1);
			}
			ResetMouseEventArgs();
		}
		
		protected override void OnMouseHover(EventArgs e)
		{
			base.OnMouseHover(e);
			//Console.WriteLine("Hover raised at " + PointToClient(Control.MousePosition));
			if (MouseButtons == MouseButtons.None) {
				RequestToolTip(PointToClient(Control.MousePosition));
			} else {
				CloseToolTip();
			}
		}
		
		protected void RequestToolTip(Point mousePos)
		{
			if (toolTipRectangle.Contains(mousePos)) {
				if (!toolTipActive)
					ResetMouseEventArgs();
				return;
			}
			
			//Console.WriteLine("Request tooltip for " + mousePos);
			
			toolTipRectangle = new Rectangle(mousePos.X - 4, mousePos.Y - 4, 8, 8);
			
			TextLocation logicPos = textView.GetLogicalPosition(mousePos.X - textView.DrawingPosition.Left,
			                                                    mousePos.Y - textView.DrawingPosition.Top);
			bool inDocument = textView.DrawingPosition.Contains(mousePos)
				&& logicPos.Y >= 0 && logicPos.Y < Document.TotalNumberOfLines;
			ToolTipRequestEventArgs args = new ToolTipRequestEventArgs(mousePos, logicPos, inDocument);
			OnToolTipRequest(args);
			if (args.ToolTipShown) {
				//Console.WriteLine("Set tooltip to " + args.toolTipText);
				toolTipActive = true;
				SetToolTip(args.toolTipText, inDocument ? logicPos.Y + 1 : -1);
			} else {
				CloseToolTip();
			}
		}
		
		// external interface to the attached event
		internal void RaiseMouseMove(MouseEventArgs e)
		{
			OnMouseMove(e);
		}

		protected override void OnMouseMove(MouseEventArgs e)
		{
			base.OnMouseMove(e);
			if (!toolTipRectangle.Contains(e.Location)) {
				toolTipRectangle = Rectangle.Empty;
				if (toolTipActive)
					RequestToolTip(e.Location);
			}
			foreach (AbstractMargin margin in leftMargins) {
				if (margin.DrawingPosition.Contains(e.X, e.Y)) {
					this.Cursor = margin.Cursor;
					margin.HandleMouseMove(new Point(e.X, e.Y), e.Button);
					if (lastMouseInMargin != margin) {
						if (lastMouseInMargin != null) {
							lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
						}
						lastMouseInMargin = margin;
					}
					return;
				}
			}
			if (lastMouseInMargin != null) {
				lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
				lastMouseInMargin = null;
			}
			if (textView.DrawingPosition.Contains(e.X, e.Y)) {
				TextLocation realmousepos = TextView.GetLogicalPosition(e.X - TextView.DrawingPosition.X, e.Y - TextView.DrawingPosition.Y);
				if(SelectionManager.IsSelected(Document.PositionToOffset(realmousepos)) && MouseButtons == MouseButtons.None) {
					// mouse is hovering over a selection, so show default mouse
					this.Cursor = Cursors.Default;
				} else {
					// mouse is hovering over text area, not a selection, so show the textView cursor
					this.Cursor = textView.Cursor;
				}
				return;
			}
			this.Cursor = Cursors.Default;
		}
		AbstractMargin updateMargin = null;
		
		public void Refresh(AbstractMargin margin)
		{
			updateMargin = margin;
			Invalidate(updateMargin.DrawingPosition);
			Update();
			updateMargin = null;
		}
		
		protected override void OnPaintBackground(System.Windows.Forms.PaintEventArgs pevent)
		{
		}
		
		protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
		{
			int currentXPos = 0;
			int currentYPos = 0;
			bool adjustScrollBars = false;
			Graphics  g             = e.Graphics;
			Rectangle clipRectangle = e.ClipRectangle;
			
			bool isFullRepaint = clipRectangle.X == 0 && clipRectangle.Y == 0
				&& clipRectangle.Width == this.Width && clipRectangle.Height == this.Height;
			
			g.TextRenderingHint = this.TextEditorProperties.TextRenderingHint;
			
			if (updateMargin != null) {
				updateMargin.Paint(g, updateMargin.DrawingPosition);
//				clipRectangle.Intersect(updateMargin.DrawingPosition);
			}
			
			if (clipRectangle.Width <= 0 || clipRectangle.Height <= 0) {
				return;
			}
			
			foreach (AbstractMargin margin in leftMargins) {
				if (margin.IsVisible) {
					Rectangle marginRectangle = new Rectangle(currentXPos , currentYPos, margin.Size.Width, Height - currentYPos);
					if (marginRectangle != margin.DrawingPosition) {
						// margin changed size
						if (!isFullRepaint && !clipRectangle.Contains(marginRectangle)) {
							Invalidate(); // do a full repaint
						}
						adjustScrollBars = true;
						margin.DrawingPosition = marginRectangle;
					}
					currentXPos += margin.DrawingPosition.Width;
					if (clipRectangle.IntersectsWith(marginRectangle)) {
						marginRectangle.Intersect(clipRectangle);
						if (!marginRectangle.IsEmpty) {
							margin.Paint(g, marginRectangle);
						}
					}
				}
			}
			
			Rectangle textViewArea = new Rectangle(currentXPos, currentYPos, Width - currentXPos, Height - currentYPos);
			if (textViewArea != textView.DrawingPosition) {
				adjustScrollBars = true;
				textView.DrawingPosition = textViewArea;
			}
			if (clipRectangle.IntersectsWith(textViewArea)) {
				textViewArea.Intersect(clipRectangle);
				if (!textViewArea.IsEmpty) {
					textView.Paint(g, textViewArea);
				}
			}
			
			if (adjustScrollBars) {
				this.motherTextAreaControl.AdjustScrollBars();
			}
			
			Caret.UpdateCaretPosition();
			
			base.OnPaint(e);
		}
		void DocumentFoldingsChanged(object sender, EventArgs e)
		{
			Invalidate();
			this.motherTextAreaControl.AdjustScrollBars();
		}
		
		#region keyboard handling methods
		
		/// <summary>
		/// This method is called on each Keypress
		/// </summary>
		/// <returns>
		/// True, if the key is handled by this method and should NOT be
		/// inserted in the textarea.
		/// </returns>
		protected internal virtual bool HandleKeyPress(char ch)
		{
			if (KeyEventHandler != null) {
				return KeyEventHandler(ch);
			}
			return false;
		}
		
		// Fixes SD2-747: Form containing the text editor and a button with a shortcut
		protected override bool IsInputChar(char charCode)
		{
			return true;
		}
		
		public void SimulateKeyPress(char ch)
		{
			if (Document.ReadOnly) {
				return;
			}
			
			if (TextEditorProperties.UseCustomLine == true) {
				if (SelectionManager.HasSomethingSelected) {
					if (SelectionManager.SelectionIsReadonly)
						return;
				} else if (Document.CustomLineManager.IsReadOnly(Caret.Line, false) == true)
					return;
			}
			
			if (ch < ' ') {
				return;
			}
			
			if (!hiddenMouseCursor && TextEditorProperties.HideMouseCursor) {
				if (this.ClientRectangle.Contains(PointToClient(Cursor.Position))) {
					mouseCursorHidePosition = Cursor.Position;
					hiddenMouseCursor = true;
					Cursor.Hide();
				}
			}
			CloseToolTip();
			
			motherTextEditorControl.BeginUpdate();
			Document.UndoStack.StartUndoGroup();
			// INSERT char
			if (!HandleKeyPress(ch)) {
				switch (Caret.CaretMode) {
					case CaretMode.InsertMode:
						InsertChar(ch);
						break;
					case CaretMode.OverwriteMode:
						ReplaceChar(ch);
						break;
					default:
						Debug.Assert(false, "Unknown caret mode " + Caret.CaretMode);
						break;
				}
			}
			
			int currentLineNr = Caret.Line;
			Document.FormattingStrategy.FormatLine(this, currentLineNr, Document.PositionToOffset(Caret.Position), ch);
			
			motherTextEditorControl.EndUpdate();
			Document.UndoStack.EndUndoGroup();
		}
		
		protected override void OnKeyPress(KeyPressEventArgs e)
		{
			base.OnKeyPress(e);
			SimulateKeyPress(e.KeyChar);
			e.Handled = true;
		}
		
		/// <summary>
		/// This method executes a dialog key
		/// </summary>
		public bool ExecuteDialogKey(Keys keyData)
		{
			// try, if a dialog key processor was set to use this
			if (DoProcessDialogKey != null && DoProcessDialogKey(keyData)) {
				return true;
			}
			
			if (keyData == Keys.Back || keyData == Keys.Delete || keyData == Keys.Enter) {
				if (TextEditorProperties.UseCustomLine == true) {
					if (SelectionManager.HasSomethingSelected) {
						if (SelectionManager.SelectionIsReadonly)
							return true;
					} else {
						int curLineNr   = Document.GetLineNumberForOffset(Caret.Offset);
						if (Document.CustomLineManager.IsReadOnly(curLineNr, false) == true)
							return true;
						if ((Caret.Column == 0) && (curLineNr - 1 >= 0) && keyData == Keys.Back &&
						    Document.CustomLineManager.IsReadOnly(curLineNr - 1, false) == true)
							return true;
						if (keyData == Keys.Delete) {
							LineSegment curLine = Document.GetLineSegment(curLineNr);
							if (curLine.Offset + curLine.Length == Caret.Offset &&
							    Document.CustomLineManager.IsReadOnly(curLineNr + 1, false) == true) {
								return true;
							}
						}
					}
				}
			}
			
			// if not (or the process was 'silent', use the standard edit actions
			IEditAction action =  motherTextEditorControl.GetEditAction(keyData);
			AutoClearSelection = true;
			if (action != null) {
				motherTextEditorControl.BeginUpdate();
				try {
					lock (Document) {
						action.Execute(this);
						if (SelectionManager.HasSomethingSelected && AutoClearSelection /*&& caretchanged*/) {
							if (Document.TextEditorProperties.DocumentSelectionMode == DocumentSelectionMode.Normal) {
								SelectionManager.ClearSelection();
							}
						}
					}
				} finally {
					motherTextEditorControl.EndUpdate();
					Caret.UpdateCaretPosition();
				}
				return true;
			}
			return false;
		}
		
		protected override bool ProcessDialogKey(Keys keyData)
		{
			return ExecuteDialogKey(keyData) || base.ProcessDialogKey(keyData);
		}
		#endregion
		
		public void ScrollToCaret()
		{
			motherTextAreaControl.ScrollToCaret();
		}
		
		public void ScrollTo(int line)
		{
			motherTextAreaControl.ScrollTo(line);
		}
		
		public void BeginUpdate()
		{
			motherTextEditorControl.BeginUpdate();
		}
		
		public void EndUpdate()
		{
			motherTextEditorControl.EndUpdate();
		}
		
		public bool EnableCutOrPaste {
			get {
				if (motherTextAreaControl == null)
					return false;
				if (TextEditorProperties.UseCustomLine == true) {
					if (SelectionManager.HasSomethingSelected == true) {
						if (SelectionManager.SelectionIsReadonly)
							return false;
					}
					if (Document.CustomLineManager.IsReadOnly(Caret.Line, false) == true)
						return false;
				}
				return true;
				
			}
		}
		
		string GenerateWhitespaceString(int length)
		{
			return new String(' ', length);
		}
		/// <remarks>
		/// Inserts a single character at the caret position
		/// </remarks>
		public void InsertChar(char ch)
		{
			bool updating = motherTextEditorControl.IsInUpdate;
			if (!updating) {
				BeginUpdate();
			}
			
			// filter out forgein whitespace chars and replace them with standard space (ASCII 32)
			if (Char.IsWhiteSpace(ch) && ch != '\t' && ch != '\n') {
				ch = ' ';
			}
			
			Document.UndoStack.StartUndoGroup();
			if (Document.TextEditorProperties.DocumentSelectionMode == DocumentSelectionMode.Normal &&
			    SelectionManager.SelectionCollection.Count > 0) {
				Caret.Position = SelectionManager.SelectionCollection[0].StartPosition;
				SelectionManager.RemoveSelectedText();
			}
			LineSegment caretLine = Document.GetLineSegment(Caret.Line);
			int offset = Caret.Offset;
			// use desired column for generated whitespaces
			int dc=Math.Min(Caret.Column,Caret.DesiredColumn);
			if (caretLine.Length < dc && ch != '\n') {
				Document.Insert(offset, GenerateWhitespaceString(dc - caretLine.Length) + ch);
			} else {
				Document.Insert(offset, ch.ToString());
			}
			Document.UndoStack.EndUndoGroup();
			++Caret.Column;
			
			if (!updating) {
				EndUpdate();
				UpdateLineToEnd(Caret.Line, Caret.Column);
			}
			
			// I prefer to set NOT the standard column, if you type something
//			++Caret.DesiredColumn;
		}
		
		/// <remarks>
		/// Inserts a whole string at the caret position
		/// </remarks>
		public void InsertString(string str)
		{
			bool updating = motherTextEditorControl.IsInUpdate;
			if (!updating) {
				BeginUpdate();
			}
			try {
				Document.UndoStack.StartUndoGroup();
				if (Document.TextEditorProperties.DocumentSelectionMode == DocumentSelectionMode.Normal &&
				    SelectionManager.SelectionCollection.Count > 0) {
					Caret.Position = SelectionManager.SelectionCollection[0].StartPosition;
					SelectionManager.RemoveSelectedText();
				}
				
				int oldOffset = Document.PositionToOffset(Caret.Position);
				int oldLine   = Caret.Line;
				LineSegment caretLine = Document.GetLineSegment(Caret.Line);
				if (caretLine.Length < Caret.Column) {
					int whiteSpaceLength = Caret.Column - caretLine.Length;
					Document.Insert(oldOffset, GenerateWhitespaceString(whiteSpaceLength) + str);
					Caret.Position = Document.OffsetToPosition(oldOffset + str.Length + whiteSpaceLength);
				} else {
					Document.Insert(oldOffset, str);
					Caret.Position = Document.OffsetToPosition(oldOffset + str.Length);
				}
				Document.UndoStack.EndUndoGroup();
				if (oldLine != Caret.Line) {
					UpdateToEnd(oldLine);
				} else {
					UpdateLineToEnd(Caret.Line, Caret.Column);
				}
			} finally {
				if (!updating) {
					EndUpdate();
				}
			}
		}
		
		/// <remarks>
		/// Replaces a char at the caret position
		/// </remarks>
		public void ReplaceChar(char ch)
		{
			bool updating = motherTextEditorControl.IsInUpdate;
			if (!updating) {
				BeginUpdate();
			}
			if (Document.TextEditorProperties.DocumentSelectionMode == DocumentSelectionMode.Normal && SelectionManager.SelectionCollection.Count > 0) {
				Caret.Position = SelectionManager.SelectionCollection[0].StartPosition;
				SelectionManager.RemoveSelectedText();
			}
			
			int lineNr   = Caret.Line;
			LineSegment  line = Document.GetLineSegment(lineNr);
			int offset = Document.PositionToOffset(Caret.Position);
			if (offset < line.Offset + line.Length) {
				Document.Replace(offset, 1, ch.ToString());
			} else {
				Document.Insert(offset, ch.ToString());
			}
			if (!updating) {
				EndUpdate();
				UpdateLineToEnd(lineNr, Caret.Column);
			}
			++Caret.Column;
//			++Caret.DesiredColumn;
		}
		
		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			if (disposing) {
				if (!disposed) {
					disposed = true;
					if (caret != null) {
						caret.PositionChanged -= new EventHandler(SearchMatchingBracket);
						caret.Dispose();
					}
					if (selectionManager != null) {
						selectionManager.Dispose();
					}
					Document.TextContentChanged -= new EventHandler(TextContentChanged);
					Document.FoldingManager.FoldingsChanged -= new EventHandler(DocumentFoldingsChanged);
					motherTextAreaControl = null;
					motherTextEditorControl = null;
					foreach (AbstractMargin margin in leftMargins) {
						if (margin is IDisposable)
							(margin as IDisposable).Dispose();
					}
					textView.Dispose();
				}
			}
		}
		
		#region UPDATE Commands
		internal void UpdateLine(int line)
		{
			UpdateLines(0, line, line);
		}
		
		internal void UpdateLines(int lineBegin, int lineEnd)
		{
			UpdateLines(0, lineBegin, lineEnd);
		}
		
		internal void UpdateToEnd(int lineBegin)
		{
//			if (lineBegin > FirstPhysicalLine + textView.VisibleLineCount) {
//				return;
//			}
			
			lineBegin = Document.GetVisibleLine(lineBegin);
			int y         = Math.Max(    0, (int)(lineBegin * textView.FontHeight));
			y = Math.Max(0, y - this.virtualTop.Y);
			Rectangle r = new Rectangle(0,
			                            y,
			                            Width,
			                            Height - y);
			Invalidate(r);
		}
		
		internal void UpdateLineToEnd(int lineNr, int xStart)
		{
			UpdateLines(xStart, lineNr, lineNr);
		}
		
		internal void UpdateLine(int line, int begin, int end)
		{
			UpdateLines(line, line);
		}
		int FirstPhysicalLine {
			get {
				return VirtualTop.Y / textView.FontHeight;
			}
		}
		internal void UpdateLines(int xPos, int lineBegin, int lineEnd)
		{
//			if (lineEnd < FirstPhysicalLine || lineBegin > FirstPhysicalLine + textView.VisibleLineCount) {
//				return;
//			}
			
			InvalidateLines((int)(xPos * this.TextView.WideSpaceWidth), lineBegin, lineEnd);
		}
		
		void InvalidateLines(int xPos, int lineBegin, int lineEnd)
		{
			lineBegin     = Math.Max(Document.GetVisibleLine(lineBegin), FirstPhysicalLine);
			lineEnd       = Math.Min(Document.GetVisibleLine(lineEnd),   FirstPhysicalLine + textView.VisibleLineCount);
			int y         = Math.Max(    0, (int)(lineBegin  * textView.FontHeight));
			int height    = Math.Min(textView.DrawingPosition.Height, (int)((1 + lineEnd - lineBegin) * (textView.FontHeight + 1)));
			
			Rectangle r = new Rectangle(0,
			                            y - 1 - this.virtualTop.Y,
			                            Width,
			                            height + 3);
			
			Invalidate(r);
		}
		#endregion
		public event KeyEventHandler    KeyEventHandler;
		public event DialogKeyProcessor DoProcessDialogKey;
		
		//internal void
	}
}

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: 2683 $</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.Text;
15		using System.Windows.Forms;
16
17		using ICSharpCode.TextEditor.Actions;
18		using ICSharpCode.TextEditor.Document;
19		using ICSharpCode.TextEditor.Gui.CompletionWindow;
20
21		namespace ICSharpCode.TextEditor
22		{
23		public delegate bool KeyEventHandler(char ch);
24		public delegate bool DialogKeyProcessor(Keys keyData);
25
26		/// <summary>
27		/// This class paints the textarea.
28		/// </summary>
29		[ToolboxItem(false)]
30		public class TextArea : Control
31		{
32		bool hiddenMouseCursor = false;
33		/// <summary>
34		/// The position where the mouse cursor was when it was hidden. Sometimes the text editor gets MouseMove
35		/// events when typing text even if the mouse is not moved.
36		/// </summary>
37		Point mouseCursorHidePosition;
38
39		Point virtualTop = new Point(0, 0);
40		TextAreaControl motherTextAreaControl;
41		TextEditorControl motherTextEditorControl;
42
43		List<BracketHighlightingSheme> bracketshemes = new List<BracketHighlightingSheme>();
44		TextAreaClipboardHandler textAreaClipboardHandler;
45		bool autoClearSelection = false;
46
47		List<AbstractMargin> leftMargins = new List<AbstractMargin>();
48
49		TextView textView;
50		GutterMargin gutterMargin;
51		FoldMargin foldMargin;
52		IconBarMargin iconBarMargin;
53
54		SelectionManager selectionManager;
55		Caret caret;
56
57		internal Point mousepos = new Point(0, 0);
58		//public Point selectionStartPos = new Point(0,0);
59
60		bool disposed;
61
62		[Browsable(false)]
63		public IList<AbstractMargin> LeftMargins {
64		get {
65		return leftMargins.AsReadOnly();
66		}
67		}
68
69		public void InsertLeftMargin(int index, AbstractMargin margin)
70		{
71		leftMargins.Insert(index, margin);
72		Refresh();
73		}
74
75		public TextEditorControl MotherTextEditorControl {
76		get {
77		return motherTextEditorControl;
78		}
79		}
80
81		public TextAreaControl MotherTextAreaControl {
82		get {
83		return motherTextAreaControl;
84		}
85		}
86
87		public SelectionManager SelectionManager {
88		get {
89		return selectionManager;
90		}
91		}
92
93		public Caret Caret {
94		get {
95		return caret;
96		}
97		}
98
99		public TextView TextView {
100		get {
101		return textView;
102		}
103		}
104
105		public GutterMargin GutterMargin {
106		get {
107		return gutterMargin;
108		}
109		}
110
111		public FoldMargin FoldMargin {
112		get {
113		return foldMargin;
114		}
115		}
116
117		public IconBarMargin IconBarMargin {
118		get {
119		return iconBarMargin;
120		}
121		}
122
123		public Encoding Encoding {
124		get {
125		return motherTextEditorControl.Encoding;
126		}
127		}
128		public int MaxVScrollValue {
129		get {
130		return (Document.GetVisibleLine(Document.TotalNumberOfLines - 1) + 1 + TextView.VisibleLineCount * 2 / 3) * TextView.FontHeight;
131		}
132		}
133
134		public Point VirtualTop {
135		get {
136		return virtualTop;
137		}
138		set {
139		Point newVirtualTop = new Point(value.X, Math.Min(MaxVScrollValue, Math.Max(0, value.Y)));
140		if (virtualTop != newVirtualTop) {
141		virtualTop = newVirtualTop;
142		motherTextAreaControl.VScrollBar.Value = virtualTop.Y;
143		Invalidate();
144		}
145		}
146		}
147
148		public bool AutoClearSelection {
149		get {
150		return autoClearSelection;
151		}
152		set {
153		autoClearSelection = value;
154		}
155		}
156
157		[Browsable(false)]
158		public IDocument Document {
159		get {
160		return motherTextEditorControl.Document;
161		}
162		}
163
164		public TextAreaClipboardHandler ClipboardHandler {
165		get {
166		return textAreaClipboardHandler;
167		}
168		}
169
170
171		public ITextEditorProperties TextEditorProperties {
172		get {
173		return motherTextEditorControl.TextEditorProperties;
174		}
175		}
176
177		public TextArea(TextEditorControl motherTextEditorControl, TextAreaControl motherTextAreaControl)
178		{
179		this.motherTextAreaControl = motherTextAreaControl;
180		this.motherTextEditorControl = motherTextEditorControl;
181
182		caret = new Caret(this);
183		selectionManager = new SelectionManager(Document, this);
184
185		this.textAreaClipboardHandler = new TextAreaClipboardHandler(this);
186
187		ResizeRedraw = true;
188
189		SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
190		// SetStyle(ControlStyles.AllPaintingInWmPaint, true);
191		// SetStyle(ControlStyles.UserPaint, true);
192		SetStyle(ControlStyles.Opaque, false);
193		SetStyle(ControlStyles.ResizeRedraw, true);
194		SetStyle(ControlStyles.Selectable, true);
195
196		textView = new TextView(this);
197
198		gutterMargin = new GutterMargin(this);
199		foldMargin = new FoldMargin(this);
200		iconBarMargin = new IconBarMargin(this);
201		leftMargins.AddRange(new AbstractMargin[] { iconBarMargin, gutterMargin, foldMargin });
202		OptionsChanged();
203
204
205		new TextAreaMouseHandler(this).Attach();
206		new TextAreaDragDropHandler().Attach(this);
207
208		bracketshemes.Add(new BracketHighlightingSheme('{', '}'));
209		bracketshemes.Add(new BracketHighlightingSheme('(', ')'));
210		bracketshemes.Add(new BracketHighlightingSheme('[', ']'));
211
212		caret.PositionChanged += new EventHandler(SearchMatchingBracket);
213		Document.TextContentChanged += new EventHandler(TextContentChanged);
214		Document.FoldingManager.FoldingsChanged += new EventHandler(DocumentFoldingsChanged);
215		}
216
217		public void UpdateMatchingBracket()
218		{
219		SearchMatchingBracket(null, null);
220		}
221
222		void TextContentChanged(object sender, EventArgs e)
223		{
224		Caret.Position = new TextLocation(0, 0);
225		SelectionManager.SelectionCollection.Clear();
226		}
227		void SearchMatchingBracket(object sender, EventArgs e)
228		{
229		if (!TextEditorProperties.ShowMatchingBracket) {
230		textView.Highlight = null;
231		return;
232		}
233		int oldLine1 = -1, oldLine2 = -1;
234		if (textView.Highlight != null && textView.Highlight.OpenBrace.Y >=0 && textView.Highlight.OpenBrace.Y < Document.TotalNumberOfLines) {
235		oldLine1 = textView.Highlight.OpenBrace.Y;
236		}
237		if (textView.Highlight != null && textView.Highlight.CloseBrace.Y >=0 && textView.Highlight.CloseBrace.Y < Document.TotalNumberOfLines) {
238		oldLine2 = textView.Highlight.CloseBrace.Y;
239		}
240		textView.Highlight = FindMatchingBracketHighlight();
241		if (oldLine1 >= 0)
242		UpdateLine(oldLine1);
243		if (oldLine2 >= 0 && oldLine2 != oldLine1)
244		UpdateLine(oldLine2);
245		if (textView.Highlight != null) {
246		int newLine1 = textView.Highlight.OpenBrace.Y;
247		int newLine2 = textView.Highlight.CloseBrace.Y;
248		if (newLine1 != oldLine1 && newLine1 != oldLine2)
249		UpdateLine(newLine1);
250		if (newLine2 != oldLine1 && newLine2 != oldLine2 && newLine2 != newLine1)
251		UpdateLine(newLine2);
252		}
253		}
254
255		public Highlight FindMatchingBracketHighlight()
256		{
257		if (Caret.Offset == 0)
258		return null;
259		foreach (BracketHighlightingSheme bracketsheme in bracketshemes) {
260		Highlight highlight = bracketsheme.GetHighlight(Document, Caret.Offset - 1);
261		if (highlight != null) {
262		return highlight;
263		}
264		}
265		return null;
266		}
267
268		public void SetDesiredColumn()
269		{
270		Caret.DesiredColumn = TextView.GetDrawingXPos(Caret.Line, Caret.Column) + VirtualTop.X;
271		}
272
273		public void SetCaretToDesiredColumn()
274		{
275		FoldMarker dummy;
276		Caret.Position = textView.GetLogicalColumn(Caret.Line, Caret.DesiredColumn + VirtualTop.X, out dummy);
277		}
278
279		public void OptionsChanged()
280		{
281		UpdateMatchingBracket();
282		textView.OptionsChanged();
283		caret.RecreateCaret();
284		caret.UpdateCaretPosition();
285		Refresh();
286		}
287
288		AbstractMargin lastMouseInMargin;
289
290		protected override void OnMouseLeave(System.EventArgs e)
291		{
292		base.OnMouseLeave(e);
293		this.Cursor = Cursors.Default;
294		if (lastMouseInMargin != null) {
295		lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
296		lastMouseInMargin = null;
297		}
298		CloseToolTip();
299		}
300
301		protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
302		{
303		// this corrects weird problems when text is selected,
304		// then a menu item is selected, then the text is
305		// clicked again - it correctly synchronises the
306		// click position
307		mousepos = new Point(e.X, e.Y);
308
309		base.OnMouseDown(e);
310		CloseToolTip();
311
312		foreach (AbstractMargin margin in leftMargins) {
313		if (margin.DrawingPosition.Contains(e.X, e.Y)) {
314		margin.HandleMouseDown(new Point(e.X, e.Y), e.Button);
315		}
316		}
317		}
318
319		/// <summary>
320		/// Shows the mouse cursor if it has been hidden.
321		/// </summary>
322		/// <param name="forceShow"><c>true</c> to always show the cursor or <c>false</c> to show it only if it has been moved since it was hidden.</param>
323		internal void ShowHiddenCursor(bool forceShow)
324		{
325		if (hiddenMouseCursor) {
326		if (mouseCursorHidePosition != Cursor.Position \|\| forceShow) {
327		Cursor.Show();
328		hiddenMouseCursor = false;
329		}
330		}
331		}
332
333
334		// static because the mouse can only be in one text area and we don't want to have
335		// tooltips of text areas from inactive tabs floating around.
336		static DeclarationViewWindow toolTip;
337		static string oldToolTip;
338
339		void SetToolTip(string text, int lineNumber)
340		{
341		if (toolTip == null \|\| toolTip.IsDisposed)
342		toolTip = new DeclarationViewWindow(this.FindForm());
343		if (oldToolTip == text)
344		return;
345		if (text == null) {
346		toolTip.Hide();
347		} else {
348		Point p = Control.MousePosition;
349		Point cp = PointToClient(p);
350		if (lineNumber >= 0) {
351		lineNumber = this.Document.GetVisibleLine(lineNumber);
352		p.Y = (p.Y - cp.Y) + (lineNumber * this.TextView.FontHeight) - this.virtualTop.Y;
353		}
354		p.Offset(3, 3);
355		toolTip.Location = p;
356		toolTip.Description = text;
357		toolTip.HideOnClick = true;
358		toolTip.Show();
359		}
360		oldToolTip = text;
361		}
362
363		public event ToolTipRequestEventHandler ToolTipRequest;
364
365		protected virtual void OnToolTipRequest(ToolTipRequestEventArgs e)
366		{
367		if (ToolTipRequest != null) {
368		ToolTipRequest(this, e);
369		}
370		}
371
372		bool toolTipActive;
373		/// <summary>
374		/// Rectangle in text area that caused the current tool tip.
375		/// Prevents tooltip from re-showing when it was closed because of a click or keyboard
376		/// input and the mouse was not used.
377		/// </summary>
378		Rectangle toolTipRectangle;
379
380		void CloseToolTip()
381		{
382		if (toolTipActive) {
383		//Console.WriteLine("Closing tooltip");
384		toolTipActive = false;
385		SetToolTip(null, -1);
386		}
387		ResetMouseEventArgs();
388		}
389
390		protected override void OnMouseHover(EventArgs e)
391		{
392		base.OnMouseHover(e);
393		//Console.WriteLine("Hover raised at " + PointToClient(Control.MousePosition));
394		if (MouseButtons == MouseButtons.None) {
395		RequestToolTip(PointToClient(Control.MousePosition));
396		} else {
397		CloseToolTip();
398		}
399		}
400
401		protected void RequestToolTip(Point mousePos)
402		{
403		if (toolTipRectangle.Contains(mousePos)) {
404		if (!toolTipActive)
405		ResetMouseEventArgs();
406		return;
407		}
408
409		//Console.WriteLine("Request tooltip for " + mousePos);
410
411		toolTipRectangle = new Rectangle(mousePos.X - 4, mousePos.Y - 4, 8, 8);
412
413		TextLocation logicPos = textView.GetLogicalPosition(mousePos.X - textView.DrawingPosition.Left,
414		mousePos.Y - textView.DrawingPosition.Top);
415		bool inDocument = textView.DrawingPosition.Contains(mousePos)
416		&& logicPos.Y >= 0 && logicPos.Y < Document.TotalNumberOfLines;
417		ToolTipRequestEventArgs args = new ToolTipRequestEventArgs(mousePos, logicPos, inDocument);
418		OnToolTipRequest(args);
419		if (args.ToolTipShown) {
420		//Console.WriteLine("Set tooltip to " + args.toolTipText);
421		toolTipActive = true;
422		SetToolTip(args.toolTipText, inDocument ? logicPos.Y + 1 : -1);
423		} else {
424		CloseToolTip();
425		}
426		}
427
428		// external interface to the attached event
429		internal void RaiseMouseMove(MouseEventArgs e)
430		{
431		OnMouseMove(e);
432		}
433
434		protected override void OnMouseMove(MouseEventArgs e)
435		{
436		base.OnMouseMove(e);
437		if (!toolTipRectangle.Contains(e.Location)) {
438		toolTipRectangle = Rectangle.Empty;
439		if (toolTipActive)
440		RequestToolTip(e.Location);
441		}
442		foreach (AbstractMargin margin in leftMargins) {
443		if (margin.DrawingPosition.Contains(e.X, e.Y)) {
444		this.Cursor = margin.Cursor;
445		margin.HandleMouseMove(new Point(e.X, e.Y), e.Button);
446		if (lastMouseInMargin != margin) {
447		if (lastMouseInMargin != null) {
448		lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
449		}
450		lastMouseInMargin = margin;
451		}
452		return;
453		}
454		}
455		if (lastMouseInMargin != null) {
456		lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
457		lastMouseInMargin = null;
458		}
459		if (textView.DrawingPosition.Contains(e.X, e.Y)) {
460		TextLocation realmousepos = TextView.GetLogicalPosition(e.X - TextView.DrawingPosition.X, e.Y - TextView.DrawingPosition.Y);
461		if(SelectionManager.IsSelected(Document.PositionToOffset(realmousepos)) && MouseButtons == MouseButtons.None) {
462		// mouse is hovering over a selection, so show default mouse
463		this.Cursor = Cursors.Default;
464		} else {
465		// mouse is hovering over text area, not a selection, so show the textView cursor
466		this.Cursor = textView.Cursor;
467		}
468		return;
469		}
470		this.Cursor = Cursors.Default;
471		}
472		AbstractMargin updateMargin = null;
473
474		public void Refresh(AbstractMargin margin)
475		{
476		updateMargin = margin;
477		Invalidate(updateMargin.DrawingPosition);
478		Update();
479		updateMargin = null;
480		}
481
482		protected override void OnPaintBackground(System.Windows.Forms.PaintEventArgs pevent)
483		{
484		}
485
486		protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
487		{
488		int currentXPos = 0;
489		int currentYPos = 0;
490		bool adjustScrollBars = false;
491		Graphics g = e.Graphics;
492		Rectangle clipRectangle = e.ClipRectangle;
493
494		bool isFullRepaint = clipRectangle.X == 0 && clipRectangle.Y == 0
495		&& clipRectangle.Width == this.Width && clipRectangle.Height == this.Height;
496
497		g.TextRenderingHint = this.TextEditorProperties.TextRenderingHint;
498
499		if (updateMargin != null) {
500		updateMargin.Paint(g, updateMargin.DrawingPosition);