Working on FSE/PPC monitoring/system info.

11 files changed, 366 insertions, 29 deletions

diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/Themes/Generic.xaml b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/Themes/Generic.xaml
index 1070736ef..64145bcfa 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/Themes/Generic.xaml
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/Themes/Generic.xaml
@@ -34,7 +34,7 @@
                         <ItemsControl x:Name="PART_ItemsControl" ItemsSource="{TemplateBinding Items}" ItemTemplate="{TemplateBinding ItemTemplate}">
                             <ItemsControl.ItemsPanel>
                                 <ItemsPanelTemplate>
-                                    <local:WpfGraphAxisPanel Orientation="{Binding RelativeSource={RelativeSource AncestorType=local:WpfGraphAxisControl},Path=Orientation}"></local:WpfGraphAxisPanel>
+                                    <local:WpfGraphAxisPanel x:Name="PART_AxisPanel" Orientation="{Binding RelativeSource={RelativeSource AncestorType=local:WpfGraphAxisControl},Path=Orientation}"></local:WpfGraphAxisPanel>
                                 </ItemsPanelTemplate>
                             </ItemsControl.ItemsPanel>
                         </ItemsControl>
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisControl.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisControl.cs
index 23b831abe..aa738b203 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisControl.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisControl.cs
@@ -25,6 +25,7 @@ namespace RealTimeGraphX.WPF
     public class WpfGraphAxisControl : WpfGraphComponentBase
     {
         private ItemsControl _items_control;
+        private WpfGraphAxisPanel _axisPanel;
 
         /// <summary>
         /// Initializes the <see cref="WpfGraphAxisControl"/> class.
@@ -97,9 +98,37 @@ namespace RealTimeGraphX.WPF
             base.OnApplyTemplate();
 
             _items_control = GetTemplateChild("PART_ItemsControl") as ItemsControl;
+
+            _items_control.Loaded += (x, e) => 
+            {
+                ItemsPresenter itemsPresenter = GetVisualChild<ItemsPresenter>(_items_control);
+                _axisPanel = VisualTreeHelper.GetChild(itemsPresenter, 0) as WpfGraphAxisPanel;
+            };
+
             OnTicksChanged();
         }
 
+        private static T GetVisualChild<T>(DependencyObject parent) where T : Visual
+        {
+            T child = default(T);
+
+            int numVisuals = VisualTreeHelper.GetChildrenCount(parent);
+            for (int i = 0; i < numVisuals; i++)
+            {
+                Visual v = (Visual)VisualTreeHelper.GetChild(parent, i);
+                child = v as T;
+                if (child == null)
+                {
+                    child = GetVisualChild<T>(v);
+                }
+                if (child != null)
+                {
+                    break;
+                }
+            }
+            return child;
+        }
+
         /// <summary>
         /// Called when the <see cref="Ticks"/> property has changed.
         /// </summary>
@@ -107,16 +136,15 @@ namespace RealTimeGraphX.WPF
         {
             Items = new ObservableCollection<WpfGraphAxisTickData>(Enumerable.Range(0, Ticks).Select(x => new WpfGraphAxisTickData()));
 
-            if (Controller != null)
-            {
-                Controller.RequestVirtualRangeChange();
-            }
+            Controller?.RequestVirtualRangeChange();
+
+            _axisPanel?.UpdatePanel();
         }
 
         protected override void OnControllerChanged(IGraphController oldController, IGraphController newController)
         {
             base.OnControllerChanged(oldController, newController);
-            
+
             if (newController != null)
             {
                 newController.RequestVirtualRangeChange();
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisPanel.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisPanel.cs
index f10b583f4..4fb6d94bc 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisPanel.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphAxisPanel.cs
@@ -46,7 +46,7 @@ namespace RealTimeGraphX.WPF
         /// <summary>
         /// Updates the panel.
         /// </summary>
-        private void UpdatePanel()
+        public void UpdatePanel()
         {
             RowDefinitions.Clear();
             ColumnDefinitions.Clear();
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphDataSeries.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphDataSeries.cs
index 15a99ab54..8eab3eabe 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphDataSeries.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphDataSeries.cs
@@ -135,5 +135,15 @@ namespace RealTimeGraphX.WPF
         {
             get { return Fill != null; }
         }
+
+        private object _currentValue;
+        /// <summary>
+        /// Gets the current value.
+        /// </summary>
+        public object CurrentValue
+        {
+            get { return _currentValue; }
+            set { _currentValue = value; RaisePropertyChangedAuto(); }
+        }
     }
 }
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphSurface.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphSurface.cs
index ebcff3472..1a3015728 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphSurface.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX.WPF/WpfGraphSurface.cs
@@ -40,6 +40,20 @@ namespace RealTimeGraphX.WPF
         private Point _last_mouse_position;
         private Grid _grid;
 
+        #region Events
+
+        /// <summary>
+        /// Occurs when the surface size has changed.
+        /// </summary>
+        public event EventHandler SurfaceSizeChanged;
+
+        /// <summary>
+        /// Occurs when the surface zoom rectangle has changed.
+        /// </summary>
+        public event EventHandler ZoomRectChanged;
+
+        #endregion
+
         #region Properties
 
         /// <summary>
@@ -177,6 +191,8 @@ namespace RealTimeGraphX.WPF
                 }
 
                 _zoom_rect = new System.Drawing.RectangleF((float)x, (float)y, _zoom_rect.Width, _zoom_rect.Height);
