MERGE

25 files changed, 5650 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/AbstractMargin.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/AbstractMargin.cs
new file mode 100644
index 000000000..c82ff94a0
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/AbstractMargin.cs
@@ -0,0 +1,102 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Diagnostics;
+using System.Windows;
+
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Base class for margins.
+	/// Margins don't have to derive from this class, it just helps maintaining a reference to the TextView
+	/// and the TextDocument.
+	/// AbstractMargin derives from FrameworkElement, so if you don't want to handle visual children and rendering
+	/// on your own, choose another base class for your margin!
+	/// </summary>
+	public abstract class AbstractMargin : FrameworkElement, ITextViewConnect
+	{
+		/// <summary>
+		/// TextView property.
+		/// </summary>
+		public static readonly DependencyProperty TextViewProperty =
+			DependencyProperty.Register("TextView", typeof(TextView), typeof(AbstractMargin),
+			                            new FrameworkPropertyMetadata(OnTextViewChanged));
+		
+		/// <summary>
+		/// Gets/sets the text view for which line numbers are displayed.
+		/// </summary>
+		/// <remarks>Adding a margin to <see cref="TextArea.LeftMargins"/> will automatically set this property to the text area's TextView.</remarks>
+		public TextView TextView {
+			get { return (TextView)GetValue(TextViewProperty); }
+			set { SetValue(TextViewProperty, value); }
+		}
+		
+		static void OnTextViewChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
+		{
+			AbstractMargin margin = (AbstractMargin)dp;
+			margin.wasAutoAddedToTextView = false;
+			margin.OnTextViewChanged((TextView)e.OldValue, (TextView)e.NewValue);
+		}
+		
+		// automatically set/unset TextView property using ITextViewConnect
+		bool wasAutoAddedToTextView;
+		
+		void ITextViewConnect.AddToTextView(TextView textView)
+		{
+			if (this.TextView == null) {
+				this.TextView = textView;
+				wasAutoAddedToTextView = true;
+			} else if (this.TextView != textView) {
+				throw new InvalidOperationException("This margin belongs to a different TextView.");
+			}
+		}
+		
+		void ITextViewConnect.RemoveFromTextView(TextView textView)
+		{
+			if (wasAutoAddedToTextView && this.TextView == textView) {
+				this.TextView = null;
+				Debug.Assert(!wasAutoAddedToTextView); // setting this.TextView should have unset this flag
+			}
+		}
+		
+		TextDocument document;
+		
+		/// <summary>
+		/// Gets the document associated with the margin.
+		/// </summary>
+		public TextDocument Document {
+			get { return document; }
+		}
+		
+		/// <summary>
+		/// Called when the <see cref="TextView"/> is changing.
+		/// </summary>
+		protected virtual void OnTextViewChanged(TextView oldTextView, TextView newTextView)
+		{
+			if (oldTextView != null) {
+				oldTextView.DocumentChanged -= TextViewDocumentChanged;
+			}
+			if (newTextView != null) {
+				newTextView.DocumentChanged += TextViewDocumentChanged;
+			}
+			TextViewDocumentChanged(null, null);
+		}
+		
+		void TextViewDocumentChanged(object sender, EventArgs e)
+		{
+			OnDocumentChanged(document, TextView != null ? TextView.Document : null);
+		}
+		
+		/// <summary>
+		/// Called when the <see cref="Document"/> is changing.
+		/// </summary>
+		protected virtual void OnDocumentChanged(TextDocument oldDocument, TextDocument newDocument)
+		{
+			document = newDocument;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Caret.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Caret.cs
new file mode 100644
index 000000000..fb21448e5
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Caret.cs
@@ -0,0 +1,472 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Media;
+using System.Windows.Media.TextFormatting;
+using System.Windows.Threading;
+
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Helper class with caret-related methods.
+	/// </summary>
+	public sealed class Caret
+	{
+		readonly TextArea textArea;
+		readonly TextView textView;
+		readonly CaretLayer caretAdorner;
+		bool visible;
+		
+		internal Caret(TextArea textArea)
+		{
+			this.textArea = textArea;
+			this.textView = textArea.TextView;
+			position = new TextViewPosition(1, 1, 0);
+			
+			caretAdorner = new CaretLayer(textView);
+			textView.InsertLayer(caretAdorner, KnownLayer.Caret, LayerInsertionPosition.Replace);
+			textView.VisualLinesChanged += TextView_VisualLinesChanged;
+			textView.ScrollOffsetChanged += TextView_ScrollOffsetChanged;
+		}
+		
+		void TextView_VisualLinesChanged(object sender, EventArgs e)
+		{
+			if (visible) {
+				Show();
+			}
+			// required because the visual columns might have changed if the
+			// element generators did something differently than on the last run
+			// (e.g. a FoldingSection was collapsed)
+			InvalidateVisualColumn();
+		}
+		
+		void TextView_ScrollOffsetChanged(object sender, EventArgs e)
+		{
+			if (caretAdorner != null) {
+				caretAdorner.InvalidateVisual();
+			}
+		}
+		
+		double desiredXPos = double.NaN;
+		TextViewPosition position;
+		
+		/// <summary>
+		/// Gets/Sets the position of the caret.
+		/// Retrieving this property will validate the visual column (which can be expensive).
+		/// Use the <see cref="Location"/> property instead if you don't need the visual column.
+		/// </summary>
+		public TextViewPosition Position {
+			get {
+				ValidateVisualColumn();
+				return position;
+			}
+			set {
+				if (position != value) {
+					position = value;
+					
+					storedCaretOffset = -1;
+					
+					//Debug.WriteLine("Caret position changing to " + value);
+					
+					ValidatePosition();
+					InvalidateVisualColumn();
+					RaisePositionChanged();
+					Log("Caret position changed to " + value);
+					if (visible)
+						Show();
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Gets the caret position without validating it.
+		/// </summary>
+		internal TextViewPosition NonValidatedPosition {
+			get {
+				return position;
+			}
+		}
+		
+		/// <summary>
+		/// Gets/Sets the location of the caret.
+		/// The getter of this property is faster than <see cref="Position"/> because it doesn't have
+		/// to validate the visual column.
+		/// </summary>
+		public TextLocation Location {
+			get {
+				return position.Location;
+			}
+			set {
+				this.Position = new TextViewPosition(value);
+			}
+		}
+		
+		/// <summary>
+		/// Gets/Sets the caret line.
+		/// </summary>
+		public int Line {
+			get { return position.Line; }
+			set {
+				this.Position = new TextViewPosition(value, position.Column);
+			}
+		}
+		
+		/// <summary>
+		/// Gets/Sets the caret column.
+		/// </summary>
+		public int Column {
+			get { return position.Column; }
+			set {
+				this.Position = new TextViewPosition(position.Line, value);
+			}
+		}
+		
+		/// <summary>
+		/// Gets/Sets the caret visual column.
+		/// </summary>
+		public int VisualColumn {
+			get {
+				ValidateVisualColumn();
+				return position.VisualColumn;
+			}
+			set {
+				this.Position = new TextViewPosition(position.Line, position.Column, value);
+			}
+		}
+		
+		bool isInVirtualSpace;
+		
+		/// <summary>
+		/// Gets whether the caret is in virtual space.
+		/// </summary>
+		public bool IsInVirtualSpace {
+			get {
+				ValidateVisualColumn();
+				return isInVirtualSpace;
+			}
+		}
+		
+		int storedCaretOffset;
+		
+		internal void OnDocumentChanging()
+		{
+			storedCaretOffset = this.Offset;
+			InvalidateVisualColumn();
+		}
+		
+		internal void OnDocumentChanged(DocumentChangeEventArgs e)
+		{
+			InvalidateVisualColumn();
+			if (storedCaretOffset >= 0) {
+				int newCaretOffset = e.GetNewOffset(storedCaretOffset, AnchorMovementType.Default);
+				TextDocument document = textArea.Document;
+				if (document != null) {
+					// keep visual column
+					this.Position = new TextViewPosition(document.GetLocation(newCaretOffset), position.VisualColumn);
+				}
+			}
+			storedCaretOffset = -1;
+		}
+		
+		/// <summary>
+		/// Gets/Sets the caret offset.
+		/// Setting the caret offset has the side effect of setting the <see cref="DesiredXPos"/> to NaN.
+		/// </summary>
+		public int Offset {
+			get {
+				TextDocument document = textArea.Document;
+				if (document == null) {
+					return 0;
+				} else {
+					return document.GetOffset(position.Location);
+				}
+			}
+			set {
+				TextDocument document = textArea.Document;
+				if (document != null) {
+					this.Position = new TextViewPosition(document.GetLocation(value));
+					this.DesiredXPos = double.NaN;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Gets/Sets the desired x-position of the caret, in device-independent pixels.
+		/// This property is NaN if the caret has no desired position.
+		/// </summary>
+		public double DesiredXPos {
+			get { return desiredXPos; }
+			set { desiredXPos = value; }
+		}
+		
+		void ValidatePosition()
+		{
+			if (position.Line < 1)
+				position.Line = 1;
+			if (position.Column < 1)
+				position.Column = 1;
+			if (position.VisualColumn < -1)
+				position.VisualColumn = -1;
+			TextDocument document = textArea.Document;
+			if (document != null) {
+				if (position.Line > document.LineCount) {
+					position.Line = document.LineCount;
+					position.Column = document.GetLineByNumber(position.Line).Length + 1;
+					position.VisualColumn = -1;
+				} else {
+					DocumentLine line = document.GetLineByNumber(position.Line);
+					if (position.Column > line.Length + 1) {
+						position.Column = line.Length + 1;
+						position.VisualColumn = -1;
+					}
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Event raised when the caret position has changed.
+		/// If the caret position is changed inside a document update (between BeginUpdate/EndUpdate calls),
+		/// the PositionChanged event is raised only once at the end of the document update.
+		/// </summary>
+		public event EventHandler PositionChanged;
+		
+		bool raisePositionChangedOnUpdateFinished;
+		
+		void RaisePositionChanged()
+		{
+			if (textArea.Document != null && textArea.Document.IsInUpdate) {
+				raisePositionChangedOnUpdateFinished = true;
+			} else {
+				if (PositionChanged != null) {
+					PositionChanged(this, EventArgs.Empty);
+				}
+			}
+		}
+		
+		internal void OnDocumentUpdateFinished()
+		{
+			if (raisePositionChangedOnUpdateFinished) {
+				if (PositionChanged != null) {
+					PositionChanged(this, EventArgs.Empty);
+				}
+			}
+		}
+		
+		bool visualColumnValid;
+		
+		void ValidateVisualColumn()
+		{
+			if (!visualColumnValid) {
+				TextDocument document = textArea.Document;
+				if (document != null) {
+					//Debug.WriteLine("Explicit validation of caret column");
+					var documentLine = document.GetLineByNumber(position.Line);
+					RevalidateVisualColumn(textView.GetOrConstructVisualLine(documentLine));
+				}
+			}
+		}
+		
+		void InvalidateVisualColumn()
+		{
+			visualColumnValid = false;
+		}
+		
+		/// <summary>
+		/// Validates the visual column of the caret using the specified visual line.
+		/// The visual line must contain the caret offset.
+		/// </summary>
+		void RevalidateVisualColumn(VisualLine visualLine)
+		{
+			if (visualLine == null)
+				throw new ArgumentNullException("visualLine");
+			
+			// mark column as validated
+			visualColumnValid = true;
+			
+			int caretOffset = textView.Document.GetOffset(position.Location);
+			int firstDocumentLineOffset = visualLine.FirstDocumentLine.Offset;
+			position.VisualColumn = visualLine.ValidateVisualColumn(position, textArea.Selection.EnableVirtualSpace);
+			
+			// search possible caret positions
+			int newVisualColumnForwards = visualLine.GetNextCaretPosition(position.VisualColumn - 1, LogicalDirection.Forward, CaretPositioningMode.Normal, textArea.Selection.EnableVirtualSpace);
+			// If position.VisualColumn was valid, we're done with validation.
+			if (newVisualColumnForwards != position.VisualColumn) {
+				// also search backwards so that we can pick the better match
+				int newVisualColumnBackwards = visualLine.GetNextCaretPosition(position.VisualColumn + 1, LogicalDirection.Backward, CaretPositioningMode.Normal, textArea.Selection.EnableVirtualSpace);
+				
+				if (newVisualColumnForwards < 0 && newVisualColumnBackwards < 0)
+					throw ThrowUtil.NoValidCaretPosition();
+				
+				// determine offsets for new visual column positions
+				int newOffsetForwards;
+				if (newVisualColumnForwards >= 0)
+					newOffsetForwards = visualLine.GetRelativeOffset(newVisualColumnForwards) + firstDocumentLineOffset;
+				else
+					newOffsetForwards = -1;
+				int newOffsetBackwards;
+				if (newVisualColumnBackwards >= 0)
+					newOffsetBackwards = visualLine.GetRelativeOffset(newVisualColumnBackwards) + firstDocumentLineOffset;
+				else
+					newOffsetBackwards = -1;
+				
+				int newVisualColumn, newOffset;
+				// if there's only one valid position, use it
+				if (newVisualColumnForwards < 0) {
+					newVisualColumn = newVisualColumnBackwards;
+					newOffset = newOffsetBackwards;
+				} else if (newVisualColumnBackwards < 0) {
+					newVisualColumn = newVisualColumnForwards;
+					newOffset = newOffsetForwards;
+				} else {
+					// two valid positions: find the better match
+					if (Math.Abs(newOffsetBackwards - caretOffset) < Math.Abs(newOffsetForwards - caretOffset)) {
+						// backwards is better
+						newVisualColumn = newVisualColumnBackwards;
+						newOffset = newOffsetBackwards;
+					} else {
+						// forwards is better
+						newVisualColumn = newVisualColumnForwards;
+						newOffset = newOffsetForwards;
+					}
+				}
+				this.Position = new TextViewPosition(textView.Document.GetLocation(newOffset), newVisualColumn);
+			}
+			isInVirtualSpace = (position.VisualColumn > visualLine.VisualLength);
+		}
+		
+		Rect CalcCaretRectangle(VisualLine visualLine)
+		{
+			if (!visualColumnValid) {
+				RevalidateVisualColumn(visualLine);
+			}
+			
+			TextLine textLine = visualLine.GetTextLine(position.VisualColumn);
+			double xPos = visualLine.GetTextLineVisualXPosition(textLine, position.VisualColumn);
+			double lineTop = visualLine.GetTextLineVisualYPosition(textLine, VisualYPosition.TextTop);
+			double lineBottom = visualLine.GetTextLineVisualYPosition(textLine, VisualYPosition.TextBottom);
+			
+			return new Rect(xPos,
+			                lineTop,
+			                SystemParameters.CaretWidth,
+			                lineBottom - lineTop);
+		}
+		
+		/// <summary>
+		/// Returns the caret rectangle. The coordinate system is in device-independent pixels from the top of the document.
+		/// </summary>
+		public Rect CalculateCaretRectangle()
+		{
+			if (textView != null && textView.Document != null) {
+				VisualLine visualLine = textView.GetOrConstructVisualLine(textView.Document.GetLineByNumber(position.Line));
+				return CalcCaretRectangle(visualLine);
+			} else {
+				return Rect.Empty;
+			}
+		}
+		
+		/// <summary>
+		/// Minimum distance of the caret to the view border.
+		/// </summary>
+		internal const double MinimumDistanceToViewBorder = 30;
+		
+		/// <summary>
+		/// Scrolls the text view so that the caret is visible.
+		/// </summary>
+		public void BringCaretToView()
+		{
+			BringCaretToView(MinimumDistanceToViewBorder);
+		}
+		
+		internal void BringCaretToView(double border)
+		{
+			Rect caretRectangle = CalculateCaretRectangle();
+			if (!caretRectangle.IsEmpty) {
+				caretRectangle.Inflate(border, border);
+				textView.MakeVisible(caretRectangle);
+			}
+		}
+		
+		/// <summary>
+		/// Makes the caret visible and updates its on-screen position.
+		/// </summary>
+		public void Show()
+		{
+			Log("Caret.Show()");
+			visible = true;
+			if (!showScheduled) {
+				showScheduled = true;
+				textArea.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(ShowInternal));
+			}
+		}
+		
+		bool showScheduled;
+		bool hasWin32Caret;
+		
+		void ShowInternal()
+		{
+			showScheduled = false;
+			
+			// if show was scheduled but caret hidden in the meantime
+			if (!visible)
+				return;
+			
+			if (caretAdorner != null && textView != null) {
+				VisualLine visualLine = textView.GetVisualLine(position.Line);
+				if (visualLine != null) {
+					Rect caretRect = CalcCaretRectangle(visualLine);
+					// Create Win32 caret so that Windows knows where our managed caret is. This is necessary for
+					// features like 'Follow text editing' in the Windows Magnifier.
+					if (!hasWin32Caret) {
+						hasWin32Caret = Win32.CreateCaret(textView, caretRect.Size);
+					}
+					if (hasWin32Caret) {
+						Win32.SetCaretPosition(textView, caretRect.Location - textView.ScrollOffset);
+					}
+					caretAdorner.Show(caretRect);
+					textArea.ime.UpdateCompositionWindow();
+				} else {
+					caretAdorner.Hide();
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Makes the caret invisible.
+		/// </summary>
+		public void Hide()
+		{
+			Log("Caret.Hide()");
+			visible = false;
+			if (hasWin32Caret) {
+				Win32.DestroyCaret();
+				hasWin32Caret = false;
+			}
+			if (caretAdorner != null) {
+				caretAdorner.Hide();
+			}
+		}
+		
+		[Conditional("DEBUG")]
+		static void Log(string text)
+		{
+			// commented out to make debug output less noisy - add back if there are any problems with the caret
+			//Debug.WriteLine(text);
+		}
+		
+		/// <summary>
+		/// Gets/Sets the color of the caret.
+		/// </summary>
+		public Brush CaretBrush {
+			get { return caretAdorner.CaretBrush; }
+			set { caretAdorner.CaretBrush = value; }
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretLayer.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretLayer.cs
new file mode 100644
index 000000000..105f38d16
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretLayer.cs
@@ -0,0 +1,86 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Threading;
+
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	sealed class CaretLayer : Layer
+	{
+		bool isVisible;
+		Rect caretRectangle;
+		
+		DispatcherTimer caretBlinkTimer = new DispatcherTimer();
+		bool blink;
+		
+		public CaretLayer(TextView textView) : base(textView, KnownLayer.Caret)
+		{
+			this.IsHitTestVisible = false;
+			caretBlinkTimer.Tick += new EventHandler(caretBlinkTimer_Tick);
+		}
+
+		void caretBlinkTimer_Tick(object sender, EventArgs e)
+		{
+			blink = !blink;
+			InvalidateVisual();
+		}
+		
+		public void Show(Rect caretRectangle)
+		{
+			this.caretRectangle = caretRectangle;
+			this.isVisible = true;
+			StartBlinkAnimation();
+			InvalidateVisual();
+		}
+		
+		public void Hide()
+		{
+			if (isVisible) {
+				isVisible = false;
+				StopBlinkAnimation();
+				InvalidateVisual();
+			}
+		}
+		
+		void StartBlinkAnimation()
+		{
+			TimeSpan blinkTime = Win32.CaretBlinkTime;
+			blink = true; // the caret should visible initially
+			// This is important if blinking is disabled (system reports a negative blinkTime)
+			if (blinkTime.TotalMilliseconds > 0) {
+				caretBlinkTimer.Interval = blinkTime;
+				caretBlinkTimer.Start();
+			}
+		}
+		
+		void StopBlinkAnimation()
+		{
+			caretBlinkTimer.Stop();
+		}
+		
+		internal Brush CaretBrush;
+		
+		protected override void OnRender(DrawingContext drawingContext)
+		{
+			base.OnRender(drawingContext);
+			if (isVisible && blink) {
+				Brush caretBrush = this.CaretBrush;
+				if (caretBrush == null)
+					caretBrush = (Brush)textView.GetValue(TextBlock.ForegroundProperty);
+				Rect r = new Rect(caretRectangle.X - textView.HorizontalOffset,
+				                  caretRectangle.Y - textView.VerticalOffset,
+				                  caretRectangle.Width,
+				                  caretRectangle.Height);
+				drawingContext.DrawRectangle(caretBrush, null, PixelSnapHelpers.Round(r, PixelSnapHelpers.GetPixelSize(this)));
+			}
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretNavigationCommandHandler.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretNavigationCommandHandler.cs
new file mode 100644
index 000000000..d1b812b66
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretNavigationCommandHandler.cs
@@ -0,0 +1,375 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media.TextFormatting;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	static class CaretNavigationCommandHandler
+	{
+		/// <summary>
+		/// Creates a new <see cref="TextAreaInputHandler"/> for the text area.
+		/// </summary>
+		public static TextAreaInputHandler Create(TextArea textArea)
+		{
+			TextAreaInputHandler handler = new TextAreaInputHandler(textArea);
+			handler.CommandBindings.AddRange(CommandBindings);
+			handler.InputBindings.AddRange(InputBindings);
+			return handler;
+		}
+		
+		static readonly List<CommandBinding> CommandBindings = new List<CommandBinding>();
+		static readonly List<InputBinding> InputBindings = new List<InputBinding>();
+		
+		static void AddBinding(ICommand command, ModifierKeys modifiers, Key key, ExecutedRoutedEventHandler handler)
+		{
+			CommandBindings.Add(new CommandBinding(command, handler));
+			InputBindings.Add(TextAreaDefaultInputHandler.CreateFrozenKeyBinding(command, modifiers, key));
+		}
+		
+		static CaretNavigationCommandHandler()
+		{
+			const ModifierKeys None = ModifierKeys.None;
+			const ModifierKeys Ctrl = ModifierKeys.Control;
+			const ModifierKeys Shift = ModifierKeys.Shift;
+			const ModifierKeys Alt = ModifierKeys.Alt;
+			
+			AddBinding(EditingCommands.MoveLeftByCharacter, None, Key.Left, OnMoveCaret(CaretMovementType.CharLeft));
+			AddBinding(EditingCommands.SelectLeftByCharacter, Shift, Key.Left, OnMoveCaretExtendSelection(CaretMovementType.CharLeft));
+			AddBinding(RectangleSelection.BoxSelectLeftByCharacter, Alt | Shift, Key.Left, OnMoveCaretBoxSelection(CaretMovementType.CharLeft));
+			AddBinding(EditingCommands.MoveRightByCharacter, None, Key.Right, OnMoveCaret(CaretMovementType.CharRight));
+			AddBinding(EditingCommands.SelectRightByCharacter, Shift, Key.Right, OnMoveCaretExtendSelection(CaretMovementType.CharRight));
+			AddBinding(RectangleSelection.BoxSelectRightByCharacter, Alt | Shift, Key.Right, OnMoveCaretBoxSelection(CaretMovementType.CharRight));
+			
+			AddBinding(EditingCommands.MoveLeftByWord, Ctrl, Key.Left, OnMoveCaret(CaretMovementType.WordLeft));
+			AddBinding(EditingCommands.SelectLeftByWord, Ctrl | Shift, Key.Left, OnMoveCaretExtendSelection(CaretMovementType.WordLeft));
+			AddBinding(RectangleSelection.BoxSelectLeftByWord, Ctrl | Alt | Shift, Key.Left, OnMoveCaretBoxSelection(CaretMovementType.WordLeft));
+			AddBinding(EditingCommands.MoveRightByWord, Ctrl, Key.Right, OnMoveCaret(CaretMovementType.WordRight));
+			AddBinding(EditingCommands.SelectRightByWord, Ctrl | Shift, Key.Right, OnMoveCaretExtendSelection(CaretMovementType.WordRight));
+			AddBinding(RectangleSelection.BoxSelectRightByWord, Ctrl | Alt | Shift, Key.Right, OnMoveCaretBoxSelection(CaretMovementType.WordRight));
+			
+			AddBinding(EditingCommands.MoveUpByLine, None, Key.Up, OnMoveCaret(CaretMovementType.LineUp));
+			AddBinding(EditingCommands.SelectUpByLine, Shift, Key.Up, OnMoveCaretExtendSelection(CaretMovementType.LineUp));
+			AddBinding(RectangleSelection.BoxSelectUpByLine, Alt | Shift, Key.Up, OnMoveCaretBoxSelection(CaretMovementType.LineUp));
+			AddBinding(EditingCommands.MoveDownByLine, None, Key.Down, OnMoveCaret(CaretMovementType.LineDown));
+			AddBinding(EditingCommands.SelectDownByLine, Shift, Key.Down, OnMoveCaretExtendSelection(CaretMovementType.LineDown));
+			AddBinding(RectangleSelection.BoxSelectDownByLine, Alt | Shift, Key.Down, OnMoveCaretBoxSelection(CaretMovementType.LineDown));
+			
+			AddBinding(EditingCommands.MoveDownByPage, None, Key.PageDown, OnMoveCaret(CaretMovementType.PageDown));
+			AddBinding(EditingCommands.SelectDownByPage, Shift, Key.PageDown, OnMoveCaretExtendSelection(CaretMovementType.PageDown));
+			AddBinding(EditingCommands.MoveUpByPage, None, Key.PageUp, OnMoveCaret(CaretMovementType.PageUp));
+			AddBinding(EditingCommands.SelectUpByPage, Shift, Key.PageUp, OnMoveCaretExtendSelection(CaretMovementType.PageUp));
+			
+			AddBinding(EditingCommands.MoveToLineStart, None, Key.Home, OnMoveCaret(CaretMovementType.LineStart));
+			AddBinding(EditingCommands.SelectToLineStart, Shift, Key.Home, OnMoveCaretExtendSelection(CaretMovementType.LineStart));
+			AddBinding(RectangleSelection.BoxSelectToLineStart, Alt | Shift, Key.Home, OnMoveCaretBoxSelection(CaretMovementType.LineStart));
+			AddBinding(EditingCommands.MoveToLineEnd, None, Key.End, OnMoveCaret(CaretMovementType.LineEnd));
+			AddBinding(EditingCommands.SelectToLineEnd, Shift, Key.End, OnMoveCaretExtendSelection(CaretMovementType.LineEnd));
+			AddBinding(RectangleSelection.BoxSelectToLineEnd, Alt | Shift, Key.End, OnMoveCaretBoxSelection(CaretMovementType.LineEnd));
+			
+			AddBinding(EditingCommands.MoveToDocumentStart, Ctrl, Key.Home, OnMoveCaret(CaretMovementType.DocumentStart));
+			AddBinding(EditingCommands.SelectToDocumentStart, Ctrl | Shift, Key.Home, OnMoveCaretExtendSelection(CaretMovementType.DocumentStart));
+			AddBinding(EditingCommands.MoveToDocumentEnd, Ctrl, Key.End, OnMoveCaret(CaretMovementType.DocumentEnd));
+			AddBinding(EditingCommands.SelectToDocumentEnd, Ctrl | Shift, Key.End, OnMoveCaretExtendSelection(CaretMovementType.DocumentEnd));
+			
+			CommandBindings.Add(new CommandBinding(ApplicationCommands.SelectAll, OnSelectAll));
+			
+			TextAreaDefaultInputHandler.WorkaroundWPFMemoryLeak(InputBindings);
+		}
+		
+		static void OnSelectAll(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				args.Handled = true;
+				textArea.Caret.Offset = textArea.Document.TextLength;
+				textArea.Selection = SimpleSelection.Create(textArea, 0, textArea.Document.TextLength);
+			}
+		}
+		
+		static TextArea GetTextArea(object target)
+		{
+			return target as TextArea;
+		}
+		
+		enum CaretMovementType
+		{
+			CharLeft,
+			CharRight,
+			WordLeft,
+			WordRight,
+			LineUp,
+			LineDown,
+			PageUp,
+			PageDown,
+			LineStart,
+			LineEnd,
+			DocumentStart,
+			DocumentEnd
+		}
+		
+		static ExecutedRoutedEventHandler OnMoveCaret(CaretMovementType direction)
+		{
+			return (target, args) => {
+				TextArea textArea = GetTextArea(target);
+				if (textArea != null && textArea.Document != null) {
+					args.Handled = true;
+					textArea.ClearSelection();
+					MoveCaret(textArea, direction);
+					textArea.Caret.BringCaretToView();
+				}
+			};
+		}
+		
+		static ExecutedRoutedEventHandler OnMoveCaretExtendSelection(CaretMovementType direction)
+		{
+			return (target, args) => {
+				TextArea textArea = GetTextArea(target);
+				if (textArea != null && textArea.Document != null) {
+					args.Handled = true;
+					TextViewPosition oldPosition = textArea.Caret.Position;
+					MoveCaret(textArea, direction);
+					textArea.Selection = textArea.Selection.StartSelectionOrSetEndpoint(oldPosition, textArea.Caret.Position);
+					if (!textArea.Document.IsInUpdate) // if we're inside a larger update (e.g. called by EditingCommandHandler.OnDelete()), avoid calculating the caret rectangle now
+						textArea.Caret.BringCaretToView();
+				}
+			};
+		}
+		
+		static ExecutedRoutedEventHandler OnMoveCaretBoxSelection(CaretMovementType direction)
+		{
+			return (target, args) => {
+				TextArea textArea = GetTextArea(target);
+				if (textArea != null && textArea.Document != null) {
+					args.Handled = true;
+					// First, convert the selection into a rectangle selection
+					// (this is required so that virtual space gets enabled for the caret movement)
+					if (textArea.Options.EnableRectangularSelection && !(textArea.Selection is RectangleSelection)) {
+						if (textArea.Selection.IsEmpty) {
+							textArea.Selection = new RectangleSelection(textArea, textArea.Caret.Position, textArea.Caret.Position);
+						} else {
+							// Convert normal selection to rectangle selection
+							textArea.Selection = new RectangleSelection(textArea, textArea.Selection.StartPosition, textArea.Caret.Position);
+						}
+					}
+					// Now move the caret and extend the selection
+					TextViewPosition oldPosition = textArea.Caret.Position;
+					MoveCaret(textArea, direction);
+					textArea.Selection = textArea.Selection.StartSelectionOrSetEndpoint(oldPosition, textArea.Caret.Position);
+					textArea.Caret.BringCaretToView();
+				}
+			};
+		}
+		
+		#region Caret movement
+		static void MoveCaret(TextArea textArea, CaretMovementType direction)
+		{
+			DocumentLine caretLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+			VisualLine visualLine = textArea.TextView.GetOrConstructVisualLine(caretLine);
+			TextViewPosition caretPosition = textArea.Caret.Position;
+			TextLine textLine = visualLine.GetTextLine(caretPosition.VisualColumn);
+			switch (direction) {
+				case CaretMovementType.CharLeft:
+					MoveCaretLeft(textArea, caretPosition, visualLine, CaretPositioningMode.Normal);
+					break;
+				case CaretMovementType.CharRight:
+					MoveCaretRight(textArea, caretPosition, visualLine, CaretPositioningMode.Normal);
+					break;
+				case CaretMovementType.WordLeft:
+					MoveCaretLeft(textArea, caretPosition, visualLine, CaretPositioningMode.WordStart);
+					break;
+				case CaretMovementType.WordRight:
+					MoveCaretRight(textArea, caretPosition, visualLine, CaretPositioningMode.WordStart);
+					break;
+				case CaretMovementType.LineUp:
+				case CaretMovementType.LineDown:
+				case CaretMovementType.PageUp:
+				case CaretMovementType.PageDown:
+					MoveCaretUpDown(textArea, direction, visualLine, textLine, caretPosition.VisualColumn);
+					break;
+				case CaretMovementType.DocumentStart:
+					SetCaretPosition(textArea, 0, 0);
+					break;
+				case CaretMovementType.DocumentEnd:
+					SetCaretPosition(textArea, -1, textArea.Document.TextLength);
+					break;
+				case CaretMovementType.LineStart:
+					MoveCaretToStartOfLine(textArea, visualLine);
+					break;
+				case CaretMovementType.LineEnd:
+					MoveCaretToEndOfLine(textArea, visualLine);
+					break;
+				default:
+					throw new NotSupportedException(direction.ToString());
+			}
+		}
+		#endregion
+		
+		#region Home/End
+		static void MoveCaretToStartOfLine(TextArea textArea, VisualLine visualLine)
+		{
+			int newVC = visualLine.GetNextCaretPosition(-1, LogicalDirection.Forward, CaretPositioningMode.WordStart, textArea.Selection.EnableVirtualSpace);
+			if (newVC < 0)
+				throw ThrowUtil.NoValidCaretPosition();
+			// when the caret is already at the start of the text, jump to start before whitespace
+			if (newVC == textArea.Caret.VisualColumn)
+				newVC = 0;
+			int offset = visualLine.FirstDocumentLine.Offset + visualLine.GetRelativeOffset(newVC);
+			SetCaretPosition(textArea, newVC, offset);
+		}
+		
+		static void MoveCaretToEndOfLine(TextArea textArea, VisualLine visualLine)
+		{
+			int newVC = visualLine.VisualLength;
+			int offset = visualLine.FirstDocumentLine.Offset + visualLine.GetRelativeOffset(newVC);
+			SetCaretPosition(textArea, newVC, offset);
+		}
+		#endregion
+		
+		#region By-character / By-word movement
+		static void MoveCaretRight(TextArea textArea, TextViewPosition caretPosition, VisualLine visualLine, CaretPositioningMode mode)
+		{
+			int pos = visualLine.GetNextCaretPosition(caretPosition.VisualColumn, LogicalDirection.Forward, mode, textArea.Selection.EnableVirtualSpace);
+			if (pos >= 0) {
+				SetCaretPosition(textArea, pos, visualLine.GetRelativeOffset(pos) + visualLine.FirstDocumentLine.Offset);
+			} else {
+				// move to start of next line
+				DocumentLine nextDocumentLine = visualLine.LastDocumentLine.NextLine;
+				if (nextDocumentLine != null) {
+					VisualLine nextLine = textArea.TextView.GetOrConstructVisualLine(nextDocumentLine);
+					pos = nextLine.GetNextCaretPosition(-1, LogicalDirection.Forward, mode, textArea.Selection.EnableVirtualSpace);
+					if (pos < 0)
+						throw ThrowUtil.NoValidCaretPosition();
+					SetCaretPosition(textArea, pos, nextLine.GetRelativeOffset(pos) + nextLine.FirstDocumentLine.Offset);
+				} else {
+					// at end of document
+					Debug.Assert(visualLine.LastDocumentLine.Offset + visualLine.LastDocumentLine.TotalLength == textArea.Document.TextLength);
+					SetCaretPosition(textArea, -1, textArea.Document.TextLength);
+				}
+			}
+		}
+		
+		static void MoveCaretLeft(TextArea textArea, TextViewPosition caretPosition, VisualLine visualLine, CaretPositioningMode mode)
+		{
+			int pos = visualLine.GetNextCaretPosition(caretPosition.VisualColumn, LogicalDirection.Backward, mode, textArea.Selection.EnableVirtualSpace);
+			if (pos >= 0) {
+				SetCaretPosition(textArea, pos, visualLine.GetRelativeOffset(pos) + visualLine.FirstDocumentLine.Offset);
+			} else {
+				// move to end of previous line
+				DocumentLine previousDocumentLine = visualLine.FirstDocumentLine.PreviousLine;
+				if (previousDocumentLine != null) {
+					VisualLine previousLine = textArea.TextView.GetOrConstructVisualLine(previousDocumentLine);
+					pos = previousLine.GetNextCaretPosition(previousLine.VisualLength + 1, LogicalDirection.Backward, mode, textArea.Selection.EnableVirtualSpace);
+					if (pos < 0)
+						throw ThrowUtil.NoValidCaretPosition();
+					SetCaretPosition(textArea, pos, previousLine.GetRelativeOffset(pos) + previousLine.FirstDocumentLine.Offset);
+				} else {
+					// at start of document
+					Debug.Assert(visualLine.FirstDocumentLine.Offset == 0);
+					SetCaretPosition(textArea, 0, 0);
+				}
+			}
+		}
+		#endregion
+
+		#region Line+Page up/down
+		static void MoveCaretUpDown(TextArea textArea, CaretMovementType direction, VisualLine visualLine, TextLine textLine, int caretVisualColumn)
+		{
+			// moving up/down happens using the desired visual X position
+			double xPos = textArea.Caret.DesiredXPos;
+			if (double.IsNaN(xPos))
+				xPos = visualLine.GetTextLineVisualXPosition(textLine, caretVisualColumn);
+			// now find the TextLine+VisualLine where the caret will end up in
+			VisualLine targetVisualLine = visualLine;
+			TextLine targetLine;
+			int textLineIndex = visualLine.TextLines.IndexOf(textLine);
+			switch (direction) {
+				case CaretMovementType.LineUp:
+					{
+						// Move up: move to the previous TextLine in the same visual line
+						// or move to the last TextLine of the previous visual line
+						int prevLineNumber = visualLine.FirstDocumentLine.LineNumber - 1;
+						if (textLineIndex > 0) {
+							targetLine = visualLine.TextLines[textLineIndex - 1];
+						} else if (prevLineNumber >= 1) {
+							DocumentLine prevLine = textArea.Document.GetLineByNumber(prevLineNumber);
+							targetVisualLine = textArea.TextView.GetOrConstructVisualLine(prevLine);
+							targetLine = targetVisualLine.TextLines[targetVisualLine.TextLines.Count - 1];
+						} else {
+							targetLine = null;
+						}
+						break;
+					}
+				case CaretMovementType.LineDown:
+					{
+						// Move down: move to the next TextLine in the same visual line
+						// or move to the first TextLine of the next visual line
+						int nextLineNumber = visualLine.LastDocumentLine.LineNumber + 1;
+						if (textLineIndex < visualLine.TextLines.Count - 1) {
+							targetLine = visualLine.TextLines[textLineIndex + 1];
+						} else if (nextLineNumber <= textArea.Document.LineCount) {
+							DocumentLine nextLine = textArea.Document.GetLineByNumber(nextLineNumber);
+							targetVisualLine = textArea.TextView.GetOrConstructVisualLine(nextLine);
+							targetLine = targetVisualLine.TextLines[0];
+						} else {
+							targetLine = null;
+						}
+						break;
+					}
+				case CaretMovementType.PageUp:
+				case CaretMovementType.PageDown:
+					{
+						// Page up/down: find the target line using its visual position
+						double yPos = visualLine.GetTextLineVisualYPosition(textLine, VisualYPosition.LineMiddle);
+						if (direction == CaretMovementType.PageUp)
+							yPos -= textArea.TextView.RenderSize.Height;
+						else
+							yPos += textArea.TextView.RenderSize.Height;
+						DocumentLine newLine = textArea.TextView.GetDocumentLineByVisualTop(yPos);
+						targetVisualLine = textArea.TextView.GetOrConstructVisualLine(newLine);
+						targetLine = targetVisualLine.GetTextLineByVisualYPosition(yPos);
+						break;
+					}
+				default:
+					throw new NotSupportedException(direction.ToString());
+			}
+			if (targetLine != null) {
+				double yPos = targetVisualLine.GetTextLineVisualYPosition(targetLine, VisualYPosition.LineMiddle);
+				int newVisualColumn = targetVisualLine.GetVisualColumn(new Point(xPos, yPos), textArea.Selection.EnableVirtualSpace);
+				SetCaretPosition(textArea, targetVisualLine, targetLine, newVisualColumn, false);
+				textArea.Caret.DesiredXPos = xPos;
+			}
+		}
+		#endregion
+		
+		#region SetCaretPosition
+		static void SetCaretPosition(TextArea textArea, VisualLine targetVisualLine, TextLine targetLine,
+		                             int newVisualColumn, bool allowWrapToNextLine)
+		{
+			int targetLineStartCol = targetVisualLine.GetTextLineVisualStartColumn(targetLine);
+			if (!allowWrapToNextLine && newVisualColumn >= targetLineStartCol + targetLine.Length) {
+				if (newVisualColumn <= targetVisualLine.VisualLength)
+					newVisualColumn = targetLineStartCol + targetLine.Length - 1;
+			}
+			int newOffset = targetVisualLine.GetRelativeOffset(newVisualColumn) + targetVisualLine.FirstDocumentLine.Offset;
+			SetCaretPosition(textArea, newVisualColumn, newOffset);
+		}
+		
+		static void SetCaretPosition(TextArea textArea, int newVisualColumn, int newOffset)
+		{
+			textArea.Caret.Position = new TextViewPosition(textArea.Document.GetLocation(newOffset), newVisualColumn);
+			textArea.Caret.DesiredXPos = double.NaN;
+		}
+		#endregion
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretWeakEventHandler.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretWeakEventHandler.cs
new file mode 100644
index 000000000..ebf5e4947
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/CaretWeakEventHandler.cs
@@ -0,0 +1,33 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using Tango.Scripting.Editors.Utils;
+using System;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Contains classes for handling weak events on the Caret class.
+	/// </summary>
+	public static class CaretWeakEventManager
+	{
+		/// <summary>
+		/// Handles the Caret.PositionChanged event.
+		/// </summary>
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+		public sealed class PositionChanged : WeakEventManagerBase<PositionChanged, Caret>
+		{
+			/// <inheritdoc/>
+			protected override void StartListening(Caret source)
+			{
+				source.PositionChanged += DeliverEvent;
+			}
+			
+			/// <inheritdoc/>
+			protected override void StopListening(Caret source)
+			{
+				source.PositionChanged -= DeliverEvent;
+			}
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DottedLineMargin.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DottedLineMargin.cs
new file mode 100644
index 000000000..3de848dda
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DottedLineMargin.cs
@@ -0,0 +1,63 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Windows;
+using System.Windows.Data;
+using System.Windows.Media;
+using System.Windows.Shapes;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Margin for use with the text area.
+	/// A vertical dotted line to separate the line numbers from the text view.
+	/// </summary>
+	public static class DottedLineMargin
+	{
+		static readonly object tag = new object();
+		
+		/// <summary>
+		/// Creates a vertical dotted line to separate the line numbers from the text view.
+		/// </summary>
+		public static UIElement Create()
+		{
+			Line line = new Line {
+				//X1 = 0, Y1 = 0, X2 = 0, Y2 = 1,
+				//StrokeDashArray = { 0, 2 },
+				//Stretch = Stretch.Fill,
+				//StrokeThickness = 1,
+				//StrokeDashCap = PenLineCap.Round,
+				//Margin = new Thickness(2, 0, 2, 0),
+				//Tag = tag
+			};
+			
+			return line;
+		}
+		
+		/// <summary>
+		/// Creates a vertical dotted line to separate the line numbers from the text view.
+		/// </summary>
+		[Obsolete("This method got published accidentally; and will be removed again in a future version. Use the parameterless overload instead.")]
+		public static UIElement Create(TextEditor editor)
+		{
+			Line line = (Line)Create();
+			
+			line.SetBinding(
+				Line.StrokeProperty,
+				new Binding("LineNumbersForeground") { Source = editor }
+			);
+			
+			return line;
+		}
+		
+		/// <summary>
+		/// Gets whether the specified UIElement is the result of a DottedLineMargin.Create call.
+		/// </summary>
+		public static bool IsDottedLineMargin(UIElement element)
+		{
+			Line l = element as Line;
+			return l != null && l.Tag == tag;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DragDropException.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DragDropException.cs
new file mode 100644
index 000000000..2ba8e41ec
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/DragDropException.cs
@@ -0,0 +1,46 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Wraps exceptions that occur during drag'n'drop.
+	/// Exceptions during drag'n'drop might
+	/// get swallowed by WPF/COM, so AvalonEdit catches them and re-throws them later
+	/// wrapped in a DragDropException.
+	/// </summary>
+	[Serializable()]
+	public class DragDropException : Exception
+	{
+		/// <summary>
+		/// Creates a new DragDropException.
+		/// </summary>
+		public DragDropException() : base()
+		{
+		}
+		
+		/// <summary>
+		/// Creates a new DragDropException.
+		/// </summary>
+		public DragDropException(string message) : base(message)
+		{
+		}
+		
+		/// <summary>
+		/// Creates a new DragDropException.
+		/// </summary>
+		public DragDropException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+		
+		/// <summary>
+		/// Deserializes a DragDropException.
+		/// </summary>
+		protected DragDropException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EditingCommandHandler.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EditingCommandHandler.cs
new file mode 100644
index 000000000..685e7ae31
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EditingCommandHandler.cs
@@ -0,0 +1,578 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Input;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Highlighting;
+using Tango.Scripting.Editors.Search;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// We re-use the CommandBinding and InputBinding instances between multiple text areas,
+	/// so this class is static.
+	/// </summary>
+	static class EditingCommandHandler
+	{
+		/// <summary>
+		/// Creates a new <see cref="TextAreaInputHandler"/> for the text area.
+		/// </summary>
+		public static TextAreaInputHandler Create(TextArea textArea)
+		{
+			TextAreaInputHandler handler = new TextAreaInputHandler(textArea);
+			handler.CommandBindings.AddRange(CommandBindings);
+			handler.InputBindings.AddRange(InputBindings);
+			return handler;
+		}
+		
+		static readonly List<CommandBinding> CommandBindings = new List<CommandBinding>();
+		static readonly List<InputBinding> InputBindings = new List<InputBinding>();
+		
+		static void AddBinding(ICommand command, ModifierKeys modifiers, Key key, ExecutedRoutedEventHandler handler)
+		{
+			CommandBindings.Add(new CommandBinding(command, handler));
+			InputBindings.Add(TextAreaDefaultInputHandler.CreateFrozenKeyBinding(command, modifiers, key));
+		}
+		
+		static EditingCommandHandler()
+		{
+			CommandBindings.Add(new CommandBinding(ApplicationCommands.Delete, OnDelete(ApplicationCommands.NotACommand), CanDelete));
+			AddBinding(EditingCommands.Delete, ModifierKeys.None, Key.Delete, OnDelete(EditingCommands.SelectRightByCharacter));
+			AddBinding(EditingCommands.DeleteNextWord, ModifierKeys.Control, Key.Delete, OnDelete(EditingCommands.SelectRightByWord));
+			AddBinding(EditingCommands.Backspace, ModifierKeys.None, Key.Back, OnDelete(EditingCommands.SelectLeftByCharacter));
+			InputBindings.Add(TextAreaDefaultInputHandler.CreateFrozenKeyBinding(EditingCommands.Backspace, ModifierKeys.Shift, Key.Back)); // make Shift-Backspace do the same as plain backspace
+			AddBinding(EditingCommands.DeletePreviousWord, ModifierKeys.Control, Key.Back, OnDelete(EditingCommands.SelectLeftByWord));
+			AddBinding(EditingCommands.EnterParagraphBreak, ModifierKeys.None, Key.Enter, OnEnter);
+			AddBinding(EditingCommands.EnterLineBreak, ModifierKeys.Shift, Key.Enter, OnEnter);
+			AddBinding(EditingCommands.TabForward, ModifierKeys.None, Key.Tab, OnTab);
+			AddBinding(EditingCommands.TabBackward, ModifierKeys.Shift, Key.Tab, OnShiftTab);
+			
+			CommandBindings.Add(new CommandBinding(ApplicationCommands.Copy, OnCopy, CanCutOrCopy));
+			CommandBindings.Add(new CommandBinding(ApplicationCommands.Cut, OnCut, CanCutOrCopy));
+			CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste, OnPaste, CanPaste));
+			
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.DeleteLine, OnDeleteLine));
+			
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.RemoveLeadingWhitespace, OnRemoveLeadingWhitespace));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.RemoveTrailingWhitespace, OnRemoveTrailingWhitespace));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertToUppercase, OnConvertToUpperCase));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertToLowercase, OnConvertToLowerCase));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertToTitleCase, OnConvertToTitleCase));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.InvertCase, OnInvertCase));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertTabsToSpaces, OnConvertTabsToSpaces));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertSpacesToTabs, OnConvertSpacesToTabs));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertLeadingTabsToSpaces, OnConvertLeadingTabsToSpaces));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.ConvertLeadingSpacesToTabs, OnConvertLeadingSpacesToTabs));
+			CommandBindings.Add(new CommandBinding(AvalonEditCommands.IndentSelection, OnIndentSelection));
+			
+			TextAreaDefaultInputHandler.WorkaroundWPFMemoryLeak(InputBindings);
+		}
+		
+		static TextArea GetTextArea(object target)
+		{
+			return target as TextArea;
+		}
+		
+		#region Text Transformation Helpers
+		enum DefaultSegmentType
+		{
+			None,
+			WholeDocument,
+			CurrentLine
+		}
+		
+		/// <summary>
+		/// Calls transformLine on all lines in the selected range.
+		/// transformLine needs to handle read-only segments!
+		/// </summary>
+		static void TransformSelectedLines(Action<TextArea, DocumentLine> transformLine, object target, ExecutedRoutedEventArgs args, DefaultSegmentType defaultSegmentType)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				using (textArea.Document.RunUpdate()) {
+					DocumentLine start, end;
+					if (textArea.Selection.IsEmpty) {
+						if (defaultSegmentType == DefaultSegmentType.CurrentLine) {
+							start = end = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+						} else if (defaultSegmentType == DefaultSegmentType.WholeDocument) {
+							start = textArea.Document.Lines.First();
+							end = textArea.Document.Lines.Last();
+						} else {
+							start = end = null;
+						}
+					} else {
+						ISegment segment = textArea.Selection.SurroundingSegment;
+						start = textArea.Document.GetLineByOffset(segment.Offset);
+						end = textArea.Document.GetLineByOffset(segment.EndOffset);
+						// don't include the last line if no characters on it are selected
+						if (start != end && end.Offset == segment.EndOffset)
+							end = end.PreviousLine;
+					}
+					if (start != null) {
+						transformLine(textArea, start);
+						while (start != end) {
+							start = start.NextLine;
+							transformLine(textArea, start);
+						}
+					}
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+		
+		/// <summary>
+		/// Calls transformLine on all writable segment in the selected range.
+		/// </summary>
+		static void TransformSelectedSegments(Action<TextArea, ISegment> transformSegment, object target, ExecutedRoutedEventArgs args, DefaultSegmentType defaultSegmentType)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				using (textArea.Document.RunUpdate()) {
+					IEnumerable<ISegment> segments;
+					if (textArea.Selection.IsEmpty) {
+						if (defaultSegmentType == DefaultSegmentType.CurrentLine) {
+							segments = new ISegment[] { textArea.Document.GetLineByNumber(textArea.Caret.Line) };
+						} else if (defaultSegmentType == DefaultSegmentType.WholeDocument) {
+							segments = textArea.Document.Lines.Cast<ISegment>();
+						} else {
+							segments = null;
+						}
+					} else {
+						segments = textArea.Selection.Segments.Cast<ISegment>();
+					}
+					if (segments != null) {
+						foreach (ISegment segment in segments.Reverse()) {
+							foreach (ISegment writableSegment in textArea.GetDeletableSegments(segment).Reverse()) {
+								transformSegment(textArea, writableSegment);
+							}
+						}
+					}
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+		#endregion
+		
+		#region EnterLineBreak
+		static void OnEnter(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.IsKeyboardFocused) {
+				textArea.PerformTextInput("\n");
+				args.Handled = true;
+			}
+		}
+		#endregion
+		
+		#region Tab
+		static void OnTab(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				using (textArea.Document.RunUpdate()) {
+					if (textArea.Selection.IsMultiline) {
+						var segment = textArea.Selection.SurroundingSegment;
+						DocumentLine start = textArea.Document.GetLineByOffset(segment.Offset);
+						DocumentLine end = textArea.Document.GetLineByOffset(segment.EndOffset);
+						// don't include the last line if no characters on it are selected
+						if (start != end && end.Offset == segment.EndOffset)
+							end = end.PreviousLine;
+						DocumentLine current = start;
+						while (true) {
+							int offset = current.Offset;
+							if (textArea.ReadOnlySectionProvider.CanInsert(offset))
+								textArea.Document.Replace(offset, 0, textArea.Options.IndentationString, OffsetChangeMappingType.KeepAnchorBeforeInsertion);
+							if (current == end)
+								break;
+							current = current.NextLine;
+						}
+					} else {
+						string indentationString = textArea.Options.GetIndentationString(textArea.Caret.Column);
+						textArea.ReplaceSelectionWithText(indentationString);
+					}
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+		
+		static void OnShiftTab(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedLines(
+				delegate (TextArea textArea, DocumentLine line) {
+					int offset = line.Offset;
+					ISegment s = TextUtilities.GetSingleIndentationSegment(textArea.Document, offset, textArea.Options.IndentationSize);
+					if (s.Length > 0) {
+						s = textArea.GetDeletableSegments(s).FirstOrDefault();
+						if (s != null && s.Length > 0) {
+							textArea.Document.Remove(s.Offset, s.Length);
+						}
+					}
+				}, target, args, DefaultSegmentType.CurrentLine);
+		}
+		#endregion
+		
+		#region Delete
+		static ExecutedRoutedEventHandler OnDelete(RoutedUICommand selectingCommand)
+		{
+			return (target, args) => {
+				TextArea textArea = GetTextArea(target);
+				if (textArea != null && textArea.Document != null) {
+					// call BeginUpdate before running the 'selectingCommand'
+					// so that undoing the delete does not select the deleted character
+					using (textArea.Document.RunUpdate()) {
+						if (textArea.Selection.IsEmpty) {
+							TextViewPosition oldCaretPosition = textArea.Caret.Position;
+							if (textArea.Caret.IsInVirtualSpace && selectingCommand == EditingCommands.SelectRightByCharacter)
+								EditingCommands.SelectRightByWord.Execute(args.Parameter, textArea);
+							else
+								selectingCommand.Execute(args.Parameter, textArea);
+							bool hasSomethingDeletable = false;
+							foreach (ISegment s in textArea.Selection.Segments) {
+								if (textArea.GetDeletableSegments(s).Length > 0) {
+									hasSomethingDeletable = true;
+									break;
+								}
+							}
+							if (!hasSomethingDeletable) {
+								// If nothing in the selection is deletable; then reset caret+selection
+								// to the previous value. This prevents the caret from moving through read-only sections.
+								textArea.Caret.Position = oldCaretPosition;
+								textArea.ClearSelection();
+							}
+						}
+						textArea.RemoveSelectedText();
+					}
+					textArea.Caret.BringCaretToView();
+					args.Handled = true;
+				}
+			};
+		}
+		
+		static void CanDelete(object target, CanExecuteRoutedEventArgs args)
+		{
+			// HasSomethingSelected for delete command
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				args.CanExecute = !textArea.Selection.IsEmpty;
+				args.Handled = true;
+			}
+		}
+		#endregion
+		
+		#region Clipboard commands
+		static void CanCutOrCopy(object target, CanExecuteRoutedEventArgs args)
+		{
+			// HasSomethingSelected for copy and cut commands
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				args.CanExecute = textArea.Options.CutCopyWholeLine || !textArea.Selection.IsEmpty;
+				args.Handled = true;
+			}
+		}
+		
+		static void OnCopy(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				if (textArea.Selection.IsEmpty && textArea.Options.CutCopyWholeLine) {
+					DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+					CopyWholeLine(textArea, currentLine);
+				} else {
+					CopySelectedText(textArea);
+				}
+				args.Handled = true;
+			}
+		}
+		
+		static void OnCut(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				if (textArea.Selection.IsEmpty && textArea.Options.CutCopyWholeLine) {
+					DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+					CopyWholeLine(textArea, currentLine);
+					ISegment[] segmentsToDelete = textArea.GetDeletableSegments(new SimpleSegment(currentLine.Offset, currentLine.TotalLength));
+					for (int i = segmentsToDelete.Length - 1; i >= 0; i--) {
+						textArea.Document.Remove(segmentsToDelete[i]);
+					}
+				} else {
+					CopySelectedText(textArea);
+					textArea.RemoveSelectedText();
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+		
+		static void CopySelectedText(TextArea textArea)
+		{
+			var data = textArea.Selection.CreateDataObject(textArea);
+			
+			try {
+				Clipboard.SetDataObject(data, true);
+			} catch (ExternalException) {
+				// Apparently this exception sometimes happens randomly.
+				// The MS controls just ignore it, so we'll do the same.
+				return;
+			}
+			
+			string text = textArea.Selection.GetText();
+			text = TextUtilities.NormalizeNewLines(text, Environment.NewLine);
+			textArea.OnTextCopied(new TextEventArgs(text));
+		}
+		
+		const string LineSelectedType = "MSDEVLineSelect";  // This is the type VS 2003 and 2005 use for flagging a whole line copy
+		
+		static void CopyWholeLine(TextArea textArea, DocumentLine line)
+		{
+			ISegment wholeLine = new SimpleSegment(line.Offset, line.TotalLength);
+			string text = textArea.Document.GetText(wholeLine);
+			// Ensure we use the appropriate newline sequence for the OS
+			text = TextUtilities.NormalizeNewLines(text, Environment.NewLine);
+			DataObject data = new DataObject(text);
+			
+			// Also copy text in HTML format to clipboard - good for pasting text into Word
+			// or to the SharpDevelop forums.
+			IHighlighter highlighter = textArea.GetService(typeof(IHighlighter)) as IHighlighter;
+			HtmlClipboard.SetHtml(data, HtmlClipboard.CreateHtmlFragment(textArea.Document, highlighter, wholeLine, new HtmlOptions(textArea.Options)));
+			
+			MemoryStream lineSelected = new MemoryStream(1);
+			lineSelected.WriteByte(1);
+			data.SetData(LineSelectedType, lineSelected, false);
+			
+			try {
+				Clipboard.SetDataObject(data, true);
+			} catch (ExternalException) {
+				// Apparently this exception sometimes happens randomly.
+				// The MS controls just ignore it, so we'll do the same.
+				return;
+			}
+			textArea.OnTextCopied(new TextEventArgs(text));
+		}
+		
+		static void CanPaste(object target, CanExecuteRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				args.CanExecute = textArea.ReadOnlySectionProvider.CanInsert(textArea.Caret.Offset)
+					&& Clipboard.ContainsText();
+				// WPF Clipboard.ContainsText() is safe to call without catching ExternalExceptions
+				// because it doesn't try to lock the clipboard - it just peeks inside with IsClipboardFormatAvailable().
+				args.Handled = true;
+			}
+		}
+		
+		static void OnPaste(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				IDataObject dataObject;
+				try {
+					dataObject = Clipboard.GetDataObject();
+				} catch (ExternalException) {
+					return;
+				}
+				if (dataObject == null)
+					return;
+				Debug.WriteLine( dataObject.GetData(DataFormats.Html) as string );
+				
+				// convert text back to correct newlines for this document
+				string newLine = TextUtilities.GetNewLineFromDocument(textArea.Document, textArea.Caret.Line);
+				string text;
+				try {
+					text = (string)dataObject.GetData(DataFormats.UnicodeText);
+					text = TextUtilities.NormalizeNewLines(text, newLine);
+				} catch (OutOfMemoryException) {
+					return;
+				}
+				
+				if (!string.IsNullOrEmpty(text)) {
+					bool fullLine = textArea.Options.CutCopyWholeLine && dataObject.GetDataPresent(LineSelectedType);
+					bool rectangular = dataObject.GetDataPresent(RectangleSelection.RectangularSelectionDataType);
+					if (fullLine) {
+						DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+						if (textArea.ReadOnlySectionProvider.CanInsert(currentLine.Offset)) {
+							textArea.Document.Insert(currentLine.Offset, text);
+						}
+					} else if (rectangular && textArea.Selection.IsEmpty && !(textArea.Selection is RectangleSelection)) {
+						if (!RectangleSelection.PerformRectangularPaste(textArea, textArea.Caret.Position, text, false))
+							textArea.ReplaceSelectionWithText(text);
+					} else {
+						textArea.ReplaceSelectionWithText(text);
+					}
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+		#endregion
+		
+		#region DeleteLine
+		static void OnDeleteLine(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
+				textArea.Selection = Selection.Create(textArea, currentLine.Offset, currentLine.Offset + currentLine.TotalLength);
+				textArea.RemoveSelectedText();
+				args.Handled = true;
+			}
+		}
+		#endregion
+		
+		#region Remove..Whitespace / Convert Tabs-Spaces
+		static void OnRemoveLeadingWhitespace(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedLines(
+				delegate (TextArea textArea, DocumentLine line) {
+					textArea.Document.Remove(TextUtilities.GetLeadingWhitespace(textArea.Document, line));
+				}, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void OnRemoveTrailingWhitespace(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedLines(
+				delegate (TextArea textArea, DocumentLine line) {
+					textArea.Document.Remove(TextUtilities.GetTrailingWhitespace(textArea.Document, line));
+				}, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void OnConvertTabsToSpaces(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedSegments(ConvertTabsToSpaces, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void OnConvertLeadingTabsToSpaces(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedLines(
+				delegate (TextArea textArea, DocumentLine line) {
+					ConvertTabsToSpaces(textArea, TextUtilities.GetLeadingWhitespace(textArea.Document, line));
+				}, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void ConvertTabsToSpaces(TextArea textArea, ISegment segment)
+		{
+			TextDocument document = textArea.Document;
+			int endOffset = segment.EndOffset;
+			string indentationString = new string(' ', textArea.Options.IndentationSize);
+			for (int offset = segment.Offset; offset < endOffset; offset++) {
+				if (document.GetCharAt(offset) == '\t') {
+					document.Replace(offset, 1, indentationString, OffsetChangeMappingType.CharacterReplace);
+					endOffset += indentationString.Length - 1;
+				}
+			}
+		}
+		
+		static void OnConvertSpacesToTabs(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedSegments(ConvertSpacesToTabs, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void OnConvertLeadingSpacesToTabs(object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedLines(
+				delegate (TextArea textArea, DocumentLine line) {
+					ConvertSpacesToTabs(textArea, TextUtilities.GetLeadingWhitespace(textArea.Document, line));
+				}, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void ConvertSpacesToTabs(TextArea textArea, ISegment segment)
+		{
+			TextDocument document = textArea.Document;
+			int endOffset = segment.EndOffset;
+			int indentationSize = textArea.Options.IndentationSize;
+			int spacesCount = 0;
+			for (int offset = segment.Offset; offset < endOffset; offset++) {
+				if (document.GetCharAt(offset) == ' ') {
+					spacesCount++;
+					if (spacesCount == indentationSize) {
+						document.Replace(offset - (indentationSize - 1), indentationSize, "\t", OffsetChangeMappingType.CharacterReplace);
+						spacesCount = 0;
+						offset -= indentationSize - 1;
+						endOffset -= indentationSize - 1;
+					}
+				} else {
+					spacesCount = 0;
+				}
+			}
+		}
+		#endregion
+		
+		#region Convert...Case
+		static void ConvertCase(Func<string, string> transformText, object target, ExecutedRoutedEventArgs args)
+		{
+			TransformSelectedSegments(
+				delegate (TextArea textArea, ISegment segment) {
+					string oldText = textArea.Document.GetText(segment);
+					string newText = transformText(oldText);
+					textArea.Document.Replace(segment.Offset, segment.Length, newText, OffsetChangeMappingType.CharacterReplace);
+				}, target, args, DefaultSegmentType.WholeDocument);
+		}
+		
+		static void OnConvertToUpperCase(object target, ExecutedRoutedEventArgs args)
+		{
+			ConvertCase(CultureInfo.CurrentCulture.TextInfo.ToUpper, target, args);
+		}
+		
+		static void OnConvertToLowerCase(object target, ExecutedRoutedEventArgs args)
+		{
+			ConvertCase(CultureInfo.CurrentCulture.TextInfo.ToLower, target, args);
+		}
+		
+		static void OnConvertToTitleCase(object target, ExecutedRoutedEventArgs args)
+		{
+			ConvertCase(CultureInfo.CurrentCulture.TextInfo.ToTitleCase, target, args);
+		}
+		
+		static void OnInvertCase(object target, ExecutedRoutedEventArgs args)
+		{
+			ConvertCase(InvertCase, target, args);
+		}
+		
+		static string InvertCase(string text)
+		{
+			CultureInfo culture = CultureInfo.CurrentCulture;
+			char[] buffer = text.ToCharArray();
+			for (int i = 0; i < buffer.Length; ++i) {
+				char c = buffer[i];
+				buffer[i] = char.IsUpper(c) ? char.ToLower(c, culture) : char.ToUpper(c, culture);
+			}
+			return new string(buffer);
+		}
+		#endregion
+		
+		static void OnIndentSelection(object target, ExecutedRoutedEventArgs args)
+		{
+			TextArea textArea = GetTextArea(target);
+			if (textArea != null && textArea.Document != null) {
+				using (textArea.Document.RunUpdate()) {
+					int start, end;
+					if (textArea.Selection.IsEmpty) {
+						start = 1;
+						end = textArea.Document.LineCount;
+					} else {
+						start = textArea.Document.GetLineByOffset(textArea.Selection.SurroundingSegment.Offset).LineNumber;
+						end = textArea.Document.GetLineByOffset(textArea.Selection.SurroundingSegment.EndOffset).LineNumber;
+					}
+					textArea.IndentationStrategy.IndentLines(textArea.Document, start, end);
+				}
+				textArea.Caret.BringCaretToView();
+				args.Handled = true;
+			}
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EmptySelection.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EmptySelection.cs
new file mode 100644
index 000000000..6cca63ecb
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/EmptySelection.cs
@@ -0,0 +1,85 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	sealed class EmptySelection : Selection
+	{
+		public EmptySelection(TextArea textArea) : base(textArea)
+		{
+		}
+		
+		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
+		{
+			return this;
+		}
+		
+		public override TextViewPosition StartPosition {
+			get { return new TextViewPosition(TextLocation.Empty); }
+		}
+		
+		public override TextViewPosition EndPosition {
+			get { return new TextViewPosition(TextLocation.Empty); }
+		}
+		
+		public override ISegment SurroundingSegment {
+			get { return null; }
+		}
+		
+		public override Selection SetEndpoint(TextViewPosition endPosition)
+		{
+			throw new NotSupportedException();
+		}
+		
+		public override Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition)
+		{
+			var document = textArea.Document;
+			if (document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			return Create(textArea, startPosition, endPosition);
+		}
+		
+		public override IEnumerable<SelectionSegment> Segments {
+			get { return Empty<SelectionSegment>.Array; }
+		}
+		
+		public override string GetText()
+		{
+			return string.Empty;
+		}
+		
+		public override void ReplaceSelectionWithText(string newText)
+		{
+			if (newText == null)
+				throw new ArgumentNullException("newText");
+			newText = AddSpacesIfRequired(newText, textArea.Caret.Position, textArea.Caret.Position);
+			if (newText.Length > 0) {
+				if (textArea.ReadOnlySectionProvider.CanInsert(textArea.Caret.Offset)) {
+					textArea.Document.Insert(textArea.Caret.Offset, newText);
+				}
+			}
+			textArea.Caret.VisualColumn = -1;
+		}
+		
+		public override int Length {
+			get { return 0; }
+		}
+		
+		// Use reference equality because there's only one EmptySelection per text area.
+		public override int GetHashCode()
+		{
+			return RuntimeHelpers.GetHashCode(this);
+		}
+		
+		public override bool Equals(object obj)
+		{
+			return this == obj;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/IReadOnlySectionProvider.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/IReadOnlySectionProvider.cs
new file mode 100644
index 000000000..fc775baf3
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/IReadOnlySectionProvider.cs
@@ -0,0 +1,32 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using Tango.Scripting.Editors.Document;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Determines whether the document can be modified.
+	/// </summary>
+	public interface IReadOnlySectionProvider
+	{
+		/// <summary>
+		/// Gets whether insertion is possible at the specified offset.
+		/// </summary>
+		bool CanInsert(int offset);
+		
+		/// <summary>
+		/// Gets the deletable segments inside the given segment.
+		/// </summary>
+		/// <remarks>
+		/// All segments in the result must be within the given segment, and they must be returned in order
+		/// (e.g. if two segments are returned, EndOffset of first segment must be less than StartOffset of second segment).
+		/// 
+		/// For replacements, the last segment being returned will be replaced with the new text. If an empty list is returned,
+		/// no replacement will be done.
+		/// </remarks>
+		IEnumerable<ISegment> GetDeletableSegments(ISegment segment);
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeNativeWrapper.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeNativeWrapper.cs
new file mode 100644
index 000000000..bc2c6f5e4
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeNativeWrapper.cs
@@ -0,0 +1,206 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.TextFormatting;
+
+using Tango.Scripting.Editors;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+using Draw = System.Drawing;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Native API required for IME support.
+	/// </summary>
+	static class ImeNativeWrapper
+	{
+		[StructLayout(LayoutKind.Sequential)]
+		struct CompositionForm
+		{
+			public int dwStyle;
+			public POINT ptCurrentPos;
+			public RECT rcArea;
+		}
+		
+		[StructLayout(LayoutKind.Sequential)]
+		struct POINT
+		{
+			public int x;
+			public int y;
+		}
+		
+		[StructLayout(LayoutKind.Sequential)]
+		struct RECT
+		{
+			public int left;
+			public int top;
+			public int right;
+			public int bottom;
+		}
+		
+		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+		struct LOGFONT
+		{
+			public int lfHeight;
+			public int lfWidth;
+			public int lfEscapement;
+			public int lfOrientation;
+			public int lfWeight;
+			public byte lfItalic;
+			public byte lfUnderline;
+			public byte lfStrikeOut;
+			public byte lfCharSet;
+			public byte lfOutPrecision;
+			public byte lfClipPrecision;
+			public byte lfQuality;
+			public byte lfPitchAndFamily;
+			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)] public string lfFaceName;
+		}
+		
+		const int CPS_CANCEL = 0x4;
+		const int NI_COMPOSITIONSTR = 0x15;
+		const int GCS_COMPSTR = 0x0008;
+		
+		public const int WM_IME_COMPOSITION = 0x10F;
+		public const int WM_IME_SETCONTEXT = 0x281;
+		public const int WM_INPUTLANGCHANGE = 0x51;
+		
+		[DllImport("imm32.dll")]
+		public static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hIMC);
+		[DllImport("imm32.dll")]
+		internal static extern IntPtr ImmGetContext(IntPtr hWnd);
+		[DllImport("imm32.dll")]
+		internal static extern IntPtr ImmGetDefaultIMEWnd(IntPtr hWnd);
+		[DllImport("imm32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		internal static extern bool ImmReleaseContext(IntPtr hWnd, IntPtr hIMC);
+		[DllImport("imm32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool ImmNotifyIME(IntPtr hIMC, int dwAction, int dwIndex, int dwValue = 0);
+		[DllImport("imm32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool ImmSetCompositionWindow(IntPtr hIMC, ref CompositionForm form);
+		[DllImport("imm32.dll", CharSet = CharSet.Unicode)]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool ImmSetCompositionFont(IntPtr hIMC, ref LOGFONT font);
+		[DllImport("imm32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool ImmGetCompositionFont(IntPtr hIMC, out LOGFONT font);
+		
+		[DllImport("msctf.dll")]
+		static extern int TF_CreateThreadMgr(out ITfThreadMgr threadMgr);
+		
+		[ThreadStatic] static bool textFrameworkThreadMgrInitialized;
+		[ThreadStatic] static ITfThreadMgr textFrameworkThreadMgr;
+		
+		public static ITfThreadMgr GetTextFrameworkThreadManager()
+		{
+			if (!textFrameworkThreadMgrInitialized) {
+				textFrameworkThreadMgrInitialized = true;
+				TF_CreateThreadMgr(out textFrameworkThreadMgr);
+			}
+			return textFrameworkThreadMgr;
+		}
+		
+		public static bool NotifyIme(IntPtr hIMC)
+		{
+			return ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL);
+		}
+		
+		public static bool SetCompositionWindow(HwndSource source, IntPtr hIMC, TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			Rect textViewBounds = textArea.TextView.GetBounds(source);
+			Rect characterBounds = textArea.TextView.GetCharacterBounds(textArea.Caret.Position, source);
+			CompositionForm form = new CompositionForm();
+			form.dwStyle = 0x0020;
+			form.ptCurrentPos.x = (int)Math.Max(characterBounds.Left, textViewBounds.Left);
+			form.ptCurrentPos.y = (int)Math.Max(characterBounds.Top, textViewBounds.Top);
+			form.rcArea.left = (int)textViewBounds.Left;
+			form.rcArea.top = (int)textViewBounds.Top;
+			form.rcArea.right = (int)textViewBounds.Right;
+			form.rcArea.bottom = (int)textViewBounds.Bottom;
+			return ImmSetCompositionWindow(hIMC, ref form);
+		}
+		
+		public static bool SetCompositionFont(HwndSource source, IntPtr hIMC, TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			LOGFONT lf = new LOGFONT();
+			Rect characterBounds = textArea.TextView.GetCharacterBounds(textArea.Caret.Position, source);
+			lf.lfFaceName = textArea.FontFamily.Source;
+			lf.lfHeight = (int)characterBounds.Height;
+			return ImmSetCompositionFont(hIMC, ref lf);
+		}
+		
+		static Rect GetBounds(this TextView textView, HwndSource source)
+		{
+			// this may happen during layout changes in AvalonDock, so we just return an empty rectangle
+			// in those cases. It should be refreshed immediately.
+			if (source.RootVisual == null || !source.RootVisual.IsAncestorOf(textView))
+				return EMPTY_RECT;
+			Rect displayRect = new Rect(0, 0, textView.ActualWidth, textView.ActualHeight);
+			return textView
+				.TransformToAncestor(source.RootVisual).TransformBounds(displayRect) // rect on root visual
+				.TransformToDevice(source.RootVisual); // rect on HWND
+		}
+		
+		static readonly Rect EMPTY_RECT = new Rect(0, 0, 0, 0);
+		
+		static Rect GetCharacterBounds(this TextView textView, TextViewPosition pos, HwndSource source)
+		{
+			VisualLine vl = textView.GetVisualLine(pos.Line);
+			if (vl == null)
+				return EMPTY_RECT;
+			// this may happen during layout changes in AvalonDock, so we just return an empty rectangle
+			// in those cases. It should be refreshed immediately.
+			if (source.RootVisual == null || !source.RootVisual.IsAncestorOf(textView))
+				return EMPTY_RECT;
+			TextLine line = vl.GetTextLine(pos.VisualColumn);
+			Rect displayRect;
+			// calculate the display rect for the current character
+			if (pos.VisualColumn < vl.VisualLengthWithEndOfLineMarker) {
+				displayRect = line.GetTextBounds(pos.VisualColumn, 1).First().Rectangle;
+				displayRect.Offset(0, vl.GetTextLineVisualYPosition(line, VisualYPosition.LineTop));
+			} else {
+				// if we are in virtual space, we just use one wide-space as character width
+				displayRect = new Rect(vl.GetVisualPosition(pos.VisualColumn, VisualYPosition.TextTop),
+				                       new Size(textView.WideSpaceWidth, textView.DefaultLineHeight));
+			}
+			// adjust to current scrolling
+			displayRect.Offset(-textView.ScrollOffset);
+			return textView
+				.TransformToAncestor(source.RootVisual).TransformBounds(displayRect) // rect on root visual
+				.TransformToDevice(source.RootVisual); // rect on HWND
+		}
+	}
+	
+	[ComImport, Guid("aa80e801-2021-11d2-93e0-0060b067b86e"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	interface ITfThreadMgr
+	{
+		void Activate(out int clientId);
+		void Deactivate();
+		void CreateDocumentMgr(out IntPtr docMgr);
+		void EnumDocumentMgrs(out IntPtr enumDocMgrs);
+		void GetFocus(out IntPtr docMgr);
+		void SetFocus(IntPtr docMgr);
+		void AssociateFocus(IntPtr hwnd, IntPtr newDocMgr, out IntPtr prevDocMgr);
+		void IsThreadFocus([MarshalAs(UnmanagedType.Bool)] out bool isFocus);
+		void GetFunctionProvider(ref Guid classId, out IntPtr funcProvider);
+		void EnumFunctionProviders(out IntPtr enumProviders);
+		void GetGlobalCompartment(out IntPtr compartmentMgr);
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeSupport.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeSupport.cs
new file mode 100644
index 000000000..ad4c22e10
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/ImeSupport.cs
@@ -0,0 +1,150 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.TextFormatting;
+using Tango.Scripting.Editors;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	class ImeSupport
+	{
+		readonly TextArea textArea;
+		IntPtr currentContext;
+		IntPtr previousContext;
+		IntPtr defaultImeWnd;
+		HwndSource hwndSource;
+		EventHandler requerySuggestedHandler; // we need to keep the event handler instance alive because CommandManager.RequerySuggested uses weak references
+		bool isReadOnly;
+		
+		public ImeSupport(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+			InputMethod.SetIsInputMethodSuspended(this.textArea, textArea.Options.EnableImeSupport);
+			// We listen to CommandManager.RequerySuggested for both caret offset changes and changes to the set of read-only sections.
+			// This is because there's no dedicated event for read-only section changes; but RequerySuggested needs to be raised anyways
+			// to invalidate the Paste command.
+			requerySuggestedHandler = OnRequerySuggested;
+			CommandManager.RequerySuggested += requerySuggestedHandler;
+			textArea.OptionChanged += TextAreaOptionChanged;
+		}
+
+		void OnRequerySuggested(object sender, EventArgs e)
+		{
+			UpdateImeEnabled();
+		}
+		
+		void TextAreaOptionChanged(object sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName == "EnableImeSupport") {
+				InputMethod.SetIsInputMethodSuspended(this.textArea, textArea.Options.EnableImeSupport);
+				UpdateImeEnabled();
+			}
+		}
+		
+		public void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e)
+		{
+			UpdateImeEnabled();
+		}
+		
+		public void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e)
+		{
+			if (e.OldFocus == textArea && currentContext != IntPtr.Zero)
+				ImeNativeWrapper.NotifyIme(currentContext);
+			ClearContext();
+		}
+		
+		void UpdateImeEnabled()
+		{
+			if (textArea.Options.EnableImeSupport && textArea.IsKeyboardFocused) {
+				bool newReadOnly = !textArea.ReadOnlySectionProvider.CanInsert(textArea.Caret.Offset);
+				if (hwndSource == null || isReadOnly != newReadOnly) {
+					ClearContext(); // clear existing context (on read-only change)
+					isReadOnly = newReadOnly;
+					CreateContext();
+				}
+			} else {
+				ClearContext();
+			}
+		}
+		
+		void ClearContext()
+		{
+			if (hwndSource != null) {
+				ImeNativeWrapper.ImmAssociateContext(hwndSource.Handle, previousContext);
+				ImeNativeWrapper.ImmReleaseContext(defaultImeWnd, currentContext);
+				currentContext = IntPtr.Zero;
+				defaultImeWnd = IntPtr.Zero;
+				hwndSource.RemoveHook(WndProc);
+				hwndSource = null;
+			}
+		}
+		
+		void CreateContext()
+		{
+			hwndSource = (HwndSource)PresentationSource.FromVisual(this.textArea);
+			if (hwndSource != null) {
+				if (isReadOnly) {
+					defaultImeWnd = IntPtr.Zero;
+					currentContext = IntPtr.Zero;
+				} else {
+					defaultImeWnd = ImeNativeWrapper.ImmGetDefaultIMEWnd(IntPtr.Zero);
+					currentContext = ImeNativeWrapper.ImmGetContext(defaultImeWnd);
+				}
+				previousContext = ImeNativeWrapper.ImmAssociateContext(hwndSource.Handle, currentContext);
+				hwndSource.AddHook(WndProc);
+				// UpdateCompositionWindow() will be called by the caret becoming visible
+				
+				var threadMgr = ImeNativeWrapper.GetTextFrameworkThreadManager();
+				if (threadMgr != null) {
+					// Even though the docu says passing null is invalid, this seems to help
+					// activating the IME on the default input context that is shared with WPF
+					threadMgr.SetFocus(IntPtr.Zero);
+				}
+			}
+		}
+		
+		IntPtr WndProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+		{
+			switch (msg) {
+				case ImeNativeWrapper.WM_INPUTLANGCHANGE:
+					// Don't mark the message as handled; other windows
+					// might want to handle it as well.
+					
+					// If we have a context, recreate it
+					if (hwndSource != null) {
+						ClearContext();
+						CreateContext();
+					}
+					break;
+				case ImeNativeWrapper.WM_IME_COMPOSITION:
+					UpdateCompositionWindow();
+					break;
+			}
+			return IntPtr.Zero;
+		}
+		
+		public void UpdateCompositionWindow()
+		{
+			if (currentContext != IntPtr.Zero) {
+				ImeNativeWrapper.SetCompositionFont(hwndSource, currentContext, textArea);
+				ImeNativeWrapper.SetCompositionWindow(hwndSource, currentContext, textArea);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/LineNumberMargin.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/LineNumberMargin.cs
new file mode 100644
index 000000000..3da96b08c
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/LineNumberMargin.cs
@@ -0,0 +1,243 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.TextFormatting;
+
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Margin showing line numbers.
+	/// </summary>
+	public class LineNumberMargin : AbstractMargin, IWeakEventListener
+	{
+        public Brush Foreground
+        {
+            get { return (Brush)GetValue(ForegroundProperty); }
+            set { SetValue(ForegroundProperty, value); }
+        }
+        public static readonly DependencyProperty ForegroundProperty =
+            DependencyProperty.Register("Foreground", typeof(Brush), typeof(LineNumberMargin), new PropertyMetadata(Brushes.Gray));
+
+
+
+        static LineNumberMargin()
+		{
+			DefaultStyleKeyProperty.OverrideMetadata(typeof(LineNumberMargin),
+			                                         new FrameworkPropertyMetadata(typeof(LineNumberMargin)));
+		}
+		
+		TextArea textArea;
+		
+		Typeface typeface;
+		double emSize;
+		
+		/// <inheritdoc/>
+		protected override Size MeasureOverride(Size availableSize)
+		{
+			typeface = this.CreateTypeface();
+			emSize = (double)GetValue(TextBlock.FontSizeProperty);
+			
+			FormattedText text = TextFormatterFactory.CreateFormattedText(
+				this,
+				new string('9', maxLineNumberLength),
+				typeface,
+				emSize,
+				Foreground
+			);
+			return new Size(text.Width, 0);
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnRender(DrawingContext drawingContext)
+		{
+			TextView textView = this.TextView;
+			Size renderSize = this.RenderSize;
+			if (textView != null && textView.VisualLinesValid) {
+                var foreground = Foreground;
+				foreach (VisualLine line in textView.VisualLines) {
+					int lineNumber = line.FirstDocumentLine.LineNumber;
+					FormattedText text = TextFormatterFactory.CreateFormattedText(
+						this,
+						lineNumber.ToString(CultureInfo.CurrentCulture),
+						typeface, emSize, foreground
+					);
+					double y = line.GetTextLineVisualYPosition(line.TextLines[0], VisualYPosition.TextTop);
+					drawingContext.DrawText(text, new Point((renderSize.Width / 2) - text.Width + 5, y - textView.VerticalOffset));
+				}
+			}
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnTextViewChanged(TextView oldTextView, TextView newTextView)
+		{
+			if (oldTextView != null) {
+				oldTextView.VisualLinesChanged -= TextViewVisualLinesChanged;
+			}
+			base.OnTextViewChanged(oldTextView, newTextView);
+			if (newTextView != null) {
+				newTextView.VisualLinesChanged += TextViewVisualLinesChanged;
+				
+				// find the text area belonging to the new text view
+				textArea = newTextView.Services.GetService(typeof(TextArea)) as TextArea;
+			} else {
+				textArea = null;
+			}
+			InvalidateVisual();
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnDocumentChanged(TextDocument oldDocument, TextDocument newDocument)
+		{
+			if (oldDocument != null) {
+				PropertyChangedEventManager.RemoveListener(oldDocument, this, "LineCount");
+			}
+			base.OnDocumentChanged(oldDocument, newDocument);
+			if (newDocument != null) {
+				PropertyChangedEventManager.AddListener(newDocument, this, "LineCount");
+			}
+			OnDocumentLineCountChanged();
+		}
+		
+		/// <inheritdoc cref="IWeakEventListener.ReceiveWeakEvent"/>
+		protected virtual bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+		{
+			if (managerType == typeof(PropertyChangedEventManager)) {
+				OnDocumentLineCountChanged();
+				return true;
+			}
+			return false;
+		}
+		
+		bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+		{
+			return ReceiveWeakEvent(managerType, sender, e);
+		}
+		
+		int maxLineNumberLength = 1;
+		
+		void OnDocumentLineCountChanged()
+		{
+			int documentLineCount = Document != null ? Document.LineCount : 1;
+			int newLength = documentLineCount.ToString(CultureInfo.CurrentCulture).Length;
+			
+			// The margin looks too small when there is only one digit, so always reserve space for
+			// at least two digits
+			if (newLength < 2)
+				newLength = 2;
+			
+			if (newLength != maxLineNumberLength) {
+				maxLineNumberLength = newLength;
+				InvalidateMeasure();
+			}
+		}
+		
+		void TextViewVisualLinesChanged(object sender, EventArgs e)
+		{
+			InvalidateVisual();
+		}
+		
+		AnchorSegment selectionStart;
+		bool selecting;
+		
+		/// <inheritdoc/>
+		protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
+		{
+			base.OnMouseLeftButtonDown(e);
+			if (!e.Handled && TextView != null && textArea != null) {
+				e.Handled = true;
+				textArea.Focus();
+				
+				SimpleSegment currentSeg = GetTextLineSegment(e);
+				if (currentSeg == SimpleSegment.Invalid)
+					return;
+				textArea.Caret.Offset = currentSeg.Offset + currentSeg.Length;
+				if (CaptureMouse()) {
+					selecting = true;
+					selectionStart = new AnchorSegment(Document, currentSeg.Offset, currentSeg.Length);
+					if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift) {
+						SimpleSelection simpleSelection = textArea.Selection as SimpleSelection;
+						if (simpleSelection != null)
+							selectionStart = new AnchorSegment(Document, simpleSelection.SurroundingSegment);
+					}
+					textArea.Selection = Selection.Create(textArea, selectionStart);
+					if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift) {
+						ExtendSelection(currentSeg);
+					}
+				}
+			}
+		}
+		
+		SimpleSegment GetTextLineSegment(MouseEventArgs e)
+		{
+			Point pos = e.GetPosition(TextView);
+			pos.X = 0;
+			pos.Y += TextView.VerticalOffset;
+			VisualLine vl = TextView.GetVisualLineFromVisualTop(pos.Y);
+			if (vl == null)
+				return SimpleSegment.Invalid;
+			TextLine tl = vl.GetTextLineByVisualYPosition(pos.Y);
+			int visualStartColumn = vl.GetTextLineVisualStartColumn(tl);
+			int visualEndColumn = visualStartColumn + tl.Length;
+			int relStart = vl.FirstDocumentLine.Offset;
+			int startOffset = vl.GetRelativeOffset(visualStartColumn) + relStart;
+			int endOffset = vl.GetRelativeOffset(visualEndColumn) + relStart;
+			if (endOffset == vl.LastDocumentLine.Offset + vl.LastDocumentLine.Length)
+				endOffset += vl.LastDocumentLine.DelimiterLength;
+			return new SimpleSegment(startOffset, endOffset - startOffset);
+		}
+		
+		void ExtendSelection(SimpleSegment currentSeg)
+		{
+			if (currentSeg.Offset < selectionStart.Offset) {
+				textArea.Caret.Offset = currentSeg.Offset;
+				textArea.Selection = Selection.Create(textArea, currentSeg.Offset, selectionStart.Offset + selectionStart.Length);
+			} else {
+				textArea.Caret.Offset = currentSeg.Offset + currentSeg.Length;
+				textArea.Selection = Selection.Create(textArea, selectionStart.Offset, currentSeg.Offset + currentSeg.Length);
+			}
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnMouseMove(MouseEventArgs e)
+		{
+			if (selecting && textArea != null && TextView != null) {
+				e.Handled = true;
+				SimpleSegment currentSeg = GetTextLineSegment(e);
+				if (currentSeg == SimpleSegment.Invalid)
+					return;
+				ExtendSelection(currentSeg);
+			}
+			base.OnMouseMove(e);
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
+		{
+			if (selecting) {
+				selecting = false;
+				selectionStart = null;
+				ReleaseMouseCapture();
+				e.Handled = true;
+			}
+			base.OnMouseLeftButtonUp(e);
+		}
+		
+		/// <inheritdoc/>
+		protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
+		{
+			// accept clicks even when clicking on the background
+			return new PointHitTestResult(this, hitTestParameters.HitPoint);
+		}
+    }
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/NoReadOnlySections.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/NoReadOnlySections.cs
new file mode 100644
index 000000000..35cd1dd1b
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/NoReadOnlySections.cs
@@ -0,0 +1,50 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// <see cref="IReadOnlySectionProvider"/> that has no read-only sections; all text is editable.
+	/// </summary>
+	sealed class NoReadOnlySections : IReadOnlySectionProvider
+	{
+		public static readonly NoReadOnlySections Instance = new NoReadOnlySections();
+		
+		public bool CanInsert(int offset)
+		{
+			return true;
+		}
+		
+		public IEnumerable<ISegment> GetDeletableSegments(ISegment segment)
+		{
+			if (segment == null)
+				throw new ArgumentNullException("segment");
+			// the segment is always deletable
+			return ExtensionMethods.Sequence(segment);
+		}
+	}
+	
+	/// <summary>
+	/// <see cref="IReadOnlySectionProvider"/> that completely disables editing.
+	/// </summary>
+	sealed class ReadOnlyDocument : IReadOnlySectionProvider
+	{
+		public static readonly ReadOnlyDocument Instance = new ReadOnlyDocument();
+		
+		public bool CanInsert(int offset)
+		{
+			return false;
+		}
+		
+		public IEnumerable<ISegment> GetDeletableSegments(ISegment segment)
+		{
+			return Enumerable.Empty<ISegment>();
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/RectangleSelection.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/RectangleSelection.cs
new file mode 100644
index 000000000..2d87d7934
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/RectangleSelection.cs
@@ -0,0 +1,396 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media.TextFormatting;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Rectangular selection ("box selection").
+	/// </summary>
+	public sealed class RectangleSelection : Selection
+	{
+		#region Commands
+		/// <summary>
+		/// Expands the selection left by one character, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+Left
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectLeftByCharacter = Command("BoxSelectLeftByCharacter");
+		
+		/// <summary>
+		/// Expands the selection right by one character, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+Right
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectRightByCharacter = Command("BoxSelectRightByCharacter");
+		
+		/// <summary>
+		/// Expands the selection left by one word, creating a rectangular selection.
+		/// Key gesture: Ctrl+Alt+Shift+Left
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectLeftByWord = Command("BoxSelectLeftByWord");
+		
+		/// <summary>
+		/// Expands the selection left by one word, creating a rectangular selection.
+		/// Key gesture: Ctrl+Alt+Shift+Right
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectRightByWord = Command("BoxSelectRightByWord");
+		
+		/// <summary>
+		/// Expands the selection up by one line, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+Up
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectUpByLine = Command("BoxSelectUpByLine");
+		
+		/// <summary>
+		/// Expands the selection up by one line, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+Down
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectDownByLine = Command("BoxSelectDownByLine");
+		
+		/// <summary>
+		/// Expands the selection to the start of the line, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+Home
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectToLineStart = Command("BoxSelectToLineStart");
+		
+		/// <summary>
+		/// Expands the selection to the end of the line, creating a rectangular selection.
+		/// Key gesture: Alt+Shift+End
+		/// </summary>
+		public static readonly RoutedUICommand BoxSelectToLineEnd = Command("BoxSelectToLineEnd");
+		
+		static RoutedUICommand Command(string name)
+		{
+			return new RoutedUICommand(name, name, typeof(RectangleSelection));
+		}
+		#endregion
+		
+		TextDocument document;
+		readonly int startLine, endLine;
+		readonly double startXPos, endXPos;
+		readonly int topLeftOffset, bottomRightOffset;
+		readonly TextViewPosition start, end;
+		
+		readonly List<SelectionSegment> segments = new List<SelectionSegment>();
+		
+		#region Constructors
+		/// <summary>
+		/// Creates a new rectangular selection.
+		/// </summary>
+		public RectangleSelection(TextArea textArea, TextViewPosition start, TextViewPosition end)
+			: base(textArea)
+		{
+			InitDocument();
+			this.startLine = start.Line;
+			this.endLine = end.Line;
+			this.startXPos = GetXPos(textArea, start);
+			this.endXPos = GetXPos(textArea, end);
+			CalculateSegments();
+			this.topLeftOffset = this.segments.First().StartOffset;
+			this.bottomRightOffset = this.segments.Last().EndOffset;
+			
+			this.start = start;
+			this.end = end;
+		}
+		
+		private RectangleSelection(TextArea textArea, int startLine, double startXPos, TextViewPosition end)
+			: base(textArea)
+		{
+			InitDocument();
+			this.startLine = startLine;
+			this.endLine = end.Line;
+			this.startXPos = startXPos;
+			this.endXPos = GetXPos(textArea, end);
+			CalculateSegments();
+			this.topLeftOffset = this.segments.First().StartOffset;
+			this.bottomRightOffset = this.segments.Last().EndOffset;
+			
+			this.start = GetStart();
+			this.end = end;
+		}
+		
+		private RectangleSelection(TextArea textArea, TextViewPosition start, int endLine, double endXPos)
+			: base(textArea)
+		{
+			InitDocument();
+			this.startLine = start.Line;
+			this.endLine = endLine;
+			this.startXPos = GetXPos(textArea, start);
+			this.endXPos = endXPos;
+			CalculateSegments();
+			this.topLeftOffset = this.segments.First().StartOffset;
+			this.bottomRightOffset = this.segments.Last().EndOffset;
+			
+			this.start = start;
+			this.end = GetEnd();
+		}
+		
+		void InitDocument()
+		{
+			document = textArea.Document;
+			if (document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+		}
+		
+		static double GetXPos(TextArea textArea, TextViewPosition pos)
+		{
+			DocumentLine documentLine = textArea.Document.GetLineByNumber(pos.Line);
+			VisualLine visualLine = textArea.TextView.GetOrConstructVisualLine(documentLine);
+			int vc = visualLine.ValidateVisualColumn(pos, true);
+			TextLine textLine = visualLine.GetTextLine(vc);
+			return visualLine.GetTextLineVisualXPosition(textLine, vc);
+		}
+		
+		void CalculateSegments()
+		{
+			DocumentLine nextLine = document.GetLineByNumber(Math.Min(startLine, endLine));
+			do {
+				VisualLine vl = textArea.TextView.GetOrConstructVisualLine(nextLine);
+				int startVC = vl.GetVisualColumn(new Point(startXPos, 0), true);
+				int endVC = vl.GetVisualColumn(new Point(endXPos, 0), true);
+				
+				int baseOffset = vl.FirstDocumentLine.Offset;
+				int startOffset = baseOffset + vl.GetRelativeOffset(startVC);
+				int endOffset = baseOffset + vl.GetRelativeOffset(endVC);
+				segments.Add(new SelectionSegment(startOffset, startVC, endOffset, endVC));
+				
+				nextLine = vl.LastDocumentLine.NextLine;
+			} while (nextLine != null && nextLine.LineNumber <= Math.Max(startLine, endLine));
+		}
+		
+		TextViewPosition GetStart()
+		{
+			SelectionSegment segment = (startLine < endLine ? segments.First() : segments.Last());
+			if (startXPos < endXPos) {
+				return new TextViewPosition(document.GetLocation(segment.StartOffset), segment.StartVisualColumn);
+			} else {
+				return new TextViewPosition(document.GetLocation(segment.EndOffset), segment.EndVisualColumn);
+			}
+		}
+		
+		TextViewPosition GetEnd()
+		{
+			SelectionSegment segment = (startLine < endLine ? segments.Last() : segments.First());
+			if (startXPos < endXPos) {
+				return new TextViewPosition(document.GetLocation(segment.EndOffset), segment.EndVisualColumn);
+			} else {
+				return new TextViewPosition(document.GetLocation(segment.StartOffset), segment.StartVisualColumn);
+			}
+		}
+		#endregion
+		
+		/// <inheritdoc/>
+		public override string GetText()
+		{
+			StringBuilder b = new StringBuilder();
+			foreach (ISegment s in this.Segments) {
+				if (b.Length > 0)
+					b.AppendLine();
+				b.Append(document.GetText(s));
+			}
+			return b.ToString();
+		}
+		
+		/// <inheritdoc/>
+		public override Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition)
+		{
+			return SetEndpoint(endPosition);
+		}
+		
+		/// <inheritdoc/>
+		public override int Length {
+			get {
+				return this.Segments.Sum(s => s.Length);
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override bool EnableVirtualSpace {
+			get { return true; }
+		}
+		
+		/// <inheritdoc/>
+		public override ISegment SurroundingSegment {
+			get {
+				return new SimpleSegment(topLeftOffset, bottomRightOffset - topLeftOffset);
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override IEnumerable<SelectionSegment> Segments {
+			get { return segments; }
+		}
+		
+		/// <inheritdoc/>
+		public override TextViewPosition StartPosition {
+			get { return start; }
+		}
+		
+		/// <inheritdoc/>
+		public override TextViewPosition EndPosition {
+			get { return end; }
+		}
+		
+		/// <inheritdoc/>
+		public override bool Equals(object obj)
+		{
+			RectangleSelection r = obj as RectangleSelection;
+			return r != null && r.textArea == this.textArea
+				&& r.topLeftOffset == this.topLeftOffset && r.bottomRightOffset == this.bottomRightOffset
+				&& r.startLine == this.startLine && r.endLine == this.endLine
+				&& r.startXPos == this.startXPos && r.endXPos == this.endXPos;
+		}
+		
+		/// <inheritdoc/>
+		public override int GetHashCode()
+		{
+			return topLeftOffset ^ bottomRightOffset;
+		}
+		
+		/// <inheritdoc/>
+		public override Selection SetEndpoint(TextViewPosition endPosition)
+		{
+			return new RectangleSelection(textArea, startLine, startXPos, endPosition);
+		}
+		
+		int GetVisualColumnFromXPos(int line, double xPos)
+		{
+			var vl = textArea.TextView.GetOrConstructVisualLine(textArea.Document.GetLineByNumber(line));
+			return vl.GetVisualColumn(new Point(xPos, 0), true);
+		}
+		
+		/// <inheritdoc/>
+		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
+		{
+			TextLocation newStartLocation = textArea.Document.GetLocation(e.GetNewOffset(topLeftOffset, AnchorMovementType.AfterInsertion));
+			TextLocation newEndLocation = textArea.Document.GetLocation(e.GetNewOffset(bottomRightOffset, AnchorMovementType.BeforeInsertion));
+			
+			return new RectangleSelection(textArea,
+			                              new TextViewPosition(newStartLocation, GetVisualColumnFromXPos(newStartLocation.Line, startXPos)),
+			                              new TextViewPosition(newEndLocation, GetVisualColumnFromXPos(newEndLocation.Line, endXPos)));
+		}
+		
+		/// <inheritdoc/>
+		public override void ReplaceSelectionWithText(string newText)
+		{
+			if (newText == null)
+				throw new ArgumentNullException("newText");
+			using (textArea.Document.RunUpdate()) {
+				TextViewPosition start = new TextViewPosition(document.GetLocation(topLeftOffset), GetVisualColumnFromXPos(startLine, startXPos));
+				TextViewPosition end = new TextViewPosition(document.GetLocation(bottomRightOffset), GetVisualColumnFromXPos(endLine, endXPos));
+				int insertionLength;
+				int totalInsertionLength = 0;
+				int firstInsertionLength = 0;
+				int editOffset = Math.Min(topLeftOffset, bottomRightOffset);
+				TextViewPosition pos;
+				if (NewLineFinder.NextNewLine(newText, 0) == SimpleSegment.Invalid) {
+					// insert same text into every line
+					foreach (SelectionSegment lineSegment in this.Segments.Reverse()) {
+						ReplaceSingleLineText(textArea, lineSegment, newText, out insertionLength);
+						totalInsertionLength += insertionLength;
+						firstInsertionLength = insertionLength;
+					}
+					
+					int newEndOffset = editOffset + totalInsertionLength;
+					pos = new TextViewPosition(document.GetLocation(editOffset + firstInsertionLength));
+					
+					textArea.Selection = new RectangleSelection(textArea, pos, Math.Max(startLine, endLine), GetXPos(textArea, pos));
+				} else {
+					string[] lines = newText.Split(NewLineFinder.NewlineStrings, segments.Count, StringSplitOptions.None);
+					int line = Math.Min(startLine, endLine);
+					for (int i = lines.Length - 1; i >= 0; i--) {
+						ReplaceSingleLineText(textArea, segments[i], lines[i], out insertionLength);
+						firstInsertionLength = insertionLength;
+					}
+					pos = new TextViewPosition(document.GetLocation(editOffset + firstInsertionLength));
+					textArea.ClearSelection();
+				}
+				textArea.Caret.Position = textArea.TextView.GetPosition(new Point(GetXPos(textArea, pos), textArea.TextView.GetVisualTopByDocumentLine(Math.Max(startLine, endLine)))).GetValueOrDefault();
+			}
+		}
+		
+		void ReplaceSingleLineText(TextArea textArea, SelectionSegment lineSegment, string newText, out int insertionLength)
+		{
+			if (lineSegment.Length == 0) {
+				if (newText.Length > 0 && textArea.ReadOnlySectionProvider.CanInsert(lineSegment.StartOffset)) {
+					newText = AddSpacesIfRequired(newText, new TextViewPosition(document.GetLocation(lineSegment.StartOffset), lineSegment.StartVisualColumn), new TextViewPosition(document.GetLocation(lineSegment.EndOffset), lineSegment.EndVisualColumn));
+					textArea.Document.Insert(lineSegment.StartOffset, newText);
+				}
+			} else {
+				ISegment[] segmentsToDelete = textArea.GetDeletableSegments(lineSegment);
+				for (int i = segmentsToDelete.Length - 1; i >= 0; i--) {
+					if (i == segmentsToDelete.Length - 1) {
+						if (segmentsToDelete[i].Offset == SurroundingSegment.Offset && segmentsToDelete[i].Length == SurroundingSegment.Length) {
+							newText = AddSpacesIfRequired(newText, new TextViewPosition(document.GetLocation(lineSegment.StartOffset), lineSegment.StartVisualColumn), new TextViewPosition(document.GetLocation(lineSegment.EndOffset), lineSegment.EndVisualColumn));
+						}
+						textArea.Document.Replace(segmentsToDelete[i], newText);
+					} else {
+						textArea.Document.Remove(segmentsToDelete[i]);
+					}
+				}
+			}
+			insertionLength = newText.Length;
+		}
+		
+		/// <summary>
+		/// Performs a rectangular paste operation.
+		/// </summary>
+		public static bool PerformRectangularPaste(TextArea textArea, TextViewPosition startPosition, string text, bool selectInsertedText)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			if (text == null)
+				throw new ArgumentNullException("text");
+			int newLineCount = text.Count(c => c == '\n'); // TODO might not work in all cases, but single \r line endings are really rare today.
+			TextLocation endLocation = new TextLocation(startPosition.Line + newLineCount, startPosition.Column);
+			if (endLocation.Line <= textArea.Document.LineCount) {
+				int endOffset = textArea.Document.GetOffset(endLocation);
+				if (textArea.Selection.EnableVirtualSpace || textArea.Document.GetLocation(endOffset) == endLocation) {
+					RectangleSelection rsel = new RectangleSelection(textArea, startPosition, endLocation.Line, GetXPos(textArea, startPosition));
+					rsel.ReplaceSelectionWithText(text);
+					if (selectInsertedText && textArea.Selection is RectangleSelection) {
+						RectangleSelection sel = (RectangleSelection)textArea.Selection;
+						textArea.Selection = new RectangleSelection(textArea, startPosition, sel.endLine, sel.endXPos);
+					}
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		/// <summary>
+		/// Gets the name of the entry in the DataObject that signals rectangle selections.
+		/// </summary>
+		public const string RectangularSelectionDataType = "AvalonEditRectangularSelection";
+		
+		/// <inheritdoc/>
+		public override System.Windows.DataObject CreateDataObject(TextArea textArea)
+		{
+			var data = base.CreateDataObject(textArea);
+			
+			MemoryStream isRectangle = new MemoryStream(1);
+			isRectangle.WriteByte(1);
+			data.SetData(RectangularSelectionDataType, isRectangle, false);
+			return data;
+		}
+		
+		/// <inheritdoc/>
+		public override string ToString()
+		{
+			// It's possible that ToString() gets called on old (invalid) selections, e.g. for "change from... to..." debug message
+			// make sure we don't crash even when the desired locations don't exist anymore.
+			return string.Format("[RectangleSelection {0} {1} {2} to {3} {4} {5}]", startLine, topLeftOffset, startXPos, endLine, bottomRightOffset, endXPos);
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Selection.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Selection.cs
new file mode 100644
index 000000000..014fa8680
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/Selection.cs
@@ -0,0 +1,268 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Highlighting;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Base class for selections.
+	/// </summary>
+	public abstract class Selection
+	{
+		/// <summary>
+		/// Creates a new simple selection that selects the text from startOffset to endOffset.
+		/// </summary>
+		public static Selection Create(TextArea textArea, int startOffset, int endOffset)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			if (startOffset == endOffset)
+				return textArea.emptySelection;
+			else
+				return new SimpleSelection(textArea,
+				                           new TextViewPosition(textArea.Document.GetLocation(startOffset)),
+				                           new TextViewPosition(textArea.Document.GetLocation(endOffset)));
+		}
+		
+		internal static Selection Create(TextArea textArea, TextViewPosition start, TextViewPosition end)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			if (textArea.Document.GetOffset(start.Location) == textArea.Document.GetOffset(end.Location) && start.VisualColumn == end.VisualColumn)
+				return textArea.emptySelection;
+			else
+				return new SimpleSelection(textArea, start, end);
+		}
+		
+		/// <summary>
+		/// Creates a new simple selection that selects the text in the specified segment.
+		/// </summary>
+		public static Selection Create(TextArea textArea, ISegment segment)
+		{
+			if (segment == null)
+				throw new ArgumentNullException("segment");
+			return Create(textArea, segment.Offset, segment.EndOffset);
+		}
+		
+		internal readonly TextArea textArea;
+		
+		/// <summary>
+		/// Constructor for Selection.
+		/// </summary>
+		protected Selection(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+		}
+		
+		/// <summary>
+		/// Gets the start position of the selection.
+		/// </summary>
+		public abstract TextViewPosition StartPosition { get; }
+		
+		/// <summary>
+		/// Gets the end position of the selection.
+		/// </summary>
+		public abstract TextViewPosition EndPosition { get; }
+		
+		/// <summary>
+		/// Gets the selected text segments.
+		/// </summary>
+		public abstract IEnumerable<SelectionSegment> Segments { get; }
+		
+		/// <summary>
+		/// Gets the smallest segment that contains all segments in this selection.
+		/// May return null if the selection is empty.
+		/// </summary>
+		public abstract ISegment SurroundingSegment { get; }
+		
+		/// <summary>
+		/// Replaces the selection with the specified text.
+		/// </summary>
+		public abstract void ReplaceSelectionWithText(string newText);
+		
+		internal string AddSpacesIfRequired(string newText, TextViewPosition start, TextViewPosition end)
+		{
+			if (EnableVirtualSpace && InsertVirtualSpaces(newText, start, end)) {
+				var line = textArea.Document.GetLineByNumber(start.Line);
+				string lineText = textArea.Document.GetText(line);
+				var vLine = textArea.TextView.GetOrConstructVisualLine(line);
+				int colDiff = start.VisualColumn - vLine.VisualLengthWithEndOfLineMarker;
+				if (colDiff > 0) {
+					string additionalSpaces = "";
+					if (!textArea.Options.ConvertTabsToSpaces && lineText.Trim('\t').Length == 0) {
+						int tabCount = (int)(colDiff / textArea.Options.IndentationSize);
+						additionalSpaces = new string('\t', tabCount);
+						colDiff -= tabCount * textArea.Options.IndentationSize;
+					}
+					additionalSpaces += new string(' ', colDiff);
+					return additionalSpaces + newText;
+				}
+			}
+			return newText;
+		}
+		
+		bool InsertVirtualSpaces(string newText, TextViewPosition start, TextViewPosition end)
+		{
+			return (!string.IsNullOrEmpty(newText) || !(IsInVirtualSpace(start) && IsInVirtualSpace(end)))
+				&& newText != "\r\n"
+				&& newText != "\n" 
+				&& newText != "\r";
+		}
+		
+		bool IsInVirtualSpace(TextViewPosition pos)
+		{
+			return pos.VisualColumn > textArea.TextView.GetOrConstructVisualLine(textArea.Document.GetLineByNumber(pos.Line)).VisualLength;
+		}
+		
+		/// <summary>
+		/// Updates the selection when the document changes.
+		/// </summary>
+		public abstract Selection UpdateOnDocumentChange(DocumentChangeEventArgs e);
+		
+		/// <summary>
+		/// Gets whether the selection is empty.
+		/// </summary>
+		public virtual bool IsEmpty {
+			get { return Length == 0; }
+		}
+		
+		/// <summary>
+		/// Gets whether virtual space is enabled for this selection.
+		/// </summary>
+		public virtual bool EnableVirtualSpace {
+			get { return textArea.Options.EnableVirtualSpace; }
+		}
+		
+		/// <summary>
+		/// Gets the selection length.
+		/// </summary>
+		public abstract int Length { get; }
+		
+		/// <summary>
+		/// Returns a new selection with the changed end point.
+		/// </summary>
+		/// <exception cref="NotSupportedException">Cannot set endpoint for empty selection</exception>
+		public abstract Selection SetEndpoint(TextViewPosition endPosition);
+		
+		/// <summary>
+		/// If this selection is empty, starts a new selection from <paramref name="startPosition"/> to
+		/// <paramref name="endPosition"/>, otherwise, changes the endpoint of this selection.
+		/// </summary>
+		public abstract Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition);
+		
+		/// <summary>
+		/// Gets whether the selection is multi-line.
+		/// </summary>
+		public virtual bool IsMultiline {
+			get {
+				ISegment surroundingSegment = this.SurroundingSegment;
+				if (surroundingSegment == null)
+					return false;
+				int start = surroundingSegment.Offset;
+				int end = start + surroundingSegment.Length;
+				var document = textArea.Document;
+				if (document == null)
+					throw ThrowUtil.NoDocumentAssigned();
+				return document.GetLineByOffset(start) != document.GetLineByOffset(end);
+			}
+		}
+		
+		/// <summary>
+		/// Gets the selected text.
+		/// </summary>
+		public virtual string GetText()
+		{
+			var document = textArea.Document;
+			if (document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			StringBuilder b = null;
+			string text = null;
+			foreach (ISegment s in Segments) {
+				if (text != null) {
+					if (b == null)
+						b = new StringBuilder(text);
+					else
+						b.Append(text);
+				}
+				text = document.GetText(s);
+			}
+			if (b != null) {
+				if (text != null) b.Append(text);
+				return b.ToString();
+			} else {
+				return text ?? string.Empty;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a HTML fragment for the selected text.
+		/// </summary>
+		public string CreateHtmlFragment(HtmlOptions options)
+		{
+			if (options == null)
+				throw new ArgumentNullException("options");
+			IHighlighter highlighter = textArea.GetService(typeof(IHighlighter)) as IHighlighter;
+			StringBuilder html = new StringBuilder();
+			bool first = true;
+			foreach (ISegment selectedSegment in this.Segments) {
+				if (first)
+					first = false;
+				else
+					html.AppendLine("<br>");
+				html.Append(HtmlClipboard.CreateHtmlFragment(textArea.Document, highlighter, selectedSegment, options));
+			}
+			return html.ToString();
+		}
+		
+		/// <inheritdoc/>
+		public abstract override bool Equals(object obj);
+		
+		/// <inheritdoc/>
+		public abstract override int GetHashCode();
+		
+		/// <summary>
+		/// Gets whether the specified offset is included in the selection.
+		/// </summary>
+		/// <returns>True, if the selection contains the offset (selection borders inclusive);
+		/// otherwise, false.</returns>
+		public virtual bool Contains(int offset)
+		{
+			if (this.IsEmpty)
+				return false;
+			if (this.SurroundingSegment.Contains(offset)) {
+				foreach (ISegment s in this.Segments) {
+					if (s.Contains(offset)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+		
+		/// <summary>
+		/// Creates a data object containing the selection's text.
+		/// </summary>
+		public virtual DataObject CreateDataObject(TextArea textArea)
+		{
+			string text = GetText();
+			// Ensure we use the appropriate newline sequence for the OS
+			DataObject data = new DataObject(TextUtilities.NormalizeNewLines(text, Environment.NewLine));
+			// we cannot use DataObject.SetText - then we cannot drag to SciTe
+			// (but dragging to Word works in both cases)
+			
+			// Also copy text in HTML format to clipboard - good for pasting text into Word
+			// or to the SharpDevelop forums.
+			HtmlClipboard.SetHtml(data, CreateHtmlFragment(new HtmlOptions(textArea.Options)));
+			return data;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionColorizer.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionColorizer.cs
new file mode 100644
index 000000000..857c4c060
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionColorizer.cs
@@ -0,0 +1,58 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Windows;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	sealed class SelectionColorizer : ColorizingTransformer
+	{
+		TextArea textArea;
+		
+		public SelectionColorizer(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+		}
+		
+		protected override void Colorize(ITextRunConstructionContext context)
+		{
+			// if SelectionForeground is null, keep the existing foreground color
+			if (textArea.SelectionForeground == null)
+				return;
+			
+			int lineStartOffset = context.VisualLine.FirstDocumentLine.Offset;
+			int lineEndOffset = context.VisualLine.LastDocumentLine.Offset + context.VisualLine.LastDocumentLine.TotalLength;
+			
+			foreach (SelectionSegment segment in textArea.Selection.Segments) {
+				int segmentStart = segment.StartOffset;
+				int segmentEnd = segment.EndOffset;
+				if (segmentEnd <= lineStartOffset)
+					continue;
+				if (segmentStart >= lineEndOffset)
+					continue;
+				int startColumn;
+				if (segmentStart < lineStartOffset)
+					startColumn = 0;
+				else
+					startColumn = context.VisualLine.ValidateVisualColumn(segment.StartOffset, segment.StartVisualColumn, textArea.Selection.EnableVirtualSpace);
+				
+				int endColumn;
+				if (segmentEnd > lineEndOffset)
+					endColumn = textArea.Selection.EnableVirtualSpace ? int.MaxValue : context.VisualLine.VisualLengthWithEndOfLineMarker;
+				else
+					endColumn = context.VisualLine.ValidateVisualColumn(segment.EndOffset, segment.EndVisualColumn, textArea.Selection.EnableVirtualSpace);
+				
+				ChangeVisualElements(
+					startColumn, endColumn,
+					element => {
+						element.TextRunProperties.SetForegroundBrush(textArea.SelectionForeground);
+					});
+			}
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionLayer.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionLayer.cs
new file mode 100644
index 000000000..28631affe
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionLayer.cs
@@ -0,0 +1,53 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Windows;
+using System.Windows.Media;
+
+using Tango.Scripting.Editors.Rendering;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	sealed class SelectionLayer : Layer, IWeakEventListener
+	{
+		readonly TextArea textArea;
+		
+		public SelectionLayer(TextArea textArea) : base(textArea.TextView, KnownLayer.Selection)
+		{
+			this.IsHitTestVisible = false;
+			
+			this.textArea = textArea;
+			TextViewWeakEventManager.VisualLinesChanged.AddListener(textView, this);
+			TextViewWeakEventManager.ScrollOffsetChanged.AddListener(textView, this);
+		}
+		
+		bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+		{
+			if (managerType == typeof(TextViewWeakEventManager.VisualLinesChanged)
+			    || managerType == typeof(TextViewWeakEventManager.ScrollOffsetChanged))
+			{
+				InvalidateVisual();
+				return true;
+			}
+			return false;
+		}
+		
+		protected override void OnRender(DrawingContext drawingContext)
+		{
+			base.OnRender(drawingContext);
+			
+			BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder();
+			geoBuilder.AlignToMiddleOfPixels = true;
+			geoBuilder.ExtendToFullWidthAtLineEnd = textArea.Selection.EnableVirtualSpace;
+			geoBuilder.CornerRadius = textArea.SelectionCornerRadius;
+			foreach (var segment in textArea.Selection.Segments) {
+				geoBuilder.AddSegment(textView, segment);
+			}
+			Geometry geometry = geoBuilder.CreateGeometry();
+			if (geometry != null) {
+				drawingContext.DrawGeometry(textArea.SelectionBrush, textArea.SelectionBorder, geometry);
+			}
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionMouseHandler.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionMouseHandler.cs
new file mode 100644
index 000000000..3c5ec51dc
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionMouseHandler.cs
@@ -0,0 +1,631 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media.TextFormatting;
+using System.Windows.Threading;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Handles selection of text using the mouse.
+	/// </summary>
+	sealed class SelectionMouseHandler : ITextAreaInputHandler
+	{
+		#region enum SelectionMode
+		enum SelectionMode
+		{
+			/// <summary>
+			/// no selection (no mouse button down)
+			/// </summary>
+			None,
+			/// <summary>
+			/// left mouse button down on selection, might be normal click
+			/// or might be drag'n'drop
+			/// </summary>
+			PossibleDragStart,
+			/// <summary>
+			/// dragging text
+			/// </summary>
+			Drag,
+			/// <summary>
+			/// normal selection (click+drag)
+			/// </summary>
+			Normal,
+			/// <summary>
+			/// whole-word selection (double click+drag or ctrl+click+drag)
+			/// </summary>
+			WholeWord,
+			/// <summary>
+			/// whole-line selection (triple click+drag)
+			/// </summary>
+			WholeLine,
+			/// <summary>
+			/// rectangular selection (alt+click+drag)
+			/// </summary>
+			Rectangular
+		}
+		#endregion
+		
+		readonly TextArea textArea;
+		
+		SelectionMode mode;
+		AnchorSegment startWord;
+		Point possibleDragStartMousePos;
+		
+		#region Constructor + Attach + Detach
+		public SelectionMouseHandler(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+		}
+		
+		public TextArea TextArea {
+			get { return textArea; }
+		}
+		
+		public void Attach()
+		{
+			textArea.MouseLeftButtonDown += textArea_MouseLeftButtonDown;
+			textArea.MouseMove += textArea_MouseMove;
+			textArea.MouseLeftButtonUp += textArea_MouseLeftButtonUp;
+			textArea.QueryCursor += textArea_QueryCursor;
+			textArea.OptionChanged += textArea_OptionChanged;
+			
+			enableTextDragDrop = textArea.Options.EnableTextDragDrop;
+			if (enableTextDragDrop) {
+				AttachDragDrop();
+			}
+		}
+		
+		public void Detach()
+		{
+			mode = SelectionMode.None;
+			textArea.MouseLeftButtonDown -= textArea_MouseLeftButtonDown;
+			textArea.MouseMove -= textArea_MouseMove;
+			textArea.MouseLeftButtonUp -= textArea_MouseLeftButtonUp;
+			textArea.QueryCursor -= textArea_QueryCursor;
+			textArea.OptionChanged -= textArea_OptionChanged;
+			if (enableTextDragDrop) {
+				DetachDragDrop();
+			}
+		}
+		
+		void AttachDragDrop()
+		{
+			textArea.AllowDrop = true;
+			textArea.GiveFeedback += textArea_GiveFeedback;
+			textArea.QueryContinueDrag += textArea_QueryContinueDrag;
+			textArea.DragEnter += textArea_DragEnter;
+			textArea.DragOver += textArea_DragOver;
+			textArea.DragLeave += textArea_DragLeave;
+			textArea.Drop += textArea_Drop;
+		}
+		
+		void DetachDragDrop()
+		{
+			textArea.AllowDrop = false;
+			textArea.GiveFeedback -= textArea_GiveFeedback;
+			textArea.QueryContinueDrag -= textArea_QueryContinueDrag;
+			textArea.DragEnter -= textArea_DragEnter;
+			textArea.DragOver -= textArea_DragOver;
+			textArea.DragLeave -= textArea_DragLeave;
+			textArea.Drop -= textArea_Drop;
+		}
+		
+		bool enableTextDragDrop;
+		
+		void textArea_OptionChanged(object sender, PropertyChangedEventArgs e)
+		{
+			bool newEnableTextDragDrop = textArea.Options.EnableTextDragDrop;
+			if (newEnableTextDragDrop != enableTextDragDrop) {
+				enableTextDragDrop = newEnableTextDragDrop;
+				if (newEnableTextDragDrop)
+					AttachDragDrop();
+				else
+					DetachDragDrop();
+			}
+		}
+		#endregion
+		
+		#region Dropping text
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_DragEnter(object sender, DragEventArgs e)
+		{
+			try {
+				e.Effects = GetEffect(e);
+				textArea.Caret.Show();
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_DragOver(object sender, DragEventArgs e)
+		{
+			try {
+				e.Effects = GetEffect(e);
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+		
+		DragDropEffects GetEffect(DragEventArgs e)
+		{
+			if (e.Data.GetDataPresent(DataFormats.UnicodeText, true)) {
+				e.Handled = true;
+				int visualColumn;
+				int offset = GetOffsetFromMousePosition(e.GetPosition(textArea.TextView), out visualColumn);
+				if (offset >= 0) {
+					textArea.Caret.Position = new TextViewPosition(textArea.Document.GetLocation(offset), visualColumn);
+					textArea.Caret.DesiredXPos = double.NaN;
+					if (textArea.ReadOnlySectionProvider.CanInsert(offset)) {
+						if ((e.AllowedEffects & DragDropEffects.Move) == DragDropEffects.Move
+						    && (e.KeyStates & DragDropKeyStates.ControlKey) != DragDropKeyStates.ControlKey)
+						{
+							return DragDropEffects.Move;
+						} else {
+							return e.AllowedEffects & DragDropEffects.Copy;
+						}
+					}
+				}
+			}
+			return DragDropEffects.None;
+		}
+		
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_DragLeave(object sender, DragEventArgs e)
+		{
+			try {
+				e.Handled = true;
+				if (!textArea.IsKeyboardFocusWithin)
+					textArea.Caret.Hide();
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+		
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_Drop(object sender, DragEventArgs e)
+		{
+			try {
+				DragDropEffects effect = GetEffect(e);
+				e.Effects = effect;
+				if (effect != DragDropEffects.None) {
+					string text = e.Data.GetData(DataFormats.UnicodeText, true) as string;
+					if (text != null) {
+						int start = textArea.Caret.Offset;
+						if (mode == SelectionMode.Drag && textArea.Selection.Contains(start)) {
+							Debug.WriteLine("Drop: did not drop: drop target is inside selection");
+							e.Effects = DragDropEffects.None;
+						} else {
+							Debug.WriteLine("Drop: insert at " + start);
+							
+							bool rectangular = e.Data.GetDataPresent(RectangleSelection.RectangularSelectionDataType);
+							
+							string newLine = TextUtilities.GetNewLineFromDocument(textArea.Document, textArea.Caret.Line);
+							text = TextUtilities.NormalizeNewLines(text, newLine);
+							
+							// Mark the undo group with the currentDragDescriptor, if the drag
+							// is originating from the same control. This allows combining
+							// the undo groups when text is moved.
+							textArea.Document.UndoStack.StartUndoGroup(this.currentDragDescriptor);
+							try {
+								if (rectangular && RectangleSelection.PerformRectangularPaste(textArea, textArea.Caret.Position, text, true)) {
+									
+								} else {
+									textArea.Document.Insert(start, text);
+									textArea.Selection = Selection.Create(textArea, start, start + text.Length);
+								}
+							} finally {
+								textArea.Document.UndoStack.EndUndoGroup();
+							}
+						}
+						e.Handled = true;
+					}
+				}
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+		
+		void OnDragException(Exception ex)
+		{
+			// WPF swallows exceptions during drag'n'drop or reports them incorrectly, so
+			// we re-throw them later to allow the application's unhandled exception handler
+			// to catch them
+			textArea.Dispatcher.BeginInvoke(
+				DispatcherPriority.Normal,
+				new Action(delegate {
+				           	throw new DragDropException("Exception during drag'n'drop", ex);
+				           }));
+		}
+		
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_GiveFeedback(object sender, GiveFeedbackEventArgs e)
+		{
+			try {
+				e.UseDefaultCursors = true;
+				e.Handled = true;
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+		
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+		void textArea_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
+		{
+			try {
+				if (e.EscapePressed) {
+					e.Action = DragAction.Cancel;
+				} else if ((e.KeyStates & DragDropKeyStates.LeftMouseButton) != DragDropKeyStates.LeftMouseButton) {
+					e.Action = DragAction.Drop;
+				} else {
+					e.Action = DragAction.Continue;
+				}
+				e.Handled = true;
+			} catch (Exception ex) {
+				OnDragException(ex);
+			}
+		}
+		#endregion
+		
+		#region Start Drag
+		object currentDragDescriptor;
+		
+		void StartDrag()
+		{
+			// prevent nested StartDrag calls
+			mode = SelectionMode.Drag;
+			
+			// mouse capture and Drag'n'Drop doesn't mix
+			textArea.ReleaseMouseCapture();
+			
+			DataObject dataObject = textArea.Selection.CreateDataObject(textArea);
+			
+			DragDropEffects allowedEffects = DragDropEffects.All;
+			var deleteOnMove = textArea.Selection.Segments.Select(s => new AnchorSegment(textArea.Document, s)).ToList();
+			foreach (ISegment s in deleteOnMove) {
+				ISegment[] result = textArea.GetDeletableSegments(s);
+				if (result.Length != 1 || result[0].Offset != s.Offset || result[0].EndOffset != s.EndOffset) {
+					allowedEffects &= ~DragDropEffects.Move;
+				}
+			}
+			
+			object dragDescriptor = new object();
+			this.currentDragDescriptor = dragDescriptor;
+			
+			DragDropEffects resultEffect;
+			using (textArea.AllowCaretOutsideSelection()) {
+				var oldCaretPosition = textArea.Caret.Position;
+				try {
+					Debug.WriteLine("DoDragDrop with allowedEffects=" + allowedEffects);
+					resultEffect = DragDrop.DoDragDrop(textArea, dataObject, allowedEffects);
+					Debug.WriteLine("DoDragDrop done, resultEffect=" + resultEffect);
+				} catch (COMException ex) {
+					// ignore COM errors - don't crash on badly implemented drop targets
+					Debug.WriteLine("DoDragDrop failed: " + ex.ToString());
+					return;
+				}
+				if (resultEffect == DragDropEffects.None) {
+					// reset caret if drag was aborted
+					textArea.Caret.Position = oldCaretPosition;
+				}
+			}
+			
+			this.currentDragDescriptor = null;
+			
+			if (deleteOnMove != null && resultEffect == DragDropEffects.Move && (allowedEffects & DragDropEffects.Move) == DragDropEffects.Move) {
+				bool draggedInsideSingleDocument = (dragDescriptor == textArea.Document.UndoStack.LastGroupDescriptor);
+				if (draggedInsideSingleDocument)
+					textArea.Document.UndoStack.StartContinuedUndoGroup(null);
+				textArea.Document.BeginUpdate();
+				try {
+					foreach (ISegment s in deleteOnMove) {
+						textArea.Document.Remove(s.Offset, s.Length);
+					}
+				} finally {
+					textArea.Document.EndUpdate();
+					if (draggedInsideSingleDocument)
+						textArea.Document.UndoStack.EndUndoGroup();
+				}
+			}
+		}
+		#endregion
+		
+		#region QueryCursor
+		// provide the IBeam Cursor for the text area
+		void textArea_QueryCursor(object sender, QueryCursorEventArgs e)
+		{
+			if (!e.Handled) {
+				if (mode != SelectionMode.None || !enableTextDragDrop) {
+					e.Cursor = Cursors.IBeam;
+					e.Handled = true;
+				} else if (textArea.TextView.VisualLinesValid) {
+					// Only query the cursor if the visual lines are valid.
+					// If they are invalid, the cursor will get re-queried when the visual lines
+					// get refreshed.
+					Point p = e.GetPosition(textArea.TextView);
+					if (p.X >= 0 && p.Y >= 0 && p.X <= textArea.TextView.ActualWidth && p.Y <= textArea.TextView.ActualHeight) {
+						int visualColumn;
+						int offset = GetOffsetFromMousePosition(e, out visualColumn);
+						if (textArea.Selection.Contains(offset))
+							e.Cursor = Cursors.Arrow;
+						else
+							e.Cursor = Cursors.IBeam;
+						e.Handled = true;
+					}
+				}
+			}
+		}
+		#endregion
+		
+		#region LeftButtonDown
+		void textArea_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+		{
+			mode = SelectionMode.None;
+			if (!e.Handled && e.ChangedButton == MouseButton.Left) {
+				ModifierKeys modifiers = Keyboard.Modifiers;
+				bool shift = (modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;
+				if (enableTextDragDrop && e.ClickCount == 1 && !shift) {
+					int visualColumn;
+					int offset = GetOffsetFromMousePosition(e, out visualColumn);
+					if (textArea.Selection.Contains(offset)) {
+						if (textArea.CaptureMouse()) {
+							mode = SelectionMode.PossibleDragStart;
+							possibleDragStartMousePos = e.GetPosition(textArea);
+						}
+						e.Handled = true;
+						return;
+					}
+				}
+				
+				var oldPosition = textArea.Caret.Position;
+				SetCaretOffsetToMousePosition(e);
+				
+				
+				if (!shift) {
+					textArea.ClearSelection();
+				}
+				if (textArea.CaptureMouse()) {
+					if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt && textArea.Options.EnableRectangularSelection) {
+						mode = SelectionMode.Rectangular;
+						if (shift && textArea.Selection is RectangleSelection) {
+							textArea.Selection = textArea.Selection.StartSelectionOrSetEndpoint(oldPosition, textArea.Caret.Position);
+						}
+					} else if (e.ClickCount == 1 && ((modifiers & ModifierKeys.Control) == 0)) {
+						mode = SelectionMode.Normal;
+						if (shift && !(textArea.Selection is RectangleSelection)) {
+							textArea.Selection = textArea.Selection.StartSelectionOrSetEndpoint(oldPosition, textArea.Caret.Position);
+						}
+					} else {
+						SimpleSegment startWord;
+						if (e.ClickCount == 3) {
+							mode = SelectionMode.WholeLine;
+							startWord = GetLineAtMousePosition(e);
+						} else {
+							mode = SelectionMode.WholeWord;
+							startWord = GetWordAtMousePosition(e);
+						}
+						if (startWord == SimpleSegment.Invalid) {
+							mode = SelectionMode.None;
+							textArea.ReleaseMouseCapture();
+							return;
+						}
+						if (shift && !textArea.Selection.IsEmpty) {
+							if (startWord.Offset < textArea.Selection.SurroundingSegment.Offset) {
+								textArea.Selection = textArea.Selection.SetEndpoint(new TextViewPosition(textArea.Document.GetLocation(startWord.Offset)));
+							} else if (startWord.EndOffset > textArea.Selection.SurroundingSegment.EndOffset) {
+								textArea.Selection = textArea.Selection.SetEndpoint(new TextViewPosition(textArea.Document.GetLocation(startWord.EndOffset)));
+							}
+							this.startWord = new AnchorSegment(textArea.Document, textArea.Selection.SurroundingSegment);
+						} else {
+							textArea.Selection = Selection.Create(textArea, startWord.Offset, startWord.EndOffset);
+							this.startWord = new AnchorSegment(textArea.Document, startWord.Offset, startWord.Length);
+						}
+					}
+				}
+			}
+			e.Handled = true;
+		}
+		#endregion
+		
+		#region Mouse Position <-> Text coordinates
+		SimpleSegment GetWordAtMousePosition(MouseEventArgs e)
+		{
+			TextView textView = textArea.TextView;
+			if (textView == null) return SimpleSegment.Invalid;
+			Point pos = e.GetPosition(textView);
+			if (pos.Y < 0)
+				pos.Y = 0;
+			if (pos.Y > textView.ActualHeight)
+				pos.Y = textView.ActualHeight;
+			pos += textView.ScrollOffset;
+			VisualLine line = textView.GetVisualLineFromVisualTop(pos.Y);
+			if (line != null) {
+				int visualColumn = line.GetVisualColumn(pos, textArea.Selection.EnableVirtualSpace);
+				int wordStartVC = line.GetNextCaretPosition(visualColumn + 1, LogicalDirection.Backward, CaretPositioningMode.WordStartOrSymbol, textArea.Selection.EnableVirtualSpace);
+				if (wordStartVC == -1)
+					wordStartVC = 0;
+				int wordEndVC = line.GetNextCaretPosition(wordStartVC, LogicalDirection.Forward, CaretPositioningMode.WordBorderOrSymbol, textArea.Selection.EnableVirtualSpace);
+				if (wordEndVC == -1)
+					wordEndVC = line.VisualLength;
+				int relOffset = line.FirstDocumentLine.Offset;
+				int wordStartOffset = line.GetRelativeOffset(wordStartVC) + relOffset;
+				int wordEndOffset = line.GetRelativeOffset(wordEndVC) + relOffset;
+				return new SimpleSegment(wordStartOffset, wordEndOffset - wordStartOffset);
+			} else {
+				return SimpleSegment.Invalid;
+			}
+		}
+		
+		SimpleSegment GetLineAtMousePosition(MouseEventArgs e)
+		{
+			TextView textView = textArea.TextView;
+			if (textView == null) return SimpleSegment.Invalid;
+			Point pos = e.GetPosition(textView);
+			if (pos.Y < 0)
+				pos.Y = 0;
+			if (pos.Y > textView.ActualHeight)
+				pos.Y = textView.ActualHeight;
+			pos += textView.ScrollOffset;
+			VisualLine line = textView.GetVisualLineFromVisualTop(pos.Y);
+			if (line != null) {
+				return new SimpleSegment(line.StartOffset, line.LastDocumentLine.EndOffset - line.StartOffset);
+			} else {
+				return SimpleSegment.Invalid;
+			}
+		}
+		
+		int GetOffsetFromMousePosition(MouseEventArgs e, out int visualColumn)
+		{
+			return GetOffsetFromMousePosition(e.GetPosition(textArea.TextView), out visualColumn);
+		}
+		
+		int GetOffsetFromMousePosition(Point positionRelativeToTextView, out int visualColumn)
+		{
+			visualColumn = 0;
+			TextView textView = textArea.TextView;
+			Point pos = positionRelativeToTextView;
+			if (pos.Y < 0)
+				pos.Y = 0;
+			if (pos.Y > textView.ActualHeight)
+				pos.Y = textView.ActualHeight;
+			pos += textView.ScrollOffset;
+			if (pos.Y > textView.DocumentHeight)
+				pos.Y = textView.DocumentHeight - ExtensionMethods.Epsilon;
+			VisualLine line = textView.GetVisualLineFromVisualTop(pos.Y);
+			if (line != null) {
+				visualColumn = line.GetVisualColumn(pos, textArea.Selection.EnableVirtualSpace);
+				return line.GetRelativeOffset(visualColumn) + line.FirstDocumentLine.Offset;
+			}
+			return -1;
+		}
+		
+		int GetOffsetFromMousePositionFirstTextLineOnly(Point positionRelativeToTextView, out int visualColumn)
+		{
+			visualColumn = 0;
+			TextView textView = textArea.TextView;
+			Point pos = positionRelativeToTextView;
+			if (pos.Y < 0)
+				pos.Y = 0;
+			if (pos.Y > textView.ActualHeight)
+				pos.Y = textView.ActualHeight;
+			pos += textView.ScrollOffset;
+			if (pos.Y > textView.DocumentHeight)
+				pos.Y = textView.DocumentHeight - ExtensionMethods.Epsilon;
+			VisualLine line = textView.GetVisualLineFromVisualTop(pos.Y);
+			if (line != null) {
+				visualColumn = line.GetVisualColumn(line.TextLines.First(), pos.X, textArea.Selection.EnableVirtualSpace);
+				return line.GetRelativeOffset(visualColumn) + line.FirstDocumentLine.Offset;
+			}
+			return -1;
+		}
+		#endregion
+		
+		#region MouseMove
+		void textArea_MouseMove(object sender, MouseEventArgs e)
+		{
+			if (e.Handled)
+				return;
+			if (mode == SelectionMode.Normal || mode == SelectionMode.WholeWord || mode == SelectionMode.WholeLine || mode == SelectionMode.Rectangular) {
+				e.Handled = true;
+				if (textArea.TextView.VisualLinesValid) {
+					// If the visual lines are not valid, don't extend the selection.
+					// Extending the selection forces a VisualLine refresh, and it is sufficient
+					// to do that on MouseUp, we don't have to do it every MouseMove.
+					ExtendSelectionToMouse(e);
+				}
+			} else if (mode == SelectionMode.PossibleDragStart) {
+				e.Handled = true;
+				Vector mouseMovement = e.GetPosition(textArea) - possibleDragStartMousePos;
+				if (Math.Abs(mouseMovement.X) > SystemParameters.MinimumHorizontalDragDistance
+				    || Math.Abs(mouseMovement.Y) > SystemParameters.MinimumVerticalDragDistance)
+				{
+					StartDrag();
+				}
+			}
+		}
+		#endregion
+		
+		#region ExtendSelection
+		void SetCaretOffsetToMousePosition(MouseEventArgs e)
+		{
+			SetCaretOffsetToMousePosition(e, null);
+		}
+		
+		void SetCaretOffsetToMousePosition(MouseEventArgs e, ISegment allowedSegment)
+		{
+			int visualColumn;
+			int offset;
+			if (mode == SelectionMode.Rectangular)
+				offset = GetOffsetFromMousePositionFirstTextLineOnly(e.GetPosition(textArea.TextView), out visualColumn);
+			else
+				offset = GetOffsetFromMousePosition(e, out visualColumn);
+			if (allowedSegment != null) {
+				offset = offset.CoerceValue(allowedSegment.Offset, allowedSegment.EndOffset);
+			}
+			if (offset >= 0) {
+				textArea.Caret.Position = new TextViewPosition(textArea.Document.GetLocation(offset), visualColumn);
+				textArea.Caret.DesiredXPos = double.NaN;
+			}
+		}
+		
+		void ExtendSelectionToMouse(MouseEventArgs e)
+		{
+			TextViewPosition oldPosition = textArea.Caret.Position;
+			if (mode == SelectionMode.Normal || mode == SelectionMode.Rectangular) {
+				SetCaretOffsetToMousePosition(e);
+				if (mode == SelectionMode.Normal && textArea.Selection is RectangleSelection)
+					textArea.Selection = new SimpleSelection(textArea, oldPosition, textArea.Caret.Position);
+				else if (mode == SelectionMode.Rectangular && !(textArea.Selection is RectangleSelection))
+					textArea.Selection = new RectangleSelection(textArea, oldPosition, textArea.Caret.Position);
+				else
+					textArea.Selection = textArea.Selection.StartSelectionOrSetEndpoint(oldPosition, textArea.Caret.Position);
+			} else if (mode == SelectionMode.WholeWord || mode == SelectionMode.WholeLine) {
+				var newWord = (mode == SelectionMode.WholeLine) ? GetLineAtMousePosition(e) : GetWordAtMousePosition(e);
+				if (newWord != SimpleSegment.Invalid) {
+					textArea.Selection = Selection.Create(textArea,
+					                                      Math.Min(newWord.Offset, startWord.Offset),
+					                                      Math.Max(newWord.EndOffset, startWord.EndOffset));
+					// Set caret offset, but limit the caret to stay inside the selection.
+					// in whole-word selection, it's otherwise possible that we get the caret outside the
+					// selection - but the TextArea doesn't like that and will reset the selection, causing
+					// flickering.
+					SetCaretOffsetToMousePosition(e, textArea.Selection.SurroundingSegment);
+				}
+			}
+			textArea.Caret.BringCaretToView(5.0);
+		}
+		#endregion
+		
+		#region MouseLeftButtonUp
+		void textArea_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
+		{
+			if (mode == SelectionMode.None || e.Handled)
+				return;
+			e.Handled = true;
+			if (mode == SelectionMode.PossibleDragStart) {
+				// -> this was not a drag start (mouse didn't move after mousedown)
+				SetCaretOffsetToMousePosition(e);
+				textArea.ClearSelection();
+			} else if (mode == SelectionMode.Normal || mode == SelectionMode.WholeWord || mode == SelectionMode.WholeLine || mode == SelectionMode.Rectangular) {
+				ExtendSelectionToMouse(e);
+			}
+			mode = SelectionMode.None;
+			textArea.ReleaseMouseCapture();
+		}
+		#endregion
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionSegment.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionSegment.cs
new file mode 100644
index 000000000..46c560b34
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SelectionSegment.cs
@@ -0,0 +1,89 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using Tango.Scripting.Editors.Document;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Represents a selected segment.
+	/// </summary>
+	public class SelectionSegment : ISegment
+	{
+		readonly int startOffset, endOffset;
+		readonly int startVC, endVC;
+		
+		/// <summary>
+		/// Creates a SelectionSegment from two offsets.
+		/// </summary>
+		public SelectionSegment(int startOffset, int endOffset)
+		{
+			this.startOffset = Math.Min(startOffset, endOffset);
+			this.endOffset = Math.Max(startOffset, endOffset);
+			this.startVC = this.endVC = -1;
+		}
+		
+		/// <summary>
+		/// Creates a SelectionSegment from two offsets and visual columns.
+		/// </summary>
+		public SelectionSegment(int startOffset, int startVC, int endOffset, int endVC)
+		{
+			if (startOffset < endOffset || (startOffset == endOffset && startVC <= endVC)) {
+				this.startOffset = startOffset;
+				this.startVC = startVC;
+				this.endOffset = endOffset;
+				this.endVC = endVC;
+			} else {
+				this.startOffset = endOffset;
+				this.startVC = endVC;
+				this.endOffset = startOffset;
+				this.endVC = startVC;
+			}
+		}
+		
+		/// <summary>
+		/// Gets the start offset.
+		/// </summary>
+		public int StartOffset {
+			get { return startOffset; }
+		}
+		
+		/// <summary>
+		/// Gets the end offset.
+		/// </summary>
+		public int EndOffset {
+			get { return endOffset; }
+		}
+		
+		/// <summary>
+		/// Gets the start visual column.
+		/// </summary>
+		public int StartVisualColumn {
+			get { return startVC; }
+		}
+		
+		/// <summary>
+		/// Gets the end visual column.
+		/// </summary>
+		public int EndVisualColumn {
+			get { return endVC; }
+		}
+		
+		/// <inheritdoc/>
+		int ISegment.Offset {
+			get { return startOffset; }
+		}
+		
+		/// <inheritdoc/>
+		public int Length {
+			get { return endOffset - startOffset; }
+		}
+		
+		/// <inheritdoc/>
+		public override string ToString()
+		{
+			return string.Format("[SelectionSegment StartOffset={0}, EndOffset={1}, StartVC={2}, EndVC={3}]", startOffset, endOffset, startVC, endVC);
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SimpleSelection.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SimpleSelection.cs
new file mode 100644
index 000000000..132b09e20
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/SimpleSelection.cs
@@ -0,0 +1,144 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// A simple selection.
+	/// </summary>
+	sealed class SimpleSelection : Selection
+	{
+		readonly TextViewPosition start, end;
+		readonly int startOffset, endOffset;
+		
+		/// <summary>
+		/// Creates a new SimpleSelection instance.
+		/// </summary>
+		internal SimpleSelection(TextArea textArea, TextViewPosition start, TextViewPosition end)
+			: base(textArea)
+		{
+			this.start = start;
+			this.end = end;
+			this.startOffset = textArea.Document.GetOffset(start.Location);
+			this.endOffset = textArea.Document.GetOffset(end.Location);
+		}
+		
+		/// <inheritdoc/>
+		public override IEnumerable<SelectionSegment> Segments {
+			get {
+				return ExtensionMethods.Sequence<SelectionSegment>(new SelectionSegment(startOffset, start.VisualColumn, endOffset, end.VisualColumn));
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override ISegment SurroundingSegment {
+			get {
+				return new SelectionSegment(startOffset, endOffset);
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override void ReplaceSelectionWithText(string newText)
+		{
+			if (newText == null)
+				throw new ArgumentNullException("newText");
+			using (textArea.Document.RunUpdate()) {
+				ISegment[] segmentsToDelete = textArea.GetDeletableSegments(this.SurroundingSegment);
+				for (int i = segmentsToDelete.Length - 1; i >= 0; i--) {
+					if (i == segmentsToDelete.Length - 1) {
+						if (segmentsToDelete[i].Offset == SurroundingSegment.Offset && segmentsToDelete[i].Length == SurroundingSegment.Length) {
+							newText = AddSpacesIfRequired(newText, start, end);
+						}
+						int vc = textArea.Caret.VisualColumn;
+						textArea.Caret.Offset = segmentsToDelete[i].EndOffset;
+						if (string.IsNullOrEmpty(newText))
+							textArea.Caret.VisualColumn = vc;
+						textArea.Document.Replace(segmentsToDelete[i], newText);
+					} else {
+						textArea.Document.Remove(segmentsToDelete[i]);
+					}
+				}
+				if (segmentsToDelete.Length != 0) {
+					textArea.ClearSelection();
+				}
+			}
+		}
+		
+		public override TextViewPosition StartPosition {
+			get { return start; }
+		}
+		
+		public override TextViewPosition EndPosition {
+			get { return end; }
+		}
+		
+		/// <inheritdoc/>
+		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
+		{
+			if (e == null)
+				throw new ArgumentNullException("e");
+			return Selection.Create(
+				textArea,
+				new TextViewPosition(textArea.Document.GetLocation(e.GetNewOffset(startOffset, AnchorMovementType.Default)), start.VisualColumn),
+				new TextViewPosition(textArea.Document.GetLocation(e.GetNewOffset(endOffset, AnchorMovementType.Default)), end.VisualColumn)
+			);
+		}
+		
+		/// <inheritdoc/>
+		public override bool IsEmpty {
+			get { return startOffset == endOffset; }
+		}
+		
+		/// <inheritdoc/>
+		public override int Length {
+			get {
+				return Math.Abs(endOffset - startOffset);
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override Selection SetEndpoint(TextViewPosition endPosition)
+		{
+			return Create(textArea, start, endPosition);
+		}
+		
+		public override Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition)
+		{
+			var document = textArea.Document;
+			if (document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			return Create(textArea, start, endPosition);
+		}
+		
+		/// <inheritdoc/>
+		public override int GetHashCode()
+		{
+			unchecked {
+				return startOffset * 27811 + endOffset + textArea.GetHashCode();
+			}
+		}
+		
+		/// <inheritdoc/>
+		public override bool Equals(object obj)
+		{
+			SimpleSelection other = obj as SimpleSelection;
+			if (other == null) return false;
+			return this.start.Equals(other.start) && this.end.Equals(other.end)
+				&& this.startOffset == other.startOffset && this.endOffset == other.endOffset
+				&& this.textArea == other.textArea;
+		}
+		
+		/// <inheritdoc/>
+		public override string ToString()
+		{
+			return "[SimpleSelection Start=" + start + " End=" + end + "]";
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextArea.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextArea.cs
new file mode 100644
index 000000000..393a3e29c
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextArea.cs
@@ -0,0 +1,1048 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Indentation;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Control that wraps a TextView and adds support for user input and the caret.
+	/// </summary>
+	public class TextArea : Control, IScrollInfo, IWeakEventListener, ITextEditorComponent, IServiceProvider
+	{
+		internal readonly ImeSupport ime;
+		
+		#region Constructor
+		static TextArea()
+		{
+			DefaultStyleKeyProperty.OverrideMetadata(typeof(TextArea),
+			                                         new FrameworkPropertyMetadata(typeof(TextArea)));
+			KeyboardNavigation.IsTabStopProperty.OverrideMetadata(
+				typeof(TextArea), new FrameworkPropertyMetadata(Boxes.True));
+			KeyboardNavigation.TabNavigationProperty.OverrideMetadata(
+				typeof(TextArea), new FrameworkPropertyMetadata(KeyboardNavigationMode.None));
+			FocusableProperty.OverrideMetadata(
+				typeof(TextArea), new FrameworkPropertyMetadata(Boxes.True));
+		}
+		
+		/// <summary>
+		/// Creates a new TextArea instance.
+		/// </summary>
+		public TextArea() : this(new TextView())
+		{
+		}
+		
+		/// <summary>
+		/// Creates a new TextArea instance.
+		/// </summary>
+		protected TextArea(TextView textView)
+		{
+			if (textView == null)
+				throw new ArgumentNullException("textView");
+			this.textView = textView;
+			this.Options = textView.Options;
+			
+			selection = emptySelection = new EmptySelection(this);
+			
+			textView.Services.AddService(typeof(TextArea), this);
+			
+			textView.LineTransformers.Add(new SelectionColorizer(this));
+			textView.InsertLayer(new SelectionLayer(this), KnownLayer.Selection, LayerInsertionPosition.Replace);
+			
+			caret = new Caret(this);
+			caret.PositionChanged += (sender, e) => RequestSelectionValidation();
+			ime = new ImeSupport(this);
+			
+			leftMargins.CollectionChanged += leftMargins_CollectionChanged;
+			
+			this.DefaultInputHandler = new TextAreaDefaultInputHandler(this);
+			this.ActiveInputHandler = this.DefaultInputHandler;
+		}
+		#endregion
+		
+		#region InputHandler management
+		/// <summary>
+		/// Gets the default input handler.
+		/// </summary>
+		/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+		public TextAreaDefaultInputHandler DefaultInputHandler { get; private set; }
+		
+		ITextAreaInputHandler activeInputHandler;
+		bool isChangingInputHandler;
+		
+		/// <summary>
+		/// Gets/Sets the active input handler.
+		/// This property does not return currently active stacked input handlers. Setting this property detached all stacked input handlers.
+		/// </summary>
+		/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+		public ITextAreaInputHandler ActiveInputHandler {
+			get { return activeInputHandler; }
+			set {
+				if (value != null && value.TextArea != this)
+					throw new ArgumentException("The input handler was created for a different text area than this one.");
+				if (isChangingInputHandler)
+					throw new InvalidOperationException("Cannot set ActiveInputHandler recursively");
+				if (activeInputHandler != value) {
+					isChangingInputHandler = true;
+					try {
+						// pop the whole stack
+						PopStackedInputHandler(stackedInputHandlers.LastOrDefault());
+						Debug.Assert(stackedInputHandlers.IsEmpty);
+						
+						if (activeInputHandler != null)
+							activeInputHandler.Detach();
+						activeInputHandler = value;
+						if (value != null)
+							value.Attach();
+					} finally {
+						isChangingInputHandler = false;
+					}
+					if (ActiveInputHandlerChanged != null)
+						ActiveInputHandlerChanged(this, EventArgs.Empty);
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Occurs when the ActiveInputHandler property changes.
+		/// </summary>
+		public event EventHandler ActiveInputHandlerChanged;
+		
+		ImmutableStack<TextAreaStackedInputHandler> stackedInputHandlers = ImmutableStack<TextAreaStackedInputHandler>.Empty;
+		
+		/// <summary>
+		/// Gets the list of currently active stacked input handlers.
+		/// </summary>
+		/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+		public ImmutableStack<TextAreaStackedInputHandler> StackedInputHandlers {
+			get { return stackedInputHandlers; }
+		}
+		
+		/// <summary>
+		/// Pushes an input handler onto the list of stacked input handlers.
+		/// </summary>
+		/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+		public void PushStackedInputHandler(TextAreaStackedInputHandler inputHandler)
+		{
+			if (inputHandler == null)
+				throw new ArgumentNullException("inputHandler");
+			stackedInputHandlers = stackedInputHandlers.Push(inputHandler);
+			inputHandler.Attach();
+		}
+		
+		/// <summary>
+		/// Pops the stacked input handler (and all input handlers above it).
+		/// If <paramref name="inputHandler"/> is not found in the currently stacked input handlers, or is null, this method
+		/// does nothing.
+		/// </summary>
+		/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+		public void PopStackedInputHandler(TextAreaStackedInputHandler inputHandler)
+		{
+			if (stackedInputHandlers.Any(i => i == inputHandler)) {
+				ITextAreaInputHandler oldHandler;
+				do {
+					oldHandler = stackedInputHandlers.Peek();
+					stackedInputHandlers = stackedInputHandlers.Pop();
+					oldHandler.Detach();
+				} while (oldHandler != inputHandler);
+			}
+		}
+		#endregion
+		
+		#region Document property
+		/// <summary>
+		/// Document property.
+		/// </summary>
+		public static readonly DependencyProperty DocumentProperty
+			= TextView.DocumentProperty.AddOwner(typeof(TextArea), new FrameworkPropertyMetadata(OnDocumentChanged));
+		
+		/// <summary>
+		/// Gets/Sets the document displayed by the text editor.
+		/// </summary>
+		public TextDocument Document {
+			get { return (TextDocument)GetValue(DocumentProperty); }
+			set { SetValue(DocumentProperty, value); }
+		}
+		
+		/// <inheritdoc/>
+		public event EventHandler DocumentChanged;
+		
+		static void OnDocumentChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
+		{
+			((TextArea)dp).OnDocumentChanged((TextDocument)e.OldValue, (TextDocument)e.NewValue);
+		}
+		
+		void OnDocumentChanged(TextDocument oldValue, TextDocument newValue)
+		{
+			if (oldValue != null) {
+				TextDocumentWeakEventManager.Changing.RemoveListener(oldValue, this);
+				TextDocumentWeakEventManager.Changed.RemoveListener(oldValue, this);
+				TextDocumentWeakEventManager.UpdateStarted.RemoveListener(oldValue, this);
+				TextDocumentWeakEventManager.UpdateFinished.RemoveListener(oldValue, this);
+			}
+			textView.Document = newValue;
+			if (newValue != null) {
+				TextDocumentWeakEventManager.Changing.AddListener(newValue, this);
+				TextDocumentWeakEventManager.Changed.AddListener(newValue, this);
+				TextDocumentWeakEventManager.UpdateStarted.AddListener(newValue, this);
+				TextDocumentWeakEventManager.UpdateFinished.AddListener(newValue, this);
+			}
+			// Reset caret location and selection: this is necessary because the caret/selection might be invalid
+			// in the new document (e.g. if new document is shorter than the old document).
+			caret.Location = new TextLocation(1, 1);
+			this.ClearSelection();
+			if (DocumentChanged != null)
+				DocumentChanged(this, EventArgs.Empty);
+			CommandManager.InvalidateRequerySuggested();
+		}
+		#endregion
+		
+		#region Options property
+		/// <summary>
+		/// Options property.
+		/// </summary>
+		public static readonly DependencyProperty OptionsProperty
+			= TextView.OptionsProperty.AddOwner(typeof(TextArea), new FrameworkPropertyMetadata(OnOptionsChanged));
+		
+		/// <summary>
+		/// Gets/Sets the document displayed by the text editor.
+		/// </summary>
+		public TextEditorOptions Options {
+			get { return (TextEditorOptions)GetValue(OptionsProperty); }
+			set { SetValue(OptionsProperty, value); }
+		}
+		
+		/// <summary>
+		/// Occurs when a text editor option has changed.
+		/// </summary>
+		public event PropertyChangedEventHandler OptionChanged;
+		
+		/// <summary>
+		/// Raises the <see cref="OptionChanged"/> event.
+		/// </summary>
+		protected virtual void OnOptionChanged(PropertyChangedEventArgs e)
+		{
+			if (OptionChanged != null) {
+				OptionChanged(this, e);
+			}
+		}
+		
+		static void OnOptionsChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
+		{
+			((TextArea)dp).OnOptionsChanged((TextEditorOptions)e.OldValue, (TextEditorOptions)e.NewValue);
+		}
+		
+		void OnOptionsChanged(TextEditorOptions oldValue, TextEditorOptions newValue)
+		{
+			if (oldValue != null) {
+				PropertyChangedWeakEventManager.RemoveListener(oldValue, this);
+			}
+			textView.Options = newValue;
+			if (newValue != null) {
+				PropertyChangedWeakEventManager.AddListener(newValue, this);
+			}
+			OnOptionChanged(new PropertyChangedEventArgs(null));
+		}
+		#endregion
+		
+		#region ReceiveWeakEvent
+		/// <inheritdoc cref="IWeakEventListener.ReceiveWeakEvent"/>
+		protected virtual bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+		{
+			if (managerType == typeof(TextDocumentWeakEventManager.Changing)) {
+				OnDocumentChanging();
+				return true;
+			} else if (managerType == typeof(TextDocumentWeakEventManager.Changed)) {
+				OnDocumentChanged((DocumentChangeEventArgs)e);
+				return true;
+			} else if (managerType == typeof(TextDocumentWeakEventManager.UpdateStarted)) {
+				OnUpdateStarted();
+				return true;
+			} else if (managerType == typeof(TextDocumentWeakEventManager.UpdateFinished)) {
+				OnUpdateFinished();
+				return true;
+			} else if (managerType == typeof(PropertyChangedWeakEventManager)) {
+				OnOptionChanged((PropertyChangedEventArgs)e);
+				return true;
+			}
+			return false;
+		}
+		
+		bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+		{
+			return ReceiveWeakEvent(managerType, sender, e);
+		}
+		#endregion
+		
+		#region Caret handling on document changes
+		void OnDocumentChanging()
+		{
+			caret.OnDocumentChanging();
+		}
+		
+		void OnDocumentChanged(DocumentChangeEventArgs e)
+		{
+			caret.OnDocumentChanged(e);
+			this.Selection = selection.UpdateOnDocumentChange(e);
+		}
+		
+		void OnUpdateStarted()
+		{
+			Document.UndoStack.PushOptional(new RestoreCaretAndSelectionUndoAction(this));
+		}
+		
+		void OnUpdateFinished()
+		{
+			caret.OnDocumentUpdateFinished();
+		}
+		
+		sealed class RestoreCaretAndSelectionUndoAction : IUndoableOperation
+		{
+			// keep textarea in weak reference because the IUndoableOperation is stored with the document
+			WeakReference textAreaReference;
+			TextViewPosition caretPosition;
+			Selection selection;
+			
+			public RestoreCaretAndSelectionUndoAction(TextArea textArea)
+			{
+				this.textAreaReference = new WeakReference(textArea);
+				// Just save the old caret position, no need to validate here.
+				// If we restore it, we'll validate it anyways.
+				this.caretPosition = textArea.Caret.NonValidatedPosition;
+				this.selection = textArea.Selection;
+			}
+			
+			public void Undo()
+			{
+				TextArea textArea = (TextArea)textAreaReference.Target;
+				if (textArea != null) {
+					textArea.Caret.Position = caretPosition;
+					textArea.Selection = selection;
+				}
+			}
+			
+			public void Redo()
+			{
+				// redo=undo: we just restore the caret/selection state
+				Undo();
+			}
+		}
+		#endregion
+		
+		#region TextView property
+		readonly TextView textView;
+		IScrollInfo scrollInfo;
+
+		/// <summary>
+		/// Gets the text view used to display text in this text area.
+		/// </summary>
+		public TextView TextView {
+			get {
+				return textView;
+			}
+		}
+		/// <inheritdoc/>
+		public override void OnApplyTemplate()
+		{
+			base.OnApplyTemplate();
+			scrollInfo = textView;
+			ApplyScrollInfo();
+		}
+		#endregion
+		
+		#region Selection property
+		internal readonly Selection emptySelection;
+		Selection selection;
+		
+		/// <summary>
+		/// Occurs when the selection has changed.
+		/// </summary>
+		public event EventHandler SelectionChanged;
+		
+		/// <summary>
+		/// Gets/Sets the selection in this text area.
+		/// </summary>
+		
+		public Selection Selection {
+			get { return selection; }
+			set {
+				if (value == null)
+					throw new ArgumentNullException("value");
+				if (value.textArea != this)
+					throw new ArgumentException("Cannot use a Selection instance that belongs to another text area.");
+				if (!object.Equals(selection, value)) {
+//					Debug.WriteLine("Selection change from " + selection + " to " + value);
+					if (textView != null) {
+						ISegment oldSegment = selection.SurroundingSegment;
+						ISegment newSegment = value.SurroundingSegment;
+						if (!Selection.EnableVirtualSpace && (selection is SimpleSelection && value is SimpleSelection && oldSegment != null && newSegment != null)) {
+							// perf optimization:
+							// When a simple selection changes, don't redraw the whole selection, but only the changed parts.
+							int oldSegmentOffset = oldSegment.Offset;
+							int newSegmentOffset = newSegment.Offset;
+							if (oldSegmentOffset != newSegmentOffset) {
+								textView.Redraw(Math.Min(oldSegmentOffset, newSegmentOffset),
+								                Math.Abs(oldSegmentOffset - newSegmentOffset),
+								                DispatcherPriority.Background);
+							}
+							int oldSegmentEndOffset = oldSegment.EndOffset;
+							int newSegmentEndOffset = newSegment.EndOffset;
+							if (oldSegmentEndOffset != newSegmentEndOffset) {
+								textView.Redraw(Math.Min(oldSegmentEndOffset, newSegmentEndOffset),
+								                Math.Abs(oldSegmentEndOffset - newSegmentEndOffset),
+								                DispatcherPriority.Background);
+							}
+						} else {
+							textView.Redraw(oldSegment, DispatcherPriority.Background);
+							textView.Redraw(newSegment, DispatcherPriority.Background);
+						}
+					}
+					selection = value;
+					if (SelectionChanged != null)
+						SelectionChanged(this, EventArgs.Empty);
+					// a selection change causes commands like copy/paste/etc. to change status
+					CommandManager.InvalidateRequerySuggested();
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Clears the current selection.
+		/// </summary>
+		public void ClearSelection()
+		{
+			this.Selection = emptySelection;
+		}
+		
+		/// <summary>
+		/// The <see cref="SelectionBrush"/> property.
+		/// </summary>
+		public static readonly DependencyProperty SelectionBrushProperty =
+			DependencyProperty.Register("SelectionBrush", typeof(Brush), typeof(TextArea));
+		
+		/// <summary>
+		/// Gets/Sets the background brush used for the selection.
+		/// </summary>
+		public Brush SelectionBrush {
+			get { return (Brush)GetValue(SelectionBrushProperty); }
+			set { SetValue(SelectionBrushProperty, value); }
+		}
+		
+		/// <summary>
+		/// The <see cref="SelectionForeground"/> property.
+		/// </summary>
+		public static readonly DependencyProperty SelectionForegroundProperty =
+			DependencyProperty.Register("SelectionForeground", typeof(Brush), typeof(TextArea));
+		
+		/// <summary>
+		/// Gets/Sets the foreground brush used selected text.
+		/// </summary>
+		public Brush SelectionForeground {
+			get { return (Brush)GetValue(SelectionForegroundProperty); }
+			set { SetValue(SelectionForegroundProperty, value); }
+		}
+		
+		/// <summary>
+		/// The <see cref="SelectionBorder"/> property.
+		/// </summary>
+		public static readonly DependencyProperty SelectionBorderProperty =
+			DependencyProperty.Register("SelectionBorder", typeof(Pen), typeof(TextArea));
+		
+		/// <summary>
+		/// Gets/Sets the background brush used for the selection.
+		/// </summary>
+		public Pen SelectionBorder {
+			get { return (Pen)GetValue(SelectionBorderProperty); }
+			set { SetValue(SelectionBorderProperty, value); }
+		}
+		
+		/// <summary>
+		/// The <see cref="SelectionCornerRadius"/> property.
+		/// </summary>
+		public static readonly DependencyProperty SelectionCornerRadiusProperty =
+			DependencyProperty.Register("SelectionCornerRadius", typeof(double), typeof(TextArea),
+			                            new FrameworkPropertyMetadata(3.0));
+		
+		/// <summary>
+		/// Gets/Sets the corner radius of the selection.
+		/// </summary>
+		public double SelectionCornerRadius {
+			get { return (double)GetValue(SelectionCornerRadiusProperty); }
+			set { SetValue(SelectionCornerRadiusProperty, value); }
+		}
+		#endregion
+		
+		#region Force caret to stay inside selection
+		bool ensureSelectionValidRequested;
+		int allowCaretOutsideSelection;
+		
+		void RequestSelectionValidation()
+		{
+			if (!ensureSelectionValidRequested && allowCaretOutsideSelection == 0) {
+				ensureSelectionValidRequested = true;
+				Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(EnsureSelectionValid));
+			}
+		}
+		
+		/// <summary>
+		/// Code that updates only the caret but not the selection can cause confusion when
+		/// keys like 'Delete' delete the (possibly invisible) selected text and not the
+		/// text around the caret.
+		/// 
+		/// So we'll ensure that the caret is inside the selection.
+		/// (when the caret is not in the selection, we'll clear the selection)
+		/// 
+		/// This method is invoked using the Dispatcher so that code may temporarily violate this rule
+		/// (e.g. most 'extend selection' methods work by first setting the caret, then the selection),
+		/// it's sufficient to fix it after any event handlers have run.
+		/// </summary>
+		void EnsureSelectionValid()
+		{
+			ensureSelectionValidRequested = false;
+			if (allowCaretOutsideSelection == 0) {
+				if (!selection.IsEmpty && !selection.Contains(caret.Offset)) {
+					Debug.WriteLine("Resetting selection because caret is outside");
+					this.ClearSelection();
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Temporarily allows positioning the caret outside the selection.
+		/// Dispose the returned IDisposable to revert the allowance.
+		/// </summary>
+		/// <remarks>
+		/// The text area only forces the caret to be inside the selection when other events
+		/// have finished running (using the dispatcher), so you don't have to use this method
+		/// for temporarily positioning the caret in event handlers.
+		/// This method is only necessary if you want to run the WPF dispatcher, e.g. if you
+		/// perform a drag'n'drop operation.
+		/// </remarks>
+		public IDisposable AllowCaretOutsideSelection()
+		{
+			VerifyAccess();
+			allowCaretOutsideSelection++;
+			return new CallbackOnDispose(
+				delegate {
+					VerifyAccess();
+					allowCaretOutsideSelection--;
+					RequestSelectionValidation();
+				});
+		}
+		#endregion
+		
+		#region Properties
+		readonly Caret caret;
+		
+		/// <summary>
+		/// Gets the Caret used for this text area.
+		/// </summary>
+		public Caret Caret {
+			get { return caret; }
+		}
+		
+		ObservableCollection<UIElement> leftMargins = new ObservableCollection<UIElement>();
+		
+		/// <summary>
+		/// Gets the collection of margins displayed to the left of the text view.
+		/// </summary>
+		public ObservableCollection<UIElement> LeftMargins {
+			get {
+				return leftMargins;
+			}
+		}
+		
+		void leftMargins_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (e.OldItems != null) {
+				foreach (ITextViewConnect c in e.OldItems.OfType<ITextViewConnect>()) {
+					c.RemoveFromTextView(textView);
+				}
+			}
+			if (e.NewItems != null) {
+				foreach (ITextViewConnect c in e.NewItems.OfType<ITextViewConnect>()) {
+					c.AddToTextView(textView);
+				}
+			}
+		}
+		
+		IReadOnlySectionProvider readOnlySectionProvider = NoReadOnlySections.Instance;
+		
+		/// <summary>
+		/// Gets/Sets an object that provides read-only sections for the text area.
+		/// </summary>
+		public IReadOnlySectionProvider ReadOnlySectionProvider {
+			get { return readOnlySectionProvider; }
+			set {
+				if (value == null)
+					throw new ArgumentNullException("value");
+				readOnlySectionProvider = value;
+				CommandManager.InvalidateRequerySuggested(); // the read-only status effects Paste.CanExecute and the IME
+			}
+		}
+		#endregion
+		
+		#region IScrollInfo implementation
+		ScrollViewer scrollOwner;
+		bool canVerticallyScroll, canHorizontallyScroll;
+		
+		void ApplyScrollInfo()
+		{
+			if (scrollInfo != null) {
+				scrollInfo.ScrollOwner = scrollOwner;
+				scrollInfo.CanVerticallyScroll = canVerticallyScroll;
+				scrollInfo.CanHorizontallyScroll = canHorizontallyScroll;
+				scrollOwner = null;
+			}
+		}
+		
+		bool IScrollInfo.CanVerticallyScroll {
+			get { return scrollInfo != null ? scrollInfo.CanVerticallyScroll : false; }
+			set {
+				canVerticallyScroll = value;
+				if (scrollInfo != null)
+					scrollInfo.CanVerticallyScroll = value;
+			}
+		}
+		
+		bool IScrollInfo.CanHorizontallyScroll {
+			get { return scrollInfo != null ? scrollInfo.CanHorizontallyScroll : false; }
+			set {
+				canHorizontallyScroll = value;
+				if (scrollInfo != null)
+					scrollInfo.CanHorizontallyScroll = value;
+			}
+		}
+		
+		double IScrollInfo.ExtentWidth {
+			get { return scrollInfo != null ? scrollInfo.ExtentWidth : 0; }
+		}
+		
+		double IScrollInfo.ExtentHeight {
+			get { return scrollInfo != null ? scrollInfo.ExtentHeight : 0; }
+		}
+		
+		double IScrollInfo.ViewportWidth {
+			get { return scrollInfo != null ? scrollInfo.ViewportWidth : 0; }
+		}
+		
+		double IScrollInfo.ViewportHeight {
+			get { return scrollInfo != null ? scrollInfo.ViewportHeight : 0; }
+		}
+		
+		double IScrollInfo.HorizontalOffset {
+			get { return scrollInfo != null ? scrollInfo.HorizontalOffset : 0; }
+		}
+		
+		double IScrollInfo.VerticalOffset {
+			get { return scrollInfo != null ? scrollInfo.VerticalOffset : 0; }
+		}
+		
+		ScrollViewer IScrollInfo.ScrollOwner {
+			get { return scrollInfo != null ? scrollInfo.ScrollOwner : null; }
+			set {
+				if (scrollInfo != null)
+					scrollInfo.ScrollOwner = value;
+				else
+					scrollOwner = value;
+			}
+		}
+		
+		void IScrollInfo.LineUp()
+		{
+			if (scrollInfo != null) scrollInfo.LineUp();
+		}
+		
+		void IScrollInfo.LineDown()
+		{
+			if (scrollInfo != null) scrollInfo.LineDown();
+		}
+		
+		void IScrollInfo.LineLeft()
+		{
+			if (scrollInfo != null) scrollInfo.LineLeft();
+		}
+		
+		void IScrollInfo.LineRight()
+		{
+			if (scrollInfo != null) scrollInfo.LineRight();
+		}
+		
+		void IScrollInfo.PageUp()
+		{
+			if (scrollInfo != null) scrollInfo.PageUp();
+		}
+		
+		void IScrollInfo.PageDown()
+		{
+			if (scrollInfo != null) scrollInfo.PageDown();
+		}
+		
+		void IScrollInfo.PageLeft()
+		{
+			if (scrollInfo != null) scrollInfo.PageLeft();
+		}
+		
+		void IScrollInfo.PageRight()
+		{
+			if (scrollInfo != null) scrollInfo.PageRight();
+		}
+		
+		void IScrollInfo.MouseWheelUp()
+		{
+			if (scrollInfo != null) scrollInfo.MouseWheelUp();
+		}
+		
+		void IScrollInfo.MouseWheelDown()
+		{
+			if (scrollInfo != null) scrollInfo.MouseWheelDown();
+		}
+		
+		void IScrollInfo.MouseWheelLeft()
+		{
+			if (scrollInfo != null) scrollInfo.MouseWheelLeft();
+		}
+		
+		void IScrollInfo.MouseWheelRight()
+		{
+			if (scrollInfo != null) scrollInfo.MouseWheelRight();
+		}
+		
+		void IScrollInfo.SetHorizontalOffset(double offset)
+		{
+			if (scrollInfo != null) scrollInfo.SetHorizontalOffset(offset);
+		}
+		
+		void IScrollInfo.SetVerticalOffset(double offset)
+		{
+			if (scrollInfo != null) scrollInfo.SetVerticalOffset(offset);
+		}
+		
+		Rect IScrollInfo.MakeVisible(System.Windows.Media.Visual visual, Rect rectangle)
+		{
+			if (scrollInfo != null)
+				return scrollInfo.MakeVisible(visual, rectangle);
+			else
+				return Rect.Empty;
+		}
+		#endregion
+		
+		#region Focus Handling (Show/Hide Caret)
+		/// <inheritdoc/>
+		protected override void OnMouseDown(MouseButtonEventArgs e)
+		{
+			base.OnMouseDown(e);
+			Focus();
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e)
+		{
+			base.OnGotKeyboardFocus(e);
+			// First activate IME, then show caret
+			ime.OnGotKeyboardFocus(e);
+			caret.Show();
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e)
+		{
+			base.OnLostKeyboardFocus(e);
+			caret.Hide();
+			ime.OnLostKeyboardFocus(e);
+		}
+		#endregion
+		
+		#region OnTextInput / RemoveSelectedText / ReplaceSelectionWithText
+		/// <summary>
+		/// Occurs when the TextArea receives text input.
+		/// This is like the <see cref="UIElement.TextInput"/> event,
+		/// but occurs immediately before the TextArea handles the TextInput event.
+		/// </summary>
+		public event TextCompositionEventHandler TextEntering;
+		
+		/// <summary>
+		/// Occurs when the TextArea receives text input.
+		/// This is like the <see cref="UIElement.TextInput"/> event,
+		/// but occurs immediately after the TextArea handles the TextInput event.
+		/// </summary>
+		public event TextCompositionEventHandler TextEntered;
+		
+		/// <summary>
+		/// Raises the TextEntering event.
+		/// </summary>
+		protected virtual void OnTextEntering(TextCompositionEventArgs e)
+		{
+			if (TextEntering != null) {
+				TextEntering(this, e);
+			}
+		}
+		
+		/// <summary>
+		/// Raises the TextEntered event.
+		/// </summary>
+		protected virtual void OnTextEntered(TextCompositionEventArgs e)
+		{
+			if (TextEntered != null) {
+				TextEntered(this, e);
+			}
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnTextInput(TextCompositionEventArgs e)
+		{
+			//Debug.WriteLine("TextInput: Text='" + e.Text + "' SystemText='" + e.SystemText + "' ControlText='" + e.ControlText + "'");
+			base.OnTextInput(e);
+			if (!e.Handled && this.Document != null) {
+				if (string.IsNullOrEmpty(e.Text) || e.Text == "\x1b" || e.Text == "\b") {
+					// ASCII 0x1b = ESC.
+					// WPF produces a TextInput event with that old ASCII control char
+					// when Escape is pressed. We'll just ignore it.
+					
+					// A deadkey followed by backspace causes a textinput event for the BS character.
+					
+					// Similarly, some shortcuts like Alt+Space produce an empty TextInput event.
+					// We have to ignore those (not handle them) to keep the shortcut working.
+					return;
+				}
+				PerformTextInput(e);
+				e.Handled = true;
+			}
+		}
+		
+		/// <summary>
+		/// Performs text input.
+		/// This raises the <see cref="TextEntering"/> event, replaces the selection with the text,
+		/// and then raises the <see cref="TextEntered"/> event.
+		/// </summary>
+		public void PerformTextInput(string text)
+		{
+			TextComposition textComposition = new TextComposition(InputManager.Current, this, text);
+			TextCompositionEventArgs e = new TextCompositionEventArgs(Keyboard.PrimaryDevice, textComposition);
+			e.RoutedEvent = TextInputEvent;
+			PerformTextInput(e);
+		}
+		
+		/// <summary>
+		/// Performs text input.
+		/// This raises the <see cref="TextEntering"/> event, replaces the selection with the text,
+		/// and then raises the <see cref="TextEntered"/> event.
+		/// </summary>
+		public void PerformTextInput(TextCompositionEventArgs e)
+		{
+			if (e == null)
+				throw new ArgumentNullException("e");
+			if (this.Document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			OnTextEntering(e);
+			if (!e.Handled) {
+				if (e.Text == "\n" || e.Text == "\r" || e.Text == "\r\n")
+					ReplaceSelectionWithNewLine();
+				else
+					ReplaceSelectionWithText(e.Text);
+				OnTextEntered(e);
+				caret.BringCaretToView();
+			}
+		}
+		
+		void ReplaceSelectionWithNewLine()
+		{
+			string newLine = TextUtilities.GetNewLineFromDocument(this.Document, this.Caret.Line);
+			using (this.Document.RunUpdate()) {
+				ReplaceSelectionWithText(newLine);
+				if (this.IndentationStrategy != null) {
+					DocumentLine line = this.Document.GetLineByNumber(this.Caret.Line);
+					ISegment[] deletable = GetDeletableSegments(line);
+					if (deletable.Length == 1 && deletable[0].Offset == line.Offset && deletable[0].Length == line.Length) {
+						// use indentation strategy only if the line is not read-only
+						this.IndentationStrategy.IndentLine(this.Document, line);
+					}
+				}
+			}
+		}
+		
+		internal void RemoveSelectedText()
+		{
+			if (this.Document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			selection.ReplaceSelectionWithText(string.Empty);
+			#if DEBUG
+			if (!selection.IsEmpty) {
+				foreach (ISegment s in selection.Segments) {
+					Debug.Assert(this.ReadOnlySectionProvider.GetDeletableSegments(s).Count() == 0);
+				}
+			}
+			#endif
+		}
+		
+		internal void ReplaceSelectionWithText(string newText)
+		{
+			if (newText == null)
+				throw new ArgumentNullException("newText");
+			if (this.Document == null)
+				throw ThrowUtil.NoDocumentAssigned();
+			selection.ReplaceSelectionWithText(newText);
+		}
+		
+		internal ISegment[] GetDeletableSegments(ISegment segment)
+		{
+			var deletableSegments = this.ReadOnlySectionProvider.GetDeletableSegments(segment);
+			if (deletableSegments == null)
+				throw new InvalidOperationException("ReadOnlySectionProvider.GetDeletableSegments returned null");
+			var array = deletableSegments.ToArray();
+			int lastIndex = segment.Offset;
+			for (int i = 0; i < array.Length; i++) {
+				if (array[i].Offset < lastIndex)
+					throw new InvalidOperationException("ReadOnlySectionProvider returned incorrect segments (outside of input segment / wrong order)");
+				lastIndex = array[i].EndOffset;
+			}
+			if (lastIndex > segment.EndOffset)
+				throw new InvalidOperationException("ReadOnlySectionProvider returned incorrect segments (outside of input segment / wrong order)");
+			return array;
+		}
+		#endregion
+		
+		#region IndentationStrategy property
+		/// <summary>
+		/// IndentationStrategy property.
+		/// </summary>
+		public static readonly DependencyProperty IndentationStrategyProperty =
+			DependencyProperty.Register("IndentationStrategy", typeof(IIndentationStrategy), typeof(TextArea),
+			                            new FrameworkPropertyMetadata(new DefaultIndentationStrategy()));
+		
+		/// <summary>
+		/// Gets/Sets the indentation strategy used when inserting new lines.
+		/// </summary>
+		public IIndentationStrategy IndentationStrategy {
+			get { return (IIndentationStrategy)GetValue(IndentationStrategyProperty); }
+			set { SetValue(IndentationStrategyProperty, value); }
+		}
+		#endregion
+		
+		#region OnKeyDown/OnKeyUp
+		/// <inheritdoc/>
+		protected override void OnPreviewKeyDown(KeyEventArgs e)
+		{
+			base.OnPreviewKeyDown(e);
+			foreach (TextAreaStackedInputHandler h in stackedInputHandlers) {
+				if (e.Handled)
+					break;
+				h.OnPreviewKeyDown(e);
+			}
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnPreviewKeyUp(KeyEventArgs e)
+		{
+			base.OnPreviewKeyUp(e);
+			foreach (TextAreaStackedInputHandler h in stackedInputHandlers) {
+				if (e.Handled)
+					break;
+				h.OnPreviewKeyUp(e);
+			}
+		}
+		
+		// Make life easier for text editor extensions that use a different cursor based on the pressed modifier keys.
+		/// <inheritdoc/>
+		protected override void OnKeyDown(KeyEventArgs e)
+		{
+			base.OnKeyDown(e);
+			TextView.InvalidateCursor();
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnKeyUp(KeyEventArgs e)
+		{
+			base.OnKeyUp(e);
+			TextView.InvalidateCursor();
+		}
+		#endregion
+		
+		/// <inheritdoc/>
+		protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
+		{
+			// accept clicks even where the text area draws no background
+			return new PointHitTestResult(this, hitTestParameters.HitPoint);
+		}
+		
+		/// <inheritdoc/>
+		protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
+		{
+			base.OnPropertyChanged(e);
+			if (e.Property == SelectionBrushProperty
+			    || e.Property == SelectionBorderProperty
+			    || e.Property == SelectionForegroundProperty
+			    || e.Property == SelectionCornerRadiusProperty)
+			{
+				textView.Redraw();
+			}
+		}
+		
+		/// <summary>
+		/// Gets the requested service.
+		/// </summary>
+		/// <returns>Returns the requested service instance, or null if the service cannot be found.</returns>
+		public virtual object GetService(Type serviceType)
+		{
+			return textView.Services.GetService(serviceType);
+		}
+		
+		/// <summary>
+		/// Occurs when text inside the TextArea was copied.
+		/// </summary>
+		public event EventHandler<TextEventArgs> TextCopied;
+		
+		internal void OnTextCopied(TextEventArgs e)
+		{
+			if (TextCopied != null)
+				TextCopied(this, e);
+		}
+	}
+	
+	/// <summary>
+	/// EventArgs with text.
+	/// </summary>
+	[Serializable]
+	public class TextEventArgs : EventArgs
+	{
+		string text;
+		
+		/// <summary>
+		/// Gets the text.
+		/// </summary>
+		public string Text {
+			get {
+				return text;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a new TextEventArgs instance.
+		/// </summary>
+		public TextEventArgs(string text)
+		{
+			if (text == null)
+				throw new ArgumentNullException("text");
+			this.text = text;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaDefaultInputHandlers.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaDefaultInputHandlers.cs
new file mode 100644
index 000000000..7101d16c8
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaDefaultInputHandlers.cs
@@ -0,0 +1,120 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Input;
+
+using Tango.Scripting.Editors.Document;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Contains the predefined input handlers.
+	/// </summary>
+	public class TextAreaDefaultInputHandler : TextAreaInputHandler
+	{
+		/// <summary>
+		/// Gets the caret navigation input handler.
+		/// </summary>
+		public TextAreaInputHandler CaretNavigation { get; private set; }
+		
+		/// <summary>
+		/// Gets the editing input handler.
+		/// </summary>
+		public TextAreaInputHandler Editing { get; private set; }
+		
+		/// <summary>
+		/// Gets the mouse selection input handler.
+		/// </summary>
+		public ITextAreaInputHandler MouseSelection { get; private set; }
+		
+		/// <summary>
+		/// Creates a new TextAreaDefaultInputHandler instance.
+		/// </summary>
+		public TextAreaDefaultInputHandler(TextArea textArea) : base(textArea)
+		{
+			this.NestedInputHandlers.Add(CaretNavigation = CaretNavigationCommandHandler.Create(textArea));
+			this.NestedInputHandlers.Add(Editing = EditingCommandHandler.Create(textArea));
+			this.NestedInputHandlers.Add(MouseSelection = new SelectionMouseHandler(textArea));
+			
+			this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Undo, ExecuteUndo, CanExecuteUndo));
+			this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Redo, ExecuteRedo, CanExecuteRedo));
+		}
+		
+		internal static KeyBinding CreateFrozenKeyBinding(ICommand command, ModifierKeys modifiers, Key key)
+		{
+			KeyBinding kb = new KeyBinding(command, key, modifiers);
+			// Mark KeyBindings as frozen because they're shared between multiple editor instances.
+			// KeyBinding derives from Freezable only in .NET 4, so we have to use this little trick:
+			Freezable f = ((object)kb) as Freezable;
+			if (f != null)
+				f.Freeze();
+			return kb;
+		}
+		
+		internal static void WorkaroundWPFMemoryLeak(List<InputBinding> inputBindings)
+		{
+			// Work around WPF memory leak:
+			// KeyBinding retains a reference to whichever UIElement it is used in first.
+			// Using a dummy element for this purpose ensures that we don't leak
+			// a real text editor (with a potentially large document).
+			UIElement dummyElement = new UIElement();
+			dummyElement.InputBindings.AddRange(inputBindings);
+		}
+		
+		#region Undo / Redo
+		UndoStack GetUndoStack()
+		{
+			TextDocument document = this.TextArea.Document;
+			if (document != null)
+				return document.UndoStack;
+			else
+				return null;
+		}
+		
+		void ExecuteUndo(object sender, ExecutedRoutedEventArgs e)
+		{
+			var undoStack = GetUndoStack();
+			if (undoStack != null) {
+				if (undoStack.CanUndo) {
+					undoStack.Undo();
+					this.TextArea.Caret.BringCaretToView();
+				}
+				e.Handled = true;
+			}
+		}
+		
+		void CanExecuteUndo(object sender, CanExecuteRoutedEventArgs e)
+		{
+			var undoStack = GetUndoStack();
+			if (undoStack != null) {
+				e.Handled = true;
+				e.CanExecute = undoStack.CanUndo;
+			}
+		}
+		
+		void ExecuteRedo(object sender, ExecutedRoutedEventArgs e)
+		{
+			var undoStack = GetUndoStack();
+			if (undoStack != null) {
+				if (undoStack.CanRedo) {
+					undoStack.Redo();
+					this.TextArea.Caret.BringCaretToView();
+				}
+				e.Handled = true;
+			}
+		}
+		
+		void CanExecuteRedo(object sender, CanExecuteRoutedEventArgs e)
+		{
+			var undoStack = GetUndoStack();
+			if (undoStack != null) {
+				e.Handled = true;
+				e.CanExecute = undoStack.CanRedo;
+			}
+		}
+		#endregion
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaInputHandler.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaInputHandler.cs
new file mode 100644
index 000000000..3256875be
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaInputHandler.cs
@@ -0,0 +1,242 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using Tango.Scripting.Editors.Utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows.Input;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// A set of input bindings and event handlers for the text area.
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// There is one active input handler per text area (<see cref="Editing.TextArea.ActiveInputHandler"/>), plus
+	/// a number of active stacked input handlers.
+	/// </para>
+	/// <para>
+	/// The text area also stores a reference to a default input handler, but that is not necessarily active.
+	/// </para>
+	/// <para>
+	/// Stacked input handlers work in addition to the set of currently active handlers (without detaching them).
+	/// They are detached in the reverse order of being attached.
+	/// </para>
+	/// </remarks>
+	public interface ITextAreaInputHandler
+	{
+		/// <summary>
+		/// Gets the text area that the input handler belongs to.
+		/// </summary>
+		TextArea TextArea {
+			get;
+		}
+		
+		/// <summary>
+		/// Attaches an input handler to the text area.
+		/// </summary>
+		void Attach();
+		
+		/// <summary>
+		/// Detaches the input handler from the text area.
+		/// </summary>
+		void Detach();
+	}
+	
+	/// <summary>
+	/// Stacked input handler.
+	/// Uses OnEvent-methods instead of registering event handlers to ensure that the events are handled in the correct order.
+	/// </summary>
+	public abstract class TextAreaStackedInputHandler : ITextAreaInputHandler
+	{
+		readonly TextArea textArea;
+		
+		/// <inheritdoc/>
+		public TextArea TextArea {
+			get { return textArea; }
+		}
+		
+		/// <summary>
+		/// Creates a new TextAreaInputHandler.
+		/// </summary>
+		protected TextAreaStackedInputHandler(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+		}
+		
+		/// <inheritdoc/>
+		public virtual void Attach()
+		{
+		}
+		
+		/// <inheritdoc/>
+		public virtual void Detach()
+		{
+		}
+		
+		/// <summary>
+		/// Called for the PreviewKeyDown event.
+		/// </summary>
+		public virtual void OnPreviewKeyDown(KeyEventArgs e)
+		{
+		}
+		
+		/// <summary>
+		/// Called for the PreviewKeyUp event.
+		/// </summary>
+		public virtual void OnPreviewKeyUp(KeyEventArgs e)
+		{
+		}
+	}
+	
+	/// <summary>
+	/// Default-implementation of <see cref="ITextAreaInputHandler"/>.
+	/// </summary>
+	/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
+	public class TextAreaInputHandler : ITextAreaInputHandler
+	{
+		readonly ObserveAddRemoveCollection<CommandBinding> commandBindings;
+		readonly ObserveAddRemoveCollection<InputBinding> inputBindings;
+		readonly ObserveAddRemoveCollection<ITextAreaInputHandler> nestedInputHandlers;
+		readonly TextArea textArea;
+		bool isAttached;
+		
+		/// <summary>
+		/// Creates a new TextAreaInputHandler.
+		/// </summary>
+		public TextAreaInputHandler(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+			commandBindings = new ObserveAddRemoveCollection<CommandBinding>(CommandBinding_Added, CommandBinding_Removed);
+			inputBindings = new ObserveAddRemoveCollection<InputBinding>(InputBinding_Added, InputBinding_Removed);
+			nestedInputHandlers = new ObserveAddRemoveCollection<ITextAreaInputHandler>(NestedInputHandler_Added, NestedInputHandler_Removed);
+		}
+		
+		/// <inheritdoc/>
+		public TextArea TextArea {
+			get { return textArea; }
+		}
+		
+		/// <summary>
+		/// Gets whether the input handler is currently attached to the text area.
+		/// </summary>
+		public bool IsAttached {
+			get { return isAttached; }
+		}
+		
+		#region CommandBindings / InputBindings
+		/// <summary>
+		/// Gets the command bindings of this input handler.
+		/// </summary>
+		public ICollection<CommandBinding> CommandBindings {
+			get { return commandBindings; }
+		}
+		
+		void CommandBinding_Added(CommandBinding commandBinding)
+		{
+			if (isAttached)
+				textArea.CommandBindings.Add(commandBinding);
+		}
+		
+		void CommandBinding_Removed(CommandBinding commandBinding)
+		{
+			if (isAttached)
+				textArea.CommandBindings.Remove(commandBinding);
+		}
+		
+		/// <summary>
+		/// Gets the input bindings of this input handler.
+		/// </summary>
+		public ICollection<InputBinding> InputBindings {
+			get { return inputBindings; }
+		}
+		
+		void InputBinding_Added(InputBinding inputBinding)
+		{
+			if (isAttached)
+				textArea.InputBindings.Add(inputBinding);
+		}
+		
+		void InputBinding_Removed(InputBinding inputBinding)
+		{
+			if (isAttached)
+				textArea.InputBindings.Remove(inputBinding);
+		}
+		
+		/// <summary>
+		/// Adds a command and input binding.
+		/// </summary>
+		/// <param name="command">The command ID.</param>
+		/// <param name="modifiers">The modifiers of the keyboard shortcut.</param>
+		/// <param name="key">The key of the keyboard shortcut.</param>
+		/// <param name="handler">The event handler to run when the command is executed.</param>
+		public void AddBinding(ICommand command, ModifierKeys modifiers, Key key, ExecutedRoutedEventHandler handler)
+		{
+			this.CommandBindings.Add(new CommandBinding(command, handler));
+			this.InputBindings.Add(new KeyBinding(command, key, modifiers));
+		}
+		#endregion
+		
+		#region NestedInputHandlers
+		/// <summary>
+		/// Gets the collection of nested input handlers. NestedInputHandlers are activated and deactivated
+		/// together with this input handler.
+		/// </summary>
+		public ICollection<ITextAreaInputHandler> NestedInputHandlers {
+			get { return nestedInputHandlers; }
+		}
+		
+		void NestedInputHandler_Added(ITextAreaInputHandler handler)
+		{
+			if (handler == null)
+				throw new ArgumentNullException("handler");
+			if (handler.TextArea != textArea)
+				throw new ArgumentException("The nested handler must be working for the same text area!");
+			if (isAttached)
+				handler.Attach();
+		}
+		
+		void NestedInputHandler_Removed(ITextAreaInputHandler handler)
+		{
+			if (isAttached)
+				handler.Detach();
+		}
+		#endregion
+		
+		#region Attach/Detach
+		/// <inheritdoc/>
+		public virtual void Attach()
+		{
+			if (isAttached)
+				throw new InvalidOperationException("Input handler is already attached");
+			isAttached = true;
+			
+			textArea.CommandBindings.AddRange(commandBindings);
+			textArea.InputBindings.AddRange(inputBindings);
+			foreach (ITextAreaInputHandler handler in nestedInputHandlers)
+				handler.Attach();
+		}
+		
+		/// <inheritdoc/>
+		public virtual void Detach()
+		{
+			if (!isAttached)
+				throw new InvalidOperationException("Input handler is not attached");
+			isAttached = false;
+			
+			foreach (CommandBinding b in commandBindings)
+				textArea.CommandBindings.Remove(b);
+			foreach (InputBinding b in inputBindings)
+				textArea.InputBindings.Remove(b);
+			foreach (ITextAreaInputHandler handler in nestedInputHandlers)
+				handler.Detach();
+		}
+		#endregion
+	}
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextSegmentReadOnlySectionProvider.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextSegmentReadOnlySectionProvider.cs
new file mode 100644
index 000000000..c582301d4
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextSegmentReadOnlySectionProvider.cs
@@ -0,0 +1,80 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using Tango.Scripting.Editors.Document;
+
+namespace Tango.Scripting.Editors.Editing
+{
+	/// <summary>
+	/// Implementation for <see cref="IReadOnlySectionProvider"/> that stores the segments
+	/// in a <see cref="TextSegmentCollection{T}"/>.
+	/// </summary>
+	public class TextSegmentReadOnlySectionProvider<T> : IReadOnlySectionProvider where T : TextSegment
+	{
+		readonly TextSegmentCollection<T> segments;
+		
+		/// <summary>
+		/// Gets the collection storing the read-only segments.
+		/// </summary>
+		public TextSegmentCollection<T> Segments {
+			get { return segments; }
+		}
+		
+		/// <summary>
+		/// Creates a new TextSegmentReadOnlySectionProvider instance for the specified document.
+		/// </summary>
+		public TextSegmentReadOnlySectionProvider(TextDocument textDocument)
+		{
+			segments = new TextSegmentCollection<T>(textDocument);
+		}
+		
+		/// <summary>
+		/// Creates a new TextSegmentReadOnlySectionProvider instance using the specified TextSegmentCollection.
+		/// </summary>
+		public TextSegmentReadOnlySectionProvider(TextSegmentCollection<T> segments)
+		{
+			if (segments == null)
+				throw new ArgumentNullException("segments");
+			this.segments = segments;
+		}
+		
+		/// <summary>
+		/// Gets whether insertion is possible at the specified offset.
+		/// </summary>
+		public virtual bool CanInsert(int offset)
+		{
+			foreach (TextSegment segment in segments.FindSegmentsContaining(offset)) {
+				if (segment.StartOffset < offset && offset < segment.EndOffset)
+					return false;
+			}
+			return true;
+		}
+		
+		/// <summary>
+		/// Gets the deletable segments inside the given segment.
+		/// </summary>
+		public virtual IEnumerable<ISegment> GetDeletableSegments(ISegment segment)
+		{
+			if (segment == null)
+				throw new ArgumentNullException("segment");
+			
+			int readonlyUntil = segment.Offset;
+			foreach (TextSegment ts in segments.FindOverlappingSegments(segment)) {
+				int start = ts.StartOffset;
+				int end = start + ts.Length;
+				if (start > readonlyUntil) {
+					yield return new SimpleSegment(readonlyUntil, start - readonlyUntil);
+				}
+				if (end > readonlyUntil) {
+					readonlyUntil = end;
+				}
+			}
+			int endOffset = segment.EndOffset;
+			if (readonlyUntil < endOffset) {
+				yield return new SimpleSegment(readonlyUntil, endOffset - readonlyUntil);
+			}
+		}
+	}
+}