Procedure runtime debugging and exceptions.

1 files changed, 285 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/BreakPointMargin.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/BreakPointMargin.cs
new file mode 100644
index 000000000..e566e6aa9
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Editing/BreakPointMargin.cs
@@ -0,0 +1,285 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Media.TextFormatting;
+using Tango.Scripting.Core;
+using Tango.Scripting.Editors.Document;
+using Tango.Scripting.Editors.Rendering;
+using Tango.Scripting.Editors.Utils;
+
+namespace Tango.Scripting.Editors.Editing
+{
+    public class BreakPointMargin : AbstractMargin, IWeakEventListener
+    {
+        private TextArea textArea;
+        private int maxLineNumberLength = 1;
+        private BitmapSource _arrowBitmap;
+        private ScriptEditor _editor;
+
+        public ObservableCollection<BreakPoint> BreakPoints { get; set; }
+
+        public Brush Background
+        {
+            get { return (Brush)GetValue(BackgroundProperty); }
+            set { SetValue(BackgroundProperty, value); }
+        }
+        public static readonly DependencyProperty BackgroundProperty =
+            DependencyProperty.Register("Background", typeof(Brush), typeof(BreakPointMargin), new PropertyMetadata(new SolidColorBrush(Color.FromRgb(50, 50, 50))));
+
+        public Brush Foreground
+        {
+            get { return (Brush)GetValue(ForegroundProperty); }
+            set { SetValue(ForegroundProperty, value); }
+        }
+        public static readonly DependencyProperty ForegroundProperty =
+            DependencyProperty.Register("Foreground", typeof(Brush), typeof(BreakPointMargin), new PropertyMetadata(Brushes.Red));
+
+        static BreakPointMargin()
+        {
+            DefaultStyleKeyProperty.OverrideMetadata(typeof(BreakPointMargin),
+                                                     new FrameworkPropertyMetadata(typeof(BreakPointMargin)));
+        }
+
+        public BreakPointMargin(ScriptEditor editor)
+        {
+            _editor = editor;
+            BreakPoints = new ObservableCollection<BreakPoint>();
+            BreakPoints.CollectionChanged += BreakPoints_CollectionChanged;
+            RenderOptions.SetEdgeMode(this, EdgeMode.Unspecified);
+
+            _arrowBitmap = new BitmapImage(new Uri($"pack://application:,,,/Tango.Scripting.Editors;component/Images/break_point_arrow.png", UriKind.Absolute));
+        }
+
+        private void BreakPoints_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            InvalidateVisual();
+        }
+
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            return new Size(20, 0);
+        }
+
+        protected override void OnRender(DrawingContext drawingContext)
+        {
+            TextView textView = this.TextView;
+            Size renderSize = this.RenderSize;
+            if (textView != null && textView.VisualLinesValid)
+            {
+                drawingContext.DrawRectangle(Background, new Pen(Background, 1), new Rect(0, 0, ActualWidth, ActualHeight));
+
+                var foreground = Foreground;
+                foreach (VisualLine line in textView.VisualLines)
+                {
+                    int lineNumber = line.FirstDocumentLine.LineNumber;
+
+                    BreakPoint b = BreakPoints.FirstOrDefault(x => x.LineNumber == lineNumber);
+
+                    if (b != null)
+                    {
+                        double y = line.GetTextLineVisualYPosition(line.TextLines[0], VisualYPosition.TextTop);
+                        drawingContext.DrawEllipse(Foreground, new Pen(Brushes.Gainsboro, 1), new Point(10, y - textView.VerticalOffset + 8), 6, 6);
+
+                        if (b.IsActive)
+                        {
+                            drawingContext.DrawImage(_arrowBitmap, new Rect(6, y - textView.VerticalOffset + 2.5, 8.5, 10));
+                        }
+                    }
+                }
+            }
+        }
+
+        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();
+        }
+
+        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();
+        }
+
+        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);
+        }
+
+        private void OnDocumentLineCountChanged()
+        {
+            int documentLineCount = Document != null ? Document.LineCount : 1;
+            int newLength = documentLineCount.ToString(CultureInfo.CurrentCulture).Length;
+
+            foreach (var breakPoint in BreakPoints.ToList())
+            {
+                if (breakPoint.LineNumber > documentLineCount)
+                {
+                    BreakPoints.Remove(breakPoint);
+                }
+                else
+                {
+                    try
+                    {
+                        var line = Document.GetLineByNumber(breakPoint.LineNumber);
+                        if (line != null)
+                        {
+                            String lineText = Document.GetText(line.Offset, line.Length);
+                            if (!IsBreakPointValid(lineText))
+                            {
+                                BreakPoints.Remove(breakPoint);
+                            }
+                        }
+                    }
+                    catch { }
+                }
+            }
+
+            // 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();
+            }
+        }
+
+        private void TextViewVisualLinesChanged(object sender, EventArgs e)
+        {
+            InvalidateVisual();
+        }
+
+        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
+        {
+            // accept clicks even when clicking on the background
+            return new PointHitTestResult(this, hitTestParameters.HitPoint);
+        }
+
+        private VisualLine GetLineNumberByMousePosition(MouseEventArgs e)
+        {
+            Point pos = e.GetPosition(TextView);
+            pos.X = 0;
+            pos.Y += TextView.VerticalOffset;
+            VisualLine vl = TextView.GetVisualLineFromVisualTop(pos.Y);
+            return vl;
+        }
+
+        private bool IsBreakPointValid(String lineText)
+        {
+            if (lineText.EndsWith(";") && !lineText.StartsWith("using"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override void OnPreviewMouseMove(MouseEventArgs e)
+        {
+            base.OnPreviewMouseMove(e);
+
+            if (_editor.DisableBreakPoints)
+            {
+                Cursor = Cursors.No;
+            }
+            else
+            {
+                Cursor = Cursors.Arrow;
+            }
+        }
+
+        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
+        {
+            base.OnMouseLeftButtonDown(e);
+
+            if (_editor.DisableBreakPoints)
+            {
+                return;
+            }
+
+            try
+            {
+                if (!e.Handled && TextView != null && textArea != null)
+                {
+                    e.Handled = true;
+                    textArea.Focus();
+
+                    var visualLine = GetLineNumberByMousePosition(e);
+
+                    int? lineNumber = visualLine != null ? (int?)visualLine.FirstDocumentLine.LineNumber : null;
+
+                    if (lineNumber != null)
+                    {
+                        var breakPoint = BreakPoints.FirstOrDefault(x => x.LineNumber == lineNumber.Value);
+                        if (breakPoint != null)
+                        {
+                            BreakPoints.Remove(breakPoint);
+                        }
+                        else
+                        {
+                            var lineText = Document.GetText(visualLine.FirstDocumentLine.Offset, visualLine.FirstDocumentLine.Length).Trim();
+
+                            if (IsBreakPointValid(lineText))
+                            {
+                                BreakPoint newBreakPoint = new BreakPoint();
+                                newBreakPoint.LineNumber = lineNumber.Value;
+                                BreakPoints.Add(newBreakPoint);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex);
+            }
+        }
+    }
+}