+
+                ZoomRectChanged?.Invoke(this, new EventArgs());
             }
 
             _last_mouse_position = _current_mouse_position;
@@ -202,6 +218,7 @@ namespace RealTimeGraphX.WPF
                 _zoom_rect = new System.Drawing.RectangleF((float)Canvas.GetLeft(_selection_rectangle), (float)Canvas.GetTop(_selection_rectangle), (float)_selection_rectangle.Width, (float)_selection_rectangle.Height);
                 _selection_rectangle.Visibility = Visibility.Hidden;
                 _is_scaled = true;
+                ZoomRectChanged?.Invoke(this, new EventArgs());
             }
         }
 
@@ -222,6 +239,7 @@ namespace RealTimeGraphX.WPF
             {
                 _zoom_rect = new System.Drawing.RectangleF();
                 _is_scaled = false;
+                ZoomRectChanged?.Invoke(this, new EventArgs());
             }
             else if (Keyboard.IsKeyDown(Key.LeftCtrl))
             {
@@ -301,7 +319,7 @@ namespace RealTimeGraphX.WPF
         /// <param name="points">The points.</param>
         public void DrawSeries(WpfGraphDataSeries dataSeries, IEnumerable<System.Drawing.PointF> points)
         {
-            _g.DrawCurve(dataSeries.GdiPen, points.ToArray());
+            _g.DrawPolygon(dataSeries.GdiPen, points.ToArray());
         }
 
         /// <summary>
@@ -373,6 +391,7 @@ namespace RealTimeGraphX.WPF
         {
             _size = new System.Drawing.SizeF((float)e.NewSize.Width, (float)e.NewSize.Height);
             _size_changed = true;
+            SurfaceSizeChanged?.Invoke(this, new EventArgs());
         }
 
         #endregion
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/DateTimeDataPoint.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/DateTimeDataPoint.cs
new file mode 100644
index 000000000..9ec750af9
--- /dev/null
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/DateTimeDataPoint.cs
@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RealTimeGraphX.DataPoints
+{
+    public class DateTimeDataPoint : GraphDataPoint<DateTime, DateTimeDataPoint>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DateTimeDataPoint"/> class.
+        /// </summary>
+        public DateTimeDataPoint() : base()
+        {
+
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DateTimeDataPoint"/> class.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public DateTimeDataPoint(DateTime value) : base(value)
+        {
+
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="System.TimeSpan"/> to <see cref="DateTimeDataPoint"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator DateTimeDataPoint(DateTime value)
+        {
+            return new DateTimeDataPoint(value);
+        }
+
+        /// <summary>
+        /// Implements the operator -.
+        /// </summary>
+        /// <param name="a">a.</param>
+        /// <param name="b">The b.</param>
+        /// <returns>
+        /// The result of the operator.
+        /// </returns>
+        public static DateTimeDataPoint operator -(DateTimeDataPoint a, DateTimeDataPoint b)
+        {
+            return new DateTimeDataPoint(new DateTime(a.Value.Ticks - b.Value.Ticks));
+        }
+
+        /// <summary>
+        /// Implements the operator +.
+        /// </summary>
+        /// <param name="a">a.</param>
+        /// <param name="b">The b.</param>
+        /// <returns>
+        /// The result of the operator.
+        /// </returns>
+        public static DateTimeDataPoint operator +(DateTimeDataPoint a, DateTimeDataPoint b)
+        {
+            return new DateTimeDataPoint(new DateTime(a.Value.Ticks + b.Value.Ticks));
+        }
+
+        /// <summary>
+        /// Sums the value of this instance with another instance value and returns the result.
+        /// </summary>
+        /// <param name="other">The other instance.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint Add(IGraphDataPoint other)
+        {
+            return new DateTimeDataPoint(new DateTime(this.Value.Ticks + (other as DateTimeDataPoint).Value.Ticks));
+        }
+
+        /// <summary>
+        /// Subtract the value of another instance from this instance and returns the result.
+        /// </summary>
+        /// <param name="other">The other instance.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint Subtract(IGraphDataPoint other)
+        {
+            return new DateTimeDataPoint(new DateTime(this.Value.Ticks - (other as DateTimeDataPoint).Value.Ticks));
+        }
+
+        /// <summary>
+        /// Multiplies the value of this instance with another instance value and returns the result.
+        /// </summary>
+        /// <param name="other">The other instance.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint Multiply(IGraphDataPoint other)
+        {
+            return new DateTimeDataPoint(new DateTime(this.Value.Ticks * (other as DateTimeDataPoint).Value.Ticks));
+        }
+
+        /// <summary>
+        /// Divides the value of this instance with another instance value and returns the result.
+        /// </summary>
+        /// <param name="other">The other instance.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint Divide(IGraphDataPoint other)
+        {
+            return new DateTimeDataPoint(new DateTime(this.Value.Ticks / (other as DateTimeDataPoint).Value.Ticks));
+        }
+
+        /// <summary>
+        /// Returns the percentage value of this instance between the specified minimum and maximum values.
+        /// </summary>
+        /// <param name="min">The minimum.</param>
+        /// <param name="max">The maximum.</param>
+        /// <returns></returns>
+        public override double ComputeRelativePosition(IGraphDataPoint min, IGraphDataPoint max)
+        {
+            DateTime dMin = min as DateTimeDataPoint;
+            DateTime dMax = max as DateTimeDataPoint;
+
+            if (dMax.Ticks - dMin.Ticks == 0) //Prevent divide by zero
+            {
+                return dMin.Ticks;
+            }
+
+            var result = ((Value.Ticks - dMin.Ticks) * 100) / (dMax.Ticks - dMin.Ticks);
+
+            return double.IsNaN(result) ? dMin.Ticks : result;
+        }
+
+        /// <summary>
+        /// Returns the absolute value of the specified percentage value between the specified minimum and maximum values.
+        /// </summary>
+        /// <param name="min">The minimum.</param>
+        /// <param name="max">The maximum.</param>
+        /// <param name="percentage">The percentage.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint ComputeAbsolutePosition(IGraphDataPoint min, IGraphDataPoint max, double percentage)
+        {
+            double minimum = ((DateTime)min.GetValue()).Ticks;
+            double maximum = ((DateTime)max.GetValue()).Ticks;
+
+            return new DateTimeDataPoint(new DateTime((long)(minimum + (maximum - minimum) * percentage)));
+        }
+
+        /// <summary>
+        /// Creates a range of values from the specified minimum and maximum.
+        /// </summary>
+        /// <param name="min">The minimum.</param>
+        /// <param name="max">The maximum.</param>
+        /// <param name="count">The count.</param>
+        /// <returns></returns>
+        public override IEnumerable<IGraphDataPoint> CreateRange(IGraphDataPoint min, IGraphDataPoint max, int count)
+        {
+            double minimum = ((DateTime)min.GetValue()).Ticks;
+            double maximum = ((DateTime)max.GetValue()).Ticks;
+
+            return Enumerable.Range(0, count).
+                Select(i => minimum + (maximum - minimum) * ((double)i / (count - 1))).
+                Select(x => new DateTimeDataPoint(new DateTime((long)x)));
+        }
+
+        /// <summary>
+        /// Returns a formated string of this data point.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <returns></returns>
+        public override string ToString(string format)
+        {
+            return Value.ToString(format);
+        }
+
+        /// <summary>
+        /// Parses the specified value and returns a new instance of <see cref="!:TDataType" /> data point.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns></returns>
+        public override IGraphDataPoint Parse(string value)
+        {
+            return new DateTimeDataPoint(DateTime.Parse(value));
+        }
+    }
+}
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/Int32DataPoint.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/Int32DataPoint.cs
index 4bccdcb74..787e59aae 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/Int32DataPoint.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/DataPoints/Int32DataPoint.cs
@@ -118,6 +118,11 @@ namespace RealTimeGraphX.DataPoints
             Int32DataPoint dMin = min as Int32DataPoint;
             Int32DataPoint dMax = max as Int32DataPoint;
 
+            if (dMax - dMin == 0) //Prevent divide by zero
+            {
+                return dMin;
+            }
+
             var result = ((Value - dMin) * 100) / (dMax - dMin);
 
             return result;
@@ -147,12 +152,12 @@ namespace RealTimeGraphX.DataPoints
         /// <returns></returns>
         public override IEnumerable<IGraphDataPoint> CreateRange(IGraphDataPoint min, IGraphDataPoint max, int count)
         {
-            int minimum = (int)min.GetValue();
-            int maximum = (int)max.GetValue();
+            double minimum = (int)min.GetValue();
+            double maximum = (int)max.GetValue();
 
             return Enumerable.Range(0, count).
-                Select(i => minimum + (maximum - minimum) * ((int)i / (count - 1))).
-                Select(x => new Int32DataPoint(x));
+                Select(i => minimum + (maximum - minimum) * ((double)i / (count - 1))).
+                Select(x => new Int32DataPoint((int)x));
         }
 
         /// <summary>
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/GraphController.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/GraphController.cs
index 328f0736e..1b452df57 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/GraphController.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/GraphController.cs
@@ -47,6 +47,8 @@ namespace RealTimeGraphX
             public int RenderedItems { get; set; }
 
             public bool IsClearSeries { get; set; }
+
+            public bool IsUpdateSeries { get; set; }
         }
 
         #endregion
@@ -113,8 +115,10 @@ namespace RealTimeGraphX
             get { return _surface; }
             set
             {
+                var previous = _surface;
                 _surface = value;
                 RequestVirtualRangeChange();
+                OnSurfaceChanged(previous, _surface);
             }
         }
 
