improved a little bit TableView, it can initialize cell controls later on (check PanelTableViewLazy class), so it's affects performance for the big tables;

fixed some Highchart issues (as I believe);

Author: Meragon

Controls/Highcharts/Highchart.cs

@@ -1,4 +1,6 @@
-namespace Highcharts
+using System.Linq;
+
+namespace Highcharts
 {
     using System;
     using System.Collections.Generic;
@@ -135,16 +137,18 @@ public void RecalcCategories()
                         cachedCategoriesStep = cachedPlotWidth;
                     else
                         cachedCategoriesStep = (float)cachedPlotWidth / (cachedCategories.Length - 1);
-                    
+
                     if (cachedCategoriesStep < categoriesMinStep)
                     {
                         cachedCategoriesStep = categoriesMinStep;
 
                         // Filter categories.
                         cachedCategoriesFiltered = new List<string>();
                         for (float i = 0; i < cachedCategories.Length; i += skipFactor)
-                            cachedCategoriesFiltered.Add(cachedCategories[(int)i]);
+                            cachedCategoriesFiltered.Add(cachedCategories[(int) i]);
                     }
+                    else
+                        cachedCategoriesFiltered = cachedCategories.ToList();
                 }
             }
         }
@@ -321,6 +325,7 @@ private void DrawSeries(Graphics g, Series s)
             {
                 double currentValue = s.data[(int) i];
 
+                bool last = i + pointInterval >= sdataCount;
                 float currentValueYCoef = (float) ((currentValue - cachedPlotMin) / valueRange);
                 float currentValueX = cachedPlotLeft + xStep * categoriesIndex;
                 float currentValueY = cachedPlotTop + cachedPlotHeight - cachedPlotHeight * currentValueYCoef;
@@ -333,7 +338,7 @@ private void DrawSeries(Graphics g, Series s)
                 {
                     if (locationX + currentValueX < -uwfOffset.X) // Left side.
                         clipHorizontal = true;
-                    if (locationX + currentValueX + xStep + uwfOffset.X > parentWidth) // Right side.
+                    if (locationX + currentValueX + uwfOffset.X > parentWidth) // Right side.
                         clipHorizontal = true;
                 }
 
@@ -344,8 +349,6 @@ private void DrawSeries(Graphics g, Series s)
                         {
                             if (i > 0)
                             {
-                                bool last = i + pointInterval >= sdataCount;
-    
                                 float prevValueYCoef = (float) ((prevValue - cachedPlotMin) / valueRange);
                                 float prevValueX = cachedPlotLeft + (categoriesIndex - 1) * xStep;
                                 float prevValueY = cachedPlotTop + cachedPlotHeight - cachedPlotHeight * prevValueYCoef;
@@ -366,8 +369,6 @@ private void DrawSeries(Graphics g, Series s)
                                 float prevValueX = cachedPlotLeft + (categoriesIndex - 1) * xStep;
                                 float prevValueY = cachedPlotTop + cachedPlotHeight - cachedPlotHeight * prevValueYCoef;
 
-                                bool last = i + pointInterval >= sdataCount;
-
                                 if (s.linearGradient == false)
                                 {
                                     g.uwfFillRectangle(areaColor, prevValueX, prevValueY, currentValueX - prevValueX,
@@ -408,10 +409,13 @@ private void DrawSeries(Graphics g, Series s)
                             break;
                         case SeriesTypes.line:
                         {
-                            float prevValueYCoef = (float) ((prevValue - cachedPlotMin) / valueRange);
-                            float prevValueX = cachedPlotLeft + (categoriesIndex - 1) * xStep;
-                            float prevValueY = cachedPlotTop + cachedPlotHeight - cachedPlotHeight * prevValueYCoef;
-                            g.DrawLine(s.pen, prevValueX, prevValueY, currentValueX + 1, currentValueY);
+                            if (i > 0)
+                            {
+                                float prevValueYCoef = (float) ((prevValue - cachedPlotMin) / valueRange);
+                                float prevValueX = cachedPlotLeft + (categoriesIndex - 1) * xStep;
+                                float prevValueY = cachedPlotTop + cachedPlotHeight - cachedPlotHeight * prevValueYCoef;
+                                g.DrawLine(s.pen, prevValueX, prevValueY, currentValueX + 1, currentValueY);
+                            }
                         }
                             break;
                         case SeriesTypes.lineSolid:
@@ -723,17 +727,12 @@ private double ValueAtX(Series s, int x)
             var sdataCount = s.data.Count;
             if (sdataCount == 0) return 0;
 
-            float pointInterval = s.pointInterval;
-            float xStep = cachedCategoriesStep;
-            if (sdataCount > 1)
-                xStep = (float)cachedPlotWidth / (sdataCount - 1);
-            xStep *= pointInterval;
-
-            var categoriesIndex = (int)((x - cachedPlotLeft) / xStep);
-            if (categoriesIndex < 0 || categoriesIndex >= sdataCount)
+            var xCoef = (float)(x - cachedPlotLeft) / cachedPlotWidth;
+            var dataIndex = (int)(xCoef * sdataCount);
+            if (dataIndex > sdataCount)
                 return 0;
 
-            return s.data[categoriesIndex];
+            return s.data[dataIndex];
         }
     }
 }

Controls/Highcharts/HightchartSubtitle.cs

@@ -3,8 +3,6 @@
     using System.Drawing;
     using System.Windows.Forms;
 
-    using DiaSimu;
-
     public class HightchartSubtitle
     {
         public HightchartSubtitle()

Controls/Highcharts/SeriesCollection.cs

@@ -4,7 +4,7 @@
     using System.Collections;
     using System.Collections.Generic;
 
-    public class SeriesCollection : IEnumerable, IDisposable
+    public class SeriesCollection : IList<Series>, IDisposable
     {
         private readonly List<Series> items = new List<Series>();
         private readonly Highchart owner;
@@ -15,8 +15,13 @@ public SeriesCollection(Highchart o)
         }
 
         public int Count { get { return items.Count; } }
+        public bool IsReadOnly { get; private set; }
 
-        public Series this[int index] { get { return items[index]; } }
+        public Series this[int index]
+        {
+            get { return items[index]; }
+            set { throw new NotImplementedException(); }
+        }
         public Series this[string name] { get { return items.Find(x => x.name == name); } }
 
         public Series Add(string name)
@@ -53,11 +58,58 @@ public void Clear()
             owner.ResetColorIndex();
             owner.UpdateLegend();
         }
+        public bool Contains(Series item)
+        {
+            return items.Contains(item);
+        }
+        public void CopyTo(Series[] array, int arrayIndex)
+        {
+            items.CopyTo(array, arrayIndex);
+        }
+        public Series Find(Predicate<Series> predicate)
+        {
+            return items.Find(predicate);
+        }
+        IEnumerator<Series> IEnumerable<Series>.GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
         public IEnumerator GetEnumerator()
         {
             return items.GetEnumerator();
         }
+        public int IndexOf(Series item)
+        {
+            return items.IndexOf(item);
+        }
+        public void Insert(int index, Series item)
+        {
+            if (item == null)
+                throw new ArgumentNullException("item");
+            
+            items.Insert(index, item);
+            
+            item.NameChanged += Series_OnNameChanged;
+            item.NameChanged -= Series_OnNameChanged;
+            
+            owner.UpdateLegend();
+        }
+        public bool Remove(Series item)
+        {
+            if (item == null)
+                throw new ArgumentNullException("item");
 
+            var removeResult = items.Remove(item);
+            item.NameChanged -= Series_OnNameChanged;
+            owner.UpdateLegend();
+
+            return removeResult;
+        }
+        public void RemoveAt(int index)
+        {
+            Remove(items[index]);
+        }
+        
         public void Dispose()
         {
             UnsubscribeSeries();