1 files changed, 210 insertions, 0 deletions
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphEx/ReachGraphs/RealTimeGraphExReachLineErase.cs b/Software/Visual_Studio/SideChains/RealTimeGraphEx/ReachGraphs/RealTimeGraphExReachLineErase.cs
new file mode 100644
index 000000000..a0049e0a6
--- /dev/null
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphEx/ReachGraphs/RealTimeGraphExReachLineErase.cs
@@ -0,0 +1,210 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Shapes;
+
+namespace RealTimeGraphEx.ReachGraphs
+{
+    public class RealTimeGraphExReachLineErase : RealTimeGraphExReachLineScroll, INotifyPropertyChanged
+    {
+        #region Cross Thread Fields
+
+        protected Brush _markerColor;
+        protected bool _showMarker;
+        protected bool _endReached;
+        protected int _currentReplaceIndex;
+        protected bool _enableMarkerPosition;
+        protected double lastVirtualValue;
+        protected Rectangle marker;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the graph marker color.
+        /// </summary>
+        public Brush MarkerBrush
+        {
+            get { return (Brush)GetValue(MarkerBrushProperty); }
+            set { SetValue(MarkerBrushProperty, value); }
+        }
+        public static readonly DependencyProperty MarkerBrushProperty =
+            DependencyProperty.Register("MarkerBrush", typeof(Brush), typeof(RealTimeGraphExReachLineErase), new PropertyMetadata(Brushes.Red, new PropertyChangedCallback(CrossModelChanged)));
+
+        /// <summary>
+        /// Gets or sets whether to display the marker on the graph.
+        /// </summary>
+        public bool ShowMarker
+        {
+            get { return (bool)GetValue(ShowMarkerProperty); }
+            set { SetValue(ShowMarkerProperty, value); }
+        }
+        public static readonly DependencyProperty ShowMarkerProperty =
+            DependencyProperty.Register("ShowMarker", typeof(bool), typeof(RealTimeGraphExReachLineErase), new PropertyMetadata(true, new PropertyChangedCallback(CrossModelChanged)));
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to enable the MarkerPosition property to be updated. (Affects performance).
+        /// </summary>
+        public bool EnableMarkerPosition
+        {
+            get { return (bool)GetValue(EnableMarkerPositionProperty); }
+            set { SetValue(EnableMarkerPositionProperty, value); }
+        }
+        public static readonly DependencyProperty EnableMarkerPositionProperty =
+            DependencyProperty.Register("EnableMarkerPosition", typeof(bool), typeof(RealTimeGraphExReachLineErase), new PropertyMetadata(false, new PropertyChangedCallback(CrossModelChanged)));
+
+        /// <summary>
+        /// Gets the current marker position on the graph.
+        /// </summary>
+        private Point markerPosition;
+        public Point MarkerPosition
+        {
+            private get { return markerPosition; }
+            set { markerPosition = value; RaisePropertyChanged("MarkerPosition"); }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        public RealTimeGraphExReachLineErase()
+            : base()
+        {
+
+        }
+
+        #endregion
+
+        #region Override Method
+
+        protected override void OnClearGraph()
+        {
+            base.OnClearGraph();
+
+            _currentReplaceIndex = 0;
+            _endReached = false;
+
+            this.Dispatcher.Invoke(() =>
+            {
+                marker.RenderTransform = new TranslateTransform(0, 0);
+            });
+        }
+
+        protected override void Initialize()
+        {
+            base.Initialize();
+            marker = new Rectangle() { VerticalAlignment = System.Windows.VerticalAlignment.Stretch, Width = 1, Fill = MarkerBrush, HorizontalAlignment = System.Windows.HorizontalAlignment.Left, Margin = new Thickness(-2, 0, 0, 0) };
+
+            if (!gridLinesAndImageWrapperGrid.Children.Contains(marker))
+            {
+                gridLinesAndImageWrapperGrid.Children.Add(marker);
+            }
+        }
+
+        protected override void OnSetCrossThreadFields()
+        {
+            base.OnSetCrossThreadFields();
+
+            this.Dispatcher.Invoke(() =>
+            {
+
+                _markerColor = MarkerBrush;
+                _showMarker = ShowMarker;
+                _enableMarkerPosition = EnableMarkerPosition;
+
+            }, System.Windows.Threading.DispatcherPriority.Send);
+        }
+
+        protected internal override void OnRenderGraph()
+        {
+            if (_graphController.dataSeries != null && _graphController.dataSeries.Points != null && _graphController.dataSeries.Points.Count > 0  && _width > 1 && _height > 1)
+            {
+                var points = _graphController.dataSeries.Points.GetAndClearAllPoints();
+
+                if (!_isPaused)
+                {
+                    for (int i = 0; i < points.Count; i++)
+                    {
+                        double value = points[i];
+                        lastVirtualValue = value;
+
+                        if (xValueCounter <= _width)
+                        {
+                            if (!_endReached)
+                            {
+                                graphPolygon.Add(value);
+                                xValueCounter += _scaleFactor;
+                            }
+                            else
+                            {
+                                graphPolygon.Replace(value, _currentReplaceIndex++);
+                                xValueCounter += _scaleFactor;
+
+                                if (_currentReplaceIndex > graphPolygon.Count - 1)
+                                {
+                                    xValueCounter = 0;
+                                    _currentReplaceIndex = 0;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            _endReached = true;
+                            xValueCounter = 0;
+                            graphPolygon.Replace(value, _currentReplaceIndex++);
+                            xValueCounter += _scaleFactor;
+                        }
+                    }
+                }
+
+                updateCounter++;
+
+                if (updateCounter >= 1 && !_isPaused)
+                {
+                    updateCounter = 0;
+                    if (!_disableRendering)
+                    {
+                        OnDrawVisuals();
+                    }
+                }
+            }
+        }
+
+        protected override void OnDrawVisuals()
+        {
+            base.OnDrawVisuals();
+
+            double scale = GetPolygonScaleFactor();
+
+            this.Dispatcher.Invoke(() =>
+            {
+                double x = ((_currentReplaceIndex * scale));
+                marker.RenderTransform = new TranslateTransform((x) - 2, 0);
+            });
+        }
+
+        #endregion
+
+        #region INotifyPropertyChanged Members
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public void RaisePropertyChanged(String propName)
+        {
+            this.Dispatcher.Invoke(() =>
+            {
+
+                if (PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(propName));
+
+            });
+        }
+
+        #endregion
+    }
+}