aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/TextAreaDefaultInputHandlers.cs
blob: 7101d16c860e4448587586392b14916962bcffd8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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
	}
}
class="n">syntaxErrors; /// <summary> /// The error that occured in the context of this node (excluding nested nodes) /// </summary> public IEnumerable<SyntaxError> MySyntaxErrors { get { if (syntaxErrors == null) { return new SyntaxError[] {}; } else { return syntaxErrors; } } } /// <summary> /// The error that occured in the context of this node and all nested nodes. /// It has O(n) cost. /// </summary> public IEnumerable<SyntaxError> SyntaxErrors { get { return GetSelfAndAllChildren().SelectMany(obj => obj.MySyntaxErrors); } } internal void AddSyntaxError(SyntaxError error) { DebugAssert(error.Object == this, "Must own the error"); if (this.syntaxErrors == null) this.syntaxErrors = new List<SyntaxError>(); syntaxErrors.Add(error); } /// <summary> Throws exception if condition is false </summary> /// <remarks> Present in release mode - use only for very cheap aserts </remarks> protected static void Assert(bool condition, string message) { if (!condition) { throw new InternalException("Assertion failed: " + message); } } /// <summary> Throws exception if condition is false </summary> [Conditional("DEBUG")] protected static void DebugAssert(bool condition, string message) { if (!condition) { throw new InternalException("Assertion failed: " + message); } } /// <summary> Recursively gets self and all nested nodes. </summary> [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Using a method makes the API look more LINQ-like and indicates that the returned collection is computed every time.")] public virtual IEnumerable<AXmlObject> GetSelfAndAllChildren() { return new AXmlObject[] { this }; } /// <summary> Get all ancestors of this node </summary> [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Using a method makes the API look more LINQ-like and indicates that the returned collection is computed every time.")] public IEnumerable<AXmlObject> GetAncestors() { AXmlObject curr = this.Parent; while(curr != null) { yield return curr; curr = curr.Parent; } } /// <summary> Call appropriate visit method on the given visitor </summary> public abstract void AcceptVisitor(IAXmlVisitor visitor); /// <summary> The parser tree object this object was updated from </summary> /// <remarks> Initialized to 'this' </remarks> internal AXmlObject LastUpdatedFrom { get; private set; } internal bool IsCached { get; set; } /// <summary> Is call to UpdateDataFrom is allowed? </summary> internal bool CanUpdateDataFrom(AXmlObject source) { return this.GetType() == source.GetType() && this.StartOffset == source.StartOffset && (this.LastUpdatedFrom == source || !this.IsCached); } /// <summary> Copy all data from the 'source' to this object </summary> /// <remarks> Returns true if any updates were done </remarks> internal virtual bool UpdateDataFrom(AXmlObject source) { Assert(this.GetType() == source.GetType(), "Source has different type"); DebugAssert(this.StartOffset == source.StartOffset, "Source has different StartOffset"); if (this.LastUpdatedFrom == source) { DebugAssert(this.EndOffset == source.EndOffset, "Source has different EndOffset"); return false; } Assert(!this.IsCached, "Can not update cached item"); Assert(source.IsCached, "Must update from cache"); this.LastUpdatedFrom = source; this.StartOffset = source.StartOffset; // In some cases we are just updating objects of that same // type and position and hoping to be luckily right this.EndOffset = source.EndOffset; // Do not bother comparing - assume changed if non-null if (this.syntaxErrors != null || source.syntaxErrors != null) { // May be called again in derived class - oh, well, does not matter OnChanging(); this.Document.Parser.TrackedSegments.RemoveSyntaxErrorsOf(this); if (source.syntaxErrors == null) { this.syntaxErrors = null; } else { this.syntaxErrors = new List<SyntaxError>(); foreach(var error in source.MySyntaxErrors) { // The object differs, so create our own copy // The source still might need it in the future and we do not want to break it this.AddSyntaxError(error.Clone(this)); } } this.Document.Parser.TrackedSegments.AddSyntaxErrorsOf(this); OnChanged(); } return true; } /// <summary> Verify that the item is consistent. Only in debug build. </summary> [Conditional("DEBUG")] internal virtual void DebugCheckConsistency(bool allowNullParent) { } /// <inheritdoc/> public override string ToString() { return string.Format(CultureInfo.InvariantCulture, "{0}({1}-{2})", this.GetType().Name.Remove(0, 4), this.StartOffset, this.EndOffset); } #region Helpper methods /// <summary> The part of name before ":" </summary> /// <returns> Empty string if not found </returns> protected static string GetNamespacePrefix(string name) { if (string.IsNullOrEmpty(name)) return string.Empty; int colonIndex = name.IndexOf(':'); if (colonIndex != -1) { return name.Substring(0, colonIndex); } else { return string.Empty; } } /// <summary> The part of name after ":" </summary> /// <returns> Whole name if ":" not found </returns> protected static string GetLocalName(string name) { if (string.IsNullOrEmpty(name)) return string.Empty; int colonIndex = name.IndexOf(':'); if (colonIndex != -1) { return name.Remove(0, colonIndex + 1); } else { return name ?? string.Empty; } } #endregion } }