@@ -227,11 +231,8 @@ namespace RealTimeGraphX
                     {
                         List<List<PendingSeries>> pending_lists = new List<List<PendingSeries>>();
 
-                        if (_pending_series_collection.Count == 0)
-                        {
-                            Thread.Sleep(TimeSpan.FromSeconds(1));
-                            continue;
-                        }
+                        var pending_list_first = _pending_series_collection.BlockDequeue();
+                        pending_lists.Add(pending_list_first);
 
                         while (_pending_series_collection.Count > 0)
                         {
@@ -247,24 +248,24 @@ namespace RealTimeGraphX
                                 {
                                     _pending_series_collection = new GraphDataQueue<List<PendingSeries>>();
                                     _to_render.Clear();
-                                    break;
                                 }
-
-                                if (_to_render.ContainsKey(pending_series.Series))
+                                else if (!pending_series.IsUpdateSeries)
                                 {
-                                    var s = _to_render[pending_series.Series];
-                                    s.XX.AddRange(pending_series.XX);
-                                    s.YY.AddRange(pending_series.YY);
-                                }
-                                else
-                                {
-                                    _to_render[pending_series.Series] = pending_series;
+                                    if (_to_render.ContainsKey(pending_series.Series))
+                                    {
+                                        var s = _to_render[pending_series.Series];
+                                        s.XX.AddRange(pending_series.XX);
+                                        s.YY.AddRange(pending_series.YY);
+                                    }
+                                    else
+                                    {
+                                        _to_render[pending_series.Series] = pending_series;
+                                    }
                                 }
                             }
                         }
 
                         if (_to_render.Count > 0)
