MERGE

1 files changed, 467 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Search/SearchPanel.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Search/SearchPanel.cs
new file mode 100644
index 000000000..b4af99f54
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Search/SearchPanel.cs
@@ -0,0 +1,467 @@
+// 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 System.Text;
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Editing;
+using Tango.Scripting.Editors.Folding;
+using Tango.Scripting.Editors.Rendering;
+
+namespace Tango.Scripting.Editors.Search
+{
+	/// <summary>
+	/// Provides search functionality for AvalonEdit. It is displayed in the top-right corner of the TextArea.
+	/// </summary>
+	public class SearchPanel : Control
+	{
+		TextArea textArea;
+		TextDocument currentDocument;
+		SearchResultBackgroundRenderer renderer;
+		TextBox searchTextBox;
+		SearchPanelAdorner adorner;
+		
+		#region DependencyProperties
+		/// <summary>
+		/// Dependency property for <see cref="UseRegex"/>.
+		/// </summary>
+		public static readonly DependencyProperty UseRegexProperty =
+			DependencyProperty.Register("UseRegex", typeof(bool), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata(false, SearchPatternChangedCallback));
+		
+		/// <summary>
+		/// Gets/sets whether the search pattern should be interpreted as regular expression.
+		/// </summary>
+		public bool UseRegex {
+			get { return (bool)GetValue(UseRegexProperty); }
+			set { SetValue(UseRegexProperty, value); }
+		}
+		
+		/// <summary>
+		/// Dependency property for <see cref="MatchCase"/>.
+		/// </summary>
+		public static readonly DependencyProperty MatchCaseProperty =
+			DependencyProperty.Register("MatchCase", typeof(bool), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata(false, SearchPatternChangedCallback));
+		
+		/// <summary>
+		/// Gets/sets whether the search pattern should be interpreted case-sensitive.
+		/// </summary>
+		public bool MatchCase {
+			get { return (bool)GetValue(MatchCaseProperty); }
+			set { SetValue(MatchCaseProperty, value); }
+		}
+		
+		/// <summary>
+		/// Dependency property for <see cref="WholeWords"/>.
+		/// </summary>
+		public static readonly DependencyProperty WholeWordsProperty =
+			DependencyProperty.Register("WholeWords", typeof(bool), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata(false, SearchPatternChangedCallback));
+		
+		/// <summary>
+		/// Gets/sets whether the search pattern should only match whole words.
+		/// </summary>
+		public bool WholeWords {
+			get { return (bool)GetValue(WholeWordsProperty); }
+			set { SetValue(WholeWordsProperty, value); }
+		}
+		
+		/// <summary>
+		/// Dependency property for <see cref="SearchPattern"/>.
+		/// </summary>
+		public static readonly DependencyProperty SearchPatternProperty =
+			DependencyProperty.Register("SearchPattern", typeof(string), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata("", SearchPatternChangedCallback));
+		
+		/// <summary>
+		/// Gets/sets the search pattern.
+		/// </summary>
+		public string SearchPattern {
+			get { return (string)GetValue(SearchPatternProperty); }
+			set { SetValue(SearchPatternProperty, value); }
+		}
+		
+		/// <summary>
+		/// Dependency property for <see cref="MarkerBrush"/>.
+		/// </summary>
+		public static readonly DependencyProperty MarkerBrushProperty =
+			DependencyProperty.Register("MarkerBrush", typeof(Brush), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata(Brushes.LightGreen, MarkerBrushChangedCallback));
+		
+		/// <summary>
+		/// Gets/sets the Brush used for marking search results in the TextView.
+		/// </summary>
+		public Brush MarkerBrush {
+			get { return (Brush)GetValue(MarkerBrushProperty); }
+			set { SetValue(MarkerBrushProperty, value); }
+		}
+		
+		/// <summary>
+		/// Dependency property for <see cref="Localization"/>.
+		/// </summary>
+		public static readonly DependencyProperty LocalizationProperty =
+			DependencyProperty.Register("Localization", typeof(Localization), typeof(SearchPanel),
+			                            new FrameworkPropertyMetadata(new Localization()));
+		
+		/// <summary>
+		/// Gets/sets the localization for the SearchPanel.
+		/// </summary>
+		public Localization Localization {
+			get { return (Localization)GetValue(LocalizationProperty); }
+			set { SetValue(LocalizationProperty, value); }
+		}
+		#endregion
+		
+		static void MarkerBrushChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			SearchPanel panel = d as SearchPanel;
+			if (panel != null) {
+				panel.renderer.MarkerBrush = (Brush)e.NewValue;
+			}
+		}
+		
+		static SearchPanel()
+		{
+			DefaultStyleKeyProperty.OverrideMetadata(typeof(SearchPanel), new FrameworkPropertyMetadata(typeof(SearchPanel)));
+		}
+		
+		ISearchStrategy strategy;
+		
+		static void SearchPatternChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			SearchPanel panel = d as SearchPanel;
+			if (panel != null) {
+				panel.ValidateSearchText();
+				panel.UpdateSearch();
+			}
+		}
+
+		void UpdateSearch()
+		{
+			// only reset as long as there are results
+			// if no results are found, the "no matches found" message should not flicker.
+			// if results are found by the next run, the message will be hidden inside DoSearch ...
+			if (renderer.CurrentResults.Any())
+				messageView.IsOpen = false;
+			strategy = SearchStrategyFactory.Create(SearchPattern ?? "", !MatchCase, WholeWords, UseRegex ? SearchMode.RegEx : SearchMode.Normal);
+			OnSearchOptionsChanged(new SearchOptionsChangedEventArgs(SearchPattern, MatchCase, UseRegex, WholeWords));
+			DoSearch(true);
+		}
+		
+		/// <summary>
+		/// Creates a new SearchPanel.
+		/// </summary>
+		public SearchPanel()
+		{
+		}
+		
+		/// <summary>
+		/// Attaches this SearchPanel to a TextArea instance.
+		/// </summary>
+		public void Attach(TextArea textArea)
+		{
+			if (textArea == null)
+				throw new ArgumentNullException("textArea");
+			this.textArea = textArea;
+			adorner = new SearchPanelAdorner(textArea, this);
+			DataContext = this;
+			
+			renderer = new SearchResultBackgroundRenderer();
+			currentDocument = textArea.Document;
+			if (currentDocument != null)
+				currentDocument.TextChanged += textArea_Document_TextChanged;
+			textArea.DocumentChanged += textArea_DocumentChanged;
+			KeyDown += SearchLayerKeyDown;
+			
+			this.CommandBindings.Add(new CommandBinding(SearchCommands.FindNext, (sender, e) => FindNext()));
+			this.CommandBindings.Add(new CommandBinding(SearchCommands.FindPrevious, (sender, e) => FindPrevious()));
+			this.CommandBindings.Add(new CommandBinding(SearchCommands.CloseSearchPanel, (sender, e) => Close()));
+			IsClosed = true;
+		}
+
+		void textArea_DocumentChanged(object sender, EventArgs e)
+		{
+			if (currentDocument != null)
+				currentDocument.TextChanged -= textArea_Document_TextChanged;
+			currentDocument = textArea.Document;
+			if (currentDocument != null) {
+				currentDocument.TextChanged += textArea_Document_TextChanged;
+				DoSearch(false);
+			}
+		}
+
+		void textArea_Document_TextChanged(object sender, EventArgs e)
+		{
+			DoSearch(false);
+		}
+		
+		/// <inheritdoc/>
+		public override void OnApplyTemplate()
+		{
+			base.OnApplyTemplate();
+			searchTextBox = Template.FindName("PART_searchTextBox", this) as TextBox;
+		}
+		
+		void ValidateSearchText()
+		{
+			if (searchTextBox == null)
+				return;
+			var be = searchTextBox.GetBindingExpression(TextBox.TextProperty);
+			try {
+				Validation.ClearInvalid(be);
+				UpdateSearch();
+			} catch (SearchPatternException ex) {
+				var ve = new ValidationError(be.ParentBinding.ValidationRules[0], be, ex.Message, ex);
+				Validation.MarkInvalid(be, ve);
+			}
+		}
+		
+		/// <summary>
+		/// Reactivates the SearchPanel by setting the focus on the search box and selecting all text.
+		/// </summary>
+		public void Reactivate()
+		{
+			if (searchTextBox == null)
+				return;
+			searchTextBox.Focus();
+			searchTextBox.SelectAll();
+		}
+		
+		/// <summary>
+		/// Moves to the next occurrence in the file.
+		/// </summary>
+		public void FindNext()
+		{
+			SearchResult result = renderer.CurrentResults.FindFirstSegmentWithStartAfter(textArea.Caret.Offset + 1);
+			if (result == null)
+				result = renderer.CurrentResults.FirstSegment;
+			if (result != null) {
+				SelectResult(result);
+			}
+		}
+
+		/// <summary>
+		/// Moves to the previous occurrence in the file.
+		/// </summary>
+		public void FindPrevious()
+		{
+			SearchResult result = renderer.CurrentResults.FindFirstSegmentWithStartAfter(textArea.Caret.Offset);
+			if (result != null)
+				result = renderer.CurrentResults.GetPreviousSegment(result);
+			if (result == null)
+				result = renderer.CurrentResults.LastSegment;
+			if (result != null) {
+				SelectResult(result);
+			}
+		}
+		
+		ToolTip messageView = new ToolTip { Placement = PlacementMode.Bottom, StaysOpen = false };
+
+		void DoSearch(bool changeSelection)
+		{
+			if (IsClosed)
+				return;
+			renderer.CurrentResults.Clear();
+			
+			if (!string.IsNullOrEmpty(SearchPattern)) {
+				int offset = textArea.Caret.Offset;
+				if (changeSelection) {
+					textArea.ClearSelection();
+				}
+				// We cast from ISearchResult to SearchResult; this is safe because we always use the built-in strategy
+				foreach (SearchResult result in strategy.FindAll(textArea.Document, 0, textArea.Document.TextLength)) {
+					if (changeSelection && result.StartOffset >= offset) {
+						SelectResult(result);
+						changeSelection = false;
+					}
+					renderer.CurrentResults.Add(result);
+				}
+				if (!renderer.CurrentResults.Any()) {
+					messageView.IsOpen = true;
+					messageView.Content = Localization.NoMatchesFoundText;
+					messageView.PlacementTarget = searchTextBox;
+				} else
+					messageView.IsOpen = false;
+			}
+			textArea.TextView.InvalidateLayer(KnownLayer.Selection);
+		}
+
+		void SelectResult(SearchResult result)
+		{
+			textArea.Caret.Offset = result.StartOffset;
+			textArea.Selection = Selection.Create(textArea, result.StartOffset, result.EndOffset);
+			textArea.Caret.BringCaretToView();
+			// show caret even if the editor does not have the Keyboard Focus
+			textArea.Caret.Show();
+		}
+		
+		void SearchLayerKeyDown(object sender, KeyEventArgs e)
+		{
+			switch (e.Key) {
+				case Key.Enter:
+					e.Handled = true;
+					messageView.IsOpen = false;
+					if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
+						FindPrevious();
+					else
+						FindNext();
+					if (searchTextBox != null) {
+						var error = Validation.GetErrors(searchTextBox).FirstOrDefault();
+						if (error != null) {
+							messageView.Content = Localization.ErrorText + " " + error.ErrorContent;
+							messageView.PlacementTarget = searchTextBox;
+							messageView.IsOpen = true;
+						}
+					}
+					break;
+				case Key.Escape:
+					e.Handled = true;
+					Close();
+					break;
+			}
+		}
+		
+		/// <summary>
+		/// Gets whether the Panel is already closed.
+		/// </summary>
+		public bool IsClosed { get; private set; }
+		
+		/// <summary>
+		/// Closes the SearchPanel.
+		/// </summary>
+		public void Close()
+		{
+			bool hasFocus = this.IsKeyboardFocusWithin;
+			
+			var layer = AdornerLayer.GetAdornerLayer(textArea);
+			if (layer != null)
+				layer.Remove(adorner);
+			messageView.IsOpen = false;
+			textArea.TextView.BackgroundRenderers.Remove(renderer);
+			if (hasFocus)
+				textArea.Focus();
+			IsClosed = true;
+			
+			// Clear existing search results so that the segments don't have to be maintained
+			renderer.CurrentResults.Clear();
+		}
+		
+		/// <summary>
+		/// Closes the SearchPanel and removes it.
+		/// </summary>
+		public void CloseAndRemove()
+		{
+			Close();
+			textArea.DocumentChanged -= textArea_DocumentChanged;
+			if (currentDocument != null)
+				currentDocument.TextChanged -= textArea_Document_TextChanged;
+		}
+		
+		/// <summary>
+		/// Opens the an existing search panel.
+		/// </summary>
+		public void Open()
+		{
+			if (!IsClosed) return;
+			var layer = AdornerLayer.GetAdornerLayer(textArea);
+			if (layer != null)
+				layer.Add(adorner);
+			textArea.TextView.BackgroundRenderers.Add(renderer);
+			IsClosed = false;
+			DoSearch(false);
+		}
+		
+		/// <summary>
+		/// Fired when SearchOptions are changed inside the SearchPanel.
+		/// </summary>
+		public event EventHandler<SearchOptionsChangedEventArgs> SearchOptionsChanged;
+		
+		/// <summary>
+		/// Raises the <see cref="SearchPanel.SearchOptionsChanged" /> event.
+		/// </summary>
+		protected virtual void OnSearchOptionsChanged(SearchOptionsChangedEventArgs e)
+		{
+			if (SearchOptionsChanged != null) {
+				SearchOptionsChanged(this, e);
+			}
+		}
+	}
+	
+	/// <summary>
+	/// EventArgs for <see cref="SearchPanel.SearchOptionsChanged"/> event.
+	/// </summary>
+	public class SearchOptionsChangedEventArgs : EventArgs
+	{
+		/// <summary>
+		/// Gets the search pattern.
+		/// </summary>
+		public string SearchPattern { get; private set; }
+		
+		/// <summary>
+		/// Gets whether the search pattern should be interpreted case-sensitive.
+		/// </summary>
+		public bool MatchCase { get; private set; }
+		
+		/// <summary>
+		/// Gets whether the search pattern should be interpreted as regular expression.
+		/// </summary>
+		public bool UseRegex { get; private set; }
+		
+		/// <summary>
+		/// Gets whether the search pattern should only match whole words.
+		/// </summary>
+		public bool WholeWords { get; private set; }
+		
+		/// <summary>
+		/// Creates a new SearchOptionsChangedEventArgs instance.
+		/// </summary>
+		public SearchOptionsChangedEventArgs(string searchPattern, bool matchCase, bool useRegex, bool wholeWords)
+		{
+			this.SearchPattern = searchPattern;
+			this.MatchCase = matchCase;
+			this.UseRegex = useRegex;
+			this.WholeWords = wholeWords;
+		}
+	}
+	
+	class SearchPanelAdorner : Adorner
+	{
+		SearchPanel panel;
+		
+		public SearchPanelAdorner(TextArea textArea, SearchPanel panel)
+			: base(textArea)
+		{
+			this.panel = panel;
+			AddVisualChild(panel);
+		}
+		
+		protected override int VisualChildrenCount {
+			get { return 1; }
+		}
+
+		protected override Visual GetVisualChild(int index)
+		{
+			if (index != 0)
+				throw new ArgumentOutOfRangeException();
+			return panel;
+		}
+		
+		protected override Size ArrangeOverride(Size finalSize)
+		{
+			panel.Arrange(new Rect(new Point(0, 0), finalSize));
+			return new Size(panel.ActualWidth, panel.ActualHeight);
+		}
+	}
+}
\ No newline at end of file