-                        //if (DateTime.Now > _last_render_time.AddMilliseconds(RefreshRate.TotalMilliseconds) && _to_render.Count > 0)
                         {
                             GraphDataPoint min_x = _range.MaximumX - _range.MaximumX;
                             GraphDataPoint max_x = _range.MaximumX;
@@ -346,6 +347,11 @@ namespace RealTimeGraphX
 
                                 foreach (var item in to_render)
                                 {
+                                    if (item.YY.Count > 0)
+                                    {
+                                        item.Series.CurrentValue = item.YY.Last().GetValue();
+                                    }
+
                                     var points = Renderer.Render(Surface, item.Series, _range, item.XX, item.YY, min_x, max_x, min_y, max_y);
                                     to_draw.Add(new Tuple<TDataSeries, IEnumerable<PointF>>(item.Series, points));
                                 }
@@ -385,6 +391,26 @@ namespace RealTimeGraphX
         #region Protected Methods
 
         /// <summary>
+        /// Called when the surface has changed.
+        /// </summary>
+        /// <param name="previous">The previous.</param>
+        /// <param name="surface">The surface.</param>
+        protected virtual void OnSurfaceChanged(IGraphSurface<TDataSeries> previous, IGraphSurface<TDataSeries> surface)
+        {
+            if (previous != null)
+            {
+                previous.SurfaceSizeChanged += Surface_SurfaceSizeChanged;
+                previous.ZoomRectChanged += Surface_ZoomRectChanged;
+            }
+
+            if (surface != null)
+            {
+                surface.SurfaceSizeChanged += Surface_SurfaceSizeChanged;
+                surface.ZoomRectChanged += Surface_ZoomRectChanged;
+            }
+        }
+
+        /// <summary>
         /// Raises the <see cref="EffectiveRangeChanged"/> event.
         /// </summary>
         /// <param name="minimumX">The minimum x.</param>
@@ -431,6 +457,62 @@ namespace RealTimeGraphX
 
         #endregion
 
+        #region Surface Event Handlers
+
+        /// <summary>
+        /// Handles the ZoomRectChanged event of the Surface control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
+        private void Surface_ZoomRectChanged(object sender, EventArgs e)
+        {
+            if (!_pending_series_collection.ToList().SelectMany(x => x).ToList().Exists(x => x.IsUpdateSeries))
+            {
+                List<PendingSeries> updateSeries = new List<PendingSeries>();
+
+                foreach (var pending_Series in _to_render)
+                {
+                    updateSeries.Add(new PendingSeries()
+                    {
+                        IsUpdateSeries = true,
+                        Series = pending_Series.Value.Series,
+                        XX = new List<GraphDataPoint>(),
+                        YY = new List<GraphDataPoint>(),
+                    });
+                }
+
+                _pending_series_collection.BlockEnqueue(updateSeries);
+            }
+        }
+
+        /// <summary>
+        /// Handles the SurfaceSizeChanged event of the Surface control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
+        private void Surface_SurfaceSizeChanged(object sender, EventArgs e)
+        {
+            if (!_pending_series_collection.ToList().SelectMany(x => x).ToList().Exists(x => x.IsUpdateSeries))
+            {
+                List<PendingSeries> updateSeries = new List<PendingSeries>();
+
+                foreach (var pending_Series in _to_render)
+                {
+                    updateSeries.Add(new PendingSeries()
+                    {
+                        IsUpdateSeries = true,
+                        Series = pending_Series.Value.Series,
+                        XX = new List<GraphDataPoint>(),
+                        YY = new List<GraphDataPoint>(),
+                    });
+                }
+
+                _pending_series_collection.BlockEnqueue(updateSeries);
+            }
+        }
+
+        #endregion
+
         #region Public Methods
 
         /// <summary>
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphDataSeries.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphDataSeries.cs
index dd05da92b..03640e44a 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphDataSeries.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphDataSeries.cs
@@ -27,5 +27,10 @@ namespace RealTimeGraphX
         /// Gets or sets a value indicating whether this series should be visible.
         /// </summary>
         bool IsVisible { get; set; }
+
+        /// <summary>
+        /// Gets the current value.
+        /// </summary>
+        Object CurrentValue { get; set; }
     }
 }
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphSurface.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphSurface.cs
index 310bc7c3d..a3aeb90d9 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphSurface.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/IGraphSurface.cs
@@ -12,6 +12,16 @@ namespace RealTimeGraphX
     public interface IGraphSurface : IGraphComponent
     {
         /// <summary>
+        /// Occurs when the surface size has changed.
+        /// </summary>
+        event EventHandler SurfaceSizeChanged;
+
+        /// <summary>
+        /// Occurs when the surface zoom rectangle has changed.
+        /// </summary>
+        event EventHandler ZoomRectChanged;
+
+        /// <summary>
         /// Returns the actual size of the surface.
         /// </summary>
         /// <returns></returns>
diff --git a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/Renderers/ScrollingLineRenderer.cs b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/Renderers/ScrollingLineRenderer.cs
index 82e80aa0f..0a4ac8368 100644
--- a/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/Renderers/ScrollingLineRenderer.cs
+++ b/Software/Visual_Studio/SideChains/RealTimeGraphX-master/RealTimeGraphX/Renderers/ScrollingLineRenderer.cs
@@ -78,7 +78,7 @@ namespace RealTimeGraphX.Renderers
                 surface.FillSeries(series, GetFillPoints(surface, points));
             }
 
-            surface.DrawSeries(series, points);
+            surface.DrawSeries(series, GetFillPoints(surface, points));
         }
     }
 }