From fbd7ba3b49d0ba69921e070f0f763d64db05ce3b Mon Sep 17 00:00:00 2001
From: Juergen Tem <JuergenTem@outlook.com>
Date: Tue, 1 May 2018 11:08:57 +0200
Subject: [PATCH] Update ZedGraph to latest version

---
 BDInfo/BDInfo.csproj                          |  124 +-
 BDInfo/License-LGPL.txt                       |  506 +++
 BDInfo/ZedGraph/ArrowObj.cs                   |  323 --
 BDInfo/ZedGraph/Axis.cs                       | 1440 --------
 BDInfo/ZedGraph/AxisLabel.cs                  |  180 -
 BDInfo/ZedGraph/Bar.cs                        |  523 ---
 BDInfo/ZedGraph/BarItem.cs                    |  457 ---
 BDInfo/ZedGraph/BarSettings.cs                |  484 ---
 BDInfo/ZedGraph/BasicArrayPointList.cs        |  147 -
 BDInfo/ZedGraph/Border.cs                     |  250 --
 BDInfo/ZedGraph/BoxObj.cs                     |  348 --
 BDInfo/ZedGraph/Chart.cs                      |  256 --
 BDInfo/ZedGraph/CollectionPlus.cs             |  162 -
 BDInfo/ZedGraph/ColorSymbolRotator.cs         |  188 --
 BDInfo/ZedGraph/CurveItem.cs                  | 1229 -------
 BDInfo/ZedGraph/CurveList.cs                  |  745 -----
 BDInfo/ZedGraph/DataSourcePointList.cs        |  304 --
 BDInfo/ZedGraph/DateAsOrdinalScale.cs         |  339 --
 BDInfo/ZedGraph/DateScale.cs                  |  947 ------
 BDInfo/ZedGraph/EllipseObj.cs                 |  259 --
 BDInfo/ZedGraph/ErrorBar.cs                   |  388 ---
 BDInfo/ZedGraph/ErrorBarItem.cs               |  364 --
 BDInfo/ZedGraph/ExponentScale.cs              |  404 ---
 BDInfo/ZedGraph/Fill.cs                       | 1145 -------
 BDInfo/ZedGraph/FilteredPointList.cs          |  321 --
 BDInfo/ZedGraph/FontSpec.cs                   | 1503 ---------
 BDInfo/ZedGraph/GapLabel.cs                   |  176 -
 BDInfo/ZedGraph/GasGaugeNeedle.cs             |  594 ----
 BDInfo/ZedGraph/GasGaugeRegion.cs             |  598 ----
 BDInfo/ZedGraph/GraphObj.cs                   |  505 ---
 BDInfo/ZedGraph/GraphObjList.cs               |  304 --
 BDInfo/ZedGraph/GraphPane.cs                  | 2330 -------------
 BDInfo/ZedGraph/HSBColor.cs                   |  225 --
 BDInfo/ZedGraph/HiLowBar.cs                   |  378 ---
 BDInfo/ZedGraph/HiLowBarItem.cs               |  149 -
 BDInfo/ZedGraph/IPointList.cs                 |   57 -
 BDInfo/ZedGraph/IPointListEdit.cs             |   88 -
 BDInfo/ZedGraph/ImageObj.cs                   |  342 --
 BDInfo/ZedGraph/JapaneseCandleStick.cs        |  485 ---
 BDInfo/ZedGraph/JapaneseCandleStickItem.cs    |  352 --
 BDInfo/ZedGraph/Label.cs                      |  202 --
 BDInfo/ZedGraph/Legend.cs                     | 1038 ------
 BDInfo/ZedGraph/Line.cs                       | 1455 --------
 BDInfo/ZedGraph/LineBase.cs                   |  474 ---
 BDInfo/ZedGraph/LineItem.cs                   |  394 ---
 BDInfo/ZedGraph/LineObj.cs                    |  338 --
 BDInfo/ZedGraph/LinearAsOrdinalScale.cs       |  244 --
 BDInfo/ZedGraph/LinearScale.cs                |  234 --
 BDInfo/ZedGraph/Link.cs                       |  304 --
 BDInfo/ZedGraph/Location.cs                   |  566 ----
 BDInfo/ZedGraph/LogScale.cs                   |  443 ---
 BDInfo/ZedGraph/MajorGrid.cs                  |  200 --
 BDInfo/ZedGraph/MajorTic.cs                   |  244 --
 BDInfo/ZedGraph/Margin.cs                     |  264 --
 BDInfo/ZedGraph/MasterPane.cs                 | 1179 -------
 BDInfo/ZedGraph/MinorGrid.cs                  |  294 --
 BDInfo/ZedGraph/MinorTic.cs                   |  501 ---
 BDInfo/ZedGraph/NoDupePointList.cs            |  358 --
 BDInfo/ZedGraph/OHLCBar.cs                    |  436 ---
 BDInfo/ZedGraph/OHLCBarItem.cs                |  343 --
 BDInfo/ZedGraph/OrdinalScale.cs               |  233 --
 BDInfo/ZedGraph/PaneBase.cs                   | 1220 -------
 BDInfo/ZedGraph/PaneLayoutMgr.cs              |  561 ----
 BDInfo/ZedGraph/PaneList.cs                   |  237 --
 BDInfo/ZedGraph/PieItem.cs                    | 1091 ------
 BDInfo/ZedGraph/PointD.cs                     |   59 -
 BDInfo/ZedGraph/PointPair.cs                  |  562 ----
 BDInfo/ZedGraph/PointPair4.cs                 |  218 --
 BDInfo/ZedGraph/PointPairBase.cs              |  281 --
 BDInfo/ZedGraph/PointPairCV.cs                |  122 -
 BDInfo/ZedGraph/PointPairList.cs              |  935 ------
 BDInfo/ZedGraph/PolyObj.cs                    |  336 --
 BDInfo/ZedGraph/RadarPointList.cs             |  216 --
 BDInfo/ZedGraph/RollingPointPairList.cs       |  655 ----
 BDInfo/ZedGraph/SampleMultiPointList.cs       |  284 --
 BDInfo/ZedGraph/SamplePointList.cs            |  198 --
 BDInfo/ZedGraph/Scale.cs                      | 2930 -----------------
 BDInfo/ZedGraph/ScaleState.cs                 |  186 --
 BDInfo/ZedGraph/ScaleStateList.cs             |  178 -
 BDInfo/ZedGraph/ScrollRange.cs                |   97 -
 BDInfo/ZedGraph/ScrollRangeList.cs            |  129 -
 BDInfo/ZedGraph/Selection.cs                  |  258 --
 BDInfo/ZedGraph/StickItem.cs                  |  219 --
 BDInfo/ZedGraph/StockPointList.cs             |  171 -
 BDInfo/ZedGraph/StockPt.cs                    |  316 --
 BDInfo/ZedGraph/Symbol.cs                     |  680 ----
 BDInfo/ZedGraph/TextObj.cs                    |  447 ---
 BDInfo/ZedGraph/TextScale.cs                  |  328 --
 BDInfo/ZedGraph/Types.cs                      |  868 -----
 BDInfo/ZedGraph/ValueHandler.cs               |  372 ---
 BDInfo/ZedGraph/X2Axis.cs                     |  260 --
 BDInfo/ZedGraph/XAxis.cs                      |  255 --
 BDInfo/ZedGraph/XDate.cs                      | 1732 ----------
 BDInfo/ZedGraph/Y2Axis.cs                     |  255 --
 BDInfo/ZedGraph/Y2AxisList.cs                 |  188 --
 BDInfo/ZedGraph/YAxis.cs                      |  255 --
 BDInfo/ZedGraph/YAxisList.cs                  |  187 --
 .../ZedGraph/ZedGraphControl.ContextMenu.cs   |  897 -----
 BDInfo/ZedGraph/ZedGraphControl.Designer.cs   |   78 -
 BDInfo/ZedGraph/ZedGraphControl.Events.cs     | 1462 --------
 BDInfo/ZedGraph/ZedGraphControl.Printing.cs   |  240 --
 BDInfo/ZedGraph/ZedGraphControl.Properties.cs | 1231 -------
 BDInfo/ZedGraph/ZedGraphControl.ScrollBars.cs |  395 ---
 BDInfo/ZedGraph/ZedGraphControl.cs            |  852 -----
 BDInfo/ZedGraph/ZedGraphException.cs          |   77 -
 BDInfo/ZedGraph/ZoomState.cs                  |  191 --
 BDInfo/ZedGraph/ZoomStateStack.cs             |  178 -
 BDInfo/packages.config                        |    1 +
 108 files changed, 514 insertions(+), 52037 deletions(-)
 create mode 100644 BDInfo/License-LGPL.txt
 delete mode 100644 BDInfo/ZedGraph/ArrowObj.cs
 delete mode 100644 BDInfo/ZedGraph/Axis.cs
 delete mode 100644 BDInfo/ZedGraph/AxisLabel.cs
 delete mode 100644 BDInfo/ZedGraph/Bar.cs
 delete mode 100644 BDInfo/ZedGraph/BarItem.cs
 delete mode 100644 BDInfo/ZedGraph/BarSettings.cs
 delete mode 100644 BDInfo/ZedGraph/BasicArrayPointList.cs
 delete mode 100644 BDInfo/ZedGraph/Border.cs
 delete mode 100644 BDInfo/ZedGraph/BoxObj.cs
 delete mode 100644 BDInfo/ZedGraph/Chart.cs
 delete mode 100644 BDInfo/ZedGraph/CollectionPlus.cs
 delete mode 100644 BDInfo/ZedGraph/ColorSymbolRotator.cs
 delete mode 100644 BDInfo/ZedGraph/CurveItem.cs
 delete mode 100644 BDInfo/ZedGraph/CurveList.cs
 delete mode 100644 BDInfo/ZedGraph/DataSourcePointList.cs
 delete mode 100644 BDInfo/ZedGraph/DateAsOrdinalScale.cs
 delete mode 100644 BDInfo/ZedGraph/DateScale.cs
 delete mode 100644 BDInfo/ZedGraph/EllipseObj.cs
 delete mode 100644 BDInfo/ZedGraph/ErrorBar.cs
 delete mode 100644 BDInfo/ZedGraph/ErrorBarItem.cs
 delete mode 100644 BDInfo/ZedGraph/ExponentScale.cs
 delete mode 100644 BDInfo/ZedGraph/Fill.cs
 delete mode 100644 BDInfo/ZedGraph/FilteredPointList.cs
 delete mode 100644 BDInfo/ZedGraph/FontSpec.cs
 delete mode 100644 BDInfo/ZedGraph/GapLabel.cs
 delete mode 100644 BDInfo/ZedGraph/GasGaugeNeedle.cs
 delete mode 100644 BDInfo/ZedGraph/GasGaugeRegion.cs
 delete mode 100644 BDInfo/ZedGraph/GraphObj.cs
 delete mode 100644 BDInfo/ZedGraph/GraphObjList.cs
 delete mode 100644 BDInfo/ZedGraph/GraphPane.cs
 delete mode 100644 BDInfo/ZedGraph/HSBColor.cs
 delete mode 100644 BDInfo/ZedGraph/HiLowBar.cs
 delete mode 100644 BDInfo/ZedGraph/HiLowBarItem.cs
 delete mode 100644 BDInfo/ZedGraph/IPointList.cs
 delete mode 100644 BDInfo/ZedGraph/IPointListEdit.cs
 delete mode 100644 BDInfo/ZedGraph/ImageObj.cs
 delete mode 100644 BDInfo/ZedGraph/JapaneseCandleStick.cs
 delete mode 100644 BDInfo/ZedGraph/JapaneseCandleStickItem.cs
 delete mode 100644 BDInfo/ZedGraph/Label.cs
 delete mode 100644 BDInfo/ZedGraph/Legend.cs
 delete mode 100644 BDInfo/ZedGraph/Line.cs
 delete mode 100644 BDInfo/ZedGraph/LineBase.cs
 delete mode 100644 BDInfo/ZedGraph/LineItem.cs
 delete mode 100644 BDInfo/ZedGraph/LineObj.cs
 delete mode 100644 BDInfo/ZedGraph/LinearAsOrdinalScale.cs
 delete mode 100644 BDInfo/ZedGraph/LinearScale.cs
 delete mode 100644 BDInfo/ZedGraph/Link.cs
 delete mode 100644 BDInfo/ZedGraph/Location.cs
 delete mode 100644 BDInfo/ZedGraph/LogScale.cs
 delete mode 100644 BDInfo/ZedGraph/MajorGrid.cs
 delete mode 100644 BDInfo/ZedGraph/MajorTic.cs
 delete mode 100644 BDInfo/ZedGraph/Margin.cs
 delete mode 100644 BDInfo/ZedGraph/MasterPane.cs
 delete mode 100644 BDInfo/ZedGraph/MinorGrid.cs
 delete mode 100644 BDInfo/ZedGraph/MinorTic.cs
 delete mode 100644 BDInfo/ZedGraph/NoDupePointList.cs
 delete mode 100644 BDInfo/ZedGraph/OHLCBar.cs
 delete mode 100644 BDInfo/ZedGraph/OHLCBarItem.cs
 delete mode 100644 BDInfo/ZedGraph/OrdinalScale.cs
 delete mode 100644 BDInfo/ZedGraph/PaneBase.cs
 delete mode 100644 BDInfo/ZedGraph/PaneLayoutMgr.cs
 delete mode 100644 BDInfo/ZedGraph/PaneList.cs
 delete mode 100644 BDInfo/ZedGraph/PieItem.cs
 delete mode 100644 BDInfo/ZedGraph/PointD.cs
 delete mode 100644 BDInfo/ZedGraph/PointPair.cs
 delete mode 100644 BDInfo/ZedGraph/PointPair4.cs
 delete mode 100644 BDInfo/ZedGraph/PointPairBase.cs
 delete mode 100644 BDInfo/ZedGraph/PointPairCV.cs
 delete mode 100644 BDInfo/ZedGraph/PointPairList.cs
 delete mode 100644 BDInfo/ZedGraph/PolyObj.cs
 delete mode 100644 BDInfo/ZedGraph/RadarPointList.cs
 delete mode 100644 BDInfo/ZedGraph/RollingPointPairList.cs
 delete mode 100644 BDInfo/ZedGraph/SampleMultiPointList.cs
 delete mode 100644 BDInfo/ZedGraph/SamplePointList.cs
 delete mode 100644 BDInfo/ZedGraph/Scale.cs
 delete mode 100644 BDInfo/ZedGraph/ScaleState.cs
 delete mode 100644 BDInfo/ZedGraph/ScaleStateList.cs
 delete mode 100644 BDInfo/ZedGraph/ScrollRange.cs
 delete mode 100644 BDInfo/ZedGraph/ScrollRangeList.cs
 delete mode 100644 BDInfo/ZedGraph/Selection.cs
 delete mode 100644 BDInfo/ZedGraph/StickItem.cs
 delete mode 100644 BDInfo/ZedGraph/StockPointList.cs
 delete mode 100644 BDInfo/ZedGraph/StockPt.cs
 delete mode 100644 BDInfo/ZedGraph/Symbol.cs
 delete mode 100644 BDInfo/ZedGraph/TextObj.cs
 delete mode 100644 BDInfo/ZedGraph/TextScale.cs
 delete mode 100644 BDInfo/ZedGraph/Types.cs
 delete mode 100644 BDInfo/ZedGraph/ValueHandler.cs
 delete mode 100644 BDInfo/ZedGraph/X2Axis.cs
 delete mode 100644 BDInfo/ZedGraph/XAxis.cs
 delete mode 100644 BDInfo/ZedGraph/XDate.cs
 delete mode 100644 BDInfo/ZedGraph/Y2Axis.cs
 delete mode 100644 BDInfo/ZedGraph/Y2AxisList.cs
 delete mode 100644 BDInfo/ZedGraph/YAxis.cs
 delete mode 100644 BDInfo/ZedGraph/YAxisList.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.ContextMenu.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.Designer.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.Events.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.Printing.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.Properties.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.ScrollBars.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphControl.cs
 delete mode 100644 BDInfo/ZedGraph/ZedGraphException.cs
 delete mode 100644 BDInfo/ZedGraph/ZoomState.cs
 delete mode 100644 BDInfo/ZedGraph/ZoomStateStack.cs

diff --git a/BDInfo/BDInfo.csproj b/BDInfo/BDInfo.csproj
index 630e9099a9..83790ff400 100644
--- a/BDInfo/BDInfo.csproj
+++ b/BDInfo/BDInfo.csproj
@@ -71,6 +71,10 @@
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
+    <Reference Include="ZedGraph, Version=5.1.7.430, Culture=neutral, PublicKeyToken=02a83cbd123fcd60, processorArchitecture=MSIL">
+      <HintPath>..\packages\ZedGraph.5.1.7\lib\net35-Client\ZedGraph.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BDROM\TSCodecAC3.cs" />
@@ -99,123 +103,6 @@
       <DependentUpon>FormPlaylist.cs</DependentUpon>
     </Compile>
     <Compile Include="ToolBox.cs" />
-    <Compile Include="ZedGraph\ArrowObj.cs" />
-    <Compile Include="ZedGraph\Axis.cs" />
-    <Compile Include="ZedGraph\AxisLabel.cs" />
-    <Compile Include="ZedGraph\Bar.cs" />
-    <Compile Include="ZedGraph\BarItem.cs" />
-    <Compile Include="ZedGraph\BarSettings.cs" />
-    <Compile Include="ZedGraph\BasicArrayPointList.cs" />
-    <Compile Include="ZedGraph\Border.cs" />
-    <Compile Include="ZedGraph\BoxObj.cs" />
-    <Compile Include="ZedGraph\Chart.cs" />
-    <Compile Include="ZedGraph\CollectionPlus.cs" />
-    <Compile Include="ZedGraph\ColorSymbolRotator.cs" />
-    <Compile Include="ZedGraph\CurveItem.cs" />
-    <Compile Include="ZedGraph\CurveList.cs" />
-    <Compile Include="ZedGraph\DataSourcePointList.cs" />
-    <Compile Include="ZedGraph\DateAsOrdinalScale.cs" />
-    <Compile Include="ZedGraph\DateScale.cs" />
-    <Compile Include="ZedGraph\EllipseObj.cs" />
-    <Compile Include="ZedGraph\ErrorBar.cs" />
-    <Compile Include="ZedGraph\ErrorBarItem.cs" />
-    <Compile Include="ZedGraph\ExponentScale.cs" />
-    <Compile Include="ZedGraph\Fill.cs" />
-    <Compile Include="ZedGraph\FilteredPointList.cs" />
-    <Compile Include="ZedGraph\FontSpec.cs" />
-    <Compile Include="ZedGraph\GapLabel.cs" />
-    <Compile Include="ZedGraph\GasGaugeNeedle.cs" />
-    <Compile Include="ZedGraph\GasGaugeRegion.cs" />
-    <Compile Include="ZedGraph\GraphObj.cs" />
-    <Compile Include="ZedGraph\GraphObjList.cs" />
-    <Compile Include="ZedGraph\GraphPane.cs" />
-    <Compile Include="ZedGraph\HiLowBar.cs" />
-    <Compile Include="ZedGraph\HiLowBarItem.cs" />
-    <Compile Include="ZedGraph\HSBColor.cs" />
-    <Compile Include="ZedGraph\ImageObj.cs" />
-    <Compile Include="ZedGraph\IPointList.cs" />
-    <Compile Include="ZedGraph\IPointListEdit.cs" />
-    <Compile Include="ZedGraph\JapaneseCandleStick.cs" />
-    <Compile Include="ZedGraph\JapaneseCandleStickItem.cs" />
-    <Compile Include="ZedGraph\Label.cs" />
-    <Compile Include="ZedGraph\Legend.cs" />
-    <Compile Include="ZedGraph\Line.cs" />
-    <Compile Include="ZedGraph\LinearAsOrdinalScale.cs" />
-    <Compile Include="ZedGraph\LinearScale.cs" />
-    <Compile Include="ZedGraph\LineBase.cs" />
-    <Compile Include="ZedGraph\LineItem.cs" />
-    <Compile Include="ZedGraph\LineObj.cs" />
-    <Compile Include="ZedGraph\Link.cs" />
-    <Compile Include="ZedGraph\Location.cs" />
-    <Compile Include="ZedGraph\LogScale.cs" />
-    <Compile Include="ZedGraph\MajorGrid.cs" />
-    <Compile Include="ZedGraph\MajorTic.cs" />
-    <Compile Include="ZedGraph\Margin.cs" />
-    <Compile Include="ZedGraph\MasterPane.cs" />
-    <Compile Include="ZedGraph\MinorGrid.cs" />
-    <Compile Include="ZedGraph\MinorTic.cs" />
-    <Compile Include="ZedGraph\NoDupePointList.cs" />
-    <Compile Include="ZedGraph\OHLCBar.cs" />
-    <Compile Include="ZedGraph\OHLCBarItem.cs" />
-    <Compile Include="ZedGraph\OrdinalScale.cs" />
-    <Compile Include="ZedGraph\PaneBase.cs" />
-    <Compile Include="ZedGraph\PaneLayoutMgr.cs" />
-    <Compile Include="ZedGraph\PaneList.cs" />
-    <Compile Include="ZedGraph\PieItem.cs" />
-    <Compile Include="ZedGraph\PointD.cs" />
-    <Compile Include="ZedGraph\PointPair.cs" />
-    <Compile Include="ZedGraph\PointPair4.cs" />
-    <Compile Include="ZedGraph\PointPairBase.cs" />
-    <Compile Include="ZedGraph\PointPairCV.cs" />
-    <Compile Include="ZedGraph\PointPairList.cs" />
-    <Compile Include="ZedGraph\PolyObj.cs" />
-    <Compile Include="ZedGraph\RadarPointList.cs" />
-    <Compile Include="ZedGraph\RollingPointPairList.cs" />
-    <Compile Include="ZedGraph\SampleMultiPointList.cs" />
-    <Compile Include="ZedGraph\SamplePointList.cs" />
-    <Compile Include="ZedGraph\Scale.cs" />
-    <Compile Include="ZedGraph\ScaleState.cs" />
-    <Compile Include="ZedGraph\ScaleStateList.cs" />
-    <Compile Include="ZedGraph\ScrollRange.cs" />
-    <Compile Include="ZedGraph\ScrollRangeList.cs" />
-    <Compile Include="ZedGraph\Selection.cs" />
-    <Compile Include="ZedGraph\StickItem.cs" />
-    <Compile Include="ZedGraph\StockPointList.cs" />
-    <Compile Include="ZedGraph\StockPt.cs" />
-    <Compile Include="ZedGraph\Symbol.cs" />
-    <Compile Include="ZedGraph\TextObj.cs" />
-    <Compile Include="ZedGraph\TextScale.cs" />
-    <Compile Include="ZedGraph\Types.cs" />
-    <Compile Include="ZedGraph\ValueHandler.cs" />
-    <Compile Include="ZedGraph\X2Axis.cs" />
-    <Compile Include="ZedGraph\XAxis.cs" />
-    <Compile Include="ZedGraph\XDate.cs" />
-    <Compile Include="ZedGraph\Y2Axis.cs" />
-    <Compile Include="ZedGraph\Y2AxisList.cs" />
-    <Compile Include="ZedGraph\YAxis.cs" />
-    <Compile Include="ZedGraph\YAxisList.cs" />
-    <Compile Include="ZedGraph\ZedGraphControl.ContextMenu.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphControl.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphControl.Designer.cs" />
-    <Compile Include="ZedGraph\ZedGraphControl.Events.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphControl.Printing.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphControl.Properties.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphControl.ScrollBars.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="ZedGraph\ZedGraphException.cs" />
-    <Compile Include="ZedGraph\ZoomState.cs" />
-    <Compile Include="ZedGraph\ZoomStateStack.cs" />
     <Compile Include="FormChart.cs">
       <SubType>Form</SubType>
     </Compile>
@@ -282,6 +169,9 @@
   <ItemGroup>
     <None Include="Resources\Toma4025-Rumax-Bluray-disc.ico" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="License-LGPL.txt" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/BDInfo/License-LGPL.txt b/BDInfo/License-LGPL.txt
new file mode 100644
index 0000000000..84d86408f9
--- /dev/null
+++ b/BDInfo/License-LGPL.txt
@@ -0,0 +1,506 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+
+
diff --git a/BDInfo/ZedGraph/ArrowObj.cs b/BDInfo/ZedGraph/ArrowObj.cs
deleted file mode 100644
index 393e7f0f64..0000000000
--- a/BDInfo/ZedGraph/ArrowObj.cs
+++ /dev/null
@@ -1,323 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a graphic arrow or line object on the graph.  A list of
-	/// ArrowObj objects is maintained by the <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/01/25 07:56:08 $ </version>
-	[Serializable]
-	public class ArrowObj : LineObj, ICloneable, ISerializable
-	{
-		#region Fields
-		/// <summary>
-		/// Private field that stores the arrowhead size, measured in points.
-		/// Use the public property <see cref="Size"/> to access this value.
-		/// </summary>
-		private float _size;
-		/// <summary>
-		/// Private boolean field that stores the arrowhead state.
-		/// Use the public property <see cref="IsArrowHead"/> to access this value.
-		/// </summary>
-		/// <value> true if an arrowhead is to be drawn, false otherwise </value>
-		private bool _isArrowHead;
-
-		#endregion
-
-		#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ArrowObj"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			/// <summary>
-			/// The default size for the <see cref="ArrowObj"/> item arrowhead
-			/// (<see cref="ArrowObj.Size"/> property).  Units are in points (1/72 inch).
-			/// </summary>
-			public static float Size = 12.0F;
-			/// <summary>
-			/// The default display mode for the <see cref="ArrowObj"/> item arrowhead
-			/// (<see cref="ArrowObj.IsArrowHead"/> property).  true to show the
-			/// arrowhead, false to hide it.
-			/// </summary>
-			public static bool IsArrowHead = true;
-		}
-		#endregion
-
-		#region Properties
-		/// <summary>
-		/// The size of the arrowhead.
-		/// </summary>
-		/// <remarks>The display of the arrowhead can be
-		/// enabled or disabled with the <see cref="IsArrowHead"/> property.
-		/// </remarks>
-		/// <value> The size is defined in points (1/72 inch) </value>
-		/// <seealso cref="Default.Size"/>
-		public float Size
-		{
-			get { return _size; }
-			set { _size = value; }
-		}
-		/// <summary>
-		/// Determines whether or not to draw an arrowhead
-		/// </summary>
-		/// <value> true to show the arrowhead, false to show the line segment
-		/// only</value>
-		/// <seealso cref="Default.IsArrowHead"/>
-		public bool IsArrowHead
-		{
-			get { return _isArrowHead; }
-			set { _isArrowHead = value; }
-		}
-		#endregion
-
-		#region Constructors
-		/// <overloads>Constructors for the <see cref="ArrowObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the position, color, and size of the
-		/// <see cref="ArrowObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="color">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the arrow</param>
-		/// <param name="size">The size of the arrowhead, measured in points.</param>
-		/// <param name="x1">The x position of the starting point that defines the
-		/// arrow.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y1">The y position of the starting point that defines the
-		/// arrow.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="x2">The x position of the ending point that defines the
-		/// arrow.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y2">The y position of the ending point that defines the
-		/// arrow.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public ArrowObj( Color color, float size, double x1, double y1,
-					double x2, double y2 )
-			: base( color, x1, y1, x2, y2 )
-		{
-			_isArrowHead = Default.IsArrowHead;
-			_size = size;
-		}
-
-		/// <summary>
-		/// A constructor that allows only the position of the
-		/// arrow to be pre-specified.  All other properties are set to
-		/// default values
-		/// </summary>
-		/// <param name="x1">The x position of the starting point that defines the
-		/// <see cref="ArrowObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y1">The y position of the starting point that defines the
-		/// <see cref="ArrowObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="x2">The x position of the ending point that defines the
-		/// <see cref="ArrowObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y2">The y position of the ending point that defines the
-		/// <see cref="ArrowObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public ArrowObj( double x1, double y1, double x2, double y2 )
-			: this( LineBase.Default.Color, Default.Size, x1, y1, x2, y2 )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor -- places the <see cref="ArrowObj"/> at location
-		/// (0,0) to (1,1).  All other values are defaulted.
-		/// </summary>
-		public ArrowObj()
-			:
-			this( LineBase.Default.Color, Default.Size, 0, 0, 1, 1 )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ArrowObj"/> object from which to copy</param>
-		public ArrowObj( ArrowObj rhs )
-			: base( rhs )
-		{
-			_size = rhs.Size;
-			_isArrowHead = rhs.IsArrowHead;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new ArrowObj Clone()
-		{
-			return new ArrowObj( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected ArrowObj( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-			_size = info.GetSingle( "size" );
-			_isArrowHead = info.GetBoolean( "isArrowHead" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema2 );
-			info.AddValue( "size", _size );
-			info.AddValue( "isArrowHead", _isArrowHead );
-		}
-		#endregion
-
-		#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// Convert the arrow coordinates from the user coordinate system
-			// to the screen coordinate system
-			PointF pix1 = this.Location.TransformTopLeft( pane );
-			PointF pix2 = this.Location.TransformBottomRight( pane );
-
-			if ( pix1.X > -10000 && pix1.X < 100000 && pix1.Y > -100000 && pix1.Y < 100000 &&
-				pix2.X > -10000 && pix2.X < 100000 && pix2.Y > -100000 && pix2.Y < 100000 )
-			{
-				// get a scaled size for the arrowhead
-				float scaledSize = (float)( _size * scaleFactor );
-
-				// calculate the length and the angle of the arrow "vector"
-				double dy = pix2.Y - pix1.Y;
-				double dx = pix2.X - pix1.X;
-				float angle = (float)Math.Atan2( dy, dx ) * 180.0F / (float)Math.PI;
-				float length = (float)Math.Sqrt( dx * dx + dy * dy );
-
-				// Save the old transform matrix
-				Matrix transform = g.Transform;
-				// Move the coordinate system so it is located at the starting point
-				// of this arrow
-				g.TranslateTransform( pix1.X, pix1.Y );
-				// Rotate the coordinate system according to the angle of this arrow
-				// about the starting point
-				g.RotateTransform( angle );
-
-				// get a pen according to this arrow properties
-				using ( Pen pen = _line.GetPen( pane, scaleFactor ) )
-					//new Pen( _color, pane.ScaledPenWidth( _penWidth, scaleFactor ) ) )
-				{
-					//pen.DashStyle = _style;
-
-					// Only show the arrowhead if required
-					if ( _isArrowHead )
-					{
-						// Draw the line segment for this arrow
-						g.DrawLine( pen, 0, 0, length - scaledSize + 1, 0 );
-
-						// Create a polygon representing the arrowhead based on the scaled
-						// size
-						PointF[] polyPt = new PointF[4];
-						float hsize = scaledSize / 3.0F;
-						polyPt[0].X = length;
-						polyPt[0].Y = 0;
-						polyPt[1].X = length - scaledSize;
-						polyPt[1].Y = hsize;
-						polyPt[2].X = length - scaledSize;
-						polyPt[2].Y = -hsize;
-						polyPt[3] = polyPt[0];
-
-						using ( SolidBrush brush = new SolidBrush( _line._color ) )
-							// render the arrowhead
-							g.FillPolygon( brush, polyPt );
-					}
-					else
-						g.DrawLine( pen, 0, 0, length, 0 );
-				}
-
-				// Restore the transform matrix back to its original state
-				g.Transform = transform;
-			}
-		}
-
-		#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Axis.cs b/BDInfo/ZedGraph/Axis.cs
deleted file mode 100644
index 63f6733ad7..0000000000
--- a/BDInfo/ZedGraph/Axis.cs
+++ /dev/null
@@ -1,1440 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The Axis class is an abstract base class that encompasses all properties
-	/// and methods required to define a graph Axis.
-	/// </summary>
-	/// <remarks>This class is inherited by the
-	/// <see cref="XAxis"/>, <see cref="YAxis"/>, and <see cref="Y2Axis"/> classes
-	/// to define specific characteristics for those types.
-	/// </remarks>
-	/// 
-	/// <author> John Champion modified by Jerry Vos </author>
-	/// <version> $Revision: 3.73 $ $Date: 2007/05/19 06:06:05 $ </version>
-	[Serializable]
-	abstract public class Axis : ISerializable, ICloneable
-	{
-
-	#region Class Fields
-
-		/// <summary>
-		/// private field that stores the <see cref="ZedGraph.Scale" /> class, which implements all the
-		/// calculations and methods associated with the numeric scale for this
-		/// <see cref="Axis" />.  See the public property <see cref="Scale" /> to access this class.
-		/// </summary>
-		internal Scale _scale;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.MinorTic" /> class, which handles all
-		/// the minor tic information.  See the public property <see cref="MinorTic" /> to access this class.
-		/// </summary>
-		internal MinorTic _minorTic;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.MajorTic" /> class, which handles all
-		/// the major tic information.  See the public property <see cref="MajorTic" /> to access this class.
-		/// </summary>
-		internal MajorTic _majorTic;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.MajorGrid" /> class, which handles all
-		/// the major grid information.  See the public property <see cref="MajorGrid" /> to access this class.
-		/// </summary>
-		internal MajorGrid	_majorGrid;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.MinorGrid" /> class, which handles all
-		/// the minor grid information.  See the public property <see cref="MinorGrid" /> to access this class.
-		/// </summary>
-		internal MinorGrid _minorGrid;
-
-		/// <summary> Private fields for the <see cref="Axis"/> scale rendering properties.
-		/// Use the public properties <see cref="Cross"/> and <see cref="ZedGraph.Scale.BaseTic"/>
-		/// for access to these values.
-		/// </summary>
-		internal double _cross;
-
-		/// <summary> Private field for the <see cref="Axis"/> automatic cross position mode.
-		/// Use the public property <see cref="CrossAuto"/> for access to this value.
-		/// </summary>
-		internal bool _crossAuto;
-
-		/// <summary> Private fields for the <see cref="Axis"/> attributes.
-		/// Use the public properties <see cref="IsVisible"/>, <see cref="IsAxisSegmentVisible"/>
-		/// for access to these values.
-		/// </summary>
-		protected bool _isVisible,
-							_isAxisSegmentVisible;
-
-		/// <summary> Private field for the <see cref="Axis"/> title string.
-		/// Use the public property <see cref="Title"/> for access to this value.
-		/// </summary>
-		protected AxisLabel _title;
-
-		/// <summary>
-		/// A tag object for use by the user.  This can be used to store additional
-		/// information associated with the <see cref="Axis"/>.  ZedGraph does
-		/// not use this value for any purpose.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag;
-
-		/// <summary> Private field for the <see cref="Axis"/> drawing dimensions.
-		/// Use the public property <see cref="AxisGap"/>
-		/// for access to these values. </summary>
-		private float	_axisGap;
-
-		/// <summary>
-		/// Private field for the <see cref="Axis"/> minimum allowable space allocation.
-		/// Use the public property <see cref="MinSpace"/> to access this value.
-		/// </summary>
-		/// <seealso cref="Default.MinSpace"/>
-		private float _minSpace;
-
-		/// <summary> Private fields for the <see cref="Axis"/> colors.
-		/// Use the public property <see cref="Color"/> for access to this values.
-		/// </summary>
-		private Color _color;
-
-		/// <summary>
-		/// Temporary values for axis space calculations (see <see cref="CalcSpace" />).
-		/// </summary>
-		internal float _tmpSpace;
-
-	#endregion
-
-	#region Events
-
-		/// <summary>
-		/// A delegate that allows full custom formatting of the Axis labels
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> for which the label is to be
-		/// formatted</param>
-		/// <param name="axis">The <see cref="Scale" /> of interest.</param>
-		/// <param name="val">The value to be formatted</param>
-		/// <param name="index">The zero-based index of the label to be formatted</param>
-		/// <returns>
-		/// A string value representing the label, or null if the ZedGraph should go ahead
-		/// and generate the label according to the current settings</returns>
-		/// <seealso cref="ScaleFormatEvent" />
-		public delegate string ScaleFormatHandler( GraphPane pane, Axis axis, double val, int index );
-
-		/// <summary>
-		/// Subscribe to this event to handle custom formatting of the scale labels.
-		/// </summary>
-		public event ScaleFormatHandler ScaleFormatEvent;
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Allow customization of title based on user preferences.
-		/// </summary>
-		/// <param name="axis">The <see cref="Axis" /> of interest.</param>
-		/// <returns>
-		/// A string value representing the label, or null if the ZedGraph should go ahead
-		/// and generate the label according to the current settings.  To make the title
-		/// blank, return "".</returns>
-		/// <seealso cref="ScaleFormatEvent" />
-		public delegate string ScaleTitleEventHandler( Axis axis );
-
-		//Revision: JCarpenter 10/06
-		/// <summary>
-		/// Allow customization of the title when the scale is very large
-		/// Subscribe to this event to handle custom formatting of the scale axis label.
-		/// </summary>
-		public event ScaleTitleEventHandler ScaleTitleEvent;
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Axis"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default size for the gap between multiple axes
-			/// (<see cref="Axis.AxisGap"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float AxisGap = 5;
-
-			/// <summary>
-			/// The default setting for the gap between the scale labels and the axis title.
-			/// </summary>
-			public static float TitleGap = 0.0f;
-
-			/// <summary>
-			/// The default font family for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.Family"/> property).
-			/// </summary>
-			public static string TitleFontFamily = "Arial";
-			/// <summary>
-			/// The default font size for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.Size"/> property).  Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float TitleFontSize = 14;
-			/// <summary>
-			/// The default font color for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.FontColor"/> property).
-			/// </summary>
-			public static Color TitleFontColor = Color.Black;
-			/// <summary>
-			/// The default font bold mode for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.IsBold"/> property). true
-			/// for a bold typeface, false otherwise.
-			/// </summary>
-			public static bool TitleFontBold = true;
-			/// <summary>
-			/// The default font italic mode for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.IsItalic"/> property). true
-			/// for an italic typeface, false otherwise.
-			/// </summary>
-			public static bool TitleFontItalic = false;
-			/// <summary>
-			/// The default font underline mode for the <see cref="Axis"/> <see cref="Title" /> text
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="FontSpec.IsUnderline"/> property). true
-			/// for an underlined typeface, false otherwise.
-			/// </summary>
-			public static bool TitleFontUnderline = false;
-			/// <summary>
-			/// The default color for filling in the <see cref="Title" /> text background
-			/// (see <see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color TitleFillColor = Color.White;
-			/// <summary>
-			/// The default custom brush for filling in the <see cref="Title" /> text background
-			/// (see <see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush TitleFillBrush = null;
-			/// <summary>
-			/// The default fill mode for filling in the <see cref="Title" /> text background
-			/// (see <see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType TitleFillType = FillType.None;
-
-			/// <summary>
-			/// The default color for the <see cref="Axis"/> itself
-			/// (<see cref="Axis.Color"/> property).  This color only affects the
-			/// the axis border.
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default value for <see cref="Axis.IsAxisSegmentVisible"/>, which determines
-			/// whether or not the scale segment itself is visible
-			/// </summary>
-			public static bool IsAxisSegmentVisible = true;
-
-			/// <summary>
-			/// The default setting for the <see cref="Axis"/> scale axis type
-			/// (<see cref="Axis.Type"/> property).  This value is set as per
-			/// the <see cref="AxisType"/> enumeration
-			/// </summary>
-			public static AxisType Type = AxisType.Linear;
-
-			/// <summary>
-			/// The default color for the axis segment.
-			/// </summary>
-			public static Color Color = Color.Black;
-
-			/// <summary>
-			/// The default setting for the axis space allocation.  This term, expressed in
-			/// points (1/72 inch) and scaled according to <see cref="PaneBase.CalcScaleFactor"/> for the
-			/// <see cref="GraphPane"/>, determines the minimum amount of space an axis must
-			/// have between the <see cref="Chart.Rect"/> and the
-			/// <see cref="PaneBase.Rect"/>.  This minimum space
-			/// applies whether <see cref="Axis.IsVisible"/> is true or false.
-			/// </summary>
-			public static float MinSpace = 0f;
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for <see cref="Axis"/> that sets all axis properties
-		/// to default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public Axis()
-		{
-			_scale = new LinearScale( this );
-
-			_cross = 0.0;
-
-			_crossAuto = true;
-
-			_majorTic = new MajorTic();
-			_minorTic = new MinorTic();
-
-			_majorGrid = new MajorGrid();
-			_minorGrid = new MinorGrid();
-
-			_axisGap = Default.AxisGap;
-
-			_minSpace = Default.MinSpace;
-			_isVisible = true;
-
-			_isAxisSegmentVisible = Default.IsAxisSegmentVisible;
-
-			_title = new AxisLabel( "", Default.TitleFontFamily, Default.TitleFontSize,
-					Default.TitleFontColor, Default.TitleFontBold,
-					Default.TitleFontUnderline, Default.TitleFontItalic );
-			_title.FontSpec.Fill = new Fill( Default.TitleFillColor, Default.TitleFillBrush,
-					Default.TitleFillType );
-
-			_title.FontSpec.Border.IsVisible = false;
-
-
-			_color = Default.Color;
-
-		}
-
-		/// <summary>
-		/// Constructor for <see cref="Axis"/> that sets all axis properties
-		/// to default values as defined in the <see cref="Default"/> class,
-		/// except for the <see cref="Title"/>.
-		/// </summary>
-		/// <param name="title">A string containing the axis title</param>
-		public Axis( string title )
-			: this()
-		{
-			_title._text = title;
-		}
-
-		/// <summary>
-		/// The Copy Constructor.
-		/// </summary>
-		/// <param name="rhs">The Axis object from which to copy</param>
-		public Axis( Axis rhs )
-		{
-			_scale = rhs._scale.Clone( this );
-
-			_cross = rhs._cross;
-
-			_crossAuto = rhs._crossAuto;
-
-			_majorTic = rhs.MajorTic.Clone();
-			_minorTic = rhs.MinorTic.Clone();
-
-			_majorGrid = rhs._majorGrid.Clone();
-			_minorGrid = rhs._minorGrid.Clone();
-
-			_isVisible = rhs.IsVisible;
-
-			_isAxisSegmentVisible = rhs._isAxisSegmentVisible;
-
-			_title = (AxisLabel) rhs.Title.Clone();
-
-			_axisGap = rhs._axisGap;
-
-			_minSpace = rhs.MinSpace;
-
-			_color = rhs.Color;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Axis( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_cross = info.GetDouble( "cross" );
-			_crossAuto = info.GetBoolean( "crossAuto" );
-
-			_majorTic = (MajorTic)info.GetValue( "MajorTic", typeof( MajorTic ) );
-			_minorTic = (MinorTic)info.GetValue( "MinorTic", typeof( MinorTic ) );
-			_majorGrid = (MajorGrid)info.GetValue( "majorGrid", typeof( MajorGrid ) );
-			_minorGrid = (MinorGrid)info.GetValue( "minorGrid", typeof( MinorGrid ) );
-
-			_isVisible = info.GetBoolean( "isVisible" );
-
-			_title = (AxisLabel) info.GetValue( "title", typeof( AxisLabel ) );
-
-			_minSpace = info.GetSingle( "minSpace" );
-
-			_color = (Color)info.GetValue( "color", typeof( Color ) );
-
-			_isAxisSegmentVisible = info.GetBoolean( "isAxisSegmentVisible" );
-
-
-			_axisGap = info.GetSingle( "axisGap" );
-
-			_scale = (Scale)info.GetValue( "scale", typeof( Scale ) );
-			_scale._ownerAxis = this;
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "cross", _cross );
-			info.AddValue( "crossAuto", _crossAuto );
-
-			info.AddValue( "MajorTic", MajorTic );
-			info.AddValue( "MinorTic", MinorTic );
-			info.AddValue( "majorGrid", _majorGrid );
-			info.AddValue( "minorGrid", _minorGrid );
-
-			info.AddValue( "isVisible", _isVisible );
-
-			info.AddValue( "title", _title );
-
-			info.AddValue( "minSpace", _minSpace );
-
-			info.AddValue( "color", _color );
-
-			info.AddValue( "isAxisSegmentVisible", _isAxisSegmentVisible );
-
-			info.AddValue( "axisGap", _axisGap );
-
-			info.AddValue( "scale", _scale );
-
-		}
-
-	#endregion
-
-	#region Scale Properties
-
-		/// <summary>
-		/// Gets the <see cref="Scale" /> instance associated with this <see cref="Axis" />.
-		/// </summary>
-		public Scale Scale
-		{
-			get { return _scale; }
-		}
-		/// <summary>
-		/// Gets or sets the scale value at which this axis should cross the "other" axis.
-		/// </summary>
-		/// <remarks>This property allows the axis to be shifted away from its default location.
-		/// For example, for a graph with an X range from -100 to +100, the Y Axis can be located
-		/// at the X=0 value rather than the left edge of the ChartRect.  This value can be set
-		/// automatically based on the state of <see cref="CrossAuto"/>.  If
-		/// this value is set manually, then <see cref="CrossAuto"/> will
-		/// also be set to false.  The "other" axis is the axis the handles the second dimension
-		/// for the graph.  For the XAxis, the "other" axis is the YAxis.  For the YAxis or
-		/// Y2Axis, the "other" axis is the XAxis.
-		/// </remarks>
-		/// <value> The value is defined in user scale units </value>
-		/// <seealso cref="ZedGraph.Scale.Min"/>
-		/// <seealso cref="ZedGraph.Scale.Max"/>
-		/// <seealso cref="ZedGraph.Scale.MajorStep"/>
-		/// <seealso cref="CrossAuto"/>
-		public double Cross
-		{
-			get { return _cross; }
-			set { _cross = value; _crossAuto = false; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the <see cref="Cross"/> value
-		/// is set automatically.
-		/// </summary>
-		/// <value>Set to true to have ZedGraph put the axis in the default location, or false
-		/// to specify the axis location manually with a <see cref="Cross"/> value.</value>
-		/// <seealso cref="ZedGraph.Scale.Min"/>
-		/// <seealso cref="ZedGraph.Scale.Max"/>
-		/// <seealso cref="ZedGraph.Scale.MajorStep"/>
-		/// <seealso cref="Cross"/>
-		public bool CrossAuto
-		{
-			get { return _crossAuto; }
-			set { _crossAuto = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the minimum axis space allocation.
-		/// </summary>
-		/// <remarks>
-		/// This term, expressed in
-		/// points (1/72 inch) and scaled according to <see cref="PaneBase.CalcScaleFactor"/>
-		/// for the <see cref="GraphPane"/>, determines the minimum amount of space
-		/// an axis must have between the <see cref="Chart.Rect">Chart.Rect</see> and the
-		/// <see cref="PaneBase.Rect">GraphPane.Rect</see>.  This minimum space
-		/// applies whether <see cref="IsVisible"/> is true or false.
-		/// </remarks>
-		public float MinSpace
-		{
-			get { return _minSpace; }
-			set { _minSpace = value; }
-		}
-
-	#endregion
-
-	#region Tic Properties
-
-		/// <summary>
-		/// The color to use for drawing this <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// This affects only the axis segment (see <see cref="IsAxisSegmentVisible" />),
-		/// since the <see cref="Title"/>,
-		/// <see cref="Scale"/>, <see cref="MajorTic" />, <see cref="MinorTic" />,
-		/// <see cref="MajorGrid" />, and <see cref="MinorGrid" />
-		/// all have their own color specification.
-		/// </remarks>
-		/// <value> The color is defined using the
-		/// <see cref="System.Drawing.Color"/> class</value>
-		/// <seealso cref="Default.Color"/>.
-		/// <seealso cref="IsVisible"/>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-
-		/// <summary>
-		/// Gets a reference to the <see cref="ZedGraph.MajorTic" /> class instance
-		/// for this <see cref="Axis" />.  This class stores all the major tic settings.
-		/// </summary>
-		public MajorTic MajorTic
-		{
-			get { return _majorTic; }
-		}
-		/// <summary>
-		/// Gets a reference to the <see cref="ZedGraph.MinorTic" /> class instance
-		/// for this <see cref="Axis" />.  This class stores all the minor tic settings.
-		/// </summary>
-		public MinorTic MinorTic
-		{
-			get { return _minorTic; }
-		}
-
-		#endregion
-
-	#region Grid Properties
-
-		/// <summary>
-		/// Gets a reference to the <see cref="MajorGrid" /> class that contains the properties
-		/// of the major grid.
-		/// </summary>
-		public MajorGrid MajorGrid
-		{
-			get { return _majorGrid; }
-		}
-
-		/// <summary>
-		/// Gets a reference to the <see cref="MinorGrid" /> class that contains the properties
-		/// of the minor grid.
-		/// </summary>
-		public MinorGrid MinorGrid
-		{
-			get { return _minorGrid; }
-		}
-
-
-	#endregion
-
-	#region Type Properties
-
-		/// <summary>
-		/// This property determines whether or not the <see cref="Axis"/> is shown.
-		/// </summary>
-		/// <remarks>
-		/// Note that even if
-		/// the axis is not visible, it can still be actively used to draw curves on a
-		/// graph, it will just be invisible to the user
-		/// </remarks>
-		/// <value>true to show the axis, false to disable all drawing of this axis</value>
-		/// <seealso cref="ZedGraph.Scale.IsVisible"/>.
-		/// <seealso cref="XAxis.Default.IsVisible"/>.
-		/// <seealso cref="YAxis.Default.IsVisible"/>.
-		/// <seealso cref="Y2Axis.Default.IsVisible"/>.
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the axis segment (the line that
-		/// represents the axis itself) is drawn.
-		/// </summary>
-		/// <remarks>
-		/// Under normal circumstances, this value won't affect the appearance of the display because
-		/// the Axis segment is overlain by the Axis border (see <see cref="Chart.Border"/>).
-		/// However, when the border is not visible, or when <see cref="Axis.CrossAuto"/> is set to
-		/// false, this value will make a difference.
-		/// </remarks>
-		public bool IsAxisSegmentVisible
-		{
-			get { return _isAxisSegmentVisible; }
-			set { _isAxisSegmentVisible = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="AxisType"/> for this <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// The type can be either <see cref="AxisType.Linear"/>,
-		/// <see cref="AxisType.Log"/>, <see cref="AxisType.Date"/>,
-		/// or <see cref="AxisType.Text"/>.
-		/// </remarks>
-		/// <seealso cref="ZedGraph.Scale.IsLog"/>
-		/// <seealso cref="ZedGraph.Scale.IsText"/>
-		/// <seealso cref="ZedGraph.Scale.IsOrdinal"/>
-		/// <seealso cref="ZedGraph.Scale.IsDate"/>
-		/// <seealso cref="ZedGraph.Scale.IsReverse"/>
-		public AxisType Type
-		{
-			get { return _scale.Type; }
-			set { _scale = Scale.MakeNewScale( _scale, value ); }
-		}
-
-	#endregion
-
-	#region Label Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="Label" /> class that contains the title of this
-		/// <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>The title normally shows the basis and dimensions of
-		/// the scale range, such as "Time (Years)".  The title is only shown if the
-		/// <see cref="Label.IsVisible"/> property is set to true.  If the Title text is empty,
-		/// then no title is shown, and no space is "reserved" for the title on the graph.
-		/// </remarks>
-		/// <value>the title is a string value</value>
-		/// <seealso cref="AxisLabel.IsOmitMag"/>
-		public AxisLabel Title
-		{
-			get { return _title; }
-			set { _title = value; }
-		}
-
-		/// <summary>
-		/// The size of the gap between multiple axes (see <see cref="GraphPane.YAxisList" /> and
-		/// <see cref="GraphPane.Y2AxisList" />).
-		/// </summary>
-		/// <remarks>
-		/// This size will be scaled
-		/// according to the <see cref="PaneBase.CalcScaleFactor"/> for the
-		/// <see cref="GraphPane"/>
-		/// </remarks>
-		/// <value>The axis gap is measured in points (1/72 inch)</value>
-		/// <seealso cref="Default.AxisGap"/>.
-		public float AxisGap
-		{
-			get { return _axisGap; }
-			set { _axisGap = value; }
-		}
-
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Restore the scale ranging to automatic mode, and recalculate the
-		/// <see cref="Axis"/> scale ranges
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <seealso cref="ZedGraph.Scale.MinAuto"/>
-		/// <seealso cref="ZedGraph.Scale.MaxAuto"/>
-		/// <seealso cref="ZedGraph.Scale.MajorStepAuto"/>
-		/// <seealso cref="ZedGraph.Scale.MagAuto"/>
-		/// <seealso cref="ZedGraph.Scale.FormatAuto"/>
-		public void ResetAutoScale( GraphPane pane, Graphics g )
-		{
-			_scale._minAuto = true;
-			_scale._maxAuto = true;
-			_scale._majorStepAuto = true;
-			_scale._minorStepAuto = true;
-			_crossAuto = true;
-			_scale._magAuto = true;
-			//this.numDecAuto = true;
-			_scale._formatAuto = true;
-			pane.AxisChange( g );
-		}
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="Axis"/> to the specified
-		/// <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only
-		/// called by the Draw method of the parent <see cref="GraphPane"/> object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="shiftPos">
-		/// The number of pixels to shift to account for non-primary axis position (e.g.,
-		/// the second, third, fourth, etc. <see cref="YAxis" /> or <see cref="Y2Axis" />.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, float scaleFactor, float shiftPos )
-		{
-			Matrix saveMatrix = g.Transform;
-
-			_scale.SetupScaleData( pane, this );
-
-			if ( _isVisible )
-			{
-				SetTransformMatrix( g, pane, scaleFactor );
-
-				shiftPos = CalcTotalShift( pane, scaleFactor, shiftPos );
-
-				_scale.Draw( g, pane, scaleFactor, shiftPos );
-
-				//DrawTitle( g, pane, scaleFactor );
-
-				g.Transform = saveMatrix;
-			}
-		}
-
-		internal void DrawGrid( Graphics g, GraphPane pane, float scaleFactor, float shiftPos )
-		{
-			if ( _isVisible )
-			{
-				Matrix saveMatrix = g.Transform;
-				SetTransformMatrix( g, pane, scaleFactor );
-
-				double baseVal = _scale.CalcBaseTic();
-				float topPix, rightPix;
-				_scale.GetTopRightPix( pane, out topPix, out rightPix );
-
-				shiftPos = CalcTotalShift( pane, scaleFactor, shiftPos );
-
-				_scale.DrawGrid( g, pane, baseVal, topPix, scaleFactor );
-
-				DrawMinorTics( g, pane, baseVal, shiftPos, scaleFactor, topPix );
-
-				g.Transform = saveMatrix;
-			}
-		}
-
-		/// <summary>
-		/// This method will set the <see cref="MinSpace"/> property for this <see cref="Axis"/>
-		/// using the currently required space multiplied by a fraction (<paramref>bufferFraction</paramref>).
-		/// </summary>
-		/// <remarks>
-		/// The currently required space is calculated using <see cref="CalcSpace"/>, and is
-		/// based on current data ranges, font sizes, etc.  The "space" is actually the amount of space
-		/// required to fit the tic marks, scale labels, and axis title.
-		/// </remarks>
-		/// <param name="g">A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.</param>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.</param>
-		/// <param name="bufferFraction">The amount of space to allocate for the axis, expressed
-		/// as a fraction of the currently required space.  For example, a value of 1.2 would
-		/// allow for 20% extra above the currently required space.</param>
-		/// <param name="isGrowOnly">If true, then this method will only modify the <see cref="MinSpace"/>
-		/// property if the calculated result is more than the current value.</param>
-		public void SetMinSpaceBuffer( Graphics g, GraphPane pane, float bufferFraction,
-										bool isGrowOnly )
-		{
-			// save the original value of minSpace
-			float oldSpace = this.MinSpace;
-			// set minspace to zero, since we don't want it to affect the CalcSpace() result
-			this.MinSpace = 0;
-			// Calculate the space required for the current graph assuming scalefactor = 1.0
-			// and apply the bufferFraction
-			float fixedSpace;
-			float space = this.CalcSpace( g, pane, 1.0F, out fixedSpace ) * bufferFraction;
-			// isGrowOnly indicates the minSpace can grow but not shrink
-			if ( isGrowOnly )
-				space = Math.Max( oldSpace, space );
-			// Set the minSpace
-			this.MinSpace = space;
-		}
-
-		/// <summary>
-		/// Setup the Transform Matrix to handle drawing of this <see cref="Axis"/>
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		abstract public void SetTransformMatrix( Graphics g, GraphPane pane, float scaleFactor );
-
-
-		/// <summary>
-		/// Calculate the "shift" size, in pixels, in order to shift the axis from its default
-		/// location to the value specified by <see cref="Cross"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>The shift amount measured in pixels</returns>
-		abstract internal float CalcCrossShift( GraphPane pane );
-
-		/// <summary>
-		/// Gets the "Cross" axis that corresponds to this axis.
-		/// </summary>
-		/// <remarks>
-		/// The cross axis is the axis which determines the of this Axis when the
-		/// <see cref="Axis.Cross" >Axis.Cross</see> property is used.  The
-		/// cross axis for any <see cref="XAxis" /> or <see cref="X2Axis" />
-		/// is always the primary <see cref="YAxis" />, and
-		/// the cross axis for any <see cref="YAxis" /> or <see cref="Y2Axis" /> is
-		/// always the primary <see cref="XAxis" />.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		abstract public Axis GetCrossAxis( GraphPane pane );
-
-//		abstract internal float GetMinPix( GraphPane pane );
-
-		//abstract internal float CalcCrossFraction( GraphPane pane );
-
-		/// <summary>
-		/// Returns the linearized actual cross position for this axis, reflecting the settings of
-		/// <see cref="Cross" />, <see cref="CrossAuto" />, and <see cref="ZedGraph.Scale.IsReverse" />.
-		/// </summary>
-		/// <remarks>
-		/// If the value of <see cref="Cross" /> lies outside the axis range, it is
-		/// limited to the axis range.
-		/// </remarks>
-		internal double EffectiveCrossValue( GraphPane pane )
-		{
-			Axis crossAxis = GetCrossAxis( pane );
-
-			// Use Linearize here instead of _minLinTemp because this method is called
-			// as part of CalcRect() before scale is fully setup
-			double min = crossAxis._scale.Linearize( _scale._min );
-			double max = crossAxis._scale.Linearize( _scale._max );
-
-			if ( _crossAuto )
-			{
-				if ( crossAxis._scale.IsReverse == ( this is Y2Axis || this is X2Axis ) )
-					return max;
-				else
-					return min;
-			}
-			else if ( _cross < min )
-				return min;
-			else if ( _cross > max )
-				return max;
-			else
-				return _scale.Linearize( _cross );
-		}
-
-		/// <summary>
-		/// Returns true if the axis is shifted at all due to the setting of
-		/// <see cref="Cross" />.  This function will always return false if
-		/// <see cref="CrossAuto" /> is true.
-		/// </summary>
-		internal bool IsCrossShifted( GraphPane pane )
-		{
-			if ( _crossAuto )
-				return false;
-			else
-			{
-				Axis crossAxis = GetCrossAxis( pane );
-				if ( ( ( this is XAxis || this is YAxis ) && !crossAxis._scale.IsReverse ) ||
-					( ( this is X2Axis || this is Y2Axis ) && crossAxis._scale.IsReverse ) )
-				{
-					if ( _cross <= crossAxis._scale._min )
-						return false;
-				}
-				else
-				{
-					if ( _cross >= crossAxis._scale._max )
-						return false;
-				}
-			}
-
-			return true;
-		}
-
-		/// <summary>
-		/// Calculates the proportional fraction of the total cross axis width at which
-		/// this axis is located.
-		/// </summary>
-		/// <param name="pane"></param>
-		/// <returns></returns>
-		internal float CalcCrossFraction( GraphPane pane )
-		{
-			// if this axis is not shifted due to the Cross value
-			if ( !this.IsCrossShifted( pane ) )
-			{
-				// if it's the primary axis and the scale labels are on the inside, then we
-				// don't need to save any room for the axis labels (they will be inside the chart rect)
-				if ( IsPrimary( pane ) && _scale._isLabelsInside )
-					return 1.0f;
-				// otherwise, it's a secondary (outboard) axis and we always save room for the axis and labels.
-				else
-					return 0.0f;
-			}
-
-			double effCross = EffectiveCrossValue( pane );
-			Axis crossAxis = GetCrossAxis( pane );
-
-			// Use Linearize here instead of _minLinTemp because this method is called
-			// as part of CalcRect() before scale is fully setup
-			//			double max = crossAxis._scale._maxLinTemp;
-			//			double min = crossAxis._scale._minLinTemp;
-			double max = crossAxis._scale.Linearize( _scale._min );
-			double min = crossAxis._scale.Linearize( _scale._max );
-			float frac;
-
-			if ( ( ( this is XAxis || this is YAxis ) && _scale._isLabelsInside == crossAxis._scale.IsReverse ) ||
-				 ( ( this is X2Axis || this is Y2Axis ) && _scale._isLabelsInside != crossAxis._scale.IsReverse ) )
-				frac = (float)( ( effCross - min ) / ( max - min ) );
-			else
-				frac = (float)( ( max - effCross ) / ( max - min ) );
-
-			if ( frac < 0.0f )
-				frac = 0.0f;
-			if ( frac > 1.0f )
-				frac = 1.0f;
-
-			return frac;
-		}
-
-		private float CalcTotalShift( GraphPane pane, float scaleFactor, float shiftPos )
-		{
-			if ( !IsPrimary( pane ) )
-			{
-				// if ( CalcCrossFraction( pane ) != 0.0 )
-				if ( IsCrossShifted( pane ) )
-				{
-					shiftPos = 0;
-				}
-				else
-				{
-					// Scaled size (pixels) of a tic
-					float ticSize = _majorTic.ScaledTic( scaleFactor );
-
-					// if the scalelabels are on the inside, shift everything so the axis is drawn,
-					// for example, to the left side of the available space for a YAxis type
-					if ( _scale._isLabelsInside )
-					{
-						shiftPos += _tmpSpace;
-
-						// shift the axis to leave room for the outside tics
-						if ( _majorTic.IsOutside || _majorTic._isCrossOutside ||
-										_minorTic.IsOutside || _minorTic._isCrossOutside )
-							shiftPos -= ticSize;
-					}
-					else
-					{
-						// if it's not the primary axis, add a tic space for the spacing between axes
-						shiftPos += _axisGap * scaleFactor;
-
-						// if it has inside tics, leave another tic space
-						if ( _majorTic.IsInside || _majorTic._isCrossInside ||
-								_minorTic.IsInside || _minorTic._isCrossInside )
-							shiftPos += ticSize;
-					}
-				}
-			}
-
-			// shift is the position of the actual axis line itself
-			// everything else is based on that position.
-			float crossShift = CalcCrossShift( pane );
-			shiftPos += crossShift;
-
-			return shiftPos;
-		}
-
-		/// <summary>
-		/// Calculate the space required (pixels) for this <see cref="Axis"/> object.
-		/// </summary>
-		/// <remarks>
-		/// This is the total space (vertical space for the X axis, horizontal space for
-		/// the Y axes) required to contain the axis.  If <see cref="Cross" /> is zero, then
-		/// this space will be the space required between the <see cref="Chart.Rect" /> and
-		/// the <see cref="PaneBase.Rect" />.  This method sets the internal values of
-		/// <see cref="_tmpSpace" /> for use by the <see cref="GraphPane.CalcChartRect(Graphics)" />
-		/// method.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="fixedSpace">The amount of space (pixels) at the edge of the ChartRect
-		/// that is always required for this axis, even if the axis is shifted by the
-		/// <see cref="Cross" /> value.</param>
-		/// <returns>Returns the space, in pixels, required for this axis (between the
-		/// rect and ChartRect)</returns>
-		public float CalcSpace( Graphics g, GraphPane pane, float scaleFactor, out float fixedSpace )
-		{
-			//fixedSpace = 0;
-
-			//Typical character height for the scale font
-			float charHeight = _scale._fontSpec.GetHeight( scaleFactor );
-			// Scaled size (pixels) of a tic
-			float ticSize = _majorTic.ScaledTic( scaleFactor );
-			// Scaled size (pixels) of the axis gap
-			float axisGap = _axisGap * scaleFactor;
-			float scaledLabelGap = _scale._labelGap * charHeight;
-			float scaledTitleGap = _title.GetScaledGap( scaleFactor );
-
-			// The minimum amount of space to reserve for the NORMAL position of the axis.  This would
-			// be the left side of the chart rect for the Y axis, the right side for the Y2 axis, etc.
-			// This amount of space is based on the need to reserve space for tics, etc., even if the
-			// Axis.Cross property causes the axis to be in a different location.
-			fixedSpace = 0;
-
-			// The actual space needed for this axis (ignoring the setting of Axis.Cross)
-			_tmpSpace = 0;
-
-			// Account for the Axis
-			if ( _isVisible )
-			{
-				bool hasTic = this.MajorTic.IsOutside || this.MajorTic._isCrossOutside ||
-									this.MinorTic.IsOutside || this.MinorTic._isCrossOutside;
-
-				// account for the tic space.  Leave the tic space for any type of outside tic (Outside Tic Space)
-				if ( hasTic )
-					_tmpSpace += ticSize;
-
-				// if this is not the primary axis
-				if ( !IsPrimary( pane ) )
-				{
-					// always leave an extra tic space for the space between the multi-axes (Axis Gap)
-					_tmpSpace += axisGap;
-
-					// if it has inside tics, leave another tic space (Inside Tic Space)
-					if ( this.MajorTic._isInside || this.MajorTic._isCrossInside ||
-							this.MinorTic._isInside || this.MinorTic._isCrossInside )
-						_tmpSpace += ticSize;
-				}
-
-				// tic takes up 1x tic
-				// space between tic and scale label is 0.5 tic
-				// scale label is GetScaleMaxSpace()
-				// space between scale label and axis label is 0.5 tic
-
-				// account for the tic labels + 'LabelGap' tic gap between the tic and the label
-				_tmpSpace += _scale.GetScaleMaxSpace( g, pane, scaleFactor, true ).Height +
-						scaledLabelGap;
-
-				string str = MakeTitle();
-
-				// Only add space for the title if there is one
-				// Axis Title gets actual height
-				if ( str.Length > 0 && _title._isVisible )
-				{
-					//tmpSpace += this.TitleFontSpec.BoundingBox( g, str, scaleFactor ).Height;
-					fixedSpace = this.Title.FontSpec.BoundingBox( g, str, scaleFactor ).Height +
-							scaledTitleGap;
-					_tmpSpace += fixedSpace;
-
-					fixedSpace += scaledTitleGap;
-				}
-
-				if ( hasTic )
-					fixedSpace += ticSize;
-			}
-
-			// for the Y axes, make sure that enough space is left to fit the first
-			// and last X axis scale label
-			if ( this.IsPrimary( pane ) && ( (
-					( this is YAxis && (
-						( !pane.XAxis._scale._isSkipFirstLabel && !pane.XAxis._scale._isReverse ) ||
-						( !pane.XAxis._scale._isSkipLastLabel && pane.XAxis._scale._isReverse ) ) ) ||
-					( this is Y2Axis && (
-						( !pane.XAxis._scale._isSkipFirstLabel && pane.XAxis._scale._isReverse ) ||
-						( !pane.XAxis._scale._isSkipLastLabel && !pane.XAxis._scale._isReverse ) ) ) ) &&
-					pane.XAxis.IsVisible && pane.XAxis._scale._isVisible ) )
-			{
-				// half the width of the widest item, plus a gap of 1/2 the charheight
-				float tmp = pane.XAxis._scale.GetScaleMaxSpace( g, pane, scaleFactor, true ).Width / 2.0F;
-				//+ charHeight / 2.0F;
-				//if ( tmp > tmpSpace )
-				//	tmpSpace = tmp;
-
-				fixedSpace = Math.Max( tmp, fixedSpace );
-			}
-
-			// Verify that the minSpace property was satisfied
-			_tmpSpace = Math.Max( _tmpSpace, _minSpace * (float)scaleFactor );
-
-			fixedSpace = Math.Max( fixedSpace, _minSpace * (float)scaleFactor );
-
-			return _tmpSpace;
-		}
-
-		/// <summary>
-		/// Determines if this <see cref="Axis" /> object is a "primary" one.
-		/// </summary>
-		/// <remarks>
-		/// The primary axes are the <see cref="XAxis" /> (always), the first
-		/// <see cref="YAxis" /> in the <see cref="GraphPane.YAxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0),  and the first
-		/// <see cref="Y2Axis" /> in the <see cref="GraphPane.Y2AxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0).  Note that
-		/// <see cref="GraphPane.YAxis" /> and <see cref="GraphPane.Y2Axis" />
-		/// always reference the primary axes.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>true for a primary <see cref="Axis" /> (for the <see cref="XAxis" />,
-		/// this is always true), false otherwise</returns>
-		abstract internal bool IsPrimary( GraphPane pane );
-
-		internal void FixZeroLine( Graphics g, GraphPane pane, float scaleFactor,
-				float left, float right )
-		{
-			// restore the zero line if needed (since the fill tends to cover it up)
-			if ( _isVisible && _majorGrid._isZeroLine &&
-					_scale._min < 0.0 && _scale._max > 0.0 )
-			{
-				float zeroPix = _scale.Transform( 0.0 );
-
-				using ( Pen zeroPen = new Pen( _color,
-						pane.ScaledPenWidth( _majorGrid._penWidth, scaleFactor ) ) )
-				{
-					g.DrawLine( zeroPen, left, zeroPix, right, zeroPix );
-					//zeroPen.Dispose();
-				}
-			}
-		}
-
-		/// <summary>
-		/// Draw the minor tic marks as required for this <see cref="Axis"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="baseVal">
-		/// The scale value for the first major tic position.  This is the reference point
-		/// for all other tic marks.
-		/// </param>
-		/// <param name="shift">The number of pixels to shift this axis, based on the
-		/// value of <see cref="Cross"/>.  A positive value is into the ChartRect relative to
-		/// the default axis position.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="topPix">
-		/// The pixel location of the far side of the ChartRect from this axis.
-		/// This value is the ChartRect.Height for the XAxis, or the ChartRect.Width
-		/// for the YAxis and Y2Axis.
-		/// </param>
-		public void DrawMinorTics( Graphics g, GraphPane pane, double baseVal, float shift,
-								float scaleFactor, float topPix )
-		{
-			if ( ( this.MinorTic.IsOutside || this.MinorTic.IsOpposite || this.MinorTic.IsInside ||
-					this.MinorTic._isCrossOutside || this.MinorTic._isCrossInside || _minorGrid._isVisible )
-					&& _isVisible )
-			{
-				double	tMajor = _scale._majorStep * _scale.MajorUnitMultiplier,
-							tMinor = _scale._minorStep * _scale.MinorUnitMultiplier;
-
-				if ( _scale.IsLog || tMinor < tMajor )
-				{
-					float minorScaledTic = this.MinorTic.ScaledTic( scaleFactor );
-
-					// Minor tics start at the minimum value and step all the way thru
-					// the full scale.  This means that if the minor step size is not
-					// an even division of the major step size, the minor tics won't
-					// line up with all of the scale labels and major tics.
-					double	first = _scale._minLinTemp,
-								last = _scale._maxLinTemp;
-
-					double dVal = first;
-					float pixVal;
-
-					int iTic = _scale.CalcMinorStart( baseVal );
-					int MajorTic = 0;
-					double majorVal = _scale.CalcMajorTicValue( baseVal, MajorTic );
-
-					using ( Pen	pen = new Pen( _minorTic._color,
-										pane.ScaledPenWidth( MinorTic._penWidth, scaleFactor ) ) )
-					using ( Pen minorGridPen = _minorGrid.GetPen( pane, scaleFactor ) )
-					{
-
-						// Draw the minor tic marks
-						while ( dVal < last && iTic < 5000 )
-						{
-							// Calculate the scale value for the current tic
-							dVal = _scale.CalcMinorTicValue( baseVal, iTic );
-							// Maintain a value for the current major tic
-							if ( dVal > majorVal )
-								majorVal = _scale.CalcMajorTicValue( baseVal, ++MajorTic );
-
-							// Make sure that the current value does not match up with a major tic
-							if ( ( ( Math.Abs( dVal ) < 1e-20 && Math.Abs( dVal - majorVal ) > 1e-20 ) ||
-								( Math.Abs( dVal ) > 1e-20 && Math.Abs( ( dVal - majorVal ) / dVal ) > 1e-10 ) ) &&
-								( dVal >= first && dVal <= last ) )
-							{
-								pixVal = _scale.LocalTransform( dVal );
-
-								_minorGrid.Draw( g, minorGridPen, pixVal, topPix );
-
-								_minorTic.Draw( g, pane, pen, pixVal, topPix, shift, minorScaledTic );
-							}
-
-							iTic++;
-						}
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Draw the title for this <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>On entry, it is assumed that the
-		/// graphics transform has been configured so that the origin is at the left side
-		/// of this axis, and the axis is aligned along the X coordinate direction.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="shiftPos">The number of pixels to shift this axis, based on the
-		/// value of <see cref="Cross"/>.  A positive value is into the ChartRect relative to
-		/// the default axis position.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DrawTitle( Graphics g, GraphPane pane, float shiftPos, float scaleFactor )
-		{
-			string str = MakeTitle();
-
-			// If the Axis is visible, draw the title
-			if ( _isVisible && _title._isVisible && str.Length > 0 )
-			{
-				bool hasTic = ( _scale._isLabelsInside ?
-						( this.MajorTic.IsInside || this.MajorTic._isCrossInside ||
-								this.MinorTic.IsInside || this.MinorTic._isCrossInside ) :
-						( this.MajorTic.IsOutside || this.MajorTic._isCrossOutside || this.MinorTic.IsOutside || this.MinorTic._isCrossOutside ) );
-
-				// Calculate the title position in screen coordinates
-				float x = ( _scale._maxPix - _scale._minPix ) / 2;
-
-				float scaledTic = MajorTic.ScaledTic( scaleFactor );
-				float scaledLabelGap = _scale._fontSpec.GetHeight( scaleFactor ) * _scale._labelGap;
-				float scaledTitleGap = _title.GetScaledGap( scaleFactor );
-
-				// The space for the scale labels is only reserved if the axis is not shifted due to the
-				// cross value.  Note that this could be a problem if the axis is only shifted slightly,
-				// since the scale value labels may overlap the axis title.  However, it's not possible to
-				// calculate that actual shift amount at this point, because the ChartRect rect has not yet been
-				// calculated, and the cross value is determined using a transform of scale values (which
-				// rely on ChartRect).
-
-				float gap = scaledTic * ( hasTic ? 1.0f : 0.0f ) +
-							this.Title.FontSpec.BoundingBox( g, str, scaleFactor ).Height / 2.0F;
-				float y = ( _scale._isVisible ? _scale.GetScaleMaxSpace( g, pane, scaleFactor, true ).Height
-							+ scaledLabelGap : 0 );
-
-				if ( _scale._isLabelsInside )
-					y = shiftPos - y - gap;
-				else
-					y = shiftPos + y + gap;
-
-				if ( !_crossAuto && !_title._isTitleAtCross )
-					y = Math.Max( y, gap );
-
-				AlignV alignV = AlignV.Center;
-
-				// Add in the TitleGap space
-				y += scaledTitleGap;
-
-				// Draw the title
-				this.Title.FontSpec.Draw( g, pane, str, x, y,
-							AlignH.Center, alignV, scaleFactor );
-			}
-		}
-
-		private string MakeTitle()
-		{
-			// Revision: JCarpenter 10/06
-			// Allow customization of the modified title when the scale is very large
-			// The event handler can edit the full label.  If the handler returns
-			// null, then the title will be the default.
-			if ( ScaleTitleEvent != null )
-			{
-				string label = ScaleTitleEvent( this );
-				if ( label != null )
-					return label;
-			}
-
-			// If the Mag is non-zero and IsOmitMag == false, and IsLog == false,
-			// then add the mag indicator to the title.
-			if ( _scale._mag != 0 && !_title._isOmitMag && !_scale.IsLog )
-				return _title._text + String.Format( " (10^{0})", _scale._mag );
-			else
-				return _title._text;
-
-		}
-
-		/// <summary>
-		/// Make a value label for the axis at the specified ordinal position.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="ZedGraph.Scale.IsLog"/>,
-		/// <see cref="ZedGraph.Scale.IsText"/>,
-		/// and other axis format settings.  It also implements the ScaleFormatEvent such that
-		/// custom labels can be created.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log
-		/// (<see cref="ZedGraph.Scale.IsLog"/>)
-		/// and text (<see cref="ZedGraph.Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		internal string MakeLabelEventWorks( GraphPane pane, int index, double dVal )
-		{
-			// if there is a valid ScaleFormatEvent, then try to use it to create the label
-			// the label will be non-null if it's to be used
-			if ( this.ScaleFormatEvent != null )
-			{
-				string label;
-
-				label = this.ScaleFormatEvent( pane, this, dVal, index );
-				if ( label != null )
-					return label;
-			}
-
-			// second try.  If there's no custom ScaleFormatEvent, then just call
-			// _scale.MakeLabel according to the type of scale
-			if ( this.Scale != null )
-				return _scale.MakeLabel( pane, index, dVal );
-			else
-				return "?";
-		}
-
-	#endregion
-
-	}
-}
-
diff --git a/BDInfo/ZedGraph/AxisLabel.cs b/BDInfo/ZedGraph/AxisLabel.cs
deleted file mode 100644
index 50931e55d7..0000000000
--- a/BDInfo/ZedGraph/AxisLabel.cs
+++ /dev/null
@@ -1,180 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the data associated with text title and its associated font
-	/// properties.  Inherits from <see cref="Label" />, and adds <see cref="IsOmitMag" />
-	/// and <see cref="IsTitleAtCross" /> properties, which are specifically associated with
-	/// the <see cref="Axis" /> <see cref="Axis.Title" />.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class AxisLabel : GapLabel, ICloneable, ISerializable
-	{
-		internal bool	_isOmitMag,
-							_isTitleAtCross;
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to build an <see cref="AxisLabel" /> from the text and the
-		/// associated font properties.
-		/// </summary>
-		/// <param name="text">The <see cref="string" /> representing the text to be
-		/// displayed</param>
-		/// <param name="fontFamily">The <see cref="String" /> font family name</param>
-		/// <param name="fontSize">The size of the font in points and scaled according
-		/// to the <see cref="PaneBase.CalcScaleFactor" /> logic.</param>
-		/// <param name="color">The <see cref="Color" /> instance representing the color
-		/// of the font</param>
-		/// <param name="isBold">true for a bold font face</param>
-		/// <param name="isItalic">true for an italic font face</param>
-		/// <param name="isUnderline">true for an underline font face</param>
-		public AxisLabel( string text, string fontFamily, float fontSize, Color color, bool isBold,
-								bool isItalic, bool isUnderline ) :
-			base( text, fontFamily, fontSize, color, isBold, isItalic, isUnderline )
-		{
-			_isOmitMag = false;
-			_isTitleAtCross = true;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">the <see cref="AxisLabel" /> instance to be copied.</param>
-		public AxisLabel( AxisLabel rhs )
-			: base( rhs )
-		{
-			_isOmitMag = rhs._isOmitMag;
-			_isTitleAtCross = rhs._isTitleAtCross;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new AxisLabel Clone()
-		{
-			return new AxisLabel( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the property that controls whether or not the magnitude factor (power of 10) for
-		/// this scale will be included in the label.
-		/// </summary>
-		/// <remarks>
-		/// For large scale values, a "magnitude" value (power of 10) is automatically
-		/// used for scaling the graph.  This magnitude value is automatically appended
-		/// to the end of the Axis <see cref="Axis.Title"/> (e.g., "(10^4)") to indicate
-		/// that a magnitude is in use.  This property controls whether or not the
-		/// magnitude is included in the title.  Note that it only affects the axis
-		/// title; a magnitude value may still be used even if it is not shown in the title.
-		/// </remarks>
-		/// <value>true to show the magnitude value, false to hide it</value>
-		/// <seealso cref="Axis.Title"/>
-		/// <seealso cref="Scale.Mag"/>
-		/// <seealso cref="Scale.Format"/>
-		public bool IsOmitMag
-		{
-			get { return _isOmitMag; }
-			set { _isOmitMag = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether the Axis title is located at the
-		/// <see cref="Axis.Cross" />
-		/// value or at the normal position (outside the <see cref="Chart.Rect" />).
-		/// </summary>
-		/// <remarks>
-		/// This value only applies if <see cref="Axis.CrossAuto" /> is false.
-		/// </remarks>
-		public bool IsTitleAtCross
-		{
-			get { return _isTitleAtCross; }
-			set { _isTitleAtCross = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected AxisLabel( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch2 = info.GetInt32( "schema3" );
-
-			_isOmitMag = info.GetBoolean( "isOmitMag" );
-			_isTitleAtCross = info.GetBoolean( "isTitleAtCross" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema3", schema2 );
-			info.AddValue( "isOmitMag", _isVisible );
-			info.AddValue( "isTitleAtCross", _isTitleAtCross );
-		}
-		#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Bar.cs b/BDInfo/ZedGraph/Bar.cs
deleted file mode 100644
index c55853de4a..0000000000
--- a/BDInfo/ZedGraph/Bar.cs
+++ /dev/null
@@ -1,523 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-   /// <summary>
-   /// A class representing all the characteristics of the bar
-   /// segments that make up a curve on the graph.
-   /// </summary>
-   /// 
-   /// <author> John Champion </author>
-   /// <version> $Revision: 3.30 $ $Date: 2007/11/03 04:41:28 $ </version>
-   [Serializable]
-   public class Bar : ICloneable, ISerializable
-   {
-	#region Fields
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Bar"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill  _fill;
-		/// <summary>
-		/// Private field that stores the <see cref="Border"/> class that defines the
-		/// properties of the border around this <see cref="BarItem"/>. Use the public
-		/// property <see cref="Border"/> to access this value.
-		/// </summary>
-		private Border _border;
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Bar"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default Bar properties
-			/// <summary>
-			/// The default pen width to be used for drawing the border around the bars
-			/// (<see cref="ZedGraph.LineBase.Width"/> property).  Units are points.
-			/// </summary>
-			public static float BorderWidth = 1.0F;
-			/// <summary>
-			/// The default fill mode for bars (<see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-			/// <summary>
-			/// The default border mode for bars (<see cref="ZedGraph.LineBase.IsVisible"/> property).
-			/// true to display frames around bars, false otherwise
-			/// </summary>
-			public static bool IsBorderVisible = true;
-			/// <summary>
-			/// The default color for drawing frames around bars
-			/// (<see cref="ZedGraph.LineBase.Color"/> property).
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color for filling in the bars
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.Red;
-			/// <summary>
-			/// The default custom brush for filling in the bars
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null; //new LinearGradientBrush( new Rectangle(0,0,100,100),
-			// Color.White, Color.Red, 0F );
-		}
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Default constructor that sets all <see cref="Bar"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public Bar() : this( Color.Empty )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the 
-		/// <see cref="Color"/> as specified, and the remaining
-		/// <see cref="Bar"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// The specified color is only applied to the
-		/// <see cref="ZedGraph.Fill.Color"/>, and the <see cref="ZedGraph.LineBase.Color"/>
-		/// will be defaulted.
-		/// </summary>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the <see cref="ZedGraph.Fill.Color"/>
-		/// of the Bar.
-		/// </param>
-		public Bar( Color color )
-		{
-			_border = new Border( Default.IsBorderVisible, Default.BorderColor, Default.BorderWidth );
-			_fill = new Fill( color.IsEmpty ? Default.FillColor : color,
-									Default.FillBrush, Default.FillType );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Bar object from which to copy</param>
-		public Bar( Bar rhs )
-		{
-			_border = (Border) rhs.Border.Clone();
-			_fill = (Fill) rhs.Fill.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Bar Clone()
-		{
-			return new Bar( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Bar( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_fill = (Fill) info.GetValue( "fill", typeof(Fill) );
-			_border = (Border) info.GetValue( "border", typeof(Border) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// The <see cref="Border"/> object used to draw the border around the <see cref="Bar"/>.
-		/// </summary>
-		/// <seealso cref="Default.IsBorderVisible"/>
-		/// <seealso cref="Default.BorderWidth"/>
-		/// <seealso cref="Default.BorderColor"/>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Bar"/>.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Draw the <see cref="Bar"/> to the specified <see cref="Graphics"/> device
-		/// at the specified location.  This routine draws a single bar.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="left">The x position of the left side of the bar in
-		/// pixel units</param>
-		/// <param name="right">The x position of the right side of the bar in
-		/// pixel units</param>
-		/// <param name="top">The y position of the top of the bar in
-		/// pixel units</param>
-		/// <param name="bottom">The y position of the bottom of the bar in
-		/// pixel units</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <param name="fullFrame">true to draw the bottom portion of the border around the
-		/// bar (this is for legend entries)</param> 
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable for <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/> or <see cref="FillType.GradientByZ"/>.</param>
-		/// <param name="isSelected">Indicates that the <see cref="Bar" /> should be drawn
-		/// with attributes from the <see cref="Selection" /> class.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, float left, float right, float top,
-							float bottom, float scaleFactor, bool fullFrame, bool isSelected,
-							PointPair dataValue )
-		{
-			// Do a sanity check to make sure the top < bottom.  If not, reverse them
-			if ( top > bottom )
-			{
-				float junk = top;
-				top = bottom;
-				bottom = junk;
-			}
-
-			// Do a sanity check to make sure the left < right.  If not, reverse them
-			if ( left > right )
-			{
-				float junk = right;
-				right = left;
-				left = junk;
-			}
-
-			if ( top < -10000 )
-				top = -10000;
-			else if ( top > 10000 )
-				top = 10000;
-			if ( left < -10000 )
-				left = -10000;
-			else if ( left > 10000 )
-				left = 10000;
-			if ( right < -10000 )
-				right = -10000;
-			else if ( right > 10000 )
-				right = 10000;
-			if ( bottom < -10000 )
-				bottom = -10000;
-			else if ( bottom > 10000 )
-				bottom = 10000;
-
-			// Make a rectangle for the bar and draw it
-			RectangleF rect = new RectangleF( left, top, right - left, bottom - top );
-
-			Draw( g, pane, rect, scaleFactor, fullFrame, isSelected, dataValue );      
-		}
-
-		/// <summary>
-		/// Draw the <see cref="Bar"/> to the specified <see cref="Graphics"/> device
-		/// at the specified location.  This routine draws a single bar.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="rect">The rectangle (pixels) to contain the bar</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <param name="fullFrame">true to draw the bottom portion of the border around the
-		/// bar (this is for legend entries)</param> 
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable for <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/> or <see cref="FillType.GradientByZ"/>.</param>
-		/// <param name="isSelected">Indicates that the <see cref="Bar" /> should be drawn
-		/// with attributes from the <see cref="Selection" /> class.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor,
-							bool fullFrame, bool isSelected, PointPair dataValue )
-		{
-			if ( isSelected )
-			{
-				Selection.Fill.Draw( g, rect, dataValue );
-				Selection.Border.Draw( g, pane, scaleFactor, rect );
-			}
-			else
-			{
-				_fill.Draw( g, rect, dataValue );
-				_border.Draw( g, pane, scaleFactor, rect );
-			}
-		}
-
-		/// <summary>
-		/// Draw the this <see cref="Bar"/> to the specified <see cref="Graphics"/>
-		/// device as a bar at each defined point. This method
-		/// is normally only called by the <see cref="BarItem.Draw"/> method of the
-		/// <see cref="BarItem"/> object
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> object representing the
-		/// <see cref="Bar"/>'s to be drawn.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="barWidth">
-		/// The width of each bar, in pixels.
-		/// </param>
-		/// <param name="pos">
-		/// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.)
-		/// in the cluster of bars.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DrawBars( Graphics g, GraphPane pane, CurveItem curve,
-								Axis baseAxis, Axis valueAxis,
-								float barWidth, int pos, float scaleFactor )
-		{
-			// For non-cluster bar types, the position is always zero since the bars are on top
-			// of eachother
-			BarType barType = pane._barSettings.Type;
-			if ( barType == BarType.Overlay || barType == BarType.Stack || barType == BarType.PercentStack ||
-					barType == BarType.SortedOverlay )
-				pos = 0;
-
-			// Loop over each defined point and draw the corresponding bar                
-			for ( int i=0; i<curve.Points.Count; i++ )
-				DrawSingleBar( g, pane, curve, i, pos, baseAxis, valueAxis, barWidth, scaleFactor );
-		}
-
-		/// <summary>
-		/// Draw the specified single bar (an individual "point") of this series to the specified
-		/// <see cref="Graphics"/> device.  This method is not as efficient as
-		/// <see cref="DrawBars"/>, which draws the bars for all points.  It is intended to be used
-		/// only for <see cref="BarType.SortedOverlay"/>, which requires special handling of each bar.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> object representing the
-		/// <see cref="Bar"/>'s to be drawn.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="pos">
-		/// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.)
-		/// in the cluster of bars.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based index number for the single bar to be drawn.
-		/// </param>
-		/// <param name="barWidth">
-		/// The width of each bar, in pixels.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DrawSingleBar( Graphics g, GraphPane pane, CurveItem curve,
-									Axis baseAxis, Axis valueAxis,
-									int pos, int index, float barWidth, float scaleFactor )
-		{
-			// Make sure that a bar value exists for the current curve and current ordinal position
-			if ( index >= curve.Points.Count )
-				return;
-
-			// For Overlay and Stack bars, the position is always zero since the bars are on top
-			// of eachother
-			if ( pane._barSettings.Type == BarType.Overlay || pane._barSettings.Type == BarType.Stack ||
-					pane._barSettings.Type == BarType.PercentStack )
-				pos = 0;
-
-			// Draw the specified bar
-			DrawSingleBar( g, pane, curve, index, pos, baseAxis, valueAxis, barWidth, scaleFactor );
-		}
-
-		/// <summary>
-		/// Protected internal routine that draws the specified single bar (an individual "point")
-		/// of this series to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> object representing the
-		/// <see cref="Bar"/>'s to be drawn.</param>
-		/// <param name="index">
-		/// The zero-based index number for the single bar to be drawn.
-		/// </param>
-		/// <param name="pos">
-		/// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.)
-		/// in the cluster of bars.
-		/// </param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="barWidth">
-		/// The width of each bar, in pixels.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		virtual protected void DrawSingleBar( Graphics g, GraphPane pane,
-										CurveItem curve,
-										int index, int pos, Axis baseAxis, Axis valueAxis,
-										float barWidth, float scaleFactor )
-		{
-			// pixBase = pixel value for the bar center on the base axis
-			// pixHiVal = pixel value for the bar top on the value axis
-			// pixLowVal = pixel value for the bar bottom on the value axis
-			float pixBase, pixHiVal, pixLowVal;
-
-			float clusterWidth = pane.BarSettings.GetClusterWidth();
-			//float barWidth = curve.GetBarWidth( pane );
-			float clusterGap = pane._barSettings.MinClusterGap * barWidth;
-			float barGap = barWidth * pane._barSettings.MinBarGap;
-
-			// curBase = the scale value on the base axis of the current bar
-			// curHiVal = the scale value on the value axis of the current bar
-			// curLowVal = the scale value of the bottom of the bar
-			double curBase, curLowVal, curHiVal;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			valueHandler.GetValues( curve, index, out curBase, out curLowVal, out curHiVal );
-
-			// Any value set to double max is invalid and should be skipped
-			// This is used for calculated values that are out of range, divide
-			//   by zero, etc.
-			// Also, any value <= zero on a log scale is invalid
-
-			if ( !curve.Points[index].IsInvalid )
-			{
-				// calculate a pixel value for the top of the bar on value axis
-				pixLowVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curLowVal );
-				pixHiVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curHiVal );
-				// calculate a pixel value for the center of the bar on the base axis
-				pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curBase );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F +
-								pos * ( barWidth + barGap );
-
-				// Draw the bar
-				if ( pane._barSettings.Base == BarBase.X )
-					this.Draw( g, pane, pixSide, pixSide + barWidth, pixLowVal,
-							pixHiVal, scaleFactor, true, curve.IsSelected,
-							curve.Points[index] );
-				else
-					this.Draw( g, pane, pixLowVal, pixHiVal, pixSide, pixSide + barWidth,
-							scaleFactor, true, curve.IsSelected,
-							curve.Points[index] );
-			}
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/BarItem.cs b/BDInfo/ZedGraph/BarItem.cs
deleted file mode 100644
index 125b690acb..0000000000
--- a/BDInfo/ZedGraph/BarItem.cs
+++ /dev/null
@@ -1,457 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates a bar type that displays vertical or horizontal bars
-	/// </summary>
-	/// <remarks>
-	/// The orientation of the bars depends on the state of
-	/// <see cref="BarSettings.Base"/>, and the bars can be stacked or
-	/// clustered, depending on the state of <see cref="BarSettings.Type"/>
-	/// </remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.27 $ $Date: 2007/11/03 04:41:28 $ </version>
-	[Serializable]
-	public class BarItem : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.Bar"/>
-		/// class defined for this <see cref="BarItem"/>.  Use the public
-		/// property <see cref="Bar"/> to access this value.
-		/// </summary>
-		protected Bar			_bar;
-	#endregion
-	
-	#region Properties
-		/// <summary>
-		/// Gets a reference to the <see cref="ZedGraph.Bar"/> class defined
-		/// for this <see cref="BarItem"/>.
-		/// </summary>
-		public Bar Bar
-		{
-			get { return _bar; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return this is HiLowBarItem;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return pane._barSettings.Base == BarBase.X || pane._barSettings.Base == BarBase.X2;
-		}
-		
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="BarItem"/>, specifying only the legend label for the bar.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		public BarItem( string label ) : base( label )
-		{
-			_bar = new Bar();
-		}
-		/// <summary>
-		/// Create a new <see cref="BarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="ZedGraph.Bar.Fill"/> and <see cref="ZedGraph.Bar.Border"/> properties.
-		/// </param>
-		public BarItem( string label, double[] x, double[] y, Color color )
-			: this( label, new PointPairList( x, y ), color )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="BarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="ZedGraph.Bar.Fill"/> and <see cref="ZedGraph.Bar.Border"/> properties.
-		/// </param>
-		public BarItem( string label, IPointList points, Color color )
-			: base( label, points )
-		{
-			_bar = new Bar( color );
-		}
-		
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="BarItem"/> object from which to copy</param>
-		public BarItem( BarItem rhs ) : base( rhs )
-		{
-			//bar = new Bar( rhs.Bar );
-			_bar = rhs._bar.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public BarItem Clone()
-		{
-			return new BarItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected BarItem( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_bar = (Bar) info.GetValue( "bar", typeof(Bar) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "bar", _bar );
-		}
-	#endregion
-
-	#region Methods
-		/// <summary>
-		/// Do all rendering associated with this <see cref="BarItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="Bar"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, GraphPane pane, int pos,
-									float scaleFactor  )
-		{
-			// Pass the drawing onto the bar class
-			if ( _isVisible )
-				_bar.DrawBars( g, pane, this, BaseAxis( pane ), ValueAxis( pane ),
-								this.GetBarWidth( pane ), pos, scaleFactor );
-		}
-		
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="BarItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-        /// <param name="pane">
-        /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-        /// owner of this object.
-        /// </param>
-        /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-        /// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			_bar.Draw( g, pane, rect, scaleFactor, true, false, null );
-		}
-
-		/// <summary>
-		/// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />.
-		/// </summary>
-		/// <remarks>
-		/// This method will go through the bars, create a label that corresponds to the bar value,
-		/// and place it on the graph depending on user preferences.  This works for horizontal or
-		/// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types.  This method
-		/// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects.
-		/// Call this method only after calling <see cref="GraphPane.AxisChange()" />.
-		/// </remarks>
-		/// <param name="pane">The GraphPane in which to place the text labels.</param>
-		/// <param name="isBarCenter">true to center the labels inside the bars, false to
-		/// place the labels just above the top of the bar.</param>
-		/// <param name="valueFormat">The double.ToString string format to use for creating
-		/// the labels.
-		/// </param>
-		public static void CreateBarLabels( GraphPane pane, bool isBarCenter, string valueFormat )
-		{
-			CreateBarLabels( pane, isBarCenter, valueFormat, TextObj.Default.FontFamily,
-					TextObj.Default.FontSize, TextObj.Default.FontColor, TextObj.Default.FontBold,
-					TextObj.Default.FontItalic, TextObj.Default.FontUnderline );
-		}
-
-		/// <summary>
-		/// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />.
-		/// </summary>
-		/// <remarks>
-		/// This method will go through the bars, create a label that corresponds to the bar value,
-		/// and place it on the graph depending on user preferences.  This works for horizontal or
-		/// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types.  This method
-		/// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects.
-		/// Call this method only after calling <see cref="GraphPane.AxisChange()" />.
-		/// </remarks>
-		/// <param name="pane">The GraphPane in which to place the text labels.</param>
-		/// <param name="isBarCenter">true to center the labels inside the bars, false to
-		/// place the labels just above the top of the bar.</param>
-		/// <param name="valueFormat">The double.ToString string format to use for creating
-		/// the labels.
-		/// </param>
-		/// <param name="fontColor">The color in which to draw the labels</param>
-		/// <param name="fontFamily">The string name of the font family to use for the labels</param>
-		/// <param name="fontSize">The floating point size of the font, in scaled points</param>
-		/// <param name="isBold">true for a bold font type, false otherwise</param>
-		/// <param name="isItalic">true for an italic font type, false otherwise</param>
-		/// <param name="isUnderline">true for an underline font type, false otherwise</param>
-		public static void CreateBarLabels( GraphPane pane, bool isBarCenter, string valueFormat,
-			string fontFamily, float fontSize, Color fontColor, bool isBold, bool isItalic,
-			bool isUnderline )
-		{
-			bool isVertical = pane.BarSettings.Base == BarBase.X;
-
-			// keep a count of the number of BarItems
-			int curveIndex = 0;
-
-			// Get a valuehandler to do some calculations for us
-			ValueHandler valueHandler = new ValueHandler( pane, true );
-
-			// Loop through each curve in the list
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				// work with BarItems only
-				BarItem bar = curve as BarItem;
-				if ( bar != null )
-				{
-					IPointList points = curve.Points;
-
-					// ADD JKB 9/21/07
-					// The labelOffset should depend on whether the curve is YAxis or Y2Axis.
-					// JHC - Generalize to any value axis
-					// Make the gap between the bars and the labels = 1.5% of the axis range
-					float labelOffset;
-
-					Scale scale = curve.ValueAxis( pane ).Scale;
-					labelOffset = (float)( scale._max - scale._min ) * 0.015f;
-
-					// Loop through each point in the BarItem
-					for ( int i = 0; i < points.Count; i++ )
-					{
-						// Get the high, low and base values for the current bar
-						// note that this method will automatically calculate the "effective"
-						// values if the bar is stacked
-						double baseVal, lowVal, hiVal;
-						valueHandler.GetValues( curve, i, out baseVal, out lowVal, out hiVal );
-
-						// Get the value that corresponds to the center of the bar base
-						// This method figures out how the bars are positioned within a cluster
-						float centerVal = (float)valueHandler.BarCenterValue( bar,
-							bar.GetBarWidth( pane ), i, baseVal, curveIndex );
-
-						// Create a text label -- note that we have to go back to the original point
-						// data for this, since hiVal and lowVal could be "effective" values from a bar stack
-						string barLabelText = ( isVertical ? points[i].Y : points[i].X ).ToString( valueFormat );
-
-						// Calculate the position of the label -- this is either the X or the Y coordinate
-						// depending on whether they are horizontal or vertical bars, respectively
-						float position;
-						if ( isBarCenter )
-							position = (float)( hiVal + lowVal ) / 2.0f;
-						else if ( hiVal >= 0 )
-							position = (float)hiVal + labelOffset;
-						else
-							position = (float)hiVal - labelOffset;
-
-						// Create the new TextObj
-						TextObj label;
-						if ( isVertical )
-							label = new TextObj( barLabelText, centerVal, position );
-						else
-							label = new TextObj( barLabelText, position, centerVal );
-
-						label.FontSpec.Family = fontFamily;
-
-						// Configure the TextObj
-
-                  // CHANGE JKB 9/21/07
-                  // CoordinateFrame should depend on whether curve is YAxis or Y2Axis.
-						label.Location.CoordinateFrame =
-							(isVertical && curve.IsY2Axis) ? CoordType.AxisXY2Scale : CoordType.AxisXYScale;
-
-						label.FontSpec.Size = fontSize;
-						label.FontSpec.FontColor = fontColor;
-						label.FontSpec.IsItalic = isItalic;
-						label.FontSpec.IsBold = isBold;
-						label.FontSpec.IsUnderline = isUnderline;
-
-						label.FontSpec.Angle = isVertical ? 90 : 0;
-						label.Location.AlignH = isBarCenter ? AlignH.Center :
-									( hiVal >= 0 ? AlignH.Left : AlignH.Right );
-						label.Location.AlignV = AlignV.Center;
-						label.FontSpec.Border.IsVisible = false;
-						label.FontSpec.Fill.IsVisible = false;
-
-						// Add the TextObj to the GraphPane
-						pane.GraphObjList.Add( label );
-					}
-					curveIndex++;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			if ( i < 0 || i >= _points.Count )
-				return false;
-
-			Axis valueAxis = ValueAxis( pane );
-			Axis baseAxis = BaseAxis( pane );
-
-			// pixBase = pixel value for the bar center on the base axis
-			// pixHiVal = pixel value for the bar top on the value axis
-			// pixLowVal = pixel value for the bar bottom on the value axis
-			float pixBase, pixHiVal, pixLowVal;
-
-			float clusterWidth = pane.BarSettings.GetClusterWidth();
-			float barWidth = GetBarWidth( pane );
-			float clusterGap = pane._barSettings.MinClusterGap * barWidth;
-			float barGap = barWidth * pane._barSettings.MinBarGap;
-
-			// curBase = the scale value on the base axis of the current bar
-			// curHiVal = the scale value on the value axis of the current bar
-			// curLowVal = the scale value of the bottom of the bar
-			double curBase, curLowVal, curHiVal;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			valueHandler.GetValues( this, i, out curBase, out curLowVal, out curHiVal );
-
-			// Any value set to double max is invalid and should be skipped
-			// This is used for calculated values that are out of range, divide
-			//   by zero, etc.
-			// Also, any value <= zero on a log scale is invalid
-
-			if ( !_points[i].IsInvalid3D )
-			{
-				// calculate a pixel value for the top of the bar on value axis
-				pixLowVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curLowVal );
-				pixHiVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curHiVal );
-				// calculate a pixel value for the center of the bar on the base axis
-				pixBase = baseAxis.Scale.Transform( _isOverrideOrdinal, i, curBase );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F +
-								pane.CurveList.GetBarItemPos( pane, this ) * ( barWidth + barGap );
-
-				// Draw the bar
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixSide, pixLowVal,
-								pixSide + barWidth, pixHiVal );
-				else
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixLowVal, pixSide,
-								pixHiVal, pixSide + barWidth );
-
-				return true;
-			}
-
-			return false;
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/BarSettings.cs b/BDInfo/ZedGraph/BarSettings.cs
deleted file mode 100644
index dcccdd20d7..0000000000
--- a/BDInfo/ZedGraph/BarSettings.cs
+++ /dev/null
@@ -1,484 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the global settings for bar charts
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/11/03 04:41:28 $ </version>
-	[Serializable]
-	public class BarSettings : ISerializable
-	{
-	#region Fields
-
-		/// <summary>Private field that determines the size of the gap between bar clusters
-		/// for bar charts.  This gap is expressed as a fraction of the bar size (1.0 means
-		/// leave a 1-barwidth gap between clusters).
-		/// Use the public property <see cref="MinClusterGap"/> to access this value. </summary>
-		private float _minClusterGap;
-		/// <summary>Private field that determines the size of the gap between individual bars
-		/// within a bar cluster for bar charts.  This gap is expressed as a fraction of the
-		/// bar size (1.0 means leave a 1-barwidth gap between each bar).
-		/// Use the public property <see cref="MinBarGap"/> to access this value. </summary>
-		private float _minBarGap;
-		/// <summary>Private field that determines the base axis from which <see cref="Bar"/>
-		/// graphs will be displayed.  The base axis is the axis from which the bars grow with
-		/// increasing value. The value is of the enumeration type <see cref="ZedGraph.BarBase"/>.
-		/// To access this value, use the public property <see cref="Base"/>.
-		/// </summary>
-		/// <seealso cref="Default.Base"/>
-		private BarBase _base;
-		/// <summary>Private field that determines how the <see cref="BarItem"/>
-		/// graphs will be displayed. See the <see cref="ZedGraph.BarType"/> enum
-		/// for the individual types available.
-		/// To access this value, use the public property <see cref="Type"/>.
-		/// </summary>
-		/// <seealso cref="Default.Type"/>
-		private BarType _type;
-		/// <summary>Private field that determines the width of a bar cluster (for bar charts)
-		/// in user scale units.  Normally, this value is 1.0 because bar charts are typically
-		/// <see cref="AxisType.Ordinal"/> or <see cref="AxisType.Text"/>, and the bars are
-		/// defined at ordinal values (1.0 scale units apart).  For <see cref="AxisType.Linear"/>
-		/// or other scale types, you can use this value to scale the bars to an arbitrary
-		/// user scale. Use the public property <see cref="ClusterScaleWidth"/> to access this
-		/// value. </summary>
-		internal double _clusterScaleWidth;
-
-		/// <summary>
-		/// Private field that determines if the <see cref="ClusterScaleWidth" /> will be
-		/// calculated automatically.  Use the public property <see cref="ClusterScaleWidthAuto" />
-		/// to access this value.
-		/// </summary>
-		internal bool _clusterScaleWidthAuto;
-
-		/// <summary>
-		/// private field that stores the owner GraphPane that contains this BarSettings instance.
-		/// </summary>
-		internal GraphPane _ownerPane;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to build a <see cref="BarSettings" /> instance from the defaults.
-		/// </summary>
-		public BarSettings( GraphPane parentPane )
-		{
-			_minClusterGap = Default.MinClusterGap;
-			_minBarGap = Default.MinBarGap;
-			_clusterScaleWidth = Default.ClusterScaleWidth;
-			_clusterScaleWidthAuto = Default.ClusterScaleWidthAuto;
-			_base = Default.Base;
-			_type = Default.Type;
-
-			_ownerPane = parentPane;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">the <see cref="BarSettings" /> instance to be copied.</param>
-		/// <param name="parentPane">The <see cref="GraphPane" /> that will be the
-		/// parent of this new BarSettings object.</param>
-		public BarSettings( BarSettings rhs, GraphPane parentPane )
-		{
-			_minClusterGap = rhs._minClusterGap;
-			_minBarGap = rhs._minBarGap;
-			_clusterScaleWidth = rhs._clusterScaleWidth;
-			_clusterScaleWidthAuto = rhs._clusterScaleWidthAuto;
-			_base = rhs._base;
-			_type = rhs._type;
-
-			_ownerPane = parentPane;
-		}
-
-	#endregion
-
-	#region Bar Properties
-
-		/// <summary>
-		/// The minimum space between <see cref="Bar"/> clusters, expressed as a
-		/// fraction of the bar size.
-		/// </summary>
-		/// <seealso cref="Default.MinClusterGap"/>
-		/// <seealso cref="MinBarGap"/>
-		/// <seealso cref="ClusterScaleWidth"/>
-		public float MinClusterGap
-		{
-			get { return _minClusterGap; }
-			set { _minClusterGap = value; }
-		}
-		/// <summary>
-		/// The minimum space between individual <see cref="Bar">Bars</see>
-		/// within a cluster, expressed as a
-		/// fraction of the bar size.
-		/// </summary>
-		/// <seealso cref="Default.MinBarGap"/>
-		/// <seealso cref="MinClusterGap"/>
-		/// <seealso cref="ClusterScaleWidth"/>
-		public float MinBarGap
-		{
-			get { return _minBarGap; }
-			set { _minBarGap = value; }
-		}
-		/// <summary>Determines the base axis from which <see cref="Bar"/>
-		/// graphs will be displayed.
-		/// </summary>
-		/// <remarks>The base axis is the axis from which the bars grow with
-		/// increasing value. The value is of the enumeration type <see cref="ZedGraph.BarBase"/>.
-		/// </remarks>
-		/// <seealso cref="Default.Base"/>
-		public BarBase Base
-		{
-			get { return _base; }
-			set { _base = value; }
-		}
-		/// <summary>Determines how the <see cref="BarItem"/>
-		/// graphs will be displayed. See the <see cref="ZedGraph.BarType"/> enum
-		/// for the individual types available.
-		/// </summary>
-		/// <seealso cref="Default.Type"/>
-		public BarType Type
-		{
-			get { return _type; }
-			set { _type = value; }
-		}
-		/// <summary>
-		/// The width of an individual bar cluster on a <see cref="Bar"/> graph.
-		/// This value only applies to bar graphs plotted on non-ordinal X axis
-		/// types (<see cref="AxisType.Linear"/>, <see cref="AxisType.Log"/>, and
-		/// <see cref="AxisType.Date"/>.
-		/// </summary>
-		/// <remarks>
-		/// This value can be calculated automatically if <see cref="ClusterScaleWidthAuto" />
-		/// is set to true.  In this case, ClusterScaleWidth will be calculated if
-		/// <see cref="Base" /> refers to an <see cref="Axis" /> of a non-ordinal type
-		/// (<see cref="Scale.IsAnyOrdinal" /> is false).  The ClusterScaleWidth is calculated
-		/// from the minimum difference found between any two points on the <see cref="Base" />
-		/// <see cref="Axis" /> for any <see cref="BarItem" /> in the
-		/// <see cref="GraphPane.CurveList" />.  The ClusterScaleWidth is set automatically
-		/// each time <see cref="GraphPane.AxisChange()" /> is called.  Calculations are
-		/// done by the <see cref="BarSettings.CalcClusterScaleWidth" /> method.
-		/// </remarks>
-		/// <seealso cref="Default.ClusterScaleWidth"/>
-		/// <seealso cref="ClusterScaleWidthAuto"/>
-		/// <seealso cref="MinBarGap"/>
-		/// <seealso cref="MinClusterGap"/>
-		public double ClusterScaleWidth
-		{
-			get { return _clusterScaleWidth; }
-			set { _clusterScaleWidth = value; _clusterScaleWidthAuto = false; }
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines if the <see cref="ClusterScaleWidth" /> will be
-		/// calculated automatically.
-		/// </summary>
-		/// <remarks>true for the <see cref="ClusterScaleWidth" /> to be calculated
-		/// automatically based on the available data, false otherwise.  This value will
-		/// be set to false automatically if the <see cref="ClusterScaleWidth" /> value
-		/// is changed by the user.
-		/// </remarks>
-		/// <seealso cref="Default.ClusterScaleWidthAuto"/>
-		/// <seealso cref="ClusterScaleWidth"/>
-		public bool ClusterScaleWidthAuto
-		{
-			get { return _clusterScaleWidthAuto; }
-			set { _clusterScaleWidthAuto = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <remarks>
-		/// You MUST set the _ownerPane property after deserializing a BarSettings object.
-		/// </remarks>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the
-		/// serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains
-		/// the serialized data
-		/// </param>
-		internal BarSettings( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_minClusterGap = info.GetSingle( "minClusterGap" );
-			_minBarGap = info.GetSingle( "minBarGap" );
-			_clusterScaleWidth = info.GetDouble( "clusterScaleWidth" );
-			_clusterScaleWidthAuto = info.GetBoolean( "clusterScaleWidthAuto" );
-			_base = (BarBase)info.GetValue( "base", typeof( BarBase ) );
-			_type = (BarType)info.GetValue( "type", typeof( BarType ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "minClusterGap", _minClusterGap );
-			info.AddValue( "minBarGap", _minBarGap );
-			info.AddValue( "clusterScaleWidth", _clusterScaleWidth );
-			info.AddValue( "clusterScaleWidthAuto", _clusterScaleWidthAuto );
-			info.AddValue( "base", _base );
-			info.AddValue( "type", _type );
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Calculate the width of an individual bar cluster on a <see cref="BarItem"/> graph.
-		/// This value only applies to bar graphs plotted on non-ordinal X axis
-		/// types (<see cref="Scale.IsAnyOrdinal" /> is false).
-		/// </summary>
-		/// <remarks>
-		/// This value can be calculated automatically if <see cref="ClusterScaleWidthAuto" />
-		/// is set to true.  In this case, ClusterScaleWidth will be calculated if
-		/// <see cref="Base" /> refers to an <see cref="Axis" /> of a non-ordinal type
-		/// (<see cref="Scale.IsAnyOrdinal" /> is false).  The ClusterScaleWidth is calculated
-		/// from the minimum difference found between any two points on the <see cref="Base" />
-		/// <see cref="Axis" /> for any <see cref="BarItem" /> in the
-		/// <see cref="GraphPane.CurveList" />.  The ClusterScaleWidth is set automatically
-		/// each time <see cref="GraphPane.AxisChange()" /> is called.
-		/// </remarks>
-		/// <seealso cref="Default.ClusterScaleWidth"/>
-		/// <seealso cref="ClusterScaleWidthAuto"/>
-		/// <seealso cref="MinBarGap"/>
-		/// <seealso cref="MinClusterGap"/>
-		public void CalcClusterScaleWidth()
-		{
-			Axis baseAxis = BarBaseAxis();
-
-			// First, calculate the clusterScaleWidth for BarItem objects
-			if ( _clusterScaleWidthAuto && !baseAxis.Scale.IsAnyOrdinal )
-			{
-				double minStep = Double.MaxValue;
-
-				foreach ( CurveItem curve in _ownerPane.CurveList )
-				{
-					IPointList list = curve.Points;
-
-					if ( curve is BarItem )
-					{
-						double step = GetMinStepSize( curve.Points, baseAxis );
-						minStep = step < minStep ? step : minStep;
-					}
-				}
-
-				if ( minStep == Double.MaxValue )
-					minStep = 1.0;
-
-				_clusterScaleWidth = minStep;
-			}
-
-			// Second, calculate the sizes of any HiLowBarItem and JapaneseCandleStickItem objects
-			foreach ( CurveItem curve in _ownerPane.CurveList )
-			{
-				IPointList list = curve.Points;
-
-//				if ( curve is HiLowBarItem &&
-//						(curve as HiLowBarItem).Bar.IsAutoSize )
-//				{
-//					( curve as HiLowBarItem ).Bar._userScaleSize =
-//								GetMinStepSize( list, baseAxis );
-//				}
-//				else if ( curve is JapaneseCandleStickItem &&
-				if ( curve is JapaneseCandleStickItem &&
-						(curve as JapaneseCandleStickItem).Stick.IsAutoSize )
-				{
-					( curve as JapaneseCandleStickItem ).Stick._userScaleSize =
-								GetMinStepSize( list, baseAxis );
-				}
-			}
-
-		}
-
-		/// <summary>
-		/// Determine the minimum increment between individual points to be used for
-		/// calculating a bar size that fits without overlapping
-		/// </summary>
-		/// <param name="list">The <see cref="IPointList" /> list of points for the bar
-		/// of interest</param>
-		/// <param name="baseAxis">The base axis for the bar</param>
-		/// <returns>The minimum increment between bars along the base axis</returns>
-		internal static double GetMinStepSize( IPointList list, Axis baseAxis )
-		{
-			double minStep = Double.MaxValue;
-
-			if ( list.Count <= 0 || baseAxis._scale.IsAnyOrdinal )
-				return 1.0;
-
-			PointPair lastPt = list[0];
-			for ( int i = 1; i < list.Count; i++ )
-			{
-				PointPair pt = list[i];
-				if ( !pt.IsInvalid || !lastPt.IsInvalid )
-				{
-					double step;
-					if ( baseAxis is XAxis || baseAxis is X2Axis )
-						step = pt.X - lastPt.X;
-					else
-						step = pt.Y - lastPt.Y;
-
-					if ( step > 0 && step < minStep )
-						minStep = step;
-				}
-
-				lastPt = pt;
-			}
-
-			double range = baseAxis.Scale._maxLinearized - baseAxis.Scale._minLinearized;
-			if ( range <= 0 )
-				minStep = 1.0;
-			else if ( minStep <= 0 || minStep < 0.001 * range || minStep > range )
-				minStep = 0.1 * range;
-
-			return minStep;
-		}
-
-		/// <summary>
-		/// Determine the width, in screen pixel units, of each bar cluster including
-		/// the cluster gaps and bar gaps.
-		/// </summary>
-		/// <remarks>This method calls the <see cref="Scale.GetClusterWidth(GraphPane)"/>
-		/// method for the base <see cref="Axis"/> for <see cref="Bar"/> graphs
-		/// (the base <see cref="Axis"/> is assigned by the <see cref="ZedGraph.BarSettings.Base"/>
-		/// property).
-		/// </remarks>
-		/// <seealso cref="ZedGraph.BarBase"/>
-		/// <seealso cref="ZedGraph.BarSettings"/>
-		/// <seealso cref="Scale.GetClusterWidth(GraphPane)"/>
-		/// <seealso cref="ZedGraph.BarSettings.Type"/>
-		/// <returns>The width of each bar cluster, in pixel units</returns>
-		public float GetClusterWidth()
-		{
-			return BarBaseAxis()._scale.GetClusterWidth( _ownerPane );
-		}
-
-		/// <summary>
-		/// Determine the <see cref="Axis"/> from which the <see cref="Bar"/> charts are based.
-		/// </summary>
-		/// <seealso cref="ZedGraph.BarBase"/>
-		/// <seealso cref="BarSettings"/>
-		/// <seealso cref="ZedGraph.BarSettings.Base"/>
-		/// <seealso cref="Scale.GetClusterWidth(GraphPane)"/>
-		/// <returns>The <see cref="Axis"/> class for the axis from which the bars are based</returns>
-		public Axis BarBaseAxis()
-		{
-			Axis barAxis;
-			if ( _base == BarBase.Y )
-				barAxis = _ownerPane.YAxis;
-			else if ( _base == BarBase.Y2 )
-				barAxis = _ownerPane.Y2Axis;
-			else if ( _base == BarBase.X2 )
-				barAxis = _ownerPane.X2Axis;
-			else
-				barAxis = _ownerPane.XAxis;
-
-			return barAxis;
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="BarSettings"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default dimension gap between clusters of bars on a
-			/// <see cref="Bar"/> graph.
-			/// This dimension is expressed in terms of the normal bar width.
-			/// </summary>
-			/// <seealso cref="Default.MinBarGap"/>
-			/// <seealso cref="BarSettings.MinClusterGap"/>
-			public static float MinClusterGap = 1.0F;
-			/// <summary>
-			/// The default dimension gap between each individual bar within a bar cluster
-			/// on a <see cref="Bar"/> graph.
-			/// This dimension is expressed in terms of the normal bar width.
-			/// </summary>
-			/// <seealso cref="Default.MinClusterGap"/>
-			/// <seealso cref="BarSettings.MinBarGap"/>
-			public static float MinBarGap = 0.2F;
-			/// <summary>The default value for the <see cref="BarSettings.Base"/>, which determines the base
-			/// <see cref="Axis"/> from which the <see cref="Bar"/> graphs will be displayed.
-			/// </summary>
-			/// <seealso cref="BarSettings.Base"/>
-			public static BarBase Base = BarBase.X;
-			/// <summary>The default value for the <see cref="BarSettings.Type"/> property, which
-			/// determines if the bars are drawn overlapping eachother in a "stacked" format,
-			/// or side-by-side in a "cluster" format.  See the <see cref="ZedGraph.BarType"/>
-			/// for more information.
-			/// </summary>
-			/// <seealso cref="BarSettings.Type"/>
-			public static BarType Type = BarType.Cluster;
-
-			/// <summary>
-			/// The default width of a bar cluster 
-			/// on a <see cref="Bar"/> graph.  This value only applies to
-			/// <see cref="Bar"/> graphs, and only when the
-			/// <see cref="Axis.Type"/> is <see cref="AxisType.Linear"/>,
-			/// <see cref="AxisType.Log"/> or <see cref="AxisType.Date"/>.
-			/// This dimension is expressed in terms of X scale user units.
-			/// </summary>
-			/// <seealso cref="Default.MinClusterGap"/>
-			/// <seealso cref="BarSettings.MinBarGap"/>
-			public static double ClusterScaleWidth = 1.0;
-
-			/// <summary>
-			/// The default value for <see cref="BarSettings.ClusterScaleWidthAuto" />.
-			/// </summary>
-			public static bool ClusterScaleWidthAuto = true;
-		}
-	#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/BasicArrayPointList.cs b/BDInfo/ZedGraph/BasicArrayPointList.cs
deleted file mode 100644
index e2cf3fd7b2..0000000000
--- a/BDInfo/ZedGraph/BasicArrayPointList.cs
+++ /dev/null
@@ -1,147 +0,0 @@
-//============================================================================
-//BasicArrayPointList Class
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A data collection class for ZedGraph, provided as an alternative to <see cref="PointPairList" />.
-	/// </summary>
-	/// <remarks>
-	/// The data storage class for ZedGraph can be any type, so long as it uses the <see cref="IPointList" />
-	/// interface.  This class, albeit simple, is a demonstration of implementing the <see cref="IPointList" />
-	/// interface to provide a simple data collection using only two arrays.  The <see cref="IPointList" />
-	/// interface can also be used as a layer between ZedGraph and a database, for example.
-	/// </remarks>
-	/// <seealso cref="PointPairList" />
-	/// <seealso cref="IPointList" />
-	/// 
-	/// <author> John Champion</author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/02/18 05:51:53 $ </version>
-	[Serializable]
-	public class BasicArrayPointList : IPointList
-	{
-	#region Fields
-
-		/// <summary>
-		/// Instance of an array of x values
-		/// </summary>
-		public double[] x;
-		/// <summary>
-		/// Instance of an array of x values
-		/// </summary>
-		public double[] y;
-
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Indexer to access the specified <see cref="PointPair"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <remarks>
-		/// Returns <see cref="PointPairBase.Missing" /> for any value of <see paramref="index" />
-		/// that is outside of its corresponding array bounds.
-		/// </remarks>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="PointPair"/> object to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object reference.</value>
-		public PointPair this[ int index ]  
-		{
-			get
-			{
-				double xVal, yVal;
-				if ( index >= 0 && index < x.Length )
-					xVal = x[index];
-				else
-					xVal = PointPair.Missing;
-
-				if ( index >= 0 && index < y.Length )
-					yVal = y[index];
-				else
-					yVal = PointPair.Missing;
-				return new PointPair( xVal, yVal, PointPair.Missing, null );
-			}
-			set
-			{
-				if ( index >= 0 && index < x.Length )
-					x[index] = value.X;
-				if ( index >= 0 && index < y.Length )
-					y[index] = value.Y;
-			}
-		}
-
-		/// <summary>
-		/// Returns the number of points available in the arrays.  Count will be the greater
-		/// of the lengths of the X and Y arrays.
-		/// </summary>
-		public int Count
-		{
-			get { return x.Length > y.Length ? x.Length : y.Length; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to initialize the PointPairList from two arrays of
-		/// type double.
-		/// </summary>
-		public BasicArrayPointList( double[] x, double[] y )
-		{
-			this.x = x;
-			this.y = y;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The PointPairList from which to copy</param>
-		public BasicArrayPointList( BasicArrayPointList rhs )
-		{
-			x = (double[]) rhs.x.Clone();
-			y = (double[]) rhs.y.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public BasicArrayPointList Clone()
-		{
-			return new BasicArrayPointList( this );
-		}
-
-		
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Border.cs b/BDInfo/ZedGraph/Border.cs
deleted file mode 100644
index adf914b122..0000000000
--- a/BDInfo/ZedGraph/Border.cs
+++ /dev/null
@@ -1,250 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that encapsulates Border (frame) properties for an object.  The <see cref="Border"/> class
-	/// is used in a variety of ZedGraph objects to handle the drawing of the Border around the object.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.18 $ $Date: 2007/03/17 18:43:44 $ </version>
-	[Serializable]
-	public class Border : LineBase, ISerializable, ICloneable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the amount of inflation to be done on the rectangle
-		/// before rendering.  This allows the border to be inset or outset relative to
-		/// the actual rectangle area.  Use the public property <see cref="InflateFactor"/>
-		/// to access this value.
-		/// </summary>
-		private float	_inflateFactor;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Fill"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			/// <summary>
-			/// The default value for <see cref="Border.InflateFactor"/>, in units of points (1/72 inch).
-			/// </summary>
-			/// <seealso cref="Border.InflateFactor"/>
-			public static float InflateFactor = 0.0F;
-		}
-	#endregion
-		
-	#region Constructors
-		/// <summary>
-		/// The default constructor.  Initialized to default values.
-		/// </summary>
-		public Border() : base()
-		{
-			_inflateFactor = Default.InflateFactor;
-		}
-
-		/// <summary>
-		/// Constructor that specifies the visibility, color and penWidth of the Border.
-		/// </summary>
-		/// <param name="isVisible">Determines whether or not the Border will be drawn.</param>
-		/// <param name="color">The color of the Border</param>
-        /// <param name="width">The width, in points (1/72 inch), for the Border.</param>
-        public Border( bool isVisible, Color color, float width ) :
-			  base( color )
-		{
-			_width = width;
-			_isVisible = isVisible;
-		}
-
-		/// <summary>
-		/// Constructor that specifies the color and penWidth of the Border.
-		/// </summary>
-		/// <param name="color">The color of the Border</param>
-        /// <param name="width">The width, in points (1/72 inch), for the Border.</param>
-        public Border( Color color, float width ) :
-				this( !color.IsEmpty, color, width )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Border object from which to copy</param>
-		public Border( Border rhs ) : base( rhs )
-		{
-			_inflateFactor = rhs._inflateFactor;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Border Clone()
-		{
-			return new Border( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Border( SerializationInfo info, StreamingContext context ) :
-			base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_inflateFactor = info.GetSingle( "inflateFactor" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema", schema );
-			info.AddValue( "inflateFactor", _inflateFactor );
-		}
-	#endregion
-		
-	#region Properties
-		/// <summary>
-		/// Gets or sets the amount of inflation to be done on the rectangle
-		/// before rendering.
-		/// </summary>
-		/// <remarks>This allows the border to be inset or outset relative to
-		/// the actual rectangle area.
-		/// </remarks>
-		public float InflateFactor
-		{
-			get { return _inflateFactor; }
-			set { _inflateFactor = value; }
-		}
-	#endregion
-
-	#region Methods
-		/*
-		/// <summary>
-		/// Create a new <see cref="Pen"/> object from the properties of this
-		/// <see cref="Border"/> object.
-		/// </summary>
-		/// <param name="isPenWidthScaled">
-		/// Set to true to have the <see cref="Border"/> pen width scaled with the
-		/// scaleFactor.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <returns>A <see cref="Pen"/> object with the proper color and pen width.</returns>
-		public Pen MakePen( bool isPenWidthScaled, float scaleFactor )
-		{
-			float scaledPenWidth = _width;
-			if ( isPenWidthScaled )
-				scaledPenWidth = (float)(_width * scaleFactor);
-			
-			return new Pen( _color, scaledPenWidth );
-		}
-		*/
-		
-		/// <summary>
-		/// Draw the specified Border (<see cref="RectangleF"/>) using the properties of
-		/// this <see cref="Border"/> object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <param name="rect">A <see cref="RectangleF"/> struct to be drawn.</param>
-		public void Draw( Graphics g, PaneBase pane, float scaleFactor, RectangleF rect )
-		{
-			// Need to use the RectangleF props since rounding it can cause the axisFrame to
-			// not line up properly with the last tic mark
-			if ( _isVisible )
-			{
-				RectangleF tRect = rect;
-
-				float		scaledInflate = (float) ( _inflateFactor * scaleFactor );
-				tRect.Inflate( scaledInflate, scaledInflate );
-
-				using ( Pen pen = GetPen( pane, scaleFactor) )
-					g.DrawRectangle( pen, tRect.X, tRect.Y, tRect.Width, tRect.Height );
-			}
-		}
-
-	#endregion
-	}
-}
-
-
-
-
-
-
-
-
diff --git a/BDInfo/ZedGraph/BoxObj.cs b/BDInfo/ZedGraph/BoxObj.cs
deleted file mode 100644
index 372a240623..0000000000
--- a/BDInfo/ZedGraph/BoxObj.cs
+++ /dev/null
@@ -1,348 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a bordered and/or filled box (rectangle) object on
-	/// the graph.  A list of
-	/// BoxObj objects is maintained by the <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.3 $ $Date: 2007/01/25 07:56:08 $ </version>
-	[Serializable]
-	public class BoxObj : GraphObj, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="BoxObj"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		protected Fill _fill;
-		/// <summary>
-		/// Private field that determines the properties of the border around this
-		/// <see cref="BoxObj"/>
-		/// Use the public property <see cref="Border"/> to access this value.
-		/// </summary>
-		protected Border _border;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ArrowObj"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			/// <summary>
-			/// The default pen width used for the <see cref="BoxObj"/> border
-            /// (<see cref="ZedGraph.LineBase.Width"/> property).  Units are points (1/72 inch).
-            /// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The default color used for the <see cref="BoxObj"/> border
-			/// (<see cref="ZedGraph.LineBase.Color"/> property).
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color used for the <see cref="BoxObj"/> fill
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.White;
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="BoxObj"/>.
-		/// </summary>
-		public Fill	Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Border"/> object, which
-		/// determines the properties of the border around this
-		/// <see cref="BoxObj"/>
-		/// </summary>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-	#endregion
-	
-	#region Constructors
-		/// <overloads>Constructors for the <see cref="BoxObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the position, border color, and solid fill color
-		/// of the <see cref="BoxObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box border</param>
-		/// <param name="fillColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box fill (will be a solid color fill)</param>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public BoxObj( double x, double y, double width, double height, Color borderColor, Color fillColor )
-			: base( x, y, width, height )
-		{
-			this.Border = new Border( borderColor, Default.PenWidth );
-			this.Fill = new Fill( fillColor );
-		}
-
-		/// <summary>
-		/// A constructor that allows the position
-		/// of the <see cref="BoxObj"/> to be pre-specified.  Other properties are defaulted.
-		/// </summary>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public BoxObj( double x, double y, double width, double height )
-			:
-			base( x, y, width, height )
-		{
-			this.Border = new Border( Default.BorderColor, Default.PenWidth );
-			this.Fill = new Fill( Default.FillColor );
-		}
-
-		/// <summary>
-		/// A default constructor that creates a <see cref="BoxObj"/> using a location of (0,0),
-		/// and a width,height of (1,1).  Other properties are defaulted.
-		/// </summary>
-		public BoxObj() : this( 0, 0, 1, 1 )
-		{
-		}
-
-		/// <summary>
-		/// A constructor that allows the position, border color, and two-color
-		/// gradient fill colors
-		/// of the <see cref="BoxObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box border</param>
-		/// <param name="fillColor1">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the start of the box gradient fill</param>
-		/// <param name="fillColor2">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the end of the box gradient fill</param>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public BoxObj( double x, double y, double width, double height, Color borderColor,
-							Color fillColor1, Color fillColor2 ) :
-				base( x, y, width, height )
-		{
-			this.Border = new Border( borderColor, Default.PenWidth );
-			this.Fill = new Fill( fillColor1, fillColor2 );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="BoxObj"/> object from which to copy</param>
-		public BoxObj( BoxObj rhs ) : base( rhs )
-		{
-			this.Border = rhs.Border.Clone();
-			this.Fill = rhs.Fill.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public BoxObj Clone()
-		{
-			return new BoxObj( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected BoxObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_fill = (Fill) info.GetValue( "fill", typeof(Fill) );
-			_border = (Border) info.GetValue( "border", typeof(Border) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-		}
-	#endregion
-	
-	#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// Convert the arrow coordinates from the user coordinate system
-			// to the screen coordinate system
-			RectangleF pixRect = this.Location.TransformRect( pane );
-
-			// Clip the rect to just outside the PaneRect so we don't end up with wild coordinates.
-			RectangleF tmpRect = pane.Rect;
-			tmpRect.Inflate( 20, 20 );
-			pixRect.Intersect( tmpRect );
-
-			if (	Math.Abs( pixRect.Left ) < 100000 &&
-					Math.Abs( pixRect.Top ) < 100000 &&
-					Math.Abs( pixRect.Right ) < 100000 &&
-					Math.Abs( pixRect.Bottom ) < 100000 )
-			{
-				// If the box is to be filled, fill it
-				_fill.Draw( g, pixRect );
-				
-				// Draw the border around the box if required
-				_border.Draw( g, pane, scaleFactor, pixRect );
-			}
-		}
-		
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="BoxObj"/>.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-				return false;
-
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			RectangleF pixRect = _location.TransformRect( pane );
-
-			return pixRect.Contains( pt );
-		}
-
-		/// <summary>
-		/// Determines the shape type and Coords values for this GraphObj
-		/// </summary>
-		override public void GetCoords( PaneBase pane, Graphics g, float scaleFactor,
-				out string shape, out string coords )
-		{
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			RectangleF pixRect = _location.TransformRect( pane );
-
-			shape = "rect";
-			coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-						pixRect.Left, pixRect.Top, pixRect.Right, pixRect.Bottom );
-		}
-
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/Chart.cs b/BDInfo/ZedGraph/Chart.cs
deleted file mode 100644
index 4e3fcb91c4..0000000000
--- a/BDInfo/ZedGraph/Chart.cs
+++ /dev/null
@@ -1,256 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the properties of the charting area (where the curves are
-	/// actually drawn), which is bounded by the <see cref="XAxis" />, <see cref="YAxis"/>,
-	/// and <see cref="Y2Axis" />.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class Chart : ICloneable, ISerializable
-	{
-		/// <summary>
-		/// The rectangle that contains the area bounded by the axes, in pixel units
-		/// </summary>
-		internal RectangleF _rect;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Chart"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		internal Fill _fill;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Border"/> data for this
-		/// <see cref="Chart"/>.  Use the public property <see cref="Border"/> to
-		/// access this value.
-		/// </summary>
-		internal Border _border;
-
-		/// <summary>Private field that determines if the <see cref="Rect"/> will be
-		/// sized automatically.  Use the public property <see cref="IsRectAuto"/> to access
-		/// this value. </summary>
-		internal bool _isRectAuto;
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor.
-		/// </summary>
-		public Chart()
-		{
-			_isRectAuto = true;
-			_border = new Border( Default.IsBorderVisible, Default.BorderColor, Default.BorderPenWidth );
-			_fill = new Fill( Default.FillColor, Default.FillBrush, Default.FillType );
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">The source <see cref="Chart" /> to be copied.</param>
-		public Chart( Chart rhs )
-		{
-			_border = rhs._border.Clone();
-			_fill = rhs._fill.Clone();
-			_rect = rhs._rect;
-			_isRectAuto = rhs._isRectAuto;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Chart Clone()
-		{
-			return new Chart( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the rectangle that contains the area bounded by the axes
-		/// (<see cref="XAxis"/>, <see cref="YAxis"/>, and <see cref="Y2Axis"/>).
-		/// If you set this value manually, then the <see cref="IsRectAuto"/>
-		/// value will automatically be set to false.
-		/// </summary>
-		/// <value>The rectangle units are in screen pixels</value>
-		public RectangleF Rect
-		{
-			get { return _rect; }
-			set { _rect = value; _isRectAuto = false; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Chart"/>.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Border"/> class for drawing the border
-		/// border around the <see cref="Chart"/>
-		/// </summary>
-		/// <seealso cref="Default.BorderColor"/>
-		/// <seealso cref="Default.BorderPenWidth"/>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a boolean value that determines whether or not the 
-		/// <see cref="Rect"/> will be calculated automatically (almost always true).
-		/// </summary>
-		/// <remarks>
-		/// If you have a need to set the ChartRect manually, such as you have multiple graphs
-		/// on a page and you want to line up the edges perfectly, you can set this value
-		/// to false.  If you set this value to false, you must also manually set
-		/// the <see cref="Rect"/> property.
-		/// You can easily determine the ChartRect that ZedGraph would have
-		/// calculated by calling the <see cref="GraphPane.CalcChartRect(Graphics)"/> method, which returns
-		/// a chart rect sized for the current data range, scale sizes, etc.
-		/// </remarks>
-		/// <value>true to have ZedGraph calculate the ChartRect, false to do it yourself</value>
-		public bool IsRectAuto
-		{
-			get { return _isRectAuto; }
-			set { _isRectAuto = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Chart( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_rect = (RectangleF)info.GetValue( "rect", typeof( RectangleF ) );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_isRectAuto = info.GetBoolean( "isRectAuto" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "rect", _rect );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "isRectAuto", _isRectAuto );
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Chart"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default color for the <see cref="Chart"/> border.
-			/// (<see cref="Chart.Border"/> property). 
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color for the <see cref="Chart"/> background.
-			/// (<see cref="Chart.Fill"/> property). 
-			/// </summary>
-			public static Color FillColor = Color.White;
-			/// <summary>
-			/// The default brush for the <see cref="GraphPane.Chart"/> background.
-			/// (<see cref="ZedGraph.Fill.Brush"/> property of <see cref="Chart.Fill"/>). 
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default <see cref="FillType"/> for the <see cref="GraphPane.Chart"/> background.
-			/// (<see cref="ZedGraph.Fill.Type"/> property of <see cref="Chart.Fill"/>). 
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-			/// <summary>
-			/// The default pen width for drawing the 
-			/// <see cref="GraphPane.Chart"/> border
-			/// (<see cref="Chart.Border"/> property).
-			/// Units are in points (1/72 inch).
-			/// </summary>
-			public static float BorderPenWidth = 1F;
-			/// <summary>
-			/// The default display mode for the <see cref="Chart"/> border
-			/// (<see cref="Chart.Border"/> property). true
-			/// to show the border border, false to omit the border
-			/// </summary>
-			public static bool IsBorderVisible = true;
-
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/CollectionPlus.cs b/BDInfo/ZedGraph/CollectionPlus.cs
deleted file mode 100644
index c0a7d94161..0000000000
--- a/BDInfo/ZedGraph/CollectionPlus.cs
+++ /dev/null
@@ -1,162 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright (C) 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection base class containing basic extra functionality to be inherited
-	/// by <see cref="CurveList"/>, <see cref="IPointList"/>,
-	/// <see cref="GraphObjList"/>.
-	/// </summary>
-	/// <remarks>The methods in this collection operate on basic
-	/// <see cref="object"/> types.  Therefore, in order to make sure that
-	/// the derived classes remain strongly-typed, there are no Add() or
-	/// Insert() methods here, and no methods that return an object.
-	/// Only Remove(), Move(), IndexOf(), etc. methods are included.</remarks>
-	/// 
-	/// <author> John Champion</author>
-	/// <version> $Revision: 3.8 $ $Date: 2006/06/24 20:26:43 $ </version>
-	[Serializable]
-	public class CollectionPlus : CollectionBase
-	{
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public CollectionPlus() : base()
-		{
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the specified object
-		/// in the collection.
-		/// </summary>
-		/// <param name="item">A reference to the object that is to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified object, or -1 if the
-		/// object is not in the list</returns>
-		/// <seealso cref="IList.IndexOf"/>
-		public int IndexOf( object item )
-		{
-			return List.IndexOf( item );
-		}
-
-		/// <summary>
-		/// Remove an object from the collection at the specified ordinal location.
-		/// </summary>
-		/// <param name="index">
-		/// An ordinal position in the list at which the object to be removed 
-		/// is located.
-		/// </param>
-		/// <seealso cref="IList.Remove"/>
-		public void Remove( int index )
-		{
-			if ( index >= 0 && index < List.Count )
-				List.RemoveAt( index );
-		}
-
-		/// <summary>
-		/// Remove an object from the collection based on an object reference.
-		/// </summary>
-		/// <param name="item">A reference to the object that is to be
-		/// removed.</param>
-		/// <seealso cref="IList.Remove"/>
-		public void Remove( object item )
-		{
-			List.Remove( item );
-		}
-
-		/// <summary>
-		/// Move the position of the object at the specified index
-		/// to the new relative position in the list.</summary>
-		/// <remarks>For Graphic type objects, this method controls the
-		/// Z-Order of the items.  Objects at the beginning of the list
-		/// appear in front of objects at the end of the list.</remarks>
-		/// <param name="index">The zero-based index of the object
-		/// to be moved.</param>
-		/// <param name="relativePos">The relative number of positions to move
-		/// the object.  A value of -1 will move the
-		/// object one position earlier in the list, a value
-		/// of 1 will move it one position later.  To move an item to the
-		/// beginning of the list, use a large negative value (such as -999).
-		/// To move it to the end of the list, use a large positive value.
-		/// </param>
-		/// <returns>The new position for the object, or -1 if the object
-		/// was not found.</returns>
-		public int Move( int index, int relativePos )
-		{
-			if ( index < 0 || index >= List.Count )
-				return -1;
-			object obj = List[index];
-			List.RemoveAt( index );
-			index += relativePos;
-			if ( index < 0 )
-				index = 0;
-			if ( index > List.Count )
-				index = List.Count;
-			List.Insert( index, obj );
-			return index;
-		}
-
-	/*	
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 1;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected CollectionPlus( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema", schema );
-		}
-	#endregion
-*/
-	}
-}
diff --git a/BDInfo/ZedGraph/ColorSymbolRotator.cs b/BDInfo/ZedGraph/ColorSymbolRotator.cs
deleted file mode 100644
index 9f03e17691..0000000000
--- a/BDInfo/ZedGraph/ColorSymbolRotator.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using Color		 = System.Drawing.Color;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class used to get the next color/symbol for GraphPane.AddCurve methods.
-	/// </summary>
-	/// 
-	/// <author> Jerry Vos modified by John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2006/06/24 20:26:43 $ </version>
-	public class ColorSymbolRotator
-	{
-	#region Static fields
-		/// <summary>
-		/// The <see cref="Color"/>s <see cref="ColorSymbolRotator"/> 
-		/// rotates through.
-		/// </summary>
-		public static readonly Color[] COLORS = new Color[]
-		{
-			Color.Red,
-			Color.Blue,
-			Color.Green,
-			Color.Purple,
-			Color.Cyan,
-			Color.Pink,
-			Color.LightBlue,
-			Color.PaleVioletRed,
-			Color.SeaGreen,
-			Color.Yellow
-		};
-
-		/// <summary>
-		/// The <see cref="SymbolType"/>s <see cref="ColorSymbolRotator"/> 
-		/// rotates through.
-		/// </summary>
-		public static readonly SymbolType[] SYMBOLS = new SymbolType[]
-		{
-			SymbolType.Circle,
-			SymbolType.Diamond,
-			SymbolType.Plus,
-			SymbolType.Square,
-			SymbolType.Star,
-			SymbolType.Triangle,
-			SymbolType.TriangleDown,
-			SymbolType.XCross,
-			SymbolType.HDash,
-			SymbolType.VDash
-		};		
-
-		private static ColorSymbolRotator _staticInstance;
-	#endregion
-	
-	#region Fields
-		/// <summary>
-		/// The index of the next color to be used. Note: may be 
-		/// > COLORS.Length, it is reset to 0 on the next call if it is.
-		/// </summary>
-		protected int colorIndex = 0;
-
-		/// <summary>
-		/// The index of the next symbol to be used. Note: may be 
-		/// > SYMBOLS.Length, it is reset to 0 on the next call if it is.
-		/// </summary>
-		protected int symbolIndex = 0;
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Retrieves the next color in the rotation  Calling this
-		/// method has the side effect of incrementing the color index.
-		/// <seealso cref="NextSymbol"/>
-		/// <seealso cref="NextColorIndex"/>
-		/// </summary>
-		public Color NextColor
-		{
-			get { return COLORS[NextColorIndex]; }
-		}
-
-		/// <summary>
-		/// Retrieves the index of the next color to be used.  Calling this
-		/// method has the side effect of incrementing the color index.
-		/// </summary>
-		public int NextColorIndex
-		{
-			get
-			{
-				if (colorIndex >= COLORS.Length)
-					colorIndex = 0;
-
-				return colorIndex++;
-			}
-			set
-			{
-				colorIndex = value;
-			}
-		}
-
-		/// <summary>
-		/// Retrieves the next color in the rotation.  Calling this
-		/// method has the side effect of incrementing the symbol index.
-		/// <seealso cref="NextColor"/>
-		/// <seealso cref="NextSymbolIndex"/>
-		/// </summary>
-		public SymbolType NextSymbol
-		{
-			get { return SYMBOLS[NextSymbolIndex]; }
-		}
-
-		/// <summary>
-		/// Retrieves the index of the next symbol to be used.  Calling this
-		/// method has the side effect of incrementing the symbol index.
-		/// </summary>
-		public int NextSymbolIndex
-		{
-			get
-			{
-				if (symbolIndex >= SYMBOLS.Length)
-					symbolIndex = 0;
-
-				return symbolIndex++;
-			}
-			set
-			{
-				symbolIndex = value;
-			}
-		}
-
-		/// <summary>
-		/// Retrieves the <see cref="ColorSymbolRotator"/> instance used by the
-		/// static methods.
-		/// <seealso cref="StaticNextColor"/>
-		/// <seealso cref="StaticNextSymbol"/>
-		/// </summary>
-		public static ColorSymbolRotator StaticInstance
-		{
-			get
-			{
-				if (_staticInstance == null)
-					_staticInstance = new ColorSymbolRotator();
-
-				return _staticInstance;
-			}
-		}
-		
-		/// <summary>
-		/// Retrieves the next color from this class's static 
-		/// <see cref="ColorSymbolRotator"/> instance
-		/// <seealso cref="StaticInstance"/>
-		/// <seealso cref="StaticNextSymbol"/>
-		/// </summary>
-		public static Color StaticNextColor
-		{
-			get { return StaticInstance.NextColor; } 
-		}
-
-		/// <summary>
-		/// Retrieves the next symbol type from this class's static 
-		/// <see cref="ColorSymbolRotator"/> instance
-		/// <seealso cref="StaticInstance"/>
-		/// <seealso cref="StaticNextColor"/>
-		/// </summary>
-		public static SymbolType StaticNextSymbol
-		{
-			get { return StaticInstance.NextSymbol; } 
-		}
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/CurveItem.cs b/BDInfo/ZedGraph/CurveItem.cs
deleted file mode 100644
index 3fd84229a4..0000000000
--- a/BDInfo/ZedGraph/CurveItem.cs
+++ /dev/null
@@ -1,1229 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#if ( !DOTNET1 )	// Is this a .Net 2 compilation?
-using System.Collections.Generic;
-#endif
-
-namespace ZedGraph
-{
-	
-	/// <summary>
-	/// This class contains the data and methods for an individual curve within
-	/// a graph pane.  It carries the settings for the curve including the
-	/// key and item names, colors, symbols and sizes, linetypes, etc.
-	/// </summary>
-	/// 
-	/// <author> John Champion
-	/// modified by Jerry Vos </author>
-	/// <version> $Revision: 3.43 $ $Date: 2007/11/03 04:41:28 $ </version>
-	[Serializable]
-	abstract public class CurveItem : ISerializable, ICloneable
-	{
-	
-	#region Fields
-
-		/// <summary>
-		/// protected field that stores a <see cref="Label" /> instance for this
-		/// <see cref="CurveItem"/>, which is used for the <see cref="Legend" />
-		/// label.  Use the public
-		/// property <see cref="Label"/> to access this value.
-		/// </summary>
-		internal Label _label;
-
-		/// <summary>
-		/// protected field that stores the boolean value that determines whether this
-		/// <see cref="CurveItem"/> is on the bottom X axis or the top X axis (X2).
-		/// Use the public property <see cref="IsX2Axis"/> to access this value.
-		/// </summary>
-		protected bool _isX2Axis;
-		/// <summary>
-		/// protected field that stores the boolean value that determines whether this
-		/// <see cref="CurveItem"/> is on the left Y axis or the right Y axis (Y2).
-		/// Use the public property <see cref="IsY2Axis"/> to access this value.
-		/// </summary>
-		protected bool _isY2Axis;
-
-		/// <summary>
-		/// protected field that stores the index number of the Y Axis to which this
-		/// <see cref="CurveItem" /> belongs.  Use the public property <see cref="YAxisIndex" />
-		/// to access this value.
-		/// </summary>
-		protected int		_yAxisIndex;
-
-		/// <summary>
-		/// protected field that stores the boolean value that determines whether this
-		/// <see cref="CurveItem"/> is visible on the graph.
-		/// Use the public property <see cref="IsVisible"/> to access this value.
-		/// Note that this value turns the curve display on or off, but it does not
-		/// affect the display of the legend entry.  To hide the legend entry, you
-		/// have to set <see cref="ZedGraph.Label.IsVisible"/> to false.
-		/// </summary>
-		protected bool		_isVisible;
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Protected field that stores the boolean value that determines whether this
-		/// <see cref="CurveItem"/> is selected on the graph.
-		/// Use the public property <see cref="IsSelected"/> to access this value.
-		/// Note that this value changes the curve display color, but it does not
-		/// affect the display of the legend entry.  To hide the legend entry, you
-		/// have to set <see cref="ZedGraph.Label.IsVisible"/> to false.
-		/// </summary>
-		protected bool _isSelected;
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Protected field that stores the boolean value that determines whether this
-		/// <see cref="CurveItem"/> can be selected in the graph.
-		/// </summary>
-		protected bool _isSelectable;
-
-		/// <summary>
-		/// protected field that stores a boolean value which allows you to override the normal
-		/// ordinal axis behavior.  Use the public property <see cref="IsOverrideOrdinal"/> to
-		/// access this value.
-		/// </summary>
-		protected bool		_isOverrideOrdinal;
-		
-		/// <summary>
-		/// The <see cref="IPointList"/> of value sets that
-		/// represent this <see cref="CurveItem"/>.
-		/// The size of this list determines the number of points that are
-		/// plotted.  Note that values defined as
-		/// System.Double.MaxValue are considered "missing" values
-		/// (see <see cref="PointPairBase.Missing"/>),
-		/// and are not plotted.  The curve will have a break at these points
-		/// to indicate the values are missing.
-		/// </summary>
-		protected IPointList _points;
-
-		/// <summary>
-		/// A tag object for use by the user.  This can be used to store additional
-		/// information associated with the <see cref="CurveItem"/>.  ZedGraph does
-		/// not use this value for any purpose.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag;
-
-		/// <summary>
-		/// Protected field that stores the hyperlink information for this object.
-		/// </summary>
-		internal Link _link;
-
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// <see cref="CurveItem"/> constructor the pre-specifies the curve label, the
-		/// x and y data values as a <see cref="IPointList"/>, the curve
-		/// type (Bar or Line/Symbol), the <see cref="Color"/>, and the
-		/// <see cref="SymbolType"/>. Other properties of the curve are
-		/// defaulted to the values in the <see cref="GraphPane.Default"/> class.
-		/// </summary>
-		/// <param name="label">A string label (legend entry) for this curve</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		public CurveItem( string label, double[] x, double[] y ) :
-				this( label, new PointPairList( x, y ) )
-		{
-		}
-/*	
-		public CurveItem( string _label, int  y ) : this(  _label, new IPointList( ) )
-		{
-		}
-*/
-		/// <summary>
-		/// <see cref="CurveItem"/> constructor the pre-specifies the curve label, the
-		/// x and y data values as a <see cref="IPointList"/>, the curve
-		/// type (Bar or Line/Symbol), the <see cref="Color"/>, and the
-		/// <see cref="SymbolType"/>. Other properties of the curve are
-		/// defaulted to the values in the <see cref="GraphPane.Default"/> class.
-		/// </summary>
-		/// <param name="label">A string label (legend entry) for this curve</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		public CurveItem( string label, IPointList points )
-		{
-			Init( label );
-
-			if ( points == null )
-				_points = new PointPairList();
-			else
-				//this.points = (IPointList) _points.Clone();
-				_points = points;
-		}
-		
-		/// <summary>
-		/// Internal initialization routine thats sets some initial values to defaults.
-		/// </summary>
-		/// <param name="label">A string label (legend entry) for this curve</param>
-		private void Init( string label )
-		{
-			_label = new Label( label, null );
-			_isY2Axis = false;
-			_isX2Axis = false;
-			_isVisible = true;
-			_isOverrideOrdinal = false;
-			this.Tag = null;
-			_yAxisIndex = 0;
-			_link = new Link();
-		}
-			
-		/// <summary>
-		/// <see cref="CurveItem"/> constructor that specifies the label of the CurveItem.
-		/// This is the same as <c>CurveItem(label, null, null)</c>.
-		/// <seealso cref="CurveItem( string, double[], double[] )"/>
-		/// </summary>
-		/// <param name="label">A string label (legend entry) for this curve</param>
-		public CurveItem( string label ): this( label, null )
-		{
-		}
-		 /// <summary>
-		 /// 
-		 /// </summary>
-		public CurveItem(  )
-		{
-			Init( null );
-		}
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The CurveItem object from which to copy</param>
-		public CurveItem( CurveItem rhs )
-		{
-			_label = rhs._label.Clone();
-			_isY2Axis = rhs.IsY2Axis;
-			_isX2Axis = rhs.IsX2Axis;
-			_isVisible = rhs.IsVisible;
-			_isOverrideOrdinal = rhs._isOverrideOrdinal;
-			_yAxisIndex = rhs._yAxisIndex;
-
-			if ( rhs.Tag is ICloneable )
-				this.Tag = ((ICloneable) rhs.Tag).Clone();
-			else
-				this.Tag = rhs.Tag;
-			
-			_points = (IPointList) rhs.Points.Clone();
-
-			_link = rhs._link.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected CurveItem( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_label = (Label) info.GetValue( "label", typeof(Label) );
-			_isY2Axis = info.GetBoolean( "isY2Axis" );
-			if ( sch >= 11 )
-				_isX2Axis = info.GetBoolean( "isX2Axis" );
-			else
-				_isX2Axis = false;
-
-			_isVisible = info.GetBoolean( "isVisible" );
-
-			_isOverrideOrdinal = info.GetBoolean( "isOverrideOrdinal" );
-
-			// Data Points are always stored as a PointPairList, regardless of the
-			// actual original type (which could be anything that supports IPointList).
-			_points = (PointPairList) info.GetValue( "points", typeof(PointPairList) );
-
-			Tag = info.GetValue( "Tag", typeof(object) );
-
-			_yAxisIndex = info.GetInt32( "yAxisIndex" );
-
-			_link = (Link) info.GetValue( "link", typeof(Link) );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "label", _label );
-			info.AddValue( "isY2Axis", _isY2Axis );
-			info.AddValue( "isX2Axis", _isX2Axis );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "isOverrideOrdinal", _isOverrideOrdinal );
-
-			// if points is already a PointPairList, use it
-			// otherwise, create a new PointPairList so it can be serialized
-			PointPairList list;
-			if ( _points is PointPairList )
-				list = _points as PointPairList;
-			else
-				list = new PointPairList( _points );
-
-			info.AddValue( "points", list );
-			info.AddValue( "Tag", Tag );
-			info.AddValue( "yAxisIndex", _yAxisIndex );
-
-			info.AddValue( "link", _link );
-		}
-	#endregion
-	
-	#region Properties
-		/// <summary>
-		/// A <see cref="Label" /> instance that represents the <see cref="ZedGraph.Legend"/>
-		/// entry for the this <see cref="CurveItem"/> object
-		/// </summary>
-		public Label Label
-		{
-			get { return _label; }
-			set { _label = value;}
-		}
-
-		/// <summary>
-		/// The <see cref="Line"/>/<see cref="Symbol"/>/<see cref="Bar"/> 
-		/// color (FillColor for the Bar).  This is a common access to
-		/// <see cref="ZedGraph.LineBase.Color">Line.Color</see>,
-		/// <see cref="ZedGraph.LineBase.Color">Border.Color</see>, and
-		/// <see cref="ZedGraph.Fill.Color">Fill.Color</see> properties for this curve.
-		/// </summary>
-		public Color Color
-		{
-			get
-			{
-				if ( this is BarItem )
-					return ((BarItem) this).Bar.Fill.Color;
-				else if ( this is LineItem && ((LineItem) this).Line.IsVisible )
-					return ((LineItem) this).Line.Color;
-				else if ( this is LineItem )
-					return ((LineItem) this).Symbol.Border.Color;
-				else if ( this is ErrorBarItem )
-					return ((ErrorBarItem) this).Bar.Color;
-				else if ( this is HiLowBarItem )
-					return ((HiLowBarItem) this).Bar.Fill.Color;
-				else
-					return Color.Empty;
-			}
-			set 
-			{
-				if ( this is BarItem )
-				{
-					((BarItem) this).Bar.Fill.Color = value;
-				}
-				else if ( this is LineItem )
-				{
-					((LineItem) this).Line.Color			= value;
-					((LineItem) this).Symbol.Border.Color	= value;
-					((LineItem) this).Symbol.Fill.Color		= value;
-				}
-				else if ( this is ErrorBarItem )
-					((ErrorBarItem) this).Bar.Color = value;
-				else if ( this is HiLowBarItem )
-					((HiLowBarItem) this).Bar.Fill.Color = value;
-			}
-		}
-
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/> is visible on the graph.
-		/// Note that this value turns the curve display on or off, but it does not
-		/// affect the display of the legend entry.  To hide the legend entry, you
-		/// have to set <see cref="ZedGraph.Label.IsVisible"/> to false.
-		/// </summary>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/> is selected on the graph.
-		/// Note that this value changes the curve displayed color, but it does not
-		/// affect the display of the legend entry. To hide the legend entry, you
-		/// have to set <see cref="ZedGraph.Label.IsVisible"/> to false.
-		/// </summary>
-		public bool IsSelected
-		{
-			get { return _isSelected; }
-			set
-			{
-				_isSelected = value;
-
-				/*
-				if ( this is BarItem )
-				{
-					( (BarItem)this ).Bar.Fill.UseInactiveColor = !value;
-				}
-				else if ( this is LineItem )
-				{
-					( (LineItem)this ).Line.Fill.UseInactiveColor = !value;
-					( (LineItem)this ).Symbol.Fill.UseInactiveColor = !value;
-					( (LineItem)this ).Symbol.Fill.UseInactiveColor = !value;
-				}
-				else if ( this is HiLowBarItem )
-					( (HiLowBarItem)this ).Bar.Fill.UseInactiveColor = !value;
-				else if ( this is PieItem )
-					( (PieItem)this ).Fill.UseInactiveColor = !value;
-				*/
-			}
-		}
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/> can be selected in the graph.
-		/// </summary>
-		public bool IsSelectable
-		{
-			get { return _isSelectable; }
-			set { _isSelectable = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value which allows you to override the normal
-		/// ordinal axis behavior.
-		/// </summary>
-		/// <remarks>
-		/// Normally for an ordinal axis type, the actual data values corresponding to the ordinal
-		/// axis will be ignored (essentially they are replaced by ordinal values, e.g., 1, 2, 3, etc).
-		/// If IsOverrideOrdinal is true, then the user data values will be used (even if they don't
-		/// make sense).  Fractional values are allowed, such that a value of 1.5 is between the first and
-		/// second ordinal position, etc.
-		/// </remarks>
-		/// <seealso cref="AxisType.Ordinal"/>
-		/// <seealso cref="AxisType.Text"/>
-		public bool IsOverrideOrdinal
-		{
-			get { return _isOverrideOrdinal; }
-			set { _isOverrideOrdinal = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which X axis this <see cref="CurveItem"/>
-		/// is assigned to.
-		/// </summary>
-		/// <remarks>
-		/// The
-		/// <see cref="ZedGraph.XAxis"/> is on the bottom side of the graph and the
-		/// <see cref="ZedGraph.X2Axis"/> is on the top side.  Assignment to an axis
-		/// determines the scale that is used to draw the curve on the graph.
-		/// </remarks>
-		/// <value>true to assign the curve to the <see cref="ZedGraph.X2Axis"/>,
-		/// false to assign the curve to the <see cref="ZedGraph.XAxis"/></value>
-		public bool IsX2Axis
-		{
-			get { return _isX2Axis; }
-			set { _isX2Axis = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which Y axis this <see cref="CurveItem"/>
-		/// is assigned to.
-		/// </summary>
-		/// <remarks>
-		/// The
-		/// <see cref="ZedGraph.YAxis"/> is on the left side of the graph and the
-		/// <see cref="ZedGraph.Y2Axis"/> is on the right side.  Assignment to an axis
-		/// determines the scale that is used to draw the curve on the graph.  Note that
-		/// this value is used in combination with the <see cref="YAxisIndex" /> to determine
-		/// which of the Y Axes (if there are multiples) this curve belongs to.
-		/// </remarks>
-		/// <value>true to assign the curve to the <see cref="ZedGraph.Y2Axis"/>,
-		/// false to assign the curve to the <see cref="ZedGraph.YAxis"/></value>
-		public bool IsY2Axis
-		{
-			get { return _isY2Axis; }
-			set { _isY2Axis = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the index number of the Y Axis to which this
-		/// <see cref="CurveItem" /> belongs.
-		/// </summary>
-		/// <remarks>
-		/// This value is essentially an index number into the <see cref="GraphPane.YAxisList" />
-		/// or <see cref="GraphPane.Y2AxisList" />, depending on the setting of
-		/// <see cref="IsY2Axis" />.
-		/// </remarks>
-		public int YAxisIndex
-		{
-			get { return _yAxisIndex; }
-			set { _yAxisIndex = value; }
-		}
-
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/>
-		/// is a <see cref="BarItem"/>.
-		/// </summary>
-		/// <value>true for a bar chart, or false for a line or pie graph</value>
-		public bool IsBar
-		{
-			get { return this is BarItem || this is HiLowBarItem || this is ErrorBarItem; }
-		}
-		
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/>
-		/// is a <see cref="PieItem"/>.
-		/// </summary>
-		/// <value>true for a pie chart, or false for a line or bar graph</value>
-		public bool IsPie
-		{
-			get { return this is PieItem; }
-		}
-		
-		/// <summary>
-		/// Determines whether this <see cref="CurveItem"/>
-		/// is a <see cref="LineItem"/>.
-		/// </summary>
-		/// <value>true for a line chart, or false for a bar type</value>
-		public bool IsLine
-		{
-			get { return this is LineItem; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		abstract internal bool IsZIncluded( GraphPane pane );
-		
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		abstract internal bool IsXIndependent( GraphPane pane );
-		
-		/// <summary>
-		/// Readonly property that gives the number of points that define this
-		/// <see cref="CurveItem"/> object, which is the number of points in the
-		/// <see cref="Points"/> data collection.
-		/// </summary>
-		public int NPts
-		{
-			get 
-			{
-				if ( _points == null )
-					return 0;
-				else
-					return _points.Count;
-			}
-		}
-		
-		/// <summary>
-		/// The <see cref="IPointList"/> of X,Y point sets that represent this
-		/// <see cref="CurveItem"/>.
-		/// </summary>
-		public IPointList Points
-		{
-			get { return _points; }
-			set { _points = value; }
-		}
-
-		/// <summary>
-		/// An accessor for the <see cref="PointPair"/> datum for this <see cref="CurveItem"/>.
-		/// Index is the ordinal reference (zero based) of the point.
-		/// </summary>
-		public PointPair this[int index]
-		{
-			get
-			{
-				if ( _points == null )
-					return new PointPair( PointPair.Missing, PointPair.Missing );
-				else
-					return ( _points )[index];
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets the hyperlink information for this <see cref="CurveItem" />.
-		/// </summary>
-		// /// <seealso cref="ZedGraph.Web.IsImageMap" />
-		public Link Link
-		{
-			get { return _link; }
-			set { _link = value; }
-		}
-
-	#endregion
-	
-	#region Rendering Methods
-		/// <summary>
-		/// Do all rendering associated with this <see cref="CurveItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="Bar"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		abstract public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor  );
-		
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="CurveItem"/> at the specified location.
-		/// This abstract base method passes through to <see cref="BarItem.DrawLegendKey"/> or
-		/// <see cref="LineItem.DrawLegendKey"/> to do the rendering.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-        /// <param name="pane">
-        /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-        /// owner of this object.
-        /// </param>
-        /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-        /// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		abstract public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor );
-		
-	#endregion
-
-	#region Utility Methods
-
-		/// <summary>
-		/// Add a single x,y coordinate point to the end of the points collection for this curve.
-		/// </summary>
-		/// <param name="x">The X coordinate value</param>
-		/// <param name="y">The Y coordinate value</param>
-		public void AddPoint( double x, double y )
-		{
-			this.AddPoint( new PointPair( x, y ) );
-		}
-
-		/// <summary>
-		/// Add a <see cref="PointPair"/> object to the end of the points collection for this curve.
-		/// </summary>
-		/// <remarks>
-		/// This method will only work if the <see cref="IPointList" /> instance reference
-		/// at <see cref="Points" /> supports the <see cref="IPointListEdit" /> interface.
-		/// Otherwise, it does nothing.
-		/// </remarks>
-		/// <param name="point">A reference to the <see cref="PointPair"/> object to
-		/// be added</param>
-		public void AddPoint( PointPair point )
-		{
-			if ( _points == null )
-				this.Points = new PointPairList();
-
-			if ( _points is IPointListEdit )
-				( _points as IPointListEdit ).Add( point );
-			else
-				throw new NotImplementedException();
-		}
-
-		/// <summary>
-		/// Clears the points from this <see cref="CurveItem"/>.  This is the same
-		/// as <c>CurveItem.Points.Clear()</c>.
-		/// </summary>
-		/// <remarks>
-		/// This method will only work if the <see cref="IPointList" /> instance reference
-		/// at <see cref="Points" /> supports the <see cref="IPointListEdit" /> interface.
-		/// Otherwise, it does nothing.
-		/// </remarks>
-		public void Clear()
-		{
-			if ( _points is IPointListEdit )
-				(_points as IPointListEdit).Clear();
-			else
-				throw new NotImplementedException();
-		}
-
-		/// <summary>
-		/// Removes a single point from this <see cref="CurveItem" />.
-		/// </summary>
-		/// <remarks>
-		/// This method will only work if the <see cref="IPointList" /> instance reference
-		/// at <see cref="Points" /> supports the <see cref="IPointListEdit" /> interface.
-		/// Otherwise, it does nothing.
-		/// </remarks>
-		/// <param name="index">The ordinal position of the point to be removed.</param>
-		public void RemovePoint( int index )
-		{
-			if ( _points is IPointListEdit )
-				(_points as IPointListEdit).RemoveAt( index );
-			else
-				throw new NotImplementedException();
-		}
-
-		/// <summary>
-		/// Get the X Axis instance (either <see cref="XAxis" /> or <see cref="X2Axis" />) to
-		/// which this <see cref="CurveItem" /> belongs.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param>
-		/// <returns>Either a <see cref="XAxis" /> or <see cref="X2Axis" /> to which this
-		/// <see cref="CurveItem" /> belongs.
-		/// </returns>
-		public Axis GetXAxis( GraphPane pane )
-		{
-			if ( _isX2Axis )
-				return pane.X2Axis;
-			else
-				return pane.XAxis;
-		}
-
-		/// <summary>
-		/// Get the Y Axis instance (either <see cref="YAxis" /> or <see cref="Y2Axis" />) to
-		/// which this <see cref="CurveItem" /> belongs.
-		/// </summary>
-		/// <remarks>
-		/// This method safely retrieves a Y Axis instance from either the <see cref="GraphPane.YAxisList" />
-		/// or the <see cref="GraphPane.Y2AxisList" /> using the values of <see cref="YAxisIndex" /> and
-		/// <see cref="IsY2Axis" />.  If the value of <see cref="YAxisIndex" /> is out of bounds, the
-		/// default <see cref="YAxis" /> or <see cref="Y2Axis" /> is used.
-		/// </remarks>
-		/// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param>
-		/// <returns>Either a <see cref="YAxis" /> or <see cref="Y2Axis" /> to which this
-		/// <see cref="CurveItem" /> belongs.
-		/// </returns>
-		public Axis GetYAxis( GraphPane pane )
-		{
-			if ( _isY2Axis )
-			{
-				if ( _yAxisIndex < pane.Y2AxisList.Count )
-					return pane.Y2AxisList[_yAxisIndex];
-				else
-					return pane.Y2AxisList[0];
-			}
-			else
-			{
-				if ( _yAxisIndex < pane.YAxisList.Count )
-					return pane.YAxisList[_yAxisIndex];
-				else
-					return pane.YAxisList[0];
-			}
-		}
-
-		/// <summary>
-		/// Get the index of the Y Axis in the <see cref="YAxis" /> or <see cref="Y2Axis" /> list to
-		/// which this <see cref="CurveItem" /> belongs.
-		/// </summary>
-		/// <remarks>
-		/// This method safely retrieves a Y Axis index into either the <see cref="GraphPane.YAxisList" />
-		/// or the <see cref="GraphPane.Y2AxisList" /> using the values of <see cref="YAxisIndex" /> and
-		/// <see cref="IsY2Axis" />.  If the value of <see cref="YAxisIndex" /> is out of bounds, the
-		/// default <see cref="YAxis" /> or <see cref="Y2Axis" /> is used, which is index zero.
-		/// </remarks>
-		/// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param>
-		/// <returns>An integer value indicating which index position in the list applies to this
-		/// <see cref="CurveItem" />
-		/// </returns>
-		public int GetYAxisIndex( GraphPane pane )
-		{
-			if ( _yAxisIndex >= 0 &&
-					_yAxisIndex < ( _isY2Axis ? pane.Y2AxisList.Count : pane.YAxisList.Count ) )
-				return _yAxisIndex;
-			else
-				return 0;
-		}
-
-		/// <summary>
-		/// Loads some pseudo unique colors/symbols into this CurveItem.  This
-		/// is the same as <c>MakeUnique(ColorSymbolRotator.StaticInstance)</c>.
-		/// <seealso cref="ColorSymbolRotator.StaticInstance"/>
-		/// <seealso cref="ColorSymbolRotator"/>
-		/// <seealso cref="MakeUnique(ColorSymbolRotator)"/>
-		/// </summary>
-		public void MakeUnique()
-		{
-			this.MakeUnique( ColorSymbolRotator.StaticInstance );
-		}
-
-		/// <summary>
-		/// Loads some pseudo unique colors/symbols into this CurveItem.  This
-		/// is mainly useful for differentiating a set of new CurveItems without
-		/// having to pick your own colors/symbols.
-		/// <seealso cref="MakeUnique(ColorSymbolRotator)"/>
-		/// </summary>
-		/// <param name="rotator">
-		/// The <see cref="ColorSymbolRotator"/> that is used to pick the color
-		///  and symbol for this method call.
-		/// </param>
-		virtual public void MakeUnique( ColorSymbolRotator rotator )
-		{
-			this.Color = rotator.NextColor;
-		}
-	
-		/// <summary>
-		/// Go through the list of <see cref="PointPair"/> data values for this <see cref="CurveItem"/>
-		/// and determine the minimum and maximum values in the data.
-		/// </summary>
-		/// <param name="xMin">The minimum X value in the range of data</param>
-		/// <param name="xMax">The maximum X value in the range of data</param>
-		/// <param name="yMin">The minimum Y value in the range of data</param>
-		/// <param name="yMax">The maximum Y value in the range of data</param>
-		/// <param name="ignoreInitial">ignoreInitial is a boolean value that
-		/// affects the data range that is considered for the automatic scale
-		/// ranging (see <see cref="GraphPane.IsIgnoreInitial"/>).  If true, then initial
-		/// data points where the Y value is zero are not included when
-		/// automatically determining the scale <see cref="Scale.Min"/>,
-		/// <see cref="Scale.Max"/>, and <see cref="Scale.MajorStep"/> size.  All data after
-		/// the first non-zero Y value are included.
-		/// </param>
-		/// <param name="isBoundedRanges">
-		/// Determines if the auto-scaled axis ranges will subset the
-		/// data points based on any manually set scale range values.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <seealso cref="GraphPane.IsBoundedRanges"/>
-		virtual public void GetRange( 	out double xMin, out double xMax,
-										out double yMin, out double yMax,
-										bool ignoreInitial,
-										bool isBoundedRanges,
-										GraphPane pane )
-		{
-			// The lower and upper bounds of allowable data for the X values.  These
-			// values allow you to subset the data values.  If the X range is bounded, then
-			// the resulting range for Y will reflect the Y values for the points within the X
-			// bounds.
-			double xLBound = double.MinValue;
-			double xUBound = double.MaxValue;
-			double yLBound = double.MinValue;
-			double yUBound = double.MaxValue;
-
-			// initialize the values to outrageous ones to start
-			xMin = yMin = Double.MaxValue;
-			xMax = yMax = Double.MinValue;
-
-			Axis yAxis = this.GetYAxis( pane );
-			Axis xAxis = this.GetXAxis( pane );
-			if ( yAxis == null || xAxis == null )
-				return;
-
-			if ( isBoundedRanges )
-			{
-				xLBound = xAxis._scale._lBound;
-				xUBound = xAxis._scale._uBound;
-				yLBound = yAxis._scale._lBound;
-				yUBound = yAxis._scale._uBound;
-			}
-
-
-			bool isZIncluded = this.IsZIncluded( pane );
-			bool isXIndependent = this.IsXIndependent( pane );
-			bool isXLog = xAxis.Scale.IsLog;
-			bool isYLog = yAxis.Scale.IsLog;
-			bool isXOrdinal = xAxis.Scale.IsAnyOrdinal;
-			bool isYOrdinal = yAxis.Scale.IsAnyOrdinal;
-			bool isZOrdinal = ( isXIndependent ? yAxis : xAxis ).Scale.IsAnyOrdinal;
-
-			// Loop over each point in the arrays
-			//foreach ( PointPair point in this.Points )
-			for ( int i=0; i<this.Points.Count; i++ )
-			{
-				PointPair point = this.Points[i];
-
-				double curX = isXOrdinal ? i + 1 : point.X;
-				double curY = isYOrdinal ? i + 1 : point.Y;
-				double curZ = isZOrdinal ? i + 1 : point.Z;
-
-				bool outOfBounds = curX < xLBound || curX > xUBound ||
-					curY < yLBound || curY > yUBound ||
-					( isZIncluded && isXIndependent && ( curZ < yLBound || curZ > yUBound ) ) ||
-					( isZIncluded && !isXIndependent && ( curZ < xLBound || curZ > xUBound ) ) ||
-					( curX <= 0 && isXLog ) || ( curY <= 0 && isYLog );
-			
-				// ignoreInitial becomes false at the first non-zero
-				// Y value
-				if (	ignoreInitial && curY != 0 &&
-						curY != PointPair.Missing )
-					ignoreInitial = false;
-			
-				if ( 	!ignoreInitial &&
-						!outOfBounds &&
-						curX != PointPair.Missing &&
-						curY != PointPair.Missing )
-				{
-					if ( curX < xMin )
-						xMin = curX;
-					if ( curX > xMax )
-						xMax = curX;
-					if ( curY < yMin )
-						yMin = curY;
-					if ( curY > yMax )
-						yMax = curY;
-
-					if ( isZIncluded && isXIndependent && curZ != PointPair.Missing )
-					{
-						if ( curZ < yMin )
-							yMin = curZ;
-						if ( curZ > yMax )
-							yMax = curZ;
-					}
-					else if ( isZIncluded && curZ != PointPair.Missing )
-					{
-						if ( curZ < xMin )
-							xMin = curZ;
-						if ( curZ > xMax )
-							xMax = curZ;
-					}
-				}
-			}	
-		}
-
-		/// <summary>Returns a reference to the <see cref="Axis"/> object that is the "base"
-		/// (independent axis) from which the values are drawn. </summary>
-		/// <remarks>
-		/// This property is determined by the value of <see cref="BarSettings.Base"/> for
-		/// <see cref="BarItem"/>, <see cref="ErrorBarItem"/>, and <see cref="HiLowBarItem"/>
-		/// types.  It is always the X axis for regular <see cref="LineItem"/> types.
-		/// Note that the <see cref="BarSettings.Base" /> setting can override the
-		/// <see cref="IsY2Axis" /> and <see cref="YAxisIndex" /> settings for bar types
-		/// (this is because all the bars that are clustered together must share the
-		/// same base axis).
-		/// </remarks>
-		/// <seealso cref="BarBase"/>
-		/// <seealso cref="ValueAxis"/>
-		public virtual Axis BaseAxis( GraphPane pane )
-		{
-			BarBase barBase;
-
-			if ( this is BarItem || this is ErrorBarItem || this is HiLowBarItem )
-				barBase = pane._barSettings.Base;
-			else
-				barBase = _isX2Axis ? BarBase.X2 : BarBase.X;
-
-			if ( barBase == BarBase.X )
-				return pane.XAxis;
-			else if ( barBase == BarBase.X2 )
-				return pane.X2Axis;
-			else if ( barBase == BarBase.Y )
-				return pane.YAxis;
-			else
-				return pane.Y2Axis;
-
-		}
-		/// <summary>Returns a reference to the <see cref="Axis"/> object that is the "value"
-		/// (dependent axis) from which the points are drawn. </summary>
-		/// <remarks>
-		/// This property is determined by the value of <see cref="BarSettings.Base"/> for
-		/// <see cref="BarItem"/>, <see cref="ErrorBarItem"/>, and <see cref="HiLowBarItem"/>
-		/// types.  It is always the Y axis for regular <see cref="LineItem"/> types.
-		/// </remarks>
-		/// <seealso cref="BarBase"/>
-		/// <seealso cref="BaseAxis"/>
-		public virtual Axis ValueAxis( GraphPane pane )
-		{
-			BarBase barBase;
-
-			if ( this is BarItem || this is ErrorBarItem || this is HiLowBarItem )
-				barBase = pane._barSettings.Base;
-			else
-				barBase = BarBase.X;
-
-			if ( barBase == BarBase.X || barBase == BarBase.X2 )
-			{
-				return GetYAxis( pane );
-			}
-			else
-				return GetXAxis( pane );
-		}
-
-		/// <summary>
-		/// Calculate the width of each bar, depending on the actual bar type
-		/// </summary>
-		/// <returns>The width for an individual bar, in pixel units</returns>
-		public float GetBarWidth( GraphPane pane )
-		{
-			// Total axis width = 
-			// npts * ( nbars * ( bar + bargap ) - bargap + clustgap )
-			// cg * bar = cluster gap
-			// npts = max number of points in any curve
-			// nbars = total number of curves that are of type IsBar
-			// bar = bar width
-			// bg * bar = bar gap
-			// therefore:
-			// totwidth = npts * ( nbars * (bar + bg*bar) - bg*bar + cg*bar )
-			// totwidth = bar * ( npts * ( nbars * ( 1 + bg ) - bg + cg ) )
-			// solve for bar
-
-			float barWidth;
-
-			if ( this is ErrorBarItem )
-				barWidth = (float) ( ((ErrorBarItem)this).Bar.Symbol.Size *
-						pane.CalcScaleFactor() );
-//			else if ( this is HiLowBarItem && pane._barSettings.Type != BarType.ClusterHiLow )
-//				barWidth = (float) ( ((HiLowBarItem)this).Bar.GetBarWidth( pane,
-//						((HiLowBarItem)this).BaseAxis(pane), pane.CalcScaleFactor() ) );
-//				barWidth = (float) ( ((HiLowBarItem)this).Bar.Size *
-//						pane.CalcScaleFactor() );
-			else // BarItem or LineItem
-			{
-				// For stacked bar types, the bar width will be based on a single bar
-				float numBars = 1.0F;
-				if ( pane._barSettings.Type == BarType.Cluster )
-					numBars = pane.CurveList.NumClusterableBars;
-
-				float denom = numBars * ( 1.0F + pane._barSettings.MinBarGap ) -
-							pane._barSettings.MinBarGap + pane._barSettings.MinClusterGap;
-				if ( denom <= 0 )
-					denom = 1;
-				barWidth = pane.BarSettings.GetClusterWidth() / denom;
-			}
-
-			if ( barWidth <= 0 )
-				return 1;
-
-			return barWidth;
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		abstract public bool GetCoords( GraphPane pane, int i, out string coords );
-
-	#endregion
-
-	#region Inner classes
-
-	#if ( DOTNET1 ) // Is this a .Net 1.1 compilation?
-	
-		/// <summary>
-		/// Compares <see cref="CurveItem"/>'s based on the point value at the specified
-		/// index and for the specified axis.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class Comparer : IComparer
-		{
-			private int index;
-			private SortType sortType;
-			
-			/// <summary>
-			/// Constructor for Comparer.
-			/// </summary>
-			/// <param name="type">The axis type on which to sort.</param>
-			/// <param name="index">The index number of the point on which to sort</param>
-			public Comparer( SortType type, int index )
-			{
-				this.sortType = type;
-				this.index = index;
-			}
-			
-			/// <summary>
-			/// Compares two <see cref="CurveItem"/>s using the previously specified index value
-			/// and axis.  Sorts in descending order.
-			/// </summary>
-			/// <param name="l">Curve to the left.</param>
-			/// <param name="r">Curve to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.X's relation to r.X</returns>
-			public int Compare( object l, object r ) 
-			{
-				CurveItem cl = (CurveItem) l;
-				CurveItem cr = (CurveItem) r;
-
-				if (cl == null && cr == null )
-					return 0;
-				else if (cl == null && cr != null ) 
-					return -1;
-				else if (cl != null && cr == null) 
-					return 1;
-
-				if ( cr != null && cr.NPts <= index )
-					cr = null;
-				if ( cl != null && cl.NPts <= index )
-					cl = null;
-						
-				double lVal, rVal;
-
-				if ( sortType == SortType.XValues )
-				{
-					lVal = ( l != null ) ? System.Math.Abs( cl[index].X ) : PointPair.Missing;
-					rVal = ( r != null ) ? System.Math.Abs( cr[index].X ) : PointPair.Missing;
-				}
-				else
-				{
-					lVal = ( l != null ) ? System.Math.Abs( cl[index].Y ) : PointPair.Missing;
-					rVal = ( r != null ) ? System.Math.Abs( cr[index].Y ) : PointPair.Missing;
-				}
-				
-				if ( lVal == PointPair.Missing || Double.IsInfinity( lVal ) || Double.IsNaN( lVal ) )
-					cl = null;
-				if ( rVal == PointPair.Missing || Double.IsInfinity( rVal ) || Double.IsNaN( rVal ) )
-					cr = null;
-					
-				if ( ( cl == null && cr == null) || ( System.Math.Abs( lVal - rVal ) < 1e-10 ) )
-					return 0;
-				else if ( cl == null && cr != null ) 
-					return -1;
-				else if ( cl != null && r == null ) 
-					return 1;
-				else
-					return rVal < lVal ? -1 : 1;
-			}
-		}
-	
-#else		// Otherwise, it's .Net 2.0 so use generics
-
-		/// <summary>
-		/// Compares <see cref="CurveItem"/>'s based on the point value at the specified
-		/// index and for the specified axis.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class Comparer : IComparer<CurveItem>
-		{
-			private int index;
-			private SortType sortType;
-			
-			/// <summary>
-			/// Constructor for Comparer.
-			/// </summary>
-			/// <param name="type">The axis type on which to sort.</param>
-			/// <param name="index">The index number of the point on which to sort</param>
-			public Comparer( SortType type, int index )
-			{
-				this.sortType = type;
-				this.index = index;
-			}
-			
-			/// <summary>
-			/// Compares two <see cref="CurveItem"/>s using the previously specified index value
-			/// and axis.  Sorts in descending order.
-			/// </summary>
-			/// <param name="l">Curve to the left.</param>
-			/// <param name="r">Curve to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.X's relation to r.X</returns>
-			public int Compare( CurveItem l, CurveItem r ) 
-			{
-				if (l == null && r == null )
-					return 0;
-				else if (l == null && r != null ) 
-					return -1;
-				else if (l != null && r == null) 
-					return 1;
-
-				if ( r != null && r.NPts <= index )
-					r = null;
-				if ( l != null && l.NPts <= index )
-					l = null;
-						
-				double lVal, rVal;
-
-				if ( sortType == SortType.XValues )
-				{
-					lVal = ( l != null ) ? System.Math.Abs( l[index].X ) : PointPair.Missing;
-					rVal = ( r != null ) ? System.Math.Abs( r[index].X ) : PointPair.Missing;
-				}
-				else
-				{
-					lVal = ( l != null ) ? System.Math.Abs( l[index].Y ) : PointPair.Missing;
-					rVal = ( r != null ) ? System.Math.Abs( r[index].Y ) : PointPair.Missing;
-				}
-				
-				if ( lVal == PointPair.Missing || Double.IsInfinity( lVal ) || Double.IsNaN( lVal ) )
-					l = null;
-				if ( rVal == PointPair.Missing || Double.IsInfinity( rVal ) || Double.IsNaN( rVal ) )
-					r = null;
-					
-				if ( (l == null && r == null) || ( System.Math.Abs( lVal - rVal ) < 1e-10 ) )
-					return 0;
-				else if (l == null && r != null ) 
-					return -1;
-				else if (l != null && r == null) 
-					return 1;
-				else
-					return rVal < lVal ? -1 : 1;
-			}
-		}
-
-	#endif
-	
-	#endregion
-
-	}
-}
-
-
-
diff --git a/BDInfo/ZedGraph/CurveList.cs b/BDInfo/ZedGraph/CurveList.cs
deleted file mode 100644
index 0a77a9bd4d..0000000000
--- a/BDInfo/ZedGraph/CurveList.cs
+++ /dev/null
@@ -1,745 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections.Generic;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="CurveItem"/> objects
-	/// that define the set of curves to be displayed on the graph.
-	/// </summary>
-	/// 
-	/// <author> John Champion
-	/// modified by Jerry Vos</author>
-	/// <version> $Revision: 3.43 $ $Date: 2007/11/03 04:41:28 $ </version>
-	[Serializable]
-	public class CurveList : List<CurveItem>, ICloneable
-	{
-
-	#region Properties
-		// internal temporary value that keeps
-		// the max number of points for any curve
-		// associated with this curveList
-		private int	maxPts;
-
-		/// <summary>
-		/// Read only value for the maximum number of points in any of the curves
-		/// in the list.
-		/// </summary>
-		public int MaxPts
-		{
-			get { return maxPts; }
-		}
-
-		/// <summary>
-		/// Read only property that returns the number of curves in the list that are of
-		/// type <see cref="BarItem"/>. This does not include <see cref="HiLowBarItem" /> or
-		/// <see cref="ErrorBarItem" /> types.
-		/// </summary>
-		public int NumBars
-		{
-			get
-			{
-				int count = 0;
-				foreach ( CurveItem curve in this )
-				{
-					if ( curve.IsBar )
-						count++;
-				}
-
-				return count;
-			}
-		}
-
-		/// <summary>
-		/// Read only property that returns the number of curves in the list that are
-		/// potentially "clusterable", which includes <see cref="BarItem"/> and
-		/// <see cref="HiLowBarItem" /> types. This does not include <see cref="ErrorBarItem" />,
-		/// <see cref="OHLCBarItem" />, <see cref="JapaneseCandleStickItem" />, etc. types.
-		/// </summary>
-		/// <remarks>Note that this property is only the number of bars that COULD BE clustered.  The
-		/// actual cluster settings are not considered.</remarks>
-		public int NumClusterableBars
-		{
-			get
-			{
-				int count = 0;
-				foreach ( CurveItem curve in this )
-				{
-					if ( curve.IsBar || curve is HiLowBarItem )
-						count++;
-				}
-
-				return count;
-			}
-		}
-
-
-
-		/// <summary>
-		/// Read only property that returns the number of pie slices in the list (class type is
-		/// <see cref="PieItem"/> ).
-		/// </summary>
-		public int NumPies
-		{
-			get
-			{
-				int count = 0;
-				foreach ( CurveItem curve in this )
-				{
-					if ( curve.IsPie )
-						count++;
-				}
-
-				return count;
-			}
-		}
-
-		/// <summary>
-		/// Read only property that determines if all items in the <see cref="CurveList"/> are
-		/// Pies.
-		/// </summary>
-		public bool IsPieOnly
-		{
- 			get
- 			{
-				bool hasPie = false;
- 				foreach ( CurveItem curve in this )
- 				{
- 					if ( !curve.IsPie )
- 						return false;
-					else
-						hasPie = true;
- 				}
-				return hasPie;
- 			}
-		}
-
-		/// <summary>
-		/// Determine if there is any data in any of the <see cref="CurveItem"/>
-		/// objects for this graph.  This method does not verify valid data, it
-		/// only checks to see if <see cref="CurveItem.NPts"/> > 0.
-		/// </summary>
-		/// <returns>true if there is any data, false otherwise</returns>
-		public bool HasData()
-		{
-			foreach( CurveItem curve in this )
-			{
-				if ( curve.Points.Count > 0 )
-					return true;
-			}
-			return false;
-		}
-	#endregion
-	
-	#region Constructors
-	
-		/// <summary>
-		/// Default constructor for the collection class
-		/// </summary>
-		public CurveList()
-		{
-			maxPts = 1;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The XAxis object from which to copy</param>
-		public CurveList( CurveList rhs )
-		{
-			this.maxPts = rhs.maxPts;
-
-			foreach ( CurveItem item in rhs )
-			{
-				this.Add( (CurveItem) ((ICloneable)item).Clone() );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public CurveList Clone()
-		{
-			return new CurveList( this );
-		}
-
-		
-	#endregion
-
-	#region IEnumerable Methods
-
-		//CJBL
-		/// <summary>
-		/// Iterate backwards through the <see cref="CurveList" /> items.
-		/// </summary>
-		public IEnumerable<CurveItem> Backward
-		{
-			get
-			{
-				for ( int i = this.Count - 1; i >= 0; i-- )
-					yield return this[i];
-			}
-		}
-		/// <summary>
-		/// Iterate forward through the <see cref="CurveList" /> items.
-		/// </summary>
-		public IEnumerable<CurveItem> Forward
-		{
-			get
-			{
-				for ( int i = 0; i < this.Count; i++ )
-					yield return this[i];
-			}
-		}
-
-	#endregion
-
-	#region List Methods
-/*
-		/// <summary>
-		/// Indexer to access the specified <see cref="CurveItem"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="CurveItem"/> object to be accessed.</param>
-		/// <value>A <see cref="CurveItem"/> object reference.</value>
-		public CurveItem this[ int index ]  
-		{
-			get { return( (CurveItem) List[index] ); }
-			set { List[index] = value; }
-		}
-*/
-		/// <summary>
-		/// Indexer to access the specified <see cref="CurveItem"/> object by
-		/// its <see cref="CurveItem.Label"/> string.
-		/// </summary>
-		/// <param name="label">The string label of the
-		/// <see cref="CurveItem"/> object to be accessed.</param>
-		/// <value>A <see cref="CurveItem"/> object reference.</value>
-		public CurveItem this[ string label ]  
-		{
-			get
-			{
-				int index = IndexOf( label );
-				if ( index >= 0 )
-					return( this[index]  );
-				else
-					return null;
-			}
-		}
-/*
-		/// <summary>
-		/// Add a <see cref="CurveItem"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="curve">A reference to the <see cref="CurveItem"/> object to
-		/// be added</param>
-		/// <seealso cref="IList.Add"/>
-		public void Add( CurveItem curve )
-		{
-			List.Add( curve );
-		}
-*/
-/*
-		/// <summary>
-		/// Remove a <see cref="CurveItem"/> object from the collection based on an object reference.
-		/// </summary>
-		/// <param name="curve">A reference to the <see cref="CurveItem"/> object that is to be
-		/// removed.</param>
-		/// <seealso cref="IList.Remove"/>
-		public void Remove( CurveItem curve )
-		{
-			List.Remove( curve );
-		}
-*/
-/*
-		/// <summary>
-		/// Insert a <see cref="CurveItem"/> object into the collection at the specified
-		/// zero-based index location.
-		/// </summary>
-		/// <param name="index">The zero-based index location for insertion.</param>
-		/// <param name="curve">A reference to the <see cref="CurveItem"/> object that is to be
-		/// inserted.</param>
-		/// <seealso cref="IList.Insert"/>
-		public void Insert( int index, CurveItem curve )
-		{
-			List.Insert( index, curve );
-		}
-*/
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="CurveItem"/> with the specified <see cref="CurveItem.Label"/>.
-		/// </summary>
-		/// <param name="label">The <see cref="String"/> label that is in the
-		/// <see cref="CurveItem.Label"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="CurveItem"/>,
-		/// or -1 if the <see cref="CurveItem"/> is not in the list</returns>
-		/// <seealso cref="IndexOfTag"/>
-		public int IndexOf( string label )
-		{
-			int index = 0;
-			foreach ( CurveItem p in this )
-			{
-				if ( String.Compare( p._label._text, label, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="CurveItem"/> with the specified <see cref="CurveItem.Tag"/>.
-		/// </summary>
-		/// <remarks>In order for this method to work, the <see cref="CurveItem.Tag"/>
-		/// property must be of type <see cref="String"/>.</remarks>
-		/// <param name="tag">The <see cref="String"/> tag that is in the
-		/// <see cref="CurveItem.Tag"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="CurveItem"/>,
-		/// or -1 if the <see cref="CurveItem"/> is not in the list</returns>
-		public int IndexOfTag( string tag )
-		{
-			int index = 0;
-			foreach ( CurveItem p in this )
-			{
-				if ( p.Tag is string &&
-							String.Compare( (string) p.Tag, tag, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Sorts the list according to the point values at the specified index and
-		/// for the specified axis.
-		/// </summary>
-		public void Sort( SortType type, int index )
-		{
-			this.Sort( new CurveItem.Comparer( type, index ) );
-		}
-
-		/// <summary>
-		/// Move the position of the object at the specified index
-		/// to the new relative position in the list.</summary>
-		/// <remarks>For Graphic type objects, this method controls the
-		/// Z-Order of the items.  Objects at the beginning of the list
-		/// appear in front of objects at the end of the list.</remarks>
-		/// <param name="index">The zero-based index of the object
-		/// to be moved.</param>
-		/// <param name="relativePos">The relative number of positions to move
-		/// the object.  A value of -1 will move the
-		/// object one position earlier in the list, a value
-		/// of 1 will move it one position later.  To move an item to the
-		/// beginning of the list, use a large negative value (such as -999).
-		/// To move it to the end of the list, use a large positive value.
-		/// </param>
-		/// <returns>The new position for the object, or -1 if the object
-		/// was not found.</returns>
-		public int Move( int index, int relativePos )
-		{
-			if ( index < 0 || index >= Count )
-				return -1;
-
-			CurveItem curve = this[index];
-			this.RemoveAt( index );
-
-			index += relativePos;
-			if ( index < 0 )
-				index = 0;
-			if ( index > Count )
-				index = Count;
-
-			Insert( index, curve );
-			return index;
-		}
-
-
-
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Go through each <see cref="CurveItem"/> object in the collection,
-		/// calling the <see cref="CurveItem.GetRange"/> member to 
-		/// determine the minimum and maximum values in the
-		/// <see cref="CurveItem.Points"/> list of data value pairs.  If the curves include 
-		/// a stack bar, handle within the current GetRange method. In the event that no
-		/// data are available, a default range of min=0.0 and max=1.0 are returned.
-		/// If the Y axis has a valid data range and the Y2 axis not, then the Y2
-		/// range will be a duplicate of the Y range.  Vice-versa for the Y2 axis
-		/// having valid data when the Y axis does not.
-		/// If any <see cref="CurveItem"/> in the list has a missing
-		/// <see cref="PointPairList"/>, a new empty one will be generated.
-		/// </summary>
-		/// <param name="bIgnoreInitial">ignoreInitial is a boolean value that
-		/// affects the data range that is considered for the automatic scale
-		/// ranging (see <see cref="GraphPane.IsIgnoreInitial"/>).  If true, then initial
-		/// data points where the Y value is zero are not included when
-		/// automatically determining the scale <see cref="Scale.Min"/>,
-		/// <see cref="Scale.Max"/>, and <see cref="Scale.MajorStep"/> size.  All data after
-		/// the first non-zero Y value are included.
-		/// </param>
-		/// <param name="isBoundedRanges">
-		/// Determines if the auto-scaled axis ranges will subset the
-		/// data points based on any manually set scale range values.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <seealso cref="GraphPane.IsBoundedRanges"/>
-		public void GetRange( bool bIgnoreInitial, bool isBoundedRanges, GraphPane pane )
-		{
-			double	tXMinVal,
-						tXMaxVal,
-						tYMinVal,
-						tYMaxVal;
-
-			InitScale( pane.XAxis.Scale, isBoundedRanges );
-			InitScale( pane.X2Axis.Scale, isBoundedRanges );
-
-			foreach ( YAxis axis in pane.YAxisList )
-				InitScale( axis.Scale, isBoundedRanges );
-
-			foreach ( Y2Axis axis in pane.Y2AxisList )
-				InitScale( axis.Scale, isBoundedRanges );
-
-			maxPts = 1;
-			
-			// Loop over each curve in the collection and examine the data ranges
-			foreach ( CurveItem curve in this )
-			{
-				if ( curve.IsVisible )
-				{
-					// For stacked types, use the GetStackRange() method which accounts for accumulated values
-					// rather than simple curve values.
-					if ( ( ( curve is BarItem ) && ( pane._barSettings.Type == BarType.Stack ||
-							pane._barSettings.Type == BarType.PercentStack ) ) ||
-						( ( curve is LineItem ) && pane.LineType == LineType.Stack ) )
-					{
-						GetStackRange( pane, curve, out tXMinVal, out tYMinVal,
-										out tXMaxVal, out tYMaxVal );
-					}
-					else
-					{
-						// Call the GetRange() member function for the current
-						// curve to get the min and max values
-						curve.GetRange( out tXMinVal, out tXMaxVal,
-										out tYMinVal, out tYMaxVal, bIgnoreInitial, true, pane );
-					}
-
-					// isYOrd is true if the Y axis is an ordinal type
-					Scale yScale = curve.GetYAxis( pane ).Scale;
-
-					Scale xScale = curve.GetXAxis( pane ).Scale;
-					bool isYOrd = yScale.IsAnyOrdinal;
-					// isXOrd is true if the X axis is an ordinal type
-					bool isXOrd = xScale.IsAnyOrdinal;
-
-					// For ordinal Axes, the data range is just 1 to Npts
-					if ( isYOrd && !curve.IsOverrideOrdinal )
-					{
-						tYMinVal = 1.0;
-						tYMaxVal = curve.NPts;
-					}
-					if ( isXOrd && !curve.IsOverrideOrdinal )
-					{
-						tXMinVal = 1.0;
-						tXMaxVal = curve.NPts;
-					}
-
-					// Bar types always include the Y=0 value
-					if ( curve.IsBar )
-					{
-						if ( pane._barSettings.Base == BarBase.X ||
-								pane._barSettings.Base == BarBase.X2 )
-						{
-							// Only force z=0 for BarItems, not HiLowBarItems
-							if ( ! (curve is HiLowBarItem)  )
-							{
-								if ( tYMinVal > 0 )
-									tYMinVal = 0;
-								else if ( tYMaxVal < 0 )
-									tYMaxVal = 0;
-							}
-
-							// for non-ordinal axes, expand the data range slightly for bar charts to
-							// account for the fact that the bar clusters have a width
-							if ( !isXOrd )
-							{
-								tXMinVal -= pane._barSettings._clusterScaleWidth / 2.0;
-								tXMaxVal += pane._barSettings._clusterScaleWidth / 2.0;
-							}
-						}
-						else
-						{
-							// Only force z=0 for BarItems, not HiLowBarItems
-							if ( !( curve is HiLowBarItem ) )
-							{
-								if ( tXMinVal > 0 )
-									tXMinVal = 0;
-								else if ( tXMaxVal < 0 )
-									tXMaxVal = 0;
-							}
-
-							// for non-ordinal axes, expand the data range slightly for bar charts to
-							// account for the fact that the bar clusters have a width
-							if ( !isYOrd )
-							{
-								tYMinVal -= pane._barSettings._clusterScaleWidth / 2.0;
-								tYMaxVal += pane._barSettings._clusterScaleWidth / 2.0;
-							}
-						}
-					}
-
-					// determine which curve has the maximum number of points
-					if ( curve.NPts > maxPts )
-						maxPts = curve.NPts;
-
-					// If the min and/or max values from the current curve
-					// are the absolute min and/or max, then save the values
-					// Also, differentiate between Y and Y2 values
-
-					if ( tYMinVal < yScale._rangeMin )
-						yScale._rangeMin = tYMinVal;
-					if ( tYMaxVal > yScale._rangeMax )
-						yScale._rangeMax = tYMaxVal;
-
-
-					if ( tXMinVal < xScale._rangeMin )
-						xScale._rangeMin = tXMinVal;
-					if ( tXMaxVal > xScale._rangeMax )
-						xScale._rangeMax = tXMaxVal;
-				}
-			}
-
-			pane.XAxis.Scale.SetRange( pane, pane.XAxis );
-			pane.X2Axis.Scale.SetRange( pane, pane.X2Axis );
-
-			foreach ( YAxis axis in pane.YAxisList )
-				axis.Scale.SetRange( pane, axis );
-			foreach ( Y2Axis axis in pane.Y2AxisList )
-				axis.Scale.SetRange( pane, axis );
-		}
-
-		private void InitScale( Scale scale, bool isBoundedRanges )
-		{
-			scale._rangeMin = double.MaxValue;
-			scale._rangeMax = double.MinValue;
-			scale._lBound = ( isBoundedRanges && !scale._minAuto ) ?
-				scale._min : double.MinValue;
-			scale._uBound = ( isBoundedRanges && !scale._maxAuto ) ?
-				scale._max : double.MaxValue;
-		}
-
-		/// <summary>
-		/// Calculate the range for stacked bars and lines.
-		/// </summary>
-		/// <remarks>This method is required for the stacked
-		/// types because (for bars), the negative values are a separate stack than the positive
-		/// values.  If you just sum up the bars, you will get the sum of the positive plus negative,
-		/// which is less than the maximum positive value and greater than the maximum negative value.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">The <see cref="CurveItem"/> for which to calculate the range</param>
-		/// <param name="tXMinVal">The minimum X value so far</param>
-		/// <param name="tYMinVal">The minimum Y value so far</param>
-		/// <param name="tXMaxVal">The maximum X value so far</param>
-		/// <param name="tYMaxVal">The maximum Y value so far</param>
-		/// <seealso cref="GraphPane.IsBoundedRanges"/>
-		private void GetStackRange( GraphPane pane, CurveItem curve, out double tXMinVal,
-									out double tYMinVal, out double tXMaxVal, out double tYMaxVal )
-		{
-			// initialize the values to outrageous ones to start
-			tXMinVal = tYMinVal = Double.MaxValue;
-			tXMaxVal = tYMaxVal = Double.MinValue;
-
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			Axis baseAxis = curve.BaseAxis( pane );
-			bool isXBase = baseAxis is XAxis || baseAxis is X2Axis;
-
-			double lowVal, baseVal, hiVal;
-
-			for ( int i=0; i<curve.Points.Count; i++ )
-			{
-				valueHandler.GetValues( curve, i, out baseVal, out lowVal, out hiVal );
-				double x = isXBase ? baseVal : hiVal;
-				double y = isXBase ? hiVal : baseVal;
-
-				if ( x != PointPair.Missing && y != PointPair.Missing && lowVal != PointPair.Missing )
-				{
-					if ( x < tXMinVal )
-						tXMinVal = x;
-					if ( x > tXMaxVal )
-						tXMaxVal = x;
-					if ( y < tYMinVal )
-						tYMinVal = y;
-					if ( y > tYMaxVal )
-						tYMaxVal = y;
-
-					if ( !isXBase )
-					{
-						if ( lowVal < tXMinVal )
-							tXMinVal = lowVal;
-						if ( lowVal > tXMaxVal )
-							tXMaxVal = lowVal;
-					}
-					else
-					{
-						if ( lowVal < tYMinVal )
-							tYMinVal = lowVal;
-						if ( lowVal > tYMaxVal )
-							tYMaxVal = lowVal;
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Render all the <see cref="CurveItem"/> objects in the list to the
-		/// specified <see cref="Graphics"/>
-		/// device by calling the <see cref="CurveItem.Draw"/> member function of
-		/// each <see cref="CurveItem"/> object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			// Configure the accumulator for stacked bars
-			//Bar.ResetBarStack();
-
-			// Count the number of BarItems in the curvelist
-			int pos = this.NumBars;
-			
-			// sorted overlay bars are a special case, since they are sorted independently at each
-			// ordinal position.
-			if ( pane._barSettings.Type == BarType.SortedOverlay )
-			{
-				// First, create a new curveList with references (not clones) of the curves
-				CurveList tempList = new CurveList();
-				foreach ( CurveItem curve in this )
-					if ( curve.IsBar )
-						tempList.Add( (CurveItem) curve );
-				
-				// Loop through the bars, graphing each ordinal position separately
-				for ( int i=0; i<this.maxPts; i++ )
-				{
-					// At each ordinal position, sort the curves according to the value axis value
-					tempList.Sort( pane._barSettings.Base == BarBase.X ? SortType.YValues : SortType.XValues, i );
-					// plot the bars for the current ordinal position, in sorted order
-					foreach ( BarItem barItem in tempList )
-						barItem.Bar.DrawSingleBar( g, pane, barItem,
-							((BarItem)barItem).BaseAxis( pane ),
-							((BarItem)barItem).ValueAxis( pane ),
-							0, i, ( (BarItem)barItem ).GetBarWidth( pane ), scaleFactor );
-				}
-			}
-
-			// Loop for each curve in reverse order to pick up the remaining curves
-			// The reverse order is done so that curves that are later in the list are plotted behind
-			// curves that are earlier in the list
-
-			for ( int i = this.Count - 1; i >= 0; i-- )
-			{
-				CurveItem curve = this[i];
-				
-				if ( curve.IsBar)
-					pos--;
-					
-				// Render the curve
-
-				//	if it's a sorted overlay bar type, it's already been done above
-				if ( !( curve.IsBar && pane._barSettings.Type == BarType.SortedOverlay ) )
-				{
-					curve.Draw( g, pane, pos, scaleFactor );
-				}
-			}
-		}
-
-
-		/// <summary>
-		/// Find the ordinal position of the specified <see cref="BarItem" /> within
-		/// the <see cref="CurveList" />.  This position only counts <see cef="BarItem" />
-		/// types, ignoring all other types.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> of interest</param>
-		/// <param name="barItem">The <see cref="BarItem" /> for which to search.</param>
-		/// <returns>The ordinal position of the specified bar, or -1 if the bar
-		/// was not found.</returns>
-		public int GetBarItemPos( GraphPane pane, BarItem barItem )
-		{
-			if (	pane._barSettings.Type == BarType.Overlay ||
-					pane._barSettings.Type == BarType.Stack ||
-					pane._barSettings.Type == BarType.PercentStack)
-				return 0;
-
-			int i = 0;
-			foreach ( CurveItem curve in this )
-			{
-				if ( curve == barItem )
-					return i;
-				else if ( curve is BarItem )
-					i++;
-			}
-
-			return -1;
-		}
-
-	#endregion
-
-	}
-}
-
-
diff --git a/BDInfo/ZedGraph/DataSourcePointList.cs b/BDInfo/ZedGraph/DataSourcePointList.cs
deleted file mode 100644
index 557ecd3969..0000000000
--- a/BDInfo/ZedGraph/DataSourcePointList.cs
+++ /dev/null
@@ -1,304 +0,0 @@
-//============================================================================ 
-//DataSourcePointList Class 
-//Copyright © 2006 John Champion, Jerry Vos 
-// 
-//This library is free software; you can redistribute it and/or 
-//modify it under the terms of the GNU Lesser General Public 
-//License as published by the Free Software Foundation; either 
-//version 2.1 of the License, or (at your option) any later version. 
-// 
-//This library is distributed in the hope that it will be useful, 
-//but WITHOUT ANY WARRANTY; without even the implied warranty of 
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
-//Lesser General Public License for more details. 
-// 
-//You should have received a copy of the GNU Lesser General Public 
-//License along with this library; if not, write to the Free Software 
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
-//============================================================================= 
-
-using System;
-using System.Drawing;
-using System.Collections;
-using System.ComponentModel;
-using System.Reflection;
-using System.Windows.Forms;
-using System.Data;
-
-namespace ZedGraph
-{
-	/// <summary> 
-	///  
-	/// </summary> 
-	/// <seealso cref="IPointList" /> 
-	/// <seealso cref="IPointListEdit" /> 
-	///  
-	/// <author>John Champion</author> 
-	/// <version> $Revision: 3.7 $ $Date: 2007/11/05 04:33:26 $ </version> 
-	[Serializable]
-	public class DataSourcePointList : IPointList
-	{
-		private BindingSource _bindingSource;
-
-		//private object _dataSource = null; 
-		private string _xDataMember = null;
-		private string _yDataMember = null;
-		private string _zDataMember = null;
-		private string _tagDataMember = null;
-
-		#region Properties
-
-		/// <summary> 
-		/// Indexer to access the specified <see cref="PointPair"/> object by 
-		/// its ordinal position in the list. 
-		/// </summary> 
-		/// <param name="index">The ordinal position (zero-based) of the 
-		/// <see cref="PointPair"/> object to be accessed.</param> 
-		/// <value>A <see cref="PointPair"/> object reference.</value> 
-		public PointPair this[int index]
-		{
-			get
-			{
-				if ( index < 0 || index >= _bindingSource.Count )
-					throw new System.ArgumentOutOfRangeException( "Error: Index out of range" );
-
-				object row = _bindingSource[index];
-
-				double x = GetDouble( row, _xDataMember, index );
-				double y = GetDouble( row, _yDataMember, index );
-				double z = GetDouble( row, _zDataMember, index );
-				object tag = GetObject( row, _tagDataMember );
-
-				PointPair pt = new PointPair( x, y, z );
-				pt.Tag = tag;
-				return pt;
-			}
-		}
-
-		/// <summary> 
-		/// gets the number of points available in the list 
-		/// </summary> 
-		public int Count
-		{
-			get
-			{
-				if ( _bindingSource != null )
-					return _bindingSource.Count;
-				else
-					return 0;
-			}
-		}
-
-		/// <summary> 
-		/// The <see cref="BindingSource" /> object from which to get the bound data 
-		/// </summary> 
-		/// <remarks> 
-		/// Typically, you set the <see cref="System.Windows.Forms.BindingSource.DataSource" /> 
-		/// property to a reference to your database, table or list object. The 
-		/// <see cref="System.Windows.Forms.BindingSource.DataMember" /> property would be set 
-		/// to the name of the datatable within the 
-		/// <see cref="System.Windows.Forms.BindingSource.DataSource" />, 
-		/// if applicable.</remarks> 
-		public BindingSource BindingSource
-		{
-			get { return _bindingSource; }
-		}
-
-		/// <summary> 
-		/// The table or list object from which to extract the data values. 
-		/// </summary> 
-		/// <remarks> 
-		/// This property is just an alias for 
-		/// <see cref="System.Windows.Forms.BindingSource.DataSource" />. 
-		/// </remarks> 
-		public object DataSource
-		{
-			get { return _bindingSource.DataSource; }
-			set { _bindingSource.DataSource = value; }
-		}
-
-		/// <summary> 
-		/// The <see cref="string" /> name of the property or column from which to obtain the 
-		/// X data values for the chart. 
-		/// </summary> 
-		/// <remarks>Set this to null leave the X data values set to <see cref="PointPairBase.Missing" /> 
-		/// </remarks> 
-		public string XDataMember
-		{
-			get { return _xDataMember; }
-			set { _xDataMember = value; }
-		}
-
-		/// <summary> 
-		/// The <see cref="string" /> name of the property or column from which to obtain the 
-		/// Y data values for the chart. 
-		/// </summary> 
-		/// <remarks>Set this to null leave the Y data values set to <see cref="PointPairBase.Missing" /> 
-		/// </remarks> 
-		public string YDataMember
-		{
-			get { return _yDataMember; }
-			set { _yDataMember = value; }
-		}
-
-		/// <summary> 
-		/// The <see cref="string" /> name of the property or column from which to obtain the 
-		/// Z data values for the chart. 
-		/// </summary> 
-		/// <remarks>Set this to null leave the Z data values set to <see cref="PointPairBase.Missing" /> 
-		/// </remarks> 
-		public string ZDataMember
-		{
-			get { return _zDataMember; }
-			set { _zDataMember = value; }
-		}
-
-		/// <summary> 
-		/// The <see cref="string" /> name of the property or column from which to obtain the 
-		/// tag values for the chart. 
-		/// </summary> 
-		/// <remarks>Set this to null leave the tag values set to null. If this references string 
-		/// data, then the tags may be used as tooltips using the 
-		/// <see cref="ZedGraphControl.IsShowPointValues" /> option. 
-		/// </remarks> 
-		public string TagDataMember
-		{
-			get { return _tagDataMember; }
-			set { _tagDataMember = value; }
-		}
-
-		#endregion
-
-		#region Constructors
-
-		/// <summary> 
-		/// Default Constructor 
-		/// </summary> 
-		public DataSourcePointList()
-		{
-			_bindingSource = new BindingSource();
-			_xDataMember = string.Empty;
-			_yDataMember = string.Empty;
-			_zDataMember = string.Empty;
-			_tagDataMember = string.Empty;
-		}
-
-		/// <summary> 
-		/// Constructor to initialize the DataSourcePointList from an 
-		/// existing <see cref="DataSourcePointList" /> 
-		/// </summary> 
-		public DataSourcePointList( DataSourcePointList rhs )
-			: this()
-		{
-			_bindingSource.DataSource = rhs._bindingSource.DataSource;
-			if ( rhs._xDataMember != null )
-				_xDataMember = (string)rhs._xDataMember.Clone();
-			if ( rhs._yDataMember != null )
-				_yDataMember = (string)rhs._yDataMember.Clone();
-			if ( rhs._zDataMember != null )
-				_zDataMember = (string)rhs._zDataMember.Clone();
-			if ( rhs._tagDataMember != null )
-				_tagDataMember = (string)rhs._tagDataMember.Clone();
-		}
-
-		/// <summary> 
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just 
-		/// calling the typed version of <see cref="Clone" /> 
-		/// </summary> 
-		/// <returns>A deep copy of this object</returns> 
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary> 
-		/// Typesafe, deep-copy clone method. 
-		/// </summary> 
-		/// <returns>A new, independent copy of this class</returns> 
-		public DataSourcePointList Clone()
-		{
-			return new DataSourcePointList( this );
-		}
-
-
-		#endregion
-
-		#region Methods
-
-		/// <summary> 
-		/// Extract a double value from the specified table row or data object with the 
-		/// specified column name. 
-		/// </summary> 
-		/// <param name="row">The data object from which to extract the value</param> 
-		/// <param name="dataMember">The property name or column name of the value 
-		/// to be extracted</param> 
-		/// <param name="index">The zero-based index of the point to be extracted. 
-		/// </param> 
-		private double GetDouble( object row, string dataMember, int index )
-		{
-			if ( dataMember == null || dataMember == string.Empty )
-				return index + 1;
-
-			//Type myType = row.GetType();
-			DataRowView drv = row as DataRowView;
-			PropertyInfo pInfo = null;
-			if ( drv == null )
-				pInfo = row.GetType().GetProperty( dataMember );
-
-			object val = null;
-
-			if ( pInfo != null )
-				val = pInfo.GetValue( row, null );
-			else if ( drv != null )
-				val = drv[dataMember];
-			else if ( pInfo == null )
-				throw new System.Exception( "Can't find DataMember '" + dataMember + "' in DataSource" );
-
-			// if ( val == null ) 
-			// throw new System.Exception( "Can't find DataMember '" + dataMember + "' in DataSource" ); 
-
-			double x;
-			if ( val == null || val == DBNull.Value )
-				x = PointPair.Missing;
-			else if ( val.GetType() == typeof( DateTime ) )
-				x = ( (DateTime)val ).ToOADate();
-			else if ( val.GetType() == typeof( string ) )
-				x = index + 1;
-			else
-				x = Convert.ToDouble( val );
-
-			return x;
-		}
-
-		/// <summary> 
-		/// Extract an object from the specified table row or data object with the 
-		/// specified column name. 
-		/// </summary> 
-		/// <param name="row">The data object from which to extract the object</param> 
-		/// <param name="dataMember">The property name or column name of the object 
-		/// to be extracted</param> 
-		private object GetObject( object row, string dataMember )
-		{
-			if ( dataMember == null || dataMember == string.Empty )
-				return null;
-
-			PropertyInfo pInfo = row.GetType().GetProperty( dataMember );
-			DataRowView drv = row as DataRowView;
-
-			object val = null;
-
-			if ( pInfo != null )
-				val = pInfo.GetValue( row, null );
-			else if ( drv != null )
-				val = drv[dataMember];
-
-			if ( val == null )
-				throw new System.Exception( "Can't find DataMember '" + dataMember + "' in DataSource" );
-
-			return val;
-		}
-
-
-		#endregion
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/DateAsOrdinalScale.cs b/BDInfo/ZedGraph/DateAsOrdinalScale.cs
deleted file mode 100644
index 89cae5addb..0000000000
--- a/BDInfo/ZedGraph/DateAsOrdinalScale.cs
+++ /dev/null
@@ -1,339 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The DateAsOrdinalScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.DateAsOrdinal" />.
-	/// </summary>
-	/// <remarks>DateAsOrdinalScale is an ordinal axis that will have labels formatted with dates from the
-	/// actual data values of the first <see cref="CurveItem" /> in the <see cref="CurveList" />.
-	/// Although the tics are labeled with real data values, the actual points will be
-	/// evenly-spaced in spite of the data values.  For example, if the X values of the first curve
-	/// are 1, 5, and 100, then the tic labels will show 1, 5, and 100, but they will be equal
-	/// distance from each other.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.13 $ $Date: 2007/11/28 02:38:22 $ </version>
-	[Serializable]
-	class DateAsOrdinalScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public DateAsOrdinalScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="DateAsOrdinalScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="DateAsOrdinalScale" /></param>
-		public DateAsOrdinalScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new DateAsOrdinalScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.DateAsOrdinal" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.DateAsOrdinal; }
-		}
-
-		/// <summary>
-		/// Gets or sets the minimum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.DateAsOrdinal" /> scales,
-		/// in that it automatically limits the value to the range of valid dates for the
-		/// <see cref="XDate" /> struct.
-		/// </remarks>
-		public override double Min
-		{
-			get { return _min; }
-			set { _min = XDate.MakeValidDate( value ); _minAuto = false; }
-		}
-
-		/// <summary>
-		/// Gets or sets the maximum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.DateAsOrdinal" /> scales,
-		/// in that it automatically limits the value to the range of valid dates for the
-		/// <see cref="XDate" /> struct.
-		/// </remarks>
-		public override double Max
-		{
-			get { return _max; }
-			set { _max = XDate.MakeValidDate( value ); _maxAuto = false; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Select a reasonable ordinal axis scale given a range of data values, with the expectation that
-		/// dates will be displayed.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.DateAsOrdinal"/> type axes, and it
-		/// is called by the general <see cref="PickScale"/> method.  For this type,
-		/// the first curve is the "master", which contains the dates to be applied.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="PickScale"/>
-		/// <seealso cref="AxisType.Ordinal"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-/*			// First, get the date ranges from the first curve in the list
-			double xMin; // = Double.MaxValue;
-			double xMax; // = Double.MinValue;
-			double yMin; // = Double.MaxValue;
-			double yMax; // = Double.MinValue;
-			double range = 1;
-
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( ( _ownerAxis is Y2Axis && curve.IsY2Axis ) ||
-						( _ownerAxis is YAxis && !curve.IsY2Axis ) ||
-						( _ownerAxis is X2Axis && curve.IsX2Axis ) ||
-						( _ownerAxis is XAxis && !curve.IsX2Axis ) )
-				{
-					curve.GetRange( out xMin, out xMax, out yMin, out yMax, false, pane.IsBoundedRanges, pane );
-					if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-						range = xMax - xMin;
-					else
-						range = yMax - yMin;
-				}
-			}
-*/
-			// Set the DateFormat by calling CalcDateStepSize
-			//			DateScale.CalcDateStepSize( range, Default.TargetXSteps, this );
-			SetDateFormat( pane );
-
-			// Now, set the axis range based on a ordinal scale
-			base.PickScale( pane, g, scaleFactor );
-			OrdinalScale.PickScale( pane, g, scaleFactor, this );
-		}
-
-		internal void SetDateFormat( GraphPane pane )
-		{
-			if ( _formatAuto )
-			{
-				double range = 10;
-
-				if ( pane.CurveList.Count > 0 && pane.CurveList[0].Points.Count > 1 )
-				{
-					double val1, val2;
-
-					PointPair pt1 = pane.CurveList[0].Points[0];
-					PointPair pt2 = pane.CurveList[0].Points[pane.CurveList[0].Points.Count - 1];
-					int p1 = 1;
-					int p2 = pane.CurveList[0].Points.Count;
-					if ( pane.IsBoundedRanges )
-					{
-						p1 = (int) Math.Floor( _ownerAxis.Scale.Min );
-						p2 = (int) Math.Ceiling( _ownerAxis.Scale.Max );
-						p1 = Math.Min( Math.Max( p1, 1 ), pane.CurveList[0].Points.Count );
-						p2 = Math.Min( Math.Max( p2, 1 ), pane.CurveList[0].Points.Count );
-						if ( p2 > p1 )
-						{
-							pt1 = pane.CurveList[0].Points[p1-1];
-							pt2 = pane.CurveList[0].Points[p2-1];
-						}
-					}
-					if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-					{
-						val1 = pt1.X;
-						val2 = pt2.X;
-					}
-					else
-					{
-						val1 = pt1.Y;
-						val2 = pt2.Y;
-					}
-
-					if (	val1 != PointPair.Missing &&
-							val2 != PointPair.Missing &&
-							!Double.IsNaN( val1 ) &&
-							!Double.IsNaN( val2 ) &&
-							!Double.IsInfinity( val1 ) &&
-							!Double.IsInfinity( val2 ) &&
-							Math.Abs( val2 - val1 ) > 1e-10 )
-						range = Math.Abs( val2 - val1 );
-				}
-
-				if ( range > Default.RangeYearYear )
-					_format = Default.FormatYearYear;
-				else if ( range > Default.RangeYearMonth )
-					_format = Default.FormatYearMonth;
-				else if ( range > Default.RangeMonthMonth )
-					_format = Default.FormatMonthMonth;
-				else if ( range > Default.RangeDayDay )
-					_format = Default.FormatDayDay;
-				else if ( range > Default.RangeDayHour )
-					_format = Default.FormatDayHour;
-				else if ( range > Default.RangeHourHour )
-					_format = Default.FormatHourHour;
-				else if ( range > Default.RangeHourMinute )
-					_format = Default.FormatHourMinute;
-				else if ( range > Default.RangeMinuteMinute )
-					_format = Default.FormatMinuteMinute;
-				else if ( range > Default.RangeMinuteSecond )
-					_format = Default.FormatMinuteSecond;
-				else if ( range > Default.RangeSecondSecond )
-					_format = Default.FormatSecondSecond;
-				else // MilliSecond
-					_format = Default.FormatMillisecond;
-			}
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.DateAsOrdinal" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log
-		/// (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			double val;
-
-			int tmpIndex = (int) dVal - 1;
-
-			if ( pane.CurveList.Count > 0 && pane.CurveList[0].Points.Count > tmpIndex )
-			{
-				if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-				val = pane.CurveList[0].Points[tmpIndex].X;
-				else
-					val = pane.CurveList[0].Points[tmpIndex].Y;
-				return XDate.ToString( val, _format );
-			}
-			else
-				return string.Empty;
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected DateAsOrdinalScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/DateScale.cs b/BDInfo/ZedGraph/DateScale.cs
deleted file mode 100644
index 30c581960d..0000000000
--- a/BDInfo/ZedGraph/DateScale.cs
+++ /dev/null
@@ -1,947 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The DateScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Date" />.
-	/// </summary>
-	/// <remarks>
-	/// DateScale is a cartesian axis with calendar dates or times.  The actual data values should
-	/// be created with the <see cref="XDate" /> type, which is directly translatable to a
-	/// <see cref="System.Double" /> type for storage in the point value arrays.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.15 $ $Date: 2007/09/19 06:41:56 $ </version>
-	[Serializable]
-	class DateScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public DateScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="DateScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="DateScale" /></param>
-		public DateScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new DateScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.Date" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.Date; }
-		}
-
-		/// <summary>
-		/// Gets or sets the minimum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.Date" /> scales,
-		/// in that it automatically limits the value to the range of valid dates for the
-		/// <see cref="XDate" /> struct.
-		/// </remarks>
-		public override double Min
-		{
-			get { return _min; }
-			set { _min = XDate.MakeValidDate( value ); _minAuto = false; }
-		}
-
-		/// <summary>
-		/// Gets or sets the maximum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.Date" /> scales,
-		/// in that it automatically limits the value to the range of valid dates for the
-		/// <see cref="XDate" /> struct.
-		/// </remarks>
-		public override double Max
-		{
-			get { return _max; }
-			set { _max = XDate.MakeValidDate( value ); _maxAuto = false; }
-		}
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Determine the value for any major tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double)
-		/// </param>
-		/// <param name="tic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified major tic value (floating point double).
-		/// </returns>
-		override internal double CalcMajorTicValue( double baseVal, double tic )
-		{
-			XDate xDate = new XDate( baseVal );
-
-			switch ( _majorUnit )
-			{
-				case DateUnit.Year:
-				default:
-					xDate.AddYears( tic * _majorStep );
-					break;
-				case DateUnit.Month:
-					xDate.AddMonths( tic * _majorStep );
-					break;
-				case DateUnit.Day:
-					xDate.AddDays( tic * _majorStep );
-					break;
-				case DateUnit.Hour:
-					xDate.AddHours( tic * _majorStep );
-					break;
-				case DateUnit.Minute:
-					xDate.AddMinutes( tic * _majorStep );
-					break;
-				case DateUnit.Second:
-					xDate.AddSeconds( tic * _majorStep );
-					break;
-				case DateUnit.Millisecond:
-					xDate.AddMilliseconds( tic * _majorStep );
-					break;
-			}
-
-			return xDate.XLDate;
-		}
-
-		/// <summary>
-		/// Determine the value for any minor tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double).  This tic value is the base
-		/// reference for all tics (including minor ones).
-		/// </param>
-		/// <param name="iTic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified minor tic value (floating point double).
-		/// </returns>
-		override internal double CalcMinorTicValue( double baseVal, int iTic )
-		{
-			XDate xDate = new XDate( baseVal );
-
-			switch ( _minorUnit )
-			{
-				case DateUnit.Year:
-				default:
-					xDate.AddYears( (double) iTic * _minorStep );
-					break;
-				case DateUnit.Month:
-					xDate.AddMonths( (double) iTic * _minorStep );
-					break;
-				case DateUnit.Day:
-					xDate.AddDays( (double) iTic * _minorStep );
-					break;
-				case DateUnit.Hour:
-					xDate.AddHours( (double) iTic * _minorStep );
-					break;
-				case DateUnit.Minute:
-					xDate.AddMinutes( (double) iTic * _minorStep );
-					break;
-				case DateUnit.Second:
-					xDate.AddSeconds( (double) iTic * _minorStep );
-					break;
-			}
-
-			return xDate.XLDate;
-		}
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first minor tic mark
-		/// </summary>
-		/// <param name="baseVal">
-		/// The value of the first major tic for the axis.
-		/// </param>
-		/// <returns>
-		/// The ordinal position of the first minor tic, relative to the first major tic.
-		/// This value can be negative (e.g., -3 means the first minor tic is 3 minor step
-		/// increments before the first major tic.
-		/// </returns>
-		override internal int CalcMinorStart( double baseVal )
-		{
-			switch ( _minorUnit )
-			{
-				case DateUnit.Year:
-				default:
-					return (int) ( ( _min - baseVal ) / ( 365.0 * _minorStep ) );
-				case DateUnit.Month:
-					return (int) ( ( _min - baseVal ) / ( 28.0 * _minorStep ) );
-				case DateUnit.Day:
-					return (int) ( ( _min - baseVal ) / _minorStep );
-				case DateUnit.Hour:
-					return (int) ( ( _min - baseVal ) * XDate.HoursPerDay / _minorStep );
-				case DateUnit.Minute:
-					return (int) ( ( _min - baseVal ) * XDate.MinutesPerDay / _minorStep );
-				case DateUnit.Second:
-					return (int) ( ( _min - baseVal ) * XDate.SecondsPerDay / _minorStep );
-			}
-		}
-
-		/// <summary>
-		/// Determine the value for the first major tic.
-		/// </summary>
-		/// <remarks>
-		/// This is done by finding the first possible value that is an integral multiple of
-		/// the step size, taking into account the date/time units if appropriate.
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <returns>
-		/// First major tic value (floating point double).
-		/// </returns>
-		override internal double CalcBaseTic()
-		{
-			if ( _baseTic != PointPair.Missing )
-				return _baseTic;
-			else
-			{
-				int year, month, day, hour, minute, second, millisecond;
-				XDate.XLDateToCalendarDate( _min, out year, out month, out day, out hour, out minute,
-											out second, out millisecond );
-				switch ( _majorUnit )
-				{
-					case DateUnit.Year:
-					default:
-						month = 1; day = 1; hour = 0; minute = 0; second = 0; millisecond = 0;
-						break;
-					case DateUnit.Month:
-						day = 1; hour = 0; minute = 0; second = 0; millisecond = 0;
-						break;
-					case DateUnit.Day:
-						hour = 0; minute = 0; second = 0; millisecond = 0;
-						break;
-					case DateUnit.Hour:
-						minute = 0; second = 0; millisecond = 0;
-						break;
-					case DateUnit.Minute:
-						second = 0; millisecond = 0;
-						break;
-					case DateUnit.Second:
-						millisecond = 0;
-						break;
-					case DateUnit.Millisecond:
-						break;
-
-				}
-
-				double xlDate = XDate.CalendarDateToXLDate( year, month, day, hour, minute, second, millisecond );
-				if ( xlDate < _min )
-				{
-					switch ( _majorUnit )
-					{
-						case DateUnit.Year:
-						default:
-							year++;
-							break;
-						case DateUnit.Month:
-							month++;
-							break;
-						case DateUnit.Day:
-							day++;
-							break;
-						case DateUnit.Hour:
-							hour++;
-							break;
-						case DateUnit.Minute:
-							minute++;
-							break;
-						case DateUnit.Second:
-							second++;
-							break;
-						case DateUnit.Millisecond:
-							millisecond++;
-							break;
-
-					}
-
-					xlDate = XDate.CalendarDateToXLDate( year, month, day, hour, minute, second, millisecond );
-				}
-
-				return xlDate;
-			}
-		}
-		
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first and last major axis label.
-		/// </summary>
-		/// <returns>
-		/// This is the total number of major tics for this axis.
-		/// </returns>
-		override internal int CalcNumTics()
-		{
-			int nTics = 1;
-
-			int year1, year2, month1, month2, day1, day2, hour1, hour2, minute1, minute2;
-			int second1, second2, millisecond1, millisecond2;
-
-			XDate.XLDateToCalendarDate( _min, out year1, out month1, out day1,
-										out hour1, out minute1, out second1, out millisecond1 );
-			XDate.XLDateToCalendarDate( _max, out year2, out month2, out day2,
-										out hour2, out minute2, out second2, out millisecond2 );
-
-			switch ( _majorUnit )
-			{
-				case DateUnit.Year:
-				default:
-					nTics = (int) ( ( year2 - year1 ) / _majorStep + 1.001 );
-					break;
-				case DateUnit.Month:
-					nTics = (int) ( ( month2 - month1 + 12.0 * ( year2 - year1 ) ) / _majorStep + 1.001 );
-					break;
-				case DateUnit.Day:
-					nTics = (int) ( ( _max - _min ) / _majorStep + 1.001 );
-					break;
-				case DateUnit.Hour:
-					nTics = (int) ( ( _max - _min ) / ( _majorStep / XDate.HoursPerDay ) + 1.001 );
-					break;
-				case DateUnit.Minute:
-					nTics = (int) ( ( _max - _min ) / ( _majorStep / XDate.MinutesPerDay ) + 1.001 );
-					break;
-				case DateUnit.Second:
-					nTics = (int)( ( _max - _min ) / ( _majorStep / XDate.SecondsPerDay ) + 1.001 );
-					break;
-				case DateUnit.Millisecond:
-					nTics = (int)( ( _max - _min ) / ( _majorStep / XDate.MillisecondsPerDay ) + 1.001 );
-					break;
-			}
-
-			if ( nTics < 1 )
-				nTics = 1;
-			else if ( nTics > 1000 )
-				nTics = 1000;
-
-			return nTics;
-		}
-
-		/// <summary>
-		/// Select a reasonable date-time axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Date"/> type axes, and it
-		/// is called by the general <see cref="PickScale"/> method.  The scale range is chosen
-		/// based on increments of 1, 2, or 5 (because they are even divisors of 10).
-		/// Note that the <see cref="Scale.MajorStep"/> property setting can have multiple unit
-		/// types (<see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit" />),
-		/// but the <see cref="Scale.Min"/> and
-		/// <see cref="Scale.Max"/> units are always days (<see cref="XDate"/>).  This
-		/// method honors the <see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min"/>, <see cref="Scale.Max"/>, or <see cref="Scale.MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  The basic default for
-		/// scale selection is defined with
-		/// <see cref="Scale.Default.TargetXSteps"/> and <see cref="Scale.Default.TargetYSteps"/>
-		/// from the <see cref="Scale.Default"/> default class.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="Scale.PickScale"/>
-		/// <seealso cref="AxisType.Date"/>
-		/// <seealso cref="Scale.MajorUnit"/>
-		/// <seealso cref="Scale.MinorUnit"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( _max - _min < 1.0e-20 )
-			{
-				if ( _maxAuto )
-					_max = _max + 0.2 * ( _max == 0 ? 1.0 : Math.Abs( _max ) );
-				if ( _minAuto )
-					_min = _min - 0.2 * ( _min == 0 ? 1.0 : Math.Abs( _min ) );
-			}
-
-			double targetSteps = ( _ownerAxis is XAxis || _ownerAxis is X2Axis ) ?
-						Default.TargetXSteps : Default.TargetYSteps;
-
-			// Calculate the step size based on target steps
-			double tempStep = CalcDateStepSize( _max - _min, targetSteps );
-
-			// Calculate the new step size
-			if ( _majorStepAuto )
-			{
-				_majorStep = tempStep;
-
-				if ( _isPreventLabelOverlap )
-				{
-					// Calculate the maximum number of labels
-					double maxLabels = (double) this.CalcMaxLabels( g, pane, scaleFactor );
-
-					if ( maxLabels < this.CalcNumTics() )
-						_majorStep = CalcDateStepSize( _max - _min, maxLabels );
-				}
-			}
-
-			// Calculate the scale minimum
-			if ( _minAuto )
-				_min = CalcEvenStepDate( _min, -1 );
-
-			// Calculate the scale maximum
-			if ( _maxAuto )
-				_max = CalcEvenStepDate( _max, 1 );
-
-			_mag = 0;		// Never use a magnitude shift for date scales
-			//this.numDec = 0;		// The number of decimal places to display is not used
-
-		}
-
-		/// <summary>
-		/// Calculate a step size for a <see cref="AxisType.Date"/> scale.
-		/// This method is used by <see cref="PickScale"/>.
-		/// </summary>
-		/// <param name="range">The range of data in units of days</param>
-		/// <param name="targetSteps">The desired "typical" number of steps
-		/// to divide the range into</param>
-		/// <returns>The calculated step size for the specified data range.  Also
-		/// calculates and sets the values for <see cref="Scale.MajorUnit"/>,
-		/// <see cref="Scale.MinorUnit"/>, <see cref="Scale.MinorStep"/>, and
-		/// <see cref="Scale.Format"/></returns>
-		protected double CalcDateStepSize( double range, double targetSteps )
-		{
-			return CalcDateStepSize( range, targetSteps, this );
-		}
-
-		/// <summary>
-		/// Calculate a step size for a <see cref="AxisType.Date"/> scale.
-		/// This method is used by <see cref="PickScale"/>.
-		/// </summary>
-		/// <param name="range">The range of data in units of days</param>
-		/// <param name="targetSteps">The desired "typical" number of steps
-		/// to divide the range into</param>
-		/// <param name="scale">
-		/// The <see cref="Scale" /> object on which to calculate the Date step size.</param>
-		/// <returns>The calculated step size for the specified data range.  Also
-		/// calculates and sets the values for <see cref="Scale.MajorUnit"/>,
-		/// <see cref="Scale.MinorUnit"/>, <see cref="Scale.MinorStep"/>, and
-		/// <see cref="Scale.Format"/></returns>
-		internal static double CalcDateStepSize( double range, double targetSteps, Scale scale )
-		{
-			// Calculate an initial guess at step size
-			double tempStep = range / targetSteps;
-
-			if ( range > Default.RangeYearYear )
-			{
-				scale._majorUnit = DateUnit.Year;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatYearYear;
-
-				tempStep = Math.Ceiling( tempStep / 365.0 );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Year;
-					if ( tempStep == 1.0 )
-						scale._minorStep = 0.25;
-					else
-						scale._minorStep = Scale.CalcStepSize( tempStep, targetSteps );
-				}
-			}
-			else if ( range > Default.RangeYearMonth )
-			{
-				scale._majorUnit = DateUnit.Year;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatYearMonth;
-				tempStep = Math.Ceiling( tempStep / 365.0 );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Month;
-					// Calculate the minor steps to give an estimated 4 steps
-					// per major step.
-					scale._minorStep = Math.Ceiling( range / ( targetSteps * 3 ) / 30.0 );
-					// make sure the minorStep is 1, 2, 3, 6, or 12 months
-					if ( scale._minorStep > 6 )
-						scale._minorStep = 12;
-					else if ( scale._minorStep > 3 )
-						scale._minorStep = 6;
-				}
-			}
-			else if ( range > Default.RangeMonthMonth )
-			{
-				scale._majorUnit = DateUnit.Month;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatMonthMonth;
-				tempStep = Math.Ceiling( tempStep / 30.0 );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Month;
-					scale._minorStep = tempStep * 0.25;
-				}
-			}
-			else if ( range > Default.RangeDayDay )
-			{
-				scale._majorUnit = DateUnit.Day;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatDayDay;
-				tempStep = Math.Ceiling( tempStep );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Day;
-					scale._minorStep = tempStep * 0.25;
-					// make sure the minorStep is 1, 2, 3, 6, or 12 hours
-				}
-			}
-			else if ( range > Default.RangeDayHour )
-			{
-				scale._majorUnit = DateUnit.Day;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatDayHour;
-				tempStep = Math.Ceiling( tempStep );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Hour;
-					// Calculate the minor steps to give an estimated 4 steps
-					// per major step.
-					scale._minorStep = Math.Ceiling( range / ( targetSteps * 3 ) * XDate.HoursPerDay );
-					// make sure the minorStep is 1, 2, 3, 6, or 12 hours
-					if ( scale._minorStep > 6 )
-						scale._minorStep = 12;
-					else if ( scale._minorStep > 3 )
-						scale._minorStep = 6;
-					else
-						scale._minorStep = 1;
-				}
-			}
-			else if ( range > Default.RangeHourHour )
-			{
-				scale._majorUnit = DateUnit.Hour;
-				tempStep = Math.Ceiling( tempStep * XDate.HoursPerDay );
-				if ( scale._formatAuto )
-					scale._format = Default.FormatHourHour;
-
-				if ( tempStep > 12.0 )
-					tempStep = 24.0;
-				else if ( tempStep > 6.0 )
-					tempStep = 12.0;
-				else if ( tempStep > 2.0 )
-					tempStep = 6.0;
-				else if ( tempStep > 1.0 )
-					tempStep = 2.0;
-				else
-					tempStep = 1.0;
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Hour;
-					if ( tempStep <= 1.0 )
-						scale._minorStep = 0.25;
-					else if ( tempStep <= 6.0 )
-						scale._minorStep = 1.0;
-					else if ( tempStep <= 12.0 )
-						scale._minorStep = 2.0;
-					else
-						scale._minorStep = 4.0;
-				}
-			}
-			else if ( range > Default.RangeHourMinute )
-			{
-				scale._majorUnit = DateUnit.Hour;
-				tempStep = Math.Ceiling( tempStep * XDate.HoursPerDay );
-
-				if ( scale._formatAuto )
-					scale._format = Default.FormatHourMinute;
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Minute;
-					// Calculate the minor steps to give an estimated 4 steps
-					// per major step.
-					scale._minorStep = Math.Ceiling( range / ( targetSteps * 3 ) * XDate.MinutesPerDay );
-					// make sure the minorStep is 1, 5, 15, or 30 minutes
-					if ( scale._minorStep > 15.0 )
-						scale._minorStep = 30.0;
-					else if ( scale._minorStep > 5.0 )
-						scale._minorStep = 15.0;
-					else if ( scale._minorStep > 1.0 )
-						scale._minorStep = 5.0;
-					else
-						scale._minorStep = 1.0;
-				}
-			}
-			else if ( range > Default.RangeMinuteMinute )
-			{
-				scale._majorUnit = DateUnit.Minute;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatMinuteMinute;
-
-				tempStep = Math.Ceiling( tempStep * XDate.MinutesPerDay );
-				// make sure the minute step size is 1, 5, 15, or 30 minutes
-				if ( tempStep > 15.0 )
-					tempStep = 30.0;
-				else if ( tempStep > 5.0 )
-					tempStep = 15.0;
-				else if ( tempStep > 1.0 )
-					tempStep = 5.0;
-				else
-					tempStep = 1.0;
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Minute;
-					if ( tempStep <= 1.0 )
-						scale._minorStep = 0.25;
-					else if ( tempStep <= 5.0 )
-						scale._minorStep = 1.0;
-					else
-						scale._minorStep = 5.0;
-				}
-			}
-			else if ( range > Default.RangeMinuteSecond )
-			{
-				scale._majorUnit = DateUnit.Minute;
-				tempStep = Math.Ceiling( tempStep * XDate.MinutesPerDay );
-
-				if ( scale._formatAuto )
-					scale._format = Default.FormatMinuteSecond;
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Second;
-					// Calculate the minor steps to give an estimated 4 steps
-					// per major step.
-					scale._minorStep = Math.Ceiling( range / ( targetSteps * 3 ) * XDate.SecondsPerDay );
-					// make sure the minorStep is 1, 5, 15, or 30 seconds
-					if ( scale._minorStep > 15.0 )
-						scale._minorStep = 30.0;
-					else if ( scale._minorStep > 5.0 )
-						scale._minorStep = 15.0;
-					else if ( scale._minorStep > 1.0 )
-						scale._minorStep = 5.0;
-					else
-						scale._minorStep = 1.0;
-				}
-			}
-			else  if ( range > Default.RangeSecondSecond ) // SecondSecond
-			{
-				scale._majorUnit = DateUnit.Second;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatSecondSecond;
-
-				tempStep = Math.Ceiling( tempStep * XDate.SecondsPerDay );
-				// make sure the second step size is 1, 5, 15, or 30 seconds
-				if ( tempStep > 15.0 )
-					tempStep = 30.0;
-				else if ( tempStep > 5.0 )
-					tempStep = 15.0;
-				else if ( tempStep > 1.0 )
-					tempStep = 5.0;
-				else
-					tempStep = 1.0;
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorUnit = DateUnit.Second;
-					if ( tempStep <= 1.0 )
-						scale._minorStep = 0.25;
-					else if ( tempStep <= 5.0 )
-						scale._minorStep = 1.0;
-					else
-						scale._minorStep = 5.0;
-				}
-			}
-			else // MilliSecond
-			{
-				scale._majorUnit = DateUnit.Millisecond;
-				if ( scale._formatAuto )
-					scale._format = Default.FormatMillisecond;
-
-				tempStep = CalcStepSize( range * XDate.MillisecondsPerDay, Default.TargetXSteps );
-
-				if ( scale._minorStepAuto )
-				{
-					scale._minorStep = CalcStepSize( tempStep,
-							( scale._ownerAxis is XAxis || scale._ownerAxis is X2Axis ) ?
-							Default.TargetMinorXSteps : Default.TargetMinorYSteps );
-					scale._minorUnit = DateUnit.Millisecond;
-				}
-			}
-
-			return tempStep;
-		}
-
-		/// <summary>
-		/// Calculate a date that is close to the specified date and an
-		/// even multiple of the selected
-		/// <see cref="Scale.MajorUnit"/> for a <see cref="AxisType.Date"/> scale.
-		/// This method is used by <see cref="PickScale"/>.
-		/// </summary>
-		/// <param name="date">The date which the calculation should be close to</param>
-		/// <param name="direction">The desired direction for the date to take.
-		/// 1 indicates the result date should be greater than the specified
-		/// date parameter.  -1 indicates the other direction.</param>
-		/// <returns>The calculated date</returns>
-		protected double CalcEvenStepDate( double date, int direction )
-		{
-			int year, month, day, hour, minute, second, millisecond;
-
-			XDate.XLDateToCalendarDate( date, out year, out month, out day,
-										out hour, out minute, out second, out millisecond );
-
-			// If the direction is -1, then it is sufficient to go to the beginning of
-			// the current time period, .e.g., for 15-May-95, and monthly steps, we
-			// can just back up to 1-May-95
-			if ( direction < 0 )
-				direction = 0;
-
-			switch ( _majorUnit )
-			{
-				case DateUnit.Year:
-				default:
-					// If the date is already an exact year, then don't step to the next year
-					if ( direction == 1 && month == 1 && day == 1 && hour == 0
-						&& minute == 0 && second == 0 )
-						return date;
-					else
-						return XDate.CalendarDateToXLDate( year + direction, 1, 1,
-														0, 0, 0 );
-				case DateUnit.Month:
-					// If the date is already an exact month, then don't step to the next month
-					if ( direction == 1 && day == 1 && hour == 0
-						&& minute == 0 && second == 0 )
-						return date;
-					else
-						return XDate.CalendarDateToXLDate( year, month + direction, 1,
-												0, 0, 0 );
-				case DateUnit.Day:
-					// If the date is already an exact Day, then don't step to the next day
-					if ( direction == 1 && hour == 0 && minute == 0 && second == 0 )
-						return date;
-					else
-						return XDate.CalendarDateToXLDate( year, month,
-											day + direction, 0, 0, 0 );
-				case DateUnit.Hour:
-					// If the date is already an exact hour, then don't step to the next hour
-					if ( direction == 1 && minute == 0 && second == 0 )
-						return date;
-					else
-						return XDate.CalendarDateToXLDate( year, month, day,
-													hour + direction, 0, 0 );
-				case DateUnit.Minute:
-					// If the date is already an exact minute, then don't step to the next minute
-					if ( direction == 1 && second == 0 )
-						return date;
-					else
-						return XDate.CalendarDateToXLDate( year, month, day, hour,
-													minute + direction, 0 );
-				case DateUnit.Second:
-					return XDate.CalendarDateToXLDate( year, month, day, hour,
-													minute, second + direction );
-
-				case DateUnit.Millisecond:
-					return XDate.CalendarDateToXLDate( year, month, day, hour,
-													minute, second, millisecond + direction );
-
-			}
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.Date" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			return XDate.ToString( dVal, _format );
-		}
-
-		/// <summary>
-		/// Gets the major unit multiplier for this scale type, if any.
-		/// </summary>
-		/// <remarks>The major unit multiplier will correct the units of
-		/// <see cref="Scale.MajorStep" /> to match the units of <see cref="Scale.Min" />
-		/// and <see cref="Scale.Max" />.  This reflects the setting of
-		/// <see cref="Scale.MajorUnit" />.
-		/// </remarks>
-		override internal double MajorUnitMultiplier
-		{
-			get { return GetUnitMultiple( _majorUnit ); }
-		}
-
-		/// <summary>
-		/// Gets the minor unit multiplier for this scale type, if any.
-		/// </summary>
-		/// <remarks>The minor unit multiplier will correct the units of
-		/// <see cref="Scale.MinorStep" /> to match the units of <see cref="Scale.Min" />
-		/// and <see cref="Scale.Max" />.  This reflects the setting of
-		/// <see cref="Scale.MinorUnit" />.
-		/// </remarks>
-		override internal double MinorUnitMultiplier
-		{
-			get { return GetUnitMultiple( _minorUnit ); }
-		}
-
-		/// <summary>
-		/// Internal routine to calculate a multiplier to the selected unit back to days.
-		/// </summary>
-		/// <param name="unit">The unit type for which the multiplier is to be
-		/// calculated</param>
-		/// <returns>
-		/// This is ratio of days/selected unit
-		/// </returns>
-		private double GetUnitMultiple( DateUnit unit )
-		{
-			switch ( unit )
-			{
-				case DateUnit.Year:
-				default:
-					return 365.0;
-				case DateUnit.Month:
-					return 30.0;
-				case DateUnit.Day:
-					return 1.0;
-				case DateUnit.Hour:
-					return 1.0 / XDate.HoursPerDay;
-				case DateUnit.Minute:
-					return 1.0 / XDate.MinutesPerDay;
-				case DateUnit.Second:
-					return 1.0 / XDate.SecondsPerDay;
-				case DateUnit.Millisecond:
-					return 1.0 / XDate.MillisecondsPerDay;
-			}
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected DateScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/EllipseObj.cs b/BDInfo/ZedGraph/EllipseObj.cs
deleted file mode 100644
index 48426af307..0000000000
--- a/BDInfo/ZedGraph/EllipseObj.cs
+++ /dev/null
@@ -1,259 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a bordered and/or filled ellipse object on
-	/// the graph.  A list of EllipseObj objects is maintained by the
-	/// <see cref="GraphObjList"/> collection class.  The ellipse is defined
-	/// as the ellipse that would be contained by the rectangular box as
-	/// defined by the <see cref="Location"/> property.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.3 $ $Date: 2007/01/25 07:56:08 $ </version>
-	[Serializable]
-	public class EllipseObj : BoxObj, ICloneable, ISerializable
-	{
-	#region Constructors
-		/// <overloads>Constructors for the <see cref="EllipseObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the position and size
-		/// of the <see cref="EllipseObj"/> to be pre-specified.  Other properties are defaulted.
-		/// </summary>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public EllipseObj( double x, double y, double width, double height )
-			: base( x, y, width, height )
-		{
-		}
-		
-		/// <summary>
-		/// A default constructor that places the <see cref="EllipseObj"/> at location (0,0),
-		/// with width/height of (1,1).  Other properties are defaulted.
-		/// </summary>
-		public EllipseObj() : base()
-		{
-		}
-		
-		/// <summary>
-		/// A constructor that allows the position, border color, and solid fill color
-		/// of the <see cref="EllipseObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the ellipse border</param>
-		/// <param name="fillColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the ellipse fill (will be a solid color fill)</param>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public EllipseObj( double x, double y, double width, double height, Color borderColor, Color fillColor )
-			: base( x, y, width, height, borderColor, fillColor )
-		{
-		}
-
-		/// <summary>
-		/// A constructor that allows the position, border color, and two-color
-		/// gradient fill colors
-		/// of the <see cref="EllipseObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the ellipse border</param>
-		/// <param name="fillColor1">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the start of the ellipse gradient fill</param>
-		/// <param name="fillColor2">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the end of the ellipse gradient fill</param>
-		/// <param name="x">The x location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="y">The y location for this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="width">The width of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		/// <param name="height">The height of this <see cref="BoxObj" />.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame" />.</param>
-		public EllipseObj( double x, double y, double width, double height, Color borderColor,
-							Color fillColor1, Color fillColor2 ) :
-				base( x, y, width, height, borderColor, fillColor1, fillColor2 )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="EllipseObj"/> object from
-		/// which to copy</param>
-		public EllipseObj( BoxObj rhs ) : base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new EllipseObj Clone()
-		{
-			return new EllipseObj( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected EllipseObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema3 );
-		}
-	#endregion
-	
-	#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// Convert the arrow coordinates from the user coordinate system
-			// to the screen coordinate system
-			RectangleF pixRect = this.Location.TransformRect( pane );
-
-			if (	Math.Abs( pixRect.Left ) < 100000 &&
-					Math.Abs( pixRect.Top ) < 100000 &&
-					Math.Abs( pixRect.Right ) < 100000 &&
-					Math.Abs( pixRect.Bottom ) < 100000 )
-			{
-				if ( _fill.IsVisible )
-					using ( Brush brush = _fill.MakeBrush( pixRect ) )
-						g.FillEllipse( brush, pixRect );
-
-				if ( _border.IsVisible )
-					using ( Pen pen = _border.GetPen( pane, scaleFactor ) )
-						g.DrawEllipse( pen, pixRect );
-			}
-		}
-		
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="BoxObj"/>.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-				return false;
-
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			RectangleF pixRect = _location.TransformRect( pane );
-
-			using ( GraphicsPath path = new GraphicsPath() )
-			{
-				path.AddEllipse( pixRect );
-				return path.IsVisible( pt );
-			}
-		}
-		
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/ErrorBar.cs b/BDInfo/ZedGraph/ErrorBar.cs
deleted file mode 100644
index f5a4770d6b..0000000000
--- a/BDInfo/ZedGraph/ErrorBar.cs
+++ /dev/null
@@ -1,388 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class handles the drawing of the curve <see cref="ErrorBar"/> objects.
-	/// The Error Bars are the vertical lines with a symbol at each end.
-	/// </summary>
-	/// <remarks>To draw "I-Beam" bars, the symbol type defaults to
-	/// <see cref="SymbolType.HDash"/>, which is just a horizontal line.
-	/// If <see cref="BarBase"/> is Y-oriented, then the symbol type should be
-	/// set to <see cref="SymbolType.VDash"/> to get the same effect.
-	/// </remarks>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.21 $ $Date: 2007/08/10 16:22:54 $ </version>
-	[Serializable]
-	public class ErrorBar : ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores the visibility of this
-		/// <see cref="ErrorBar"/>.  Use the public
-		/// property <see cref="IsVisible"/> to access this value.  If this value is
-		/// false, the symbols will not be shown.
-		/// </summary>
-		private bool		_isVisible;
-		/// <summary>
-		/// Private field that stores the error bar color.  Use the public
-		/// property <see cref="Color"/> to access this value.
-		/// </summary>
-		private Color		_color;
-		/// <summary>
-		/// Private field that stores the pen width for this error bar.  Use the public
-		/// property <see cref="PenWidth"/> to access this value.
-		/// </summary>
-		private float		_penWidth;
-		/// <summary>
-		/// private field that contains the symbol element that will be drawn
-		/// at the top and bottom of the error bar.  Use the public property
-		/// <see cref="Symbol"/> to access this value.
-		/// </summary>
-		private Symbol		_symbol;
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ZedGraph.ErrorBar"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default Symbol properties
-			/// <summary>
-			/// The default size for curve symbols
-			/// (<see cref="ZedGraph.Symbol.Size"/> property),
-			/// in units of points.
-			/// </summary>
-			public static float Size = 7;
-			/// <summary>
-			/// The default pen width to be used for drawing error bars
-			/// (<see cref="ErrorBar.PenWidth"/> property).  Units are points.
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The default display mode for symbols (<see cref="ErrorBar.IsVisible"/> property).
-			/// true to display symbols, false to hide them.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// The default color for drawing error bars (<see cref="ErrorBar.Color"/> property).
-			/// </summary>
-			public static Color Color = Color.Red;
-			/// <summary>
-			/// The default symbol for drawing at the top and bottom of the
-			/// error bar (see <see cref="ErrorBar.Symbol"/>).
-			/// </summary>
-			public static SymbolType Type = SymbolType.HDash;
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets or sets a property that shows or hides the <see cref="ErrorBar"/>.
-		/// </summary>
-		/// <value>true to show the error bar, false to hide it</value>
-		/// <seealso cref="Default.IsVisible"/>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-		
-		/// <summary>
-		/// Gets or sets the <see cref="System.Drawing.Color"/> data for this
-		/// <see cref="ErrorBar"/>.
-		/// </summary>
-		/// <remarks>This property only controls the color of
-		/// the vertical line.  The symbol color is controlled separately in
-		/// the <see cref="Symbol"/> property.
-		/// </remarks>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-		/// <summary>
-		/// The pen width to be used for drawing error bars
-		/// Units are points.
-		/// </summary>
-		/// <remarks>This property only controls the pen width for the
-		/// vertical line.  The pen width for the symbol outline is
-		/// controlled separately by the <see cref="Symbol"/> property.
-		/// </remarks>
-		public float PenWidth
-		{
-			get { return _penWidth; }
-			set { _penWidth = value; }
-		}
-		/// <summary>
-		/// Contains the symbol element that will be drawn
-		/// at the top and bottom of the error bar.
-		/// </summary>
-		public Symbol Symbol
-		{
-			get { return _symbol; }
-			set { _symbol = value; }
-		}
-
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Default constructor that sets all <see cref="ErrorBar"/> properties to
-		/// default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public ErrorBar() : this( Default.Color )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the
-		/// <see cref="Color"/> as specified, and the remaining
-		/// <see cref="ErrorBar"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the color of the symbol
-		/// </param>
-		public ErrorBar( Color color )
-		{
-			_symbol = new Symbol( Default.Type, color );
-			_symbol.Size = Default.Size;
-			_color = color;
-			_penWidth = Default.PenWidth;
-			_isVisible = Default.IsVisible;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ErrorBar"/> object from which to copy</param>
-		public ErrorBar( ErrorBar rhs )
-		{
-			_color = rhs.Color;
-			_isVisible = rhs.IsVisible;
-			_penWidth = rhs.PenWidth;
-			_symbol = rhs.Symbol.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ErrorBar Clone()
-		{
-			return new ErrorBar( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected ErrorBar( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_isVisible = info.GetBoolean( "isVisible" );
-			_color = (Color) info.GetValue( "color", typeof(Color) );
-			_penWidth = info.GetSingle( "penWidth" );
-			_symbol = (Symbol) info.GetValue( "symbol", typeof(Symbol) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "color", _color );
-			info.AddValue( "penWidth", _penWidth );
-			info.AddValue( "symbol", _symbol );
-		}
-	#endregion
-
-	#region Rendering Methods
-		/// <summary>
-		/// Draw the <see cref="ErrorBar"/> to the specified <see cref="Graphics"/>
-		/// device at the specified location.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="isXBase">boolean value that indicates if the "base" axis for this
-		/// <see cref="ErrorBar"/> is the X axis.  True for an <see cref="XAxis"/> base,
-		/// false for a <see cref="YAxis"/> or <see cref="Y2Axis"/> base.</param>
-		/// <param name="pixBase">The independent axis position of the center of the error bar in
-		/// pixel units</param>
-		/// <param name="pixValue">The dependent axis position of the top of the error bar in
-		/// pixel units</param>
-		/// <param name="pixLowValue">The dependent axis position of the bottom of the error bar in
-		/// pixel units</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.</param>
-		/// <param name="pen">A pen with attributes of <see cref="Color"/> and
-		/// <see cref="PenWidth"/> for this <see cref="ErrorBar"/></param>
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable for <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/> or <see cref="FillType.GradientByZ"/>.</param>
-		/// <param name="isSelected">Indicates that the <see cref="ErrorBar" /> should be drawn
-		/// with attributes from the <see cref="Selection" /> class.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, bool isXBase,
-								float pixBase, float pixValue,
-								float pixLowValue, float scaleFactor, Pen pen, bool isSelected,
-								PointPair dataValue )
-		{
-			if ( isXBase )
-			{
-				g.DrawLine( pen, pixBase, pixValue, pixBase, pixLowValue );
-				_symbol.DrawSymbol( g, pane, (int)pixBase, (int)pixValue,
-							scaleFactor, isSelected, dataValue );
-				_symbol.DrawSymbol( g, pane, (int)pixBase, (int)pixLowValue,
-							scaleFactor, isSelected, dataValue );
-			}
-			else
-			{
-				g.DrawLine( pen, pixValue, pixBase, pixLowValue, pixBase );
-				_symbol.DrawSymbol( g, pane, (int)pixValue, (int)pixBase,
-							scaleFactor, isSelected, dataValue );
-				_symbol.DrawSymbol( g, pane, (int)pixLowValue, (int)pixBase,
-							scaleFactor, isSelected, dataValue );
-			}
-		}
-
-
-		/// <summary>
-		/// Draw all the <see cref="ErrorBar"/>'s to the specified <see cref="Graphics"/>
-		/// device as a an error bar at each defined point.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> object representing the
-		/// <see cref="Bar"/>'s to be drawn.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, ErrorBarItem curve,
-							Axis baseAxis, Axis valueAxis, float scaleFactor )
-		{
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-
-			float	pixBase, pixValue, pixLowValue;
-			double	scaleBase, scaleValue, scaleLowValue;
-		
-			if ( curve.Points != null && this.IsVisible )
-			{
-				using ( Pen pen = !curve.IsSelected ? new Pen( _color, _penWidth ) :
-						new Pen( Selection.Border.Color, Selection.Border.Width ) )
-				{
-					// Loop over each defined point							
-					for ( int i = 0; i < curve.Points.Count; i++ )
-					{
-						valueHandler.GetValues( curve, i, out scaleBase,
-									out scaleLowValue, out scaleValue );
-
-						// Any value set to double max is invalid and should be skipped
-						// This is used for calculated values that are out of range, divide
-						//   by zero, etc.
-						// Also, any value <= zero on a log scale is invalid
-
-						if ( !curve.Points[i].IsInvalid3D &&
-								( scaleBase > 0 || !baseAxis._scale.IsLog ) &&
-								( ( scaleValue > 0 && scaleLowValue > 0 ) || !valueAxis._scale.IsLog ) )
-						{
-							pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, scaleBase );
-							pixValue = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, scaleValue );
-							pixLowValue = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, scaleLowValue );
-
-							//if ( this.fill.IsGradientValueType )
-							//	brush = fill.MakeBrush( _rect, _points[i] );
-
-							this.Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis, pixBase, pixValue,
-											pixLowValue, scaleFactor, pen, curve.IsSelected,
-											curve.Points[i] );
-						}
-					}
-				}
-			}
-		}
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/ErrorBarItem.cs b/BDInfo/ZedGraph/ErrorBarItem.cs
deleted file mode 100644
index c08472874f..0000000000
--- a/BDInfo/ZedGraph/ErrorBarItem.cs
+++ /dev/null
@@ -1,364 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates an "Error Bar" curve type that displays a vertical or horizontal
-	/// line with a symbol at each end.
-	/// </summary>
-	/// <remarks>The <see cref="ErrorBarItem"/> type is intended for displaying
-	/// confidence intervals, candlesticks, stock High-Low charts, etc.  It is
-	/// technically not a bar, since it is drawn as a vertical or horizontal line.
-	/// The default symbol at each end of the "bar" is <see cref="SymbolType.HDash"/>,
-	/// which creates an "I-Beam".  For horizontal bars
-	/// (<see cref="ZedGraph.BarBase.Y"/> or
-	/// <see cref="ZedGraph.BarBase.Y2"/>), you will need to change the symbol to
-	/// <see cref="SymbolType.VDash"/> to get horizontal "I-Beams".
-	/// Since the horizontal segments are actually symbols, their widths are
-	/// controlled by the symbol size in <see cref="ZedGraph.ErrorBar.Symbol"/>,
-	/// specified in points (1/72nd inch).  The position of each "I-Beam" is set
-	/// according to the <see cref="PointPair"/> values.  The independent axis
-	/// is assigned with <see cref="BarSettings.Base"/>, and is a
-	/// <see cref="ZedGraph.BarBase"/> enum type.</remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.19 $ $Date: 2007/04/16 00:03:01 $ </version>
-	[Serializable]
-	public class ErrorBarItem : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.ErrorBar"/>
-		/// class defined for this <see cref="ErrorBarItem"/>.  Use the public
-		/// property <see cref="ErrorBar"/> to access this value.
-		/// </summary>
-		private ErrorBar _bar;
-
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets a reference to the <see cref="ZedGraph.ErrorBar"/> class defined
-		/// for this <see cref="ErrorBarItem"/>.
-		/// </summary>
-		public ErrorBar Bar
-		{
-			get { return _bar; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return true;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return pane._barSettings.Base == BarBase.X;
-		}
-
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="ErrorBarItem"/>, specifying only the legend label.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		public ErrorBarItem( string label ) : base( label )
-		{
-			_bar = new ErrorBar();
-		}
-		
-		/// <summary>
-		/// Create a new <see cref="ErrorBarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the X axis values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the Y axis values for this curve</param>
-		/// <param name="lowValue">An array of double precision values that define
-		/// the lower dependent values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> properties.
-		/// </param>
-		public ErrorBarItem( string label, double[] x, double[] y, double[] lowValue,
-							System.Drawing.Color color )
-			: this( label, new PointPairList( x, y, lowValue ), color )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="ErrorBarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision values that define
-		/// the X, Y and lower dependent values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> properties.
-		/// </param>
-		public ErrorBarItem( string label, IPointList points, Color color )
-			: base( label, points )
-		{
-			_bar = new ErrorBar( color );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ErrorBarItem"/> object from which to copy</param>
-		public ErrorBarItem( ErrorBarItem rhs ) : base( rhs )
-		{
-			_bar = new ErrorBar( rhs.Bar );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ErrorBarItem Clone()
-		{
-			return new ErrorBarItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected ErrorBarItem( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_bar = (ErrorBar) info.GetValue( "bar", typeof(ErrorBar) );
-
-			// This is now just a dummy variable, since barBase was removed
-			BarBase barBase = (BarBase) info.GetValue( "barBase", typeof(BarBase) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "bar", _bar );
-
-			// BarBase is now just a dummy value, since the GraphPane.BarBase is used exclusively
-			info.AddValue( "barBase", BarBase.X );
-		}
-	#endregion
-
-	#region Methods
-		/// <summary>
-		/// Do all rendering associated with this <see cref="ErrorBarItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="ErrorBarItem"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor  )
-		{
-			if ( _isVisible )
-			{
-				_bar.Draw( g, pane, this, this.BaseAxis( pane ),
-								this.ValueAxis( pane ), scaleFactor );
-			}
-		}		
-
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="ErrorBarItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-        /// <param name="pane">
-        /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-        /// owner of this object.
-        /// </param>
-        /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-        /// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect,
-									float scaleFactor )
-		{
-			float pixBase, pixValue, pixLowValue;
-
-			if ( pane._barSettings.Base == BarBase.X )
-			{
-				pixBase = rect.Left + rect.Width / 2.0F;
-				pixValue = rect.Top;
-				pixLowValue = rect.Bottom;
-			}
-			else
-			{
-				pixBase = rect.Top + rect.Height / 2.0F;
-				pixValue = rect.Right;
-				pixLowValue = rect.Left;
-			}
-
-			using ( Pen pen = new Pen( _bar.Color, _bar.PenWidth ) )
-			{
-				this.Bar.Draw( g, pane, pane._barSettings.Base == BarBase.X, pixBase, pixValue,
-									pixLowValue, scaleFactor, pen, false, null );
-			}
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			if ( i < 0 || i >= _points.Count )
-				return false;
-
-			Axis valueAxis = ValueAxis( pane );
-			Axis baseAxis = BaseAxis( pane );
-
-			float scaledSize = _bar.Symbol.Size * pane.CalcScaleFactor();
-
-			// pixBase = pixel value for the bar center on the base axis
-			// pixHiVal = pixel value for the bar top on the value axis
-			// pixLowVal = pixel value for the bar bottom on the value axis
-			float pixBase, pixHiVal, pixLowVal;
-
-			float clusterWidth = pane.BarSettings.GetClusterWidth();
-			float barWidth = GetBarWidth( pane );
-			float clusterGap = pane._barSettings.MinClusterGap * barWidth;
-			float barGap = barWidth * pane._barSettings.MinBarGap;
-
-			// curBase = the scale value on the base axis of the current bar
-			// curHiVal = the scale value on the value axis of the current bar
-			// curLowVal = the scale value of the bottom of the bar
-			double curBase, curLowVal, curHiVal;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			valueHandler.GetValues( this, i, out curBase, out curLowVal, out curHiVal );
-
-			// Any value set to double max is invalid and should be skipped
-			// This is used for calculated values that are out of range, divide
-			//   by zero, etc.
-			// Also, any value <= zero on a log scale is invalid
-
-			if ( !_points[i].IsInvalid3D )
-			{
-				// calculate a pixel value for the top of the bar on value axis
-				pixLowVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curLowVal );
-				pixHiVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curHiVal );
-				// calculate a pixel value for the center of the bar on the base axis
-				pixBase = baseAxis.Scale.Transform( _isOverrideOrdinal, i, curBase );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - scaledSize / 2.0F;
-
-				// Draw the bar
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixSide, pixLowVal,
-								pixSide + scaledSize, pixHiVal );
-				else
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixLowVal, pixSide,
-								pixHiVal, pixSide + scaledSize );
-
-				return true;
-			}
-
-			return false;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ExponentScale.cs b/BDInfo/ZedGraph/ExponentScale.cs
deleted file mode 100644
index 07e597dfe3..0000000000
--- a/BDInfo/ZedGraph/ExponentScale.cs
+++ /dev/null
@@ -1,404 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The ExponentScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Exponent" />.
-	/// </summary>
-	/// <remarks>
-	/// ExponentScale is a non-linear axis in which the values are scaled using an exponential function
-	/// with the <see cref="Scale.Exponent" /> property.
-	/// </remarks>
-	/// 
-	/// <author> John Champion with contributions by jackply </author>
-	/// <version> $Revision: 1.8 $ $Date: 2007/04/16 00:03:01 $ </version>
-	[Serializable]
-	class ExponentScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public ExponentScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ExponentScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="ExponentScale" /></param>
-		public ExponentScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new ExponentScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		public override AxisType Type
-		{
-			get { return AxisType.Exponent; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Setup some temporary transform values in preparation for rendering the <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// This method is typically called by the parent <see cref="GraphPane"/>
-		/// object as part of the <see cref="GraphPane.Draw"/> method.  It is also
-		/// called by <see cref="GraphPane.GeneralTransform(double,double,CoordType)"/> and
-		/// <see cref="GraphPane.ReverseTransform( PointF, out double, out double )"/>
-		/// methods to setup for coordinate transformations.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="axis">
-		/// The parent <see cref="Axis" /> for this <see cref="Scale" />
-		/// </param>
-		override public void SetupScaleData( GraphPane pane, Axis axis )
-		{
-			base.SetupScaleData( pane, axis );
-
-			if (  _exponent > 0 )
-			{
-				_minLinTemp = Linearize( _min );
-				_maxLinTemp = Linearize( _max );
-			}
-			else if ( _exponent < 0 )
-			{
-				_minLinTemp = Linearize( _max );
-				_maxLinTemp = Linearize( _min );
-			}
-		}
-
-		/// <summary>
-		/// Convert a value to its linear equivalent for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the log or power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		override public double Linearize( double val )
-		{
-			return SafeExp( val, _exponent );
-		}
-
-		/// <summary>
-		/// Convert a value from its linear equivalent to its actual scale value
-		/// for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the anti-log or inverse-power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		override public double DeLinearize( double val )
-		{
-			return Math.Pow( val, 1 / _exponent );
-		}
-
-		/// <summary>
-		/// Determine the value for any major tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double)
-		/// </param>
-		/// <param name="tic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified major tic value (floating point double).
-		/// </returns>
-		override internal double CalcMajorTicValue( double baseVal, double tic )
-		{
-			if ( _exponent > 0.0 )
-			{
-				//return baseVal + Math.Pow ( (double) this.majorStep * tic, exp );
-				//baseVal is got from CalBase..., and it is exp..
-				return Math.Pow( Math.Pow( baseVal, 1 / _exponent ) + _majorStep * tic, _exponent );
-			}
-			else if ( _exponent < 0.0 )
-			{
-				//baseVal is got from CalBase..., and it is exp..
-				return Math.Pow( Math.Pow( baseVal, 1 / _exponent ) + _majorStep * tic, _exponent );
-			}
-
-			return 1.0;
-		}
-
-		/// <summary>
-		/// Determine the value for any minor tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double).  This tic value is the base
-		/// reference for all tics (including minor ones).
-		/// </param>
-		/// <param name="iTic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified minor tic value (floating point double).
-		/// </returns>
-		override internal double CalcMinorTicValue( double baseVal, int iTic )
-		{
-			return baseVal + Math.Pow( (double) _majorStep * (double) iTic, _exponent );
-		}
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first minor tic mark
-		/// </summary>
-		/// <param name="baseVal">
-		/// The value of the first major tic for the axis.
-		/// </param>
-		/// <returns>
-		/// The ordinal position of the first minor tic, relative to the first major tic.
-		/// This value can be negative (e.g., -3 means the first minor tic is 3 minor step
-		/// increments before the first major tic.
-		/// </returns>
-		override internal int CalcMinorStart( double baseVal )
-		{
-			return (int) ( ( Math.Pow( _min, _exponent ) - baseVal ) / Math.Pow( _minorStep, _exponent ) );
-		}
-
-		/// <summary>
-		/// Select a reasonable exponential axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Exponent"/> type axes, and it
-		/// is called by the general <see cref="Scale.PickScale"/> method.  The exponential scale
-		/// relies on the <see cref="Scale.Exponent" /> property to set the scaling exponent.  This
-		/// method honors the <see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min"/>, <see cref="Scale.Max"/>, or <see cref="Scale.MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  For log axes, the MinorStep
-		/// value is not used.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <seealso cref="Scale.PickScale"/>
-		/// <seealso cref="AxisType.Exponent"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( _max - _min < 1.0e-20 )
-			{
-				if ( _maxAuto )
-					_max = _max + 0.2 * ( _max == 0 ? 1.0 : Math.Abs( _max ) );
-				if ( _minAuto )
-					_min = _min - 0.2 * ( _min == 0 ? 1.0 : Math.Abs( _min ) );
-			}
-
-			// This is the zero-lever test.  If minVal is within the zero lever fraction
-			// of the data range, then use zero.
-
-			if ( _minAuto && _min > 0 &&
-				_min / ( _max - _min ) < Default.ZeroLever )
-				_min = 0;
-
-			// Repeat the zero-lever test for cases where the maxVal is less than zero
-			if ( _maxAuto && _max < 0 &&
-				Math.Abs( _max / ( _max - _min ) ) <
-				Default.ZeroLever )
-				_max = 0;
-
-			// Calculate the new step size
-			if ( _majorStepAuto )
-			{
-				double targetSteps = ( _ownerAxis is XAxis || _ownerAxis is X2Axis ) ?
-						Default.TargetXSteps : Default.TargetYSteps;
-
-				// Calculate the step size based on target steps
-				_majorStep = CalcStepSize( _max - _min, targetSteps );
-
-				if ( _isPreventLabelOverlap )
-				{
-					// Calculate the maximum number of labels
-					double maxLabels = (double) this.CalcMaxLabels( g, pane, scaleFactor );
-
-					if ( maxLabels < ( _max - _min ) / _majorStep )
-						_majorStep = CalcBoundedStepSize( _max - _min, maxLabels );
-				}
-			}
-
-			// Calculate the new step size
-			if ( _minorStepAuto )
-				_minorStep = CalcStepSize( _majorStep,
-					( _ownerAxis is XAxis || _ownerAxis is X2Axis ) ?
-							Default.TargetMinorXSteps : Default.TargetMinorYSteps );
-
-			// Calculate the scale minimum
-			if ( _minAuto )
-				_min = _min - MyMod( _min, _majorStep );
-
-			// Calculate the scale maximum
-			if ( _maxAuto )
-				_max = MyMod( _max, _majorStep ) == 0.0 ? _max :
-					_max + _majorStep - MyMod( _max, _majorStep );
-
-			// set the scale magnitude if required
-			if ( _magAuto )
-			{
-				// Find the optimal scale display multiple
-				double mag = 0;
-				double mag2 = 0;
-
-				if ( Math.Abs( _min ) > 1.0e-10 )
-					mag = Math.Floor( Math.Log10( Math.Abs( _min ) ) );
-				if ( Math.Abs( _max ) > 1.0e-10 )
-					mag2 = Math.Floor( Math.Log10( Math.Abs( _max ) ) );
-				if ( Math.Abs( mag2 ) > Math.Abs( mag ) )
-					mag = mag2;
-
-				// Do not use scale multiples for magnitudes below 4
-				if ( Math.Abs( mag ) <= 3 )
-					mag = 0;
-
-				// Use a power of 10 that is a multiple of 3 (engineering scale)
-				_mag = (int) ( Math.Floor( mag / 3.0 ) * 3.0 );
-			}
-
-			// Calculate the appropriate number of dec places to display if required
-			if ( _formatAuto )
-			{
-				int numDec = 0 - (int) ( Math.Floor( Math.Log10( _majorStep ) ) - _mag );
-				if ( numDec < 0 )
-					numDec = 0;
-				_format = "f" + numDec.ToString();
-			}
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.Exponent" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			double scaleMult = Math.Pow( (double) 10.0, _mag );
-			double val = Math.Pow( dVal, 1 / _exponent ) / scaleMult;
-			return val.ToString( _format );
-		}
-
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected ExponentScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Fill.cs b/BDInfo/ZedGraph/Fill.cs
deleted file mode 100644
index 2fd13a87ff..0000000000
--- a/BDInfo/ZedGraph/Fill.cs
+++ /dev/null
@@ -1,1145 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that encapsulates color-fill properties for an object.  The <see cref="Fill"/> class
-	/// is used in <see cref="PaneBase.Rect"/>, <see cref="Chart.Rect"/>, <see cref="Legend"/>,
-	/// <see cref="Bar"/>, and <see cref="Line"/> objects.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.22 $ $Date: 2007/01/26 09:01:49 $ </version>
-	[Serializable]
-	public class Fill : ISerializable, ICloneable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the fill color.  Use the public
-		/// property <see cref="Color"/> to access this value.  This property is
-		/// only applicable if the <see cref="Type"/> is not <see cref="ZedGraph.FillType.None"/>.
-		/// </summary>
-		private Color _color;
-		/// <summary>
-		/// Private field that stores the secondary color for gradientByValue fills.  Use the public
-		/// property <see cref="SecondaryValueGradientColor"/> to access this value.  This property is
-		/// only applicable if the <see cref="Type"/> is <see cref="ZedGraph.FillType.GradientByX"/>,
-		/// <see cref="ZedGraph.FillType.GradientByY"/>, or <see cref="ZedGraph.FillType.GradientByZ"/>.
-		/// </summary>
-		private Color _secondaryValueGradientColor;
-		/// <summary>
-		/// Private field that stores the custom fill brush.  Use the public
-		/// property <see cref="Brush"/> to access this value.  This property is
-		/// only applicable if the 
-		/// <see cref="Type"/> property is set to <see cref="ZedGraph.FillType.Brush"/>.
-		/// </summary>
-		protected Brush	_brush;
-		/// <summary>
-		/// Private field that determines the type of color fill.  Use the public
-		/// property <see cref="Type"/> to access this value.  The fill color
-		/// is determined by the property <see cref="Color"/> or
-		/// <see cref="Brush"/>.
-		/// </summary>
-		private FillType	_type;
-		/// <summary>
-		/// Private field that determines if the brush will be scaled to the bounding box
-		/// of the filled object.  If this value is false, then the brush will only be aligned
-		/// with the filled object based on the <see cref="AlignH"/> and <see cref="AlignV"/>
-		/// properties.
-		/// </summary>
-		private bool		_isScaled;
-		/// <summary>
-		/// Private field that determines how the brush will be aligned with the filled object
-		/// in the horizontal direction.  This value is a <see cref="ZedGraph.AlignH"/> enumeration.
-		/// This field only applies if <see cref="IsScaled"/> is false.
-		/// properties.
-		/// </summary>
-		/// <seealso cref="AlignH"/>
-		/// <seealso cref="AlignV"/>
-		private AlignH		_alignH;
-		/// <summary>
-		/// Private field that determines how the brush will be aligned with the filled object
-		/// in the vertical direction.  This value is a <see cref="ZedGraph.AlignV"/> enumeration.
-		/// This field only applies if <see cref="IsScaled"/> is false.
-		/// properties.
-		/// </summary>
-		/// <seealso cref="AlignH"/>
-		/// <seealso cref="AlignV"/>
-		private AlignV		_alignV;
-
-		private double	_rangeMin;
-		private double	_rangeMax;
-		private double _rangeDefault;
-		private Bitmap	_gradientBM;
-
-		/// <summary>
-		/// Private field that saves the image passed to the constructor.
-		/// This is used strictly for serialization.
-		/// </summary>
-		private Image	_image;
-		/// <summary>
-		/// Private field that saves the image wrapmode passed to the constructor.
-		/// This is used strictly for serialization.
-		/// </summary>
-		private WrapMode _wrapMode;
-		/// <summary>
-		/// Private field that saves the list of colors used to create the
-		/// <see cref="LinearGradientBrush"/> in the constructor.  This is used strictly
-		/// for serialization.
-		/// </summary>
-		private Color[] _colorList;
-		/// <summary>
-		/// Private field that saves the list of positions used to create the
-		/// <see cref="LinearGradientBrush"/> in the constructor.  This is used strictly
-		/// for serialization.
-		/// </summary>
-		private float[] _positionList;
-		/// <summary>
-		/// Private field the saves the angle of the fill.  This is used strictly for serialization.
-		/// </summary>
-		private float _angle;
-
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Fill"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default Fill properties
-			/// <summary>
-			/// The default scaling mode for <see cref="Brush"/> fills.
-			/// This is the default value for the <see cref="Fill.IsScaled"/> property.
-			/// </summary>
-			public static bool IsScaled = true;
-			/// <summary>
-			/// The default horizontal alignment for <see cref="Brush"/> fills.
-			/// This is the default value for the <see cref="Fill.AlignH"/> property.
-			/// </summary>
-			public static AlignH AlignH = AlignH.Center;
-			/// <summary>
-			/// The default vertical alignment for <see cref="Brush"/> fills.
-			/// This is the default value for the <see cref="Fill.AlignV"/> property.
-			/// </summary>
-			public static AlignV AlignV = AlignV.Center;
-		}
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Generic initializer to default values
-		/// </summary>
-		private void Init()
-		{
-			_color = Color.White;
-			_secondaryValueGradientColor = Color.White;
-			_brush = null;
-			_type = FillType.None;
-			_isScaled = Default.IsScaled;
-			_alignH = Default.AlignH;
-			_alignV = Default.AlignV;
-			_rangeMin = 0.0;
-			_rangeMax = 1.0;
-			_rangeDefault = double.MaxValue;
-			_gradientBM = null;
-
-			_colorList = null;
-			_positionList = null;
-			_angle = 0;
-			_image = null;
-			_wrapMode = WrapMode.Tile;
-
-		}
-
-		/// <summary>
-		/// The default constructor.  Initialized to no fill.
-		/// </summary>
-		public Fill()
-		{
-			Init();
-		}
-		
-		/// <summary>
-		/// Constructor that specifies the color, brush, and type for this fill.
-		/// </summary>
-		/// <param name="color">The color of the fill for solid fills</param>
-		/// <param name="brush">A custom brush for fills.  Can be a <see cref="SolidBrush"/>,
-		/// <see cref="LinearGradientBrush"/>, or <see cref="TextureBrush"/>.</param>
-		/// <param name="type">The <see cref="FillType"/> for this fill.</param>
-		public Fill( Color color, Brush brush, FillType type )
-		{
-			Init();
-			_color = color;
-			_brush = brush;
-			_type = type;
-		}
-		
-		/// <summary>
-		/// Constructor that creates a solid color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Solid"/>, and setting <see cref="Color"/> to the
-		/// specified color value.
-		/// </summary>
-		/// <param name="color">The color of the solid fill</param>
-		public Fill( Color color )
-		{
-			Init();
-			_color = color;
-			if ( color != Color.Empty )
-				_type = FillType.Solid;
-		}
-		
-		/// <summary>
-		/// Constructor that creates a linear gradient color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors and angle.
-		/// </summary>
-		/// <param name="color1">The first color for the gradient fill</param>
-		/// <param name="color2">The second color for the gradient fill</param>
-		/// <param name="angle">The angle (degrees) of the gradient fill</param>
-		public Fill( Color color1, Color color2, float angle )
-		{
-			Init();
-			_color = color2;
-
-			ColorBlend blend = new ColorBlend( 2 );
-			blend.Colors[0] = color1;
-			blend.Colors[1] = color2;
-			blend.Positions[0] = 0.0f;
-			blend.Positions[1] = 1.0f;
-			_type = FillType.Brush;
-
-			this.CreateBrushFromBlend( blend, angle );
-		}
-		
-		/// <summary>
-		/// Constructor that creates a linear gradient color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.
-		/// </summary>
-		/// <param name="color1">The first color for the gradient fill</param>
-		/// <param name="color2">The second color for the gradient fill</param>
-		public Fill( Color color1, Color color2 ) : this( color1, color2, 0.0F )
-		{
-		}
-		
-		/// <summary>
-		/// Constructor that creates a linear gradient color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of three colors.
-		/// </summary>
-		/// <param name="color1">The first color for the gradient fill</param>
-		/// <param name="color2">The second color for the gradient fill</param>
-		/// <param name="color3">The third color for the gradient fill</param>
-		public Fill( Color color1, Color color2, Color color3 ) :
-			this( color1, color2, color3, 0.0f )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of three colors
-		/// </summary>
-		/// <param name="color1">The first color for the gradient fill</param>
-		/// <param name="color2">The second color for the gradient fill</param>
-		/// <param name="color3">The third color for the gradient fill</param>
-		/// <param name="angle">The angle (degrees) of the gradient fill</param>
-		public Fill( Color color1, Color color2, Color color3, float angle )
-		{
-			Init();
-			_color = color3;
-
-			ColorBlend blend = new ColorBlend( 3 );
-			blend.Colors[0] = color1;
-			blend.Colors[1] = color2;
-			blend.Colors[2] = color3;
-			blend.Positions[0] = 0.0f;
-			blend.Positions[1] = 0.5f;
-			blend.Positions[2] = 1.0f;
-			_type = FillType.Brush;
-			
-			this.CreateBrushFromBlend( blend, angle );
-		}
-		
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on a <see cref="ColorBlend"/> object.  The gradient
-		/// angle is defaulted to zero.
-		/// </summary>
-		/// <param name="blend">The <see cref="ColorBlend"/> object that defines the colors
-		/// and positions along the gradient.</param>
-		public Fill( ColorBlend blend ) :
-			this( blend, 0.0F )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on a <see cref="ColorBlend"/> object, drawn at the
-		/// specified angle (degrees).
-		/// </summary>
-		/// <param name="blend">The <see cref="ColorBlend"/> object that defines the colors
-		/// and positions along the gradient.</param>
-		/// <param name="angle">The angle (degrees) of the gradient fill</param>
-		public Fill( ColorBlend blend, float angle )
-		{
-			Init();
-			_type = FillType.Brush;
-			this.CreateBrushFromBlend( blend, angle );
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on an array of <see cref="Color"/> objects, drawn at an
-		/// angle of zero (degrees).  The <see paramref="colors"/> array is used to create
-		/// a <see cref="ColorBlend"/> object assuming a even linear distribution of the colors
-		/// across the gradient.
-		/// </summary>
-		/// <param name="colors">The array of <see cref="Color"/> objects that defines the colors
-		/// along the gradient.</param>
-		public Fill( Color[] colors ) :
-			this( colors, 0.0F )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on an array of <see cref="Color"/> objects, drawn at the
-		/// specified angle (degrees).  The <see paramref="colors"/> array is used to create
-		/// a <see cref="ColorBlend"/> object assuming a even linear distribution of the colors
-		/// across the gradient.
-		/// </summary>
-		/// <param name="colors">The array of <see cref="Color"/> objects that defines the colors
-		/// along the gradient.</param>
-		/// <param name="angle">The angle (degrees) of the gradient fill</param>
-		public Fill( Color[] colors, float angle )
-		{
-			Init();
-			_color = colors[ colors.Length - 1 ];
-
-			ColorBlend blend = new ColorBlend();
-			blend.Colors = colors;
-			blend.Positions = new float[colors.Length];
-			blend.Positions[0] = 0.0F;
-			for ( int i=1; i<colors.Length; i++ )
-				blend.Positions[i] = (float) i / (float)( colors.Length - 1 );
-			_type = FillType.Brush;
-
-			this.CreateBrushFromBlend( blend, angle );
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on an array of <see cref="Color"/> objects, drawn at the
-		/// an angle of zero (degrees).  The <see paramref="colors"/> array is used to create
-		/// a <see cref="ColorBlend"/> object assuming a even linear distribution of the colors
-		/// across the gradient.
-		/// </summary>
-		/// <param name="colors">The array of <see cref="Color"/> objects that defines the colors
-		/// along the gradient.</param>
-		/// <param name="positions">The array of floating point values that defines the color
-		/// positions along the gradient.  Values should range from 0 to 1.</param>
-		public Fill( Color[] colors, float[] positions ) :
-			this( colors, positions, 0.0F )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a linear gradient multi-color-fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> using the specified colors.  This gradient fill
-		/// consists of many colors based on an array of <see cref="Color"/> objects, drawn at the
-		/// specified angle (degrees).  The <see paramref="colors"/> array is used to create
-		/// a <see cref="ColorBlend"/> object assuming a even linear distribution of the colors
-		/// across the gradient.
-		/// </summary>
-		/// <param name="colors">The array of <see cref="Color"/> objects that defines the colors
-		/// along the gradient.</param>
-		/// <param name="positions">The array of floating point values that defines the color
-		/// positions along the gradient.  Values should range from 0 to 1.</param>
-		/// <param name="angle">The angle (degrees) of the gradient fill</param>
-		public Fill( Color[] colors, float[] positions, float angle )
-		{
-			Init();
-			_color = colors[ colors.Length - 1 ];
-
-			ColorBlend blend = new ColorBlend();
-			blend.Colors = colors;
-			blend.Positions = positions;
-			_type = FillType.Brush;
-
-			this.CreateBrushFromBlend( blend, angle );
-		}
-
-		/// <summary>
-		/// Constructor that creates a texture fill, setting <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/> and using the specified image.
-		/// </summary>
-		/// <param name="image">The <see cref="Image"/> to use for filling</param>
-		/// <param name="wrapMode">The <see cref="WrapMode"/> class that controls the image wrapping properties</param>
-		public Fill( Image image, WrapMode wrapMode )
-		{
-			Init();
-			_color = Color.White;
-			_brush = new TextureBrush( image, wrapMode );
-			_type = FillType.Brush;
-			_image = image;
-			_wrapMode = wrapMode;
-		}
-		
-		/// <summary>
-		/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
-		/// <see cref="Brush"/>.  The brush will be scaled to fit the destination screen object
-		/// unless you manually change <see cref="IsScaled"/> to false;
-		/// </summary>
-		/// <param name="brush">The <see cref="Brush"/> to use for fancy fills.  Typically, this would
-		/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
-		public Fill( Brush brush ) : this( brush, Default.IsScaled )
-		{
-		}
-		
-		/// <summary>
-		/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
-		/// <see cref="Brush"/>.  The brush will be scaled to fit the destination screen object
-		/// according to the <see paramref="isScaled"/> parameter.
-		/// </summary>
-		/// <param name="brush">The <see cref="Brush"/> to use for fancy fills.  Typically, this would
-		/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
-		/// <param name="isScaled">Determines if the brush will be scaled to fit the bounding box
-		/// of the destination object.  true to scale it, false to leave it unscaled</param>
-		public Fill( Brush brush, bool isScaled )
-		{
-			Init();
-			_isScaled = isScaled;
-			_color = Color.White;
-			_brush = (Brush) brush.Clone();
-			_type = FillType.Brush;
-		}
-		
-		/// <summary>
-		/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
-		/// <see cref="Brush"/>.  This constructor will make the brush unscaled (see <see cref="IsScaled"/>),
-		/// but it provides <see paramref="alignH"/> and <see paramref="alignV"/> parameters to control
-		/// alignment of the brush with respect to the filled object.
-		/// </summary>
-		/// <param name="brush">The <see cref="Brush"/> to use for fancy fills.  Typically, this would
-		/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
-		/// <param name="alignH">Controls the horizontal alignment of the brush within the filled object
-		/// (see <see cref="AlignH"/></param>
-		/// <param name="alignV">Controls the vertical alignment of the brush within the filled object
-		/// (see <see cref="AlignV"/></param>
-		public Fill( Brush brush, AlignH alignH, AlignV alignV )
-		{
-			Init();
-			_alignH = alignH;
-			_alignV = alignV;
-			_isScaled = false;
-			_color = Color.White;
-			_brush = (Brush) brush.Clone();
-			_type = FillType.Brush;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Fill object from which to copy</param>
-		public Fill( Fill rhs )
-		{
-			_color = rhs._color;
-			_secondaryValueGradientColor = rhs._color;
-
-			if ( rhs._brush != null )
-				_brush = (Brush) rhs._brush.Clone();
-			else
-				_brush = null;
-			_type = rhs._type;
-			_alignH = rhs.AlignH;
-			_alignV = rhs.AlignV;
-            _isScaled = rhs.IsScaled;
-			_rangeMin = rhs._rangeMin;
-			_rangeMax = rhs._rangeMax;
-			_rangeDefault = rhs._rangeDefault;
-			_gradientBM = null;
-
-			if ( rhs._colorList != null )
-				_colorList = (Color[]) rhs._colorList.Clone();
-			else
-				_colorList = null;
-
-			if ( rhs._positionList != null )
-			{
-				_positionList = (float[]) rhs._positionList.Clone();
-			}
-			else
-				_positionList = null;
-
-			if ( rhs._image != null )
-				_image = (Image) rhs._image.Clone();
-			else
-				_image = null;
-
-			_angle = rhs._angle;
-			_wrapMode = rhs._wrapMode;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Fill Clone()
-		{
-			return new Fill( this );
-		}
-
-		private void CreateBrushFromBlend( ColorBlend blend, float angle )
-		{
-			_angle = angle;
-
-			_colorList = (Color[]) blend.Colors.Clone();
-			_positionList = (float[]) blend.Positions.Clone();
-
-			_brush = new LinearGradientBrush( new Rectangle( 0, 0, 100, 100 ),
-				Color.Red, Color.White, angle );
-			((LinearGradientBrush)_brush).InterpolationColors = blend;
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-		// schema changed to 2 with addition of rangeDefault
-		// schema changed to 10 with version 5 refactor -- not backwards compatible
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Fill( SerializationInfo info, StreamingContext context )
-		{
-			Init();
-
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_color = (Color) info.GetValue( "color", typeof(Color) );
-			_secondaryValueGradientColor = (Color) info.GetValue( "secondaryValueGradientColor", typeof( Color ) );
-			//brush = (Brush) info.GetValue( "brush", typeof(Brush) );
-			//brushHolder = (BrushHolder) info.GetValue( "brushHolder", typeof(BrushHolder) );
-			_type = (FillType) info.GetValue( "type", typeof(FillType) );
-			_isScaled = info.GetBoolean( "isScaled" );
-			_alignH = (AlignH) info.GetValue( "alignH", typeof(AlignH) );
-			_alignV = (AlignV) info.GetValue( "alignV", typeof(AlignV) );
-			_rangeMin = info.GetDouble( "rangeMin" );
-			_rangeMax = info.GetDouble( "rangeMax" );
-
-			//BrushHolder brushHolder = (BrushHolder) info.GetValue( "brushHolder", typeof( BrushHolder ) );
-			//brush = brush;
-
-			_colorList = (Color[]) info.GetValue( "colorList", typeof(Color[]) );
-			_positionList = (float[]) info.GetValue( "positionList", typeof(float[]) );
-			_angle = info.GetSingle( "angle" );
-			_image = (Image) info.GetValue( "image", typeof(Image) );
-			_wrapMode = (WrapMode) info.GetValue( "wrapMode", typeof(WrapMode) );
-
-			if ( _colorList != null && _positionList != null )
-			{
-				ColorBlend blend = new ColorBlend();
-				blend.Colors = _colorList;
-				blend.Positions = _positionList;
-				CreateBrushFromBlend( blend, _angle );
-			}
-			else if ( _image != null )
-			{
-				_brush = new TextureBrush( _image, _wrapMode );
-			}
-
-			_rangeDefault = info.GetDouble( "rangeDefault" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-
-			info.AddValue( "schema", schema );
-			info.AddValue( "color", _color );
-			info.AddValue( "secondaryValueGradientColor", _secondaryValueGradientColor );
-			//info.AddValue( "brush", brush );
-			//info.AddValue( "brushHolder", brushHolder );
-			info.AddValue( "type", _type );
-			info.AddValue( "isScaled", _isScaled );
-			info.AddValue( "alignH", _alignH );
-			info.AddValue( "alignV", _alignV );
-			info.AddValue( "rangeMin", _rangeMin );
-			info.AddValue( "rangeMax", _rangeMax );
-
-			//BrushHolder brushHolder = new BrushHolder();
-			//brush = brush;
-			//info.AddValue( "brushHolder", brushHolder );
-
-			info.AddValue( "colorList", _colorList );
-			info.AddValue( "positionList", _positionList );
-			info.AddValue( "angle", _angle );
-			info.AddValue( "image", _image );
-			info.AddValue( "wrapMode", _wrapMode );
-
-			info.AddValue( "rangeDefault", _rangeDefault );
-		}
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// The fill color.  This property is used as a single color to make a solid fill
-		/// (<see cref="Type"/> is <see cref="FillType.Solid"/>), or it can be used in 
-		/// combination with <see cref="System.Drawing.Color.White"/> to make a
-		/// <see cref="LinearGradientBrush"/>
-		/// when <see cref="Type"/> is <see cref="FillType.Brush"/> and <see cref="Brush"/>
-		/// is null.
-		/// </summary>
-		/// <seealso cref="Type"/>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the secondary color for gradientByValue fills.
-		/// </summary>
-		/// <remarks>
-		/// This property is only applicable if the <see cref="Type"/> is
-		/// <see cref="ZedGraph.FillType.GradientByX"/>,
-		/// <see cref="ZedGraph.FillType.GradientByY"/>, or
-		/// <see cref="ZedGraph.FillType.GradientByZ"/>.  Once the gradient-by-value logic picks
-		/// a color, a new gradient will be created using the SecondaryValueGradientColor, the
-		/// resulting gradient-by-value color, and the angle setting for this
-		/// <see cref="Fill" />. Use a value of <see cref="System.Drawing.Color.Empty">Color.Empty</see> to have
-		/// a solid-color <see cref="Fill" /> resulting from a gradient-by-value
-		/// <see cref="FillType" />.
-		/// </remarks>
-		public Color SecondaryValueGradientColor
-		{
-			get { return _secondaryValueGradientColor; }
-			set { _secondaryValueGradientColor = value; }
-		}
-
-		/// <summary>
-		/// The custom fill brush.  This can be a <see cref="SolidBrush"/>, a
-		/// <see cref="LinearGradientBrush"/>, or a <see cref="TextureBrush"/>.  This property is
-		/// only applicable if the <see cref="Type"/> property is set
-		/// to <see cref="FillType.Brush"/>.
-		/// </summary>
-		public Brush Brush
-		{
-			get { return _brush; }
-			set { _brush = value; }
-		}
-		/// <summary>
-		/// Determines the type of fill, which can be either solid
-		/// color (<see cref="ZedGraph.FillType.Solid"/>) or a custom brush
-		/// (<see cref="ZedGraph.FillType.Brush"/>).  See <see cref="Type"/> for
-		/// more information.
-		/// </summary>
-		/// <seealso cref="ZedGraph.Fill.Color"/>
-		public FillType Type
-		{
-			get { return _type; }
-			set { _type = value; }
-		}
-		/// <summary>
-		/// This property determines the type of color fill. 
-		/// Returns true if the <see cref="Type"/> property is either
-		/// <see cref="FillType.Solid"/> or
-		/// <see cref="FillType.Brush"/>.  If set to true, this property
-		/// will automatically set the <see cref="Type"/> to
-		/// <see cref="FillType.Brush"/>.  If set to false, this property
-		/// will automatically set the <see cref="Type"/> to
-		/// <see cref="FillType.None"/>.  In order to get a regular
-		/// solid-color fill, you have to manually set <see cref="Type"/>
-		/// to <see cref="FillType.Solid"/>.
-		/// </summary>
-		/// <seealso cref="Color"/>
-		/// <seealso cref="Brush"/>
-		/// <seealso cref="Type"/>
-		public bool IsVisible
-		{
-			get { return _type != FillType.None; }
-			set { _type = value ? ( _type == FillType.None ? FillType.Brush : _type ) : FillType.None; }
-		}
-
-		/// <summary>
-		/// Determines if the brush will be scaled to the bounding box
-		/// of the filled object.  If this value is false, then the brush will only be aligned
-		/// with the filled object based on the <see cref="AlignH"/> and <see cref="AlignV"/>
-		/// properties.
-		/// </summary>
-		public bool IsScaled
-		{
-			get { return _isScaled; }
-			set { _isScaled = value; }
-		}
-		
-		/// <summary>
-		/// Determines how the brush will be aligned with the filled object
-		/// in the horizontal direction.  This value is a <see cref="ZedGraph.AlignH"/> enumeration.
-		/// This field only applies if <see cref="IsScaled"/> is false.
-		/// </summary>
-		/// <seealso cref="AlignV"/>
-		public AlignH AlignH
-		{
-			get { return _alignH; }
-			set { _alignH = value; }
-		}
-		
-		/// <summary>
-		/// Determines how the brush will be aligned with the filled object
-		/// in the vertical direction.  This value is a <see cref="ZedGraph.AlignV"/> enumeration.
-		/// This field only applies if <see cref="IsScaled"/> is false.
-		/// </summary>
-		/// <seealso cref="AlignH"/>
-		public AlignV AlignV
-		{
-			get { return _alignV; }
-			set { _alignV = value; }
-		}
-
-		/// <summary>
-		/// Returns a boolean value indicating whether or not this fill is a "Gradient-By-Value"
-		/// type.  This is true for <see cref="FillType.GradientByX"/>, <see cref="FillType.GradientByY"/>,
-		/// or <see cref="FillType.GradientByZ"/>.
-		/// </summary>
-		/// <remarks>
-		/// The gradient by value fill method allows the fill color for each point or bar to
-		/// be based on a value for that point (either X, Y, or Z in the <see cref="IPointList"/>.
-		/// For example, assume a <see cref="Fill"/> class is defined with a linear gradient ranging from
-		/// <see cref="System.Drawing.Color.Blue"/> to <see cref="System.Drawing.Color.Red"/> and the <see cref="Fill.Type"/>
-		/// is set to <see cref="FillType.GradientByY"/>.  If <see cref="RangeMin"/> is set to 
-		/// 100.0 and <see cref="RangeMax"/> is set to 200.0, then a point that has a Y value of
-		/// 100 or less will be colored blue, a point with a Y value of 200 or more will be
-		/// colored red, and a point between 100 and 200 will have a color based on a linear scale
-		/// between blue and red.  Note that the fill color is always solid for any given point.
-		/// You can use the Z value from <see cref="IPointList"/> along with
-		/// <see cref="FillType.GradientByZ"/> to color individual points according to some
-		/// property that is independent of the X,Y point pair.
-		/// </remarks>
-		/// <value>true if this is a Gradient-by-value type, false otherwise</value>
-		/// <seealso cref="FillType.GradientByX"/>
-		/// <seealso cref="FillType.GradientByY"/>
-		/// <seealso cref="FillType.GradientByZ"/>
-		public bool IsGradientValueType
-		{
-			get { return _type == FillType.GradientByX || _type == FillType.GradientByY ||
-					_type == FillType.GradientByZ || _type == FillType.GradientByColorValue; }
-		}
-
-		/// <summary>
-		/// The minimum user-scale value for the gradient-by-value determination.  This defines
-		/// the user-scale value for the start of the gradient.
-		/// </summary>
-		/// <seealso cref="FillType.GradientByX"/>
-		/// <seealso cref="FillType.GradientByY"/>
-		/// <seealso cref="FillType.GradientByZ"/>
-		/// <seealso cref="IsGradientValueType"/>
-		/// <seealso cref="RangeMax"/>
-		/// <seealso cref="RangeDefault"/>
-		/// <value>A double value, in user scale unit</value>
-		public double RangeMin
-		{
-			get { return _rangeMin; }
-			set { _rangeMin = value; }
-		}
-		/// <summary>
-		/// The maximum user-scale value for the gradient-by-value determination.  This defines
-		/// the user-scale value for the end of the gradient.
-		/// </summary>
-		/// <seealso cref="FillType.GradientByX"/>
-		/// <seealso cref="FillType.GradientByY"/>
-		/// <seealso cref="FillType.GradientByZ"/>
-		/// <seealso cref="IsGradientValueType"/>
-		/// <seealso cref="RangeMin"/>
-		/// <seealso cref="RangeDefault"/>
-		/// <value>A double value, in user scale unit</value>
-		public double RangeMax
-		{
-			get { return _rangeMax; }
-			set { _rangeMax = value; }
-		}
-
-		/// <summary>
-		/// The default user-scale value for the gradient-by-value determination.  This defines the
-		/// value that will be used when there is no point value available, or the actual point value
-		/// is invalid.
-		/// </summary>
-		/// <remarks>
-		/// Note that this value, when defined, will determine the color that is used in the legend.
-		/// If this value is set to double.MaxValue, then it remains "undefined."  In this case, the
-		/// legend symbols will actually be filled with a color gradient representing the range of
-		/// colors.
-		/// </remarks>
-		/// <seealso cref="FillType.GradientByX"/>
-		/// <seealso cref="FillType.GradientByY"/>
-		/// <seealso cref="FillType.GradientByZ"/>
-		/// <seealso cref="IsGradientValueType"/>
-		/// <seealso cref="RangeMin"/>
-		/// <seealso cref="RangeMax"/>
-		/// <value>A double value, in user scale unit</value>
-		public double RangeDefault
-		{
-			get { return _rangeDefault; }
-			set { _rangeDefault = value; }
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Create a fill brush using current properties.  This method will construct a brush based on the
-		/// settings of <see cref="ZedGraph.Fill.Type"/>, <see cref="ZedGraph.Fill.Color"/>
-		/// and <see cref="ZedGraph.Fill.Brush"/>.  If
-		/// <see cref="ZedGraph.Fill.Type"/> is set to <see cref="ZedGraph.FillType.Brush"/> and
-		/// <see cref="ZedGraph.Fill.Brush"/>
-		/// is null, then a <see cref="LinearGradientBrush"/> will be created between the colors of
-		/// <see cref="System.Drawing.Color.White"/> and <see cref="ZedGraph.Fill.Color"/>.
-		/// </summary>
-		/// <param name="rect">A rectangle that bounds the object to be filled.  This determines
-		/// the start and end of the gradient fill.</param>
-		/// <returns>A <see cref="System.Drawing.Brush"/> class representing the fill brush</returns>
-		public Brush MakeBrush( RectangleF rect )
-		{
-			// just provide a default value for the valueFraction
-			// return MakeBrush( rect, new PointPair( 0.5, 0.5, 0.5 ) );
-			return MakeBrush( rect, null );
-		}
-
-		/// <summary>
-		/// Create a fill brush using current properties.  This method will construct a brush based on the
-		/// settings of <see cref="ZedGraph.Fill.Type"/>, <see cref="ZedGraph.Fill.Color"/>
-		/// and <see cref="ZedGraph.Fill.Brush"/>.  If
-		/// <see cref="ZedGraph.Fill.Type"/> is set to <see cref="ZedGraph.FillType.Brush"/> and
-		/// <see cref="ZedGraph.Fill.Brush"/>
-		/// is null, then a <see cref="LinearGradientBrush"/> will be created between the colors of
-		/// <see cref="System.Drawing.Color.White"/> and <see cref="ZedGraph.Fill.Color"/>.
-		/// </summary>
-		/// <param name="rect">A rectangle that bounds the object to be filled.  This determines
-		/// the start and end of the gradient fill.</param>
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable for <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/> or <see cref="FillType.GradientByZ"/>.</param>
-		/// <returns>A <see cref="System.Drawing.Brush"/> class representing the fill brush</returns>
-		public Brush MakeBrush( RectangleF rect, PointPair dataValue )
-		{
-			// get a brush
-			if ( this.IsVisible && ( !_color.IsEmpty || _brush != null ) )
-			{
-				if ( rect.Height < 1.0F )
-					rect.Height = 1.0F;
-				if ( rect.Width < 1.0F )
-					rect.Width = 1.0F;
-					
-				//Brush	brush;
-				if ( _type == FillType.Brush )
-				{
-					return ScaleBrush( rect, _brush, _isScaled );
-				}
-				else if ( IsGradientValueType )
-				{
-					if ( dataValue != null )
-					{
-						if ( !_secondaryValueGradientColor.IsEmpty )
-						{
-							// Go ahead and create a new Fill so we can do all the scaling, etc.,
-							// that is associated with a gradient
-							Fill tmpFill = new Fill( _secondaryValueGradientColor,
-									GetGradientColor( dataValue ), _angle );
-							return tmpFill.MakeBrush( rect );
-						}
-						else
-							return new SolidBrush( GetGradientColor( dataValue ) );
-					}
-					else if ( _rangeDefault != double.MaxValue )
-					{
-						if ( !_secondaryValueGradientColor.IsEmpty )
-						{
-							// Go ahead and create a new Fill so we can do all the scaling, etc.,
-							// that is associated with a gradient
-							Fill tmpFill = new Fill( _secondaryValueGradientColor,
-									GetGradientColor( _rangeDefault ), _angle );
-							return tmpFill.MakeBrush( rect );
-						}
-						else
-							return new SolidBrush( GetGradientColor( _rangeDefault ) );
-					}
-					else
-						return ScaleBrush( rect, _brush, true );
-				}
-				else
-					return new SolidBrush( _color );
-			}
-
-			// Always return a suitable default
-			return new SolidBrush( Color.White );
-		}
-
-		internal Color GetGradientColor( PointPair dataValue )
-		{
-			double val;
-
-			if ( dataValue == null )
-				val = _rangeDefault;
-			else if ( _type == FillType.GradientByColorValue )
-				val = dataValue.ColorValue;
-			else if ( _type == FillType.GradientByZ )
-				val = dataValue.Z;
-			else if ( _type == FillType.GradientByY )
-				val = dataValue.Y;
-			else
-				val = dataValue.X;
-
-			return GetGradientColor( val );
-		}
-
-		internal Color GetGradientColor( double val )
-		{
-			double valueFraction;
-
-			if ( Double.IsInfinity( val ) || double.IsNaN( val ) || val == PointPair.Missing )
-				val = _rangeDefault;
-
-			if ( _rangeMax - _rangeMin < 1e-20 || val == double.MaxValue )
-				valueFraction = 0.5;
-			else			
-				valueFraction = ( val - _rangeMin ) / ( _rangeMax - _rangeMin );
-
-			if ( valueFraction < 0.0 )
-				valueFraction = 0.0;
-			else if ( valueFraction > 1.0 )
-				valueFraction = 1.0;
-
-			if ( _gradientBM == null )
-			{
-				RectangleF rect = new RectangleF( 0, 0, 100, 1 );
-				_gradientBM = new Bitmap( 100, 1 );
-				Graphics gBM = Graphics.FromImage( _gradientBM );
-
-				Brush tmpBrush = ScaleBrush( rect, _brush, true );
-				gBM.FillRectangle( tmpBrush, rect );
-			}
-
-			return _gradientBM.GetPixel( (int) (99.9 * valueFraction), 0 );
-		}
-
-		private Brush ScaleBrush( RectangleF rect, Brush brush, bool isScaled )
-		{
-			if ( brush != null )
-			{
-				if ( brush is SolidBrush )
-				{
-					return (Brush) brush.Clone();
-				}
-				else if ( brush is LinearGradientBrush )
-				{
-					LinearGradientBrush linBrush = (LinearGradientBrush) brush.Clone();
-					
-					if ( isScaled )
-					{
-						linBrush.ScaleTransform( rect.Width / linBrush.Rectangle.Width,
-							rect.Height / linBrush.Rectangle.Height, MatrixOrder.Append );
-						linBrush.TranslateTransform( rect.Left - linBrush.Rectangle.Left,
-							rect.Top - linBrush.Rectangle.Top, MatrixOrder.Append );
-					}
-					else
-					{
-						float	dx = 0,
-								dy = 0;
-						switch ( _alignH )
-						{
-						case AlignH.Left:
-							dx = rect.Left - linBrush.Rectangle.Left;
-							break;
-						case AlignH.Center:
-							dx = ( rect.Left + rect.Width / 2.0F ) - linBrush.Rectangle.Left;
-							break;
-						case AlignH.Right:
-							dx = ( rect.Left + rect.Width ) - linBrush.Rectangle.Left;
-							break;
-						}
-						
-						switch ( _alignV )
-						{
-						case AlignV.Top:
-							dy = rect.Top - linBrush.Rectangle.Top;
-							break;
-						case AlignV.Center:
-							dy = ( rect.Top + rect.Height / 2.0F ) - linBrush.Rectangle.Top;
-							break;
-						case AlignV.Bottom:
-							dy = ( rect.Top + rect.Height) - linBrush.Rectangle.Top;
-							break;
-						}
-
-						linBrush.TranslateTransform( dx, dy, MatrixOrder.Append );
-					}
-					
-					return linBrush;
-					
-				} // LinearGradientBrush
-				else if ( brush is TextureBrush )
-				{
-					TextureBrush texBrush = (TextureBrush) brush.Clone();
-					
-					if ( isScaled )
-					{
-						texBrush.ScaleTransform( rect.Width / texBrush.Image.Width,
-							rect.Height / texBrush.Image.Height, MatrixOrder.Append );
-						texBrush.TranslateTransform( rect.Left, rect.Top, MatrixOrder.Append );
-					}
-					else
-					{
-						float	dx = 0,
-								dy = 0;
-						switch ( _alignH )
-						{
-						case AlignH.Left:
-							dx = rect.Left;
-							break;
-						case AlignH.Center:
-							dx = ( rect.Left + rect.Width / 2.0F );
-							break;
-						case AlignH.Right:
-							dx = ( rect.Left + rect.Width );
-							break;
-						}
-						
-						switch ( _alignV )
-						{
-						case AlignV.Top:
-							dy = rect.Top;
-							break;
-						case AlignV.Center:
-							dy = ( rect.Top + rect.Height / 2.0F );
-							break;
-						case AlignV.Bottom:
-							dy = ( rect.Top + rect.Height);
-							break;
-						}
-
-						texBrush.TranslateTransform( dx, dy, MatrixOrder.Append );
-					}
-					
-					return texBrush;
-				}
-				else // other brush type
-				{
-					return (Brush) brush.Clone();
-				}
-			}
-			else
-				// If they didn't provide a brush, make one using the fillcolor gradient to white
-				return new LinearGradientBrush( rect, Color.White, _color, 0F );
-		}
-
-		/// <summary>
-		/// Fill the background of the <see cref="RectangleF"/> area, using the
-		/// fill type from this <see cref="Fill"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">The <see cref="RectangleF"/> struct specifying the area
-		/// to be filled</param>
-		public void Draw( Graphics g, RectangleF rect )
-		{
-			Draw( g, rect, null );
-			/*
-			if ( this.IsVisible )
-			{
-				using( Brush brush = this.MakeBrush( rect ) )
-				{
-					g.FillRectangle( brush, rect );
-					//brush.Dispose();
-				}
-			}
-			*/
-		}
-
-		/// <summary>
-		/// Fill the background of the <see cref="RectangleF"/> area, using the
-		/// fill type from this <see cref="Fill"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">The <see cref="RectangleF"/> struct specifying the area
-		/// to be filled</param>
-		/// <param name="pt">The data value to be used in case it's a
-		/// <see cref="FillType.GradientByX" />, <see cref="FillType.GradientByY" />, or
-		/// <see cref="FillType.GradientByZ" /> <see cref="FillType" />.</param>
-		public void Draw( Graphics g, RectangleF rect, PointPair pt )
-		{
-			if ( this.IsVisible )
-			{
-				using ( Brush brush = this.MakeBrush( rect, pt ) )
-				{
-					g.FillRectangle( brush, rect );
-				}
-			}
-		}
-
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/FilteredPointList.cs b/BDInfo/ZedGraph/FilteredPointList.cs
deleted file mode 100644
index dce0251a2a..0000000000
--- a/BDInfo/ZedGraph/FilteredPointList.cs
+++ /dev/null
@@ -1,321 +0,0 @@
-//============================================================================
-//FilteredPointList class
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================using System;
-using System;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An example of an <see cref="IPointList" /> implementation that stores large datasets, and
-	/// selectively filters the output data depending on the displayed range.
-	/// </summary>
-	/// <remarks>
-	/// This class will refilter the data points each time <see cref="SetBounds" /> is called.  The
-	/// data are filtered down to <see cref="MaxPts" /> points, within the data bounds of
-	/// a minimum and maximum data range.  The data are filtered by simply skipping
-	/// points to achieve the desired total number of points.  Input arrays are assumed to be
-	/// monotonically increasing in X, and evenly spaced in X.
-	/// </remarks>
-	/// <seealso cref="PointPairList" />
-	/// <seealso cref="BasicArrayPointList" />
-	/// <seealso cref="IPointList" />
-	/// <seealso cref="IPointListEdit" />
-	///
-	/// <author> John Champion with mods by Christophe Holmes</author>
-	/// <version> $Revision: 1.10 $ $Date: 2007/11/24 03:45:18 $ </version>
-	[Serializable]
-	public class FilteredPointList : IPointList
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// Instance of an array of x values
-		/// </summary>
-		private double[] _x;
-		/// <summary>
-		/// Instance of an array of x values
-		/// </summary>
-		private double[] _y;
-		/*
-		/// <summary>
-		/// This is the minimum value of the range of interest (typically the minimum of
-		/// the range that you have zoomed into)
-		/// </summary>
-		//private double _xMinBound = double.MinValue;
-		/// <summary>
-		/// This is the maximum value of the range of interest (typically the maximum of
-		/// the range that you have zoomed into)
-		/// </summary>
-		//private double _xMaxBound = double.MaxValue;
-		*/
-		/// <summary>
-		/// This is the maximum number of points that you want to see in the filtered dataset
-		/// </summary>
-		private int _maxPts = -1;
-
-		/// <summary>
-		/// The index of the xMinBound above
-		/// </summary>
-		private int _minBoundIndex = -1;
-		/// <summary>
-		/// The index of the xMaxBound above
-		/// </summary>
-		private int _maxBoundIndex = -1;
-
-//		/// <summary>
-//		/// Switch used to indicate if the next filtered point should be the high point or the
-//		/// low point within the current range.
-//		/// </summary>
-//		private bool _upDown = false;
-
-//		/// <summary>
-//		/// Determines if the high/low logic will be used.
-//		/// </summary>
-//		private bool _isApplyHighLowLogic = true;
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="PointPair"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <remarks>
-		/// Returns <see cref="PointPairBase.Missing" /> for any value of <see paramref="index" />
-		/// that is outside of its corresponding array bounds.
-		/// </remarks>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="PointPair"/> object to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object reference.</value>
-		public PointPair this[ int index ]  
-		{
-			get
-			{
-				// See if the array should be bounded
-				if ( _minBoundIndex >= 0 && _maxBoundIndex >= 0 && _maxPts >= 0 )
-				{
-					// get number of points in bounded range
-					int nPts = _maxBoundIndex - _minBoundIndex + 1;
-
-					if ( nPts > _maxPts )
-					{
-						// if we're skipping points, then calculate the new index
-						index = _minBoundIndex + (int) ( (double) index * (double) nPts / (double) _maxPts );
-					}
-					else
-					{
-						// otherwise, index is just offset by the start of the bounded range
-						index += _minBoundIndex;
-					}
-				}
-
-				double xVal, yVal;
-				if ( index >= 0 && index < _x.Length )
-					xVal = _x[index];
-				else
-					xVal = PointPair.Missing;
-
-				if ( index >= 0 && index < _y.Length )
-					yVal = _y[index];
-				else
-					yVal = PointPair.Missing;
-
-
-
-				return new PointPair( xVal, yVal, PointPair.Missing, null );
-			}
-
-			set
-			{
-				// See if the array should be bounded
-				if ( _minBoundIndex >= 0 && _maxBoundIndex >= 0 && _maxPts >= 0 )
-				{
-					// get number of points in bounded range
-					int nPts = _maxBoundIndex - _minBoundIndex + 1;
-
-					if ( nPts > _maxPts )
-					{
-						// if we're skipping points, then calculate the new index
-						index = _minBoundIndex + (int) ( (double) index * (double) nPts / (double) _maxPts );
-					}
-					else
-					{
-						// otherwise, index is just offset by the start of the bounded range
-						index += _minBoundIndex;
-					}
-				}
-
-				if ( index >= 0 && index < _x.Length )
-					_x[index] = value.X;
-
-				if ( index >= 0 && index < _y.Length )
-					_y[index] = value.Y;
-			}
-		}
-
-		/// <summary>
-		/// Returns the number of points according to the current state of the filter.
-		/// </summary>
-		public int Count
-		{
-			get
-			{
-				int arraySize = _x.Length;
-
-				// Is the filter active?
-				if ( _minBoundIndex >= 0 && _maxBoundIndex >= 0 && _maxPts > 0 )
-				{
-					// get the number of points within the filter bounds
-					int boundSize = _maxBoundIndex - _minBoundIndex + 1;
-
-					// limit the point count to the filter bounds
-					if ( boundSize < arraySize )
-						arraySize = boundSize;
-
-					// limit the point count to the declared max points
-					if ( arraySize > _maxPts )
-						arraySize = _maxPts;
-				}
-
-				return arraySize;
-			}
-		}
-
-		/// <summary>
-		/// Gets the desired number of filtered points to output.  You can set this value by
-		/// calling <see cref="SetBounds" />.
-		/// </summary>
-		public int MaxPts
-		{
-			get { return _maxPts; }
-		}
-
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to initialize the PointPairList from two arrays of
-		/// type double.
-		/// </summary>
-		public FilteredPointList( double[] x, double[] y )
-		{
-			_x = x;
-			_y = y;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The FilteredPointList from which to copy</param>
-		public FilteredPointList( FilteredPointList rhs )
-		{
-			_x = (double[]) rhs._x.Clone();
-			_y = (double[]) rhs._y.Clone();
-			_minBoundIndex = rhs._minBoundIndex;
-			_maxBoundIndex = rhs._maxBoundIndex;
-			_maxPts = rhs._maxPts;
-
-		}
-
-		/// <summary>
-		/// Deep-copy clone routine
-		/// </summary>
-		/// <returns>A new, independent copy of the FilteredPointList</returns>
-		virtual public object Clone()
-		{ 
-			return new FilteredPointList( this ); 
-		}
-		
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Set the data bounds to the specified minimum, maximum, and point count.  Use values of
-		/// min=double.MinValue and max=double.MaxValue to get the full range of data.  Use maxPts=-1
-		/// to not limit the number of points.  Call this method anytime the zoom range is changed.
-		/// </summary>
-		/// <param name="min">The lower bound for the X data of interest</param>
-		/// <param name="max">The upper bound for the X data of interest</param>
-		/// <param name="maxPts">The maximum number of points allowed to be
-		/// output by the filter</param>
-		// New code mods by ingineer
-		public void SetBounds( double min, double max, int maxPts )
-		{
-			_maxPts = maxPts;
-
-			// find the index of the start and end of the bounded range
-			int first = Array.BinarySearch( _x, min );
-			int last = Array.BinarySearch( _x, max );
-
-			// Make sure the bounded indices are legitimate
-			// if BinarySearch() doesn't find the value, it returns the bitwise
-			// complement of the index of the 1st element larger than the sought value
-
-			if (first < 0)
-			{
-				if (first == -1)
-					first = 0;
-				else
-					first = ~(first + 1);
-			}
-
-			if ( last < 0 )
-			last = ~last;
-
-			_minBoundIndex = first;
-			_maxBoundIndex = last;
-		}
-
-		// The old version, as of 21-Oct-2007
-		//public void SetBounds2(double min, double max, int maxPts)
-		//{
-		//    _maxPts = maxPts;
-
-		//    // assume data points are equally spaced, and calculate the X step size between
-		//    // each data point
-		//    double step = (_x[_x.Length - 1] - _x[0]) / (double)_x.Length;
-
-		//    if (min < _x[0])
-		//        min = _x[0];
-		//    if (max > _x[_x.Length - 1])
-		//        max = _x[_x.Length - 1];
-
-		//    // calculate the index of the start of the bounded range
-		//    int first = (int)((min - _x[0]) / step);
-
-		//    // calculate the index of the last point of the bounded range
-		//    int last = (int)((max - min) / step + first);
-
-		//    // Make sure the bounded indices are legitimate
-		//    first = Math.Max(Math.Min(first, _x.Length), 0);
-		//    last = Math.Max(Math.Min(last, _x.Length), 0);
-
-		//    _minBoundIndex = first;
-		//    _maxBoundIndex = last;
-		//}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/FontSpec.cs b/BDInfo/ZedGraph/FontSpec.cs
deleted file mode 100644
index 6cd8e15147..0000000000
--- a/BDInfo/ZedGraph/FontSpec.cs
+++ /dev/null
@@ -1,1503 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The <see cref="FontSpec"/> class is a generic font class that maintains the font family,
-	/// attributes, colors, border and fill modes, font size, and angle information.
-	/// This class can render text with a variety of alignment options using the
-	/// <see cref="AlignH"/> and <see cref="AlignV"/> parameters in the
-	/// <see cref="Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.24 $ $Date: 2007/01/25 07:56:08 $ </version>
-	[Serializable]
-	public class FontSpec : ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores the color of the font characters for this
-		/// <see cref="FontSpec"/>.  Use the public property <see cref="FontColor"/>
-		/// to access this value.
-		/// </summary>
-		/// <value>A system <see cref="System.Drawing.Color"/> reference.</value>
-		private Color _fontColor;
-		/// <summary>
-		/// Private field that stores the font family name for this <see cref="FontSpec"/>.
-		/// Use the public property <see cref="Family"/> to access this value.
-		/// </summary>
-		/// <value>A text string with the font family name, e.g., "Arial"</value>
-		private string _family;
-		/// <summary>
-		/// Private field that determines whether this <see cref="FontSpec"/> is
-		/// drawn with bold typeface.
-		/// Use the public property <see cref="IsBold"/> to access this value.
-		/// </summary>
-		/// <value>A boolean value, true for bold, false for normal</value>
-		private bool _isBold;
-		/// <summary>
-		/// Private field that determines whether this <see cref="FontSpec"/> is
-		/// drawn with italic typeface.
-		/// Use the public property <see cref="IsItalic"/> to access this value.
-		/// </summary>
-		/// <value>A boolean value, true for italic, false for normal</value>
-		private bool _isItalic;
-		/// <summary>
-		/// Private field that determines whether this <see cref="FontSpec"/> is
-		/// drawn with underlined typeface.
-		/// Use the public property <see cref="IsUnderline"/> to access this value.
-		/// </summary>
-		/// <value>A boolean value, true for underline, false for normal</value>
-		private bool _isUnderline;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="FontSpec"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-		/// <summary>
-		/// Private field that determines the properties of the border around the text.
-		/// Use the public property <see cref="Border"/> to access this value.
-		/// </summary>
-		private Border _border;
-
-		/// <summary>
-		/// Private field that determines the angle at which this
-		/// <see cref="FontSpec"/> object is drawn.  Use the public property
-		/// <see cref="Angle"/> to access this value.
-		/// </summary>
-		/// <value>The angle of the font, measured in anti-clockwise degrees from
-		/// horizontal.  Negative values are permitted.</value>
-		private float _angle;
-
-		/// <summary>
-		/// Private field that determines the alignment with which this
-		/// <see cref="FontSpec"/> object is drawn.  This alignment really only
-		/// affects multi-line strings.  Use the public property
-		/// <see cref="StringAlignment"/> to access this value.
-		/// </summary>
-		/// <value>A <see cref="StringAlignment"/> enumeration.</value>
-		private StringAlignment _stringAlignment;
-
-		/// <summary>
-		/// Private field that determines the size of the font for this
-		/// <see cref="FontSpec"/> object.  Use the public property
-		/// <see cref="Size"/> to access this value.
-		/// </summary>
-		/// <value>The size of the font, measured in points (1/72 inch).</value>
-		private float _size;
-
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="Font"/>
-		/// object for this <see cref="FontSpec"/>.  This font object will be at
-		/// the actual drawn size <see cref="_scaledSize"/> according to the current
-		/// size of the <see cref="GraphPane"/>.  Use the public method
-		/// <see cref="GetFont"/> to access this font object.
-		/// </summary>
-		/// <value>A reference to a <see cref="Font"/> object</value>
-		private Font _font;
-
-		/// <summary>
-		/// Private field that determines if the <see cref="FontSpec" /> will be
-		/// displayed using anti-aliasing logic.
-		/// Use the public property <see cref="IsAntiAlias" /> to access this value.
-		/// </summary>
-		private bool _isAntiAlias;
-		/// <summary>
-		/// Private field that determines if the <see cref="FontSpec" /> will be
-		/// displayed with a drop shadow.
-		/// Use the public property <see cref="IsDropShadow" /> to access this value.
-		/// </summary>
-		private bool _isDropShadow;
-		/// <summary>
-		/// Private field that determines the color of the dropshadow for this
-		/// <see cref="FontSpec" />.
-		/// Use the public property <see cref="DropShadowColor" /> to access this value.
-		/// </summary>
-		private Color _dropShadowColor;
-		/// <summary>
-		/// Private field that determines the offset angle of the dropshadow for this
-		/// <see cref="FontSpec" />.
-		/// Use the public property <see cref="DropShadowAngle" /> to access this value.
-		/// </summary>
-		private float _dropShadowAngle;
-		/// <summary>
-		/// Private field that determines the offset distance of the dropshadow for this
-		/// <see cref="FontSpec" />.
-		/// Use the public property <see cref="DropShadowOffset" /> to access this value.
-		/// </summary>
-		private float _dropShadowOffset;
-
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="Font"/>
-		/// object that will be used for superscripts.  This font object will be a
-		/// fraction of the <see cref="FontSpec"/> <see cref="_scaledSize"/>,
-		/// based on the value of <see cref="Default.SuperSize"/>.  This
-		/// property is internal, and has no public access.
-		/// </summary>
-		/// <value>A reference to a <see cref="Font"/> object</value>
-		private Font _superScriptFont;
-
-		/// <summary>
-		/// Private field that temporarily stores the scaled size of the font for this
-		/// <see cref="FontSpec"/> object.  This represents the actual on-screen
-		/// size, rather than the <see cref="Size"/> that represents the reference
-		/// size for a "full-sized" <see cref="GraphPane"/>.
-		/// </summary>
-		/// <value>The size of the font, measured in points (1/72 inch).</value>
-		private float _scaledSize;
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="FontSpec"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default size fraction of the superscript font, expressed as a fraction
-			/// of the size of the main font.
-			/// </summary>
-			public static float SuperSize = 0.85F;
-			/// <summary>
-			/// The default shift fraction of the superscript, expressed as a
-			/// fraction of the superscripted character height.  This is the height
-			/// above the main font (a zero shift means the main font and the superscript
-			/// font have the tops aligned).
-			/// </summary>
-			public static float SuperShift = 0.4F;
-			/// <summary>
-			/// The default color for filling in the background of the text block
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.White;
-			/// <summary>
-			/// The default custom brush for filling in this <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default fill mode for this <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.Solid;
-			/// <summary>
-			/// Default value for the alignment with which this
-			/// <see cref="FontSpec"/> object is drawn.  This alignment really only
-			/// affects multi-line strings.
-			/// </summary>
-			/// <value>A <see cref="StringAlignment"/> enumeration.</value>
-			public static StringAlignment StringAlignment = StringAlignment.Center;
-
-			/// <summary>
-			/// Default value for <see cref="FontSpec.IsDropShadow"/>, which determines
-			/// if the drop shadow is displayed for this <see cref="FontSpec" />.
-			/// </summary>
-			public static bool IsDropShadow = false;
-			/// <summary>
-			/// Default value for <see cref="FontSpec.IsAntiAlias"/>, which determines
-			/// if anti-aliasing logic is used for this <see cref="FontSpec" />.
-			/// </summary>
-			public static bool IsAntiAlias = false;
-			/// <summary>
-			/// Default value for <see cref="FontSpec.DropShadowColor"/>, which determines
-			/// the color of the drop shadow for this <see cref="FontSpec" />.
-			/// </summary>
-			public static Color DropShadowColor = Color.Black;
-			/// <summary>
-			/// Default value for <see cref="FontSpec.DropShadowAngle"/>, which determines
-			/// the offset angle of the drop shadow for this <see cref="FontSpec" />.
-			/// </summary>
-			public static float DropShadowAngle = 45f;
-			/// <summary>
-			/// Default value for <see cref="FontSpec.DropShadowOffset"/>, which determines
-			/// the offset distance of the drop shadow for this <see cref="FontSpec" />.
-			/// </summary>
-			public static float DropShadowOffset = 0.05f;
-
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// The color of the font characters for this <see cref="FontSpec"/>.
-		/// Note that the border and background
-		/// colors are set using the <see cref="ZedGraph.LineBase.Color"/> and
-		/// <see cref="ZedGraph.Fill.Color"/> properties, respectively.
-		/// </summary>
-		/// <value>A system <see cref="System.Drawing.Color"/> reference.</value>
-		public Color FontColor
-		{
-			get { return _fontColor; }
-			set { _fontColor = value; }
-		}
-		/// <summary>
-		/// The font family name for this <see cref="FontSpec"/>.
-		/// </summary>
-		/// <value>A text string with the font family name, e.g., "Arial"</value>
-		public string Family
-		{
-			get { return _family; }
-			set
-			{
-				if ( value != _family )
-				{
-					_family = value;
-					Remake( _scaledSize / _size, this.Size, ref _scaledSize, ref _font );
-				}
-			}
-		}
-		/// <summary>
-		/// Determines whether this <see cref="FontSpec"/> is
-		/// drawn with bold typeface.
-		/// </summary>
-		/// <value>A boolean value, true for bold, false for normal</value>
-		public bool IsBold
-		{
-			get { return _isBold; }
-			set
-			{
-				if ( value != _isBold )
-				{
-					_isBold = value;
-					Remake( _scaledSize / _size, this.Size, ref _scaledSize, ref _font );
-				}
-			}
-		}
-		/// <summary>
-		/// Determines whether this <see cref="FontSpec"/> is
-		/// drawn with italic typeface.
-		/// </summary>
-		/// <value>A boolean value, true for italic, false for normal</value>
-		public bool IsItalic
-		{
-			get { return _isItalic; }
-			set
-			{
-				if ( value != _isItalic )
-				{
-					_isItalic = value;
-					Remake( _scaledSize / _size, this.Size, ref _scaledSize, ref _font );
-				}
-			}
-		}
-		/// <summary>
-		/// Determines whether this <see cref="FontSpec"/> is
-		/// drawn with underlined typeface.
-		/// </summary>
-		/// <value>A boolean value, true for underline, false for normal</value>
-		public bool IsUnderline
-		{
-			get { return _isUnderline; }
-			set
-			{
-				if ( value != _isUnderline )
-				{
-					_isUnderline = value;
-					Remake( _scaledSize / _size, this.Size, ref _scaledSize, ref _font );
-				}
-			}
-		}
-		/// <summary>
-		/// The angle at which this <see cref="FontSpec"/> object is drawn.
-		/// </summary>
-		/// <value>The angle of the font, measured in anti-clockwise degrees from
-		/// horizontal.  Negative values are permitted.</value>
-		public float Angle
-		{
-			get { return _angle; }
-			set { _angle = value; }
-		}
-
-		/// <summary>
-		/// Determines the alignment with which this
-		/// <see cref="FontSpec"/> object is drawn.  This alignment really only
-		/// affects multi-line strings.
-		/// </summary>
-		/// <value>A <see cref="StringAlignment"/> enumeration.</value>
-		public StringAlignment StringAlignment
-		{
-			get { return _stringAlignment; }
-			set { _stringAlignment = value; }
-		}
-
-		/// <summary>
-		/// The size of the font for this <see cref="FontSpec"/> object.
-		/// </summary>
-		/// <value>The size of the font, measured in points (1/72 inch).</value>
-		public float Size
-		{
-			get { return _size; }
-			set
-			{
-				if ( value != _size )
-				{
-					Remake( _scaledSize / _size * value, _size, ref _scaledSize,
-								ref _font );
-					_size = value;
-				}
-			}
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="Border"/> class used to draw the border border
-		/// around this text.
-		/// </summary>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="FontSpec"/>, which controls how the background
-		/// behind the text is filled.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the <see cref="FontSpec" /> will be
-		/// drawn using anti-aliasing logic within GDI+.
-		/// </summary>
-		/// <remarks>
-		/// If this property is set to true, it will override the current setting of
-		/// <see cref="Graphics.SmoothingMode" /> by setting the value temporarily to
-		/// <see cref="SmoothingMode.HighQuality" />.  If this property is set to false,
-		/// the the current setting of <see cref="Graphics.SmoothingMode" /> will be
-		/// left as-is.
-		/// </remarks>
-		public bool IsAntiAlias
-		{
-			get { return _isAntiAlias; }
-			set { _isAntiAlias = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines if the <see cref="FontSpec" /> will be
-		/// displayed with a drop shadow.
-		/// </summary>
-		/// <seealso cref="DropShadowColor" />
-		/// <seealso cref="DropShadowAngle" />
-		/// <seealso cref="DropShadowOffset" />
-		public bool IsDropShadow
-		{
-			get { return _isDropShadow; }
-			set { _isDropShadow = value; }
-		}
-		/// <summary>
-		/// Gets or sets the color of the drop shadow for this <see cref="FontSpec" />.
-		/// </summary>
-		/// <remarks>
-		/// This value only applies if <see cref="IsDropShadow" /> is true.
-		/// </remarks>
-		/// <seealso cref="IsDropShadow" />
-		/// <seealso cref="DropShadowAngle" />
-		/// <seealso cref="DropShadowOffset" />
-		public Color DropShadowColor
-		{
-			get { return _dropShadowColor; }
-			set { _dropShadowColor = value; }
-		}
-		/// <summary>
-		/// Gets or sets the offset angle of the drop shadow for this <see cref="FontSpec" />.
-		/// </summary>
-		/// <remarks>
-		/// This value only applies if <see cref="IsDropShadow" /> is true.
-		/// </remarks>
-		/// <value>The angle, measured in anti-clockwise degrees from
-		/// horizontal.  Negative values are permitted.</value>
-		/// <seealso cref="IsDropShadow" />
-		/// <seealso cref="DropShadowColor" />
-		/// <seealso cref="DropShadowOffset" />
-		public float DropShadowAngle
-		{
-			get { return _dropShadowAngle; }
-			set { _dropShadowAngle = value; }
-		}
-		/// <summary>
-		/// Gets or sets the offset distance of the drop shadow for this <see cref="FontSpec" />.
-		/// </summary>
-		/// <remarks>
-		/// This value only applies if <see cref="IsDropShadow" /> is true.
-		/// </remarks>
-		/// <value>The offset distance, measured as a fraction of the scaled font height.</value>
-		/// <seealso cref="IsDropShadow" />
-		/// <seealso cref="DropShadowColor" />
-		/// <seealso cref="DropShadowAngle" />
-		public float DropShadowOffset
-		{
-			get { return _dropShadowOffset; }
-			set { _dropShadowOffset = value; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Construct a <see cref="FontSpec"/> object with default properties.
-		/// </summary>
-		public FontSpec()
-			: this( "Arial", 12, Color.Black, false, false, false )
-		{
-		}
-
-		/// <summary>
-		/// Construct a <see cref="FontSpec"/> object with the given properties.  All other properties
-		/// are defaulted according to the values specified in the <see cref="Default"/>
-		/// default class.
-		/// </summary>
-		/// <param name="family">A text string representing the font family
-		/// (default is "Arial")</param>
-		/// <param name="size">A size of the font in points.  This size will be scaled
-		/// based on the ratio of the <see cref="PaneBase.Rect"/> dimension to the
-		/// <see cref="PaneBase.BaseDimension"/> of the <see cref="GraphPane"/> object. </param>
-		/// <param name="color">The color with which to render the font</param>
-		/// <param name="isBold">true for a bold typeface, false otherwise</param>
-		/// <param name="isItalic">true for an italic typeface, false otherwise</param>
-		/// <param name="isUnderline">true for an underlined font, false otherwise</param>
-		public FontSpec( string family, float size, Color color, bool isBold,
-			bool isItalic, bool isUnderline )
-		{
-			Init( family, size, color, isBold, isItalic, isUnderline,
-					Default.FillColor, Default.FillBrush, Default.FillType );
-		}
-
-		/// <summary>
-		/// Construct a <see cref="FontSpec"/> object with the given properties.  All other properties
-		/// are defaulted according to the values specified in the <see cref="Default"/>
-		/// default class.
-		/// </summary>
-		/// <param name="family">A text string representing the font family
-		/// (default is "Arial")</param>
-		/// <param name="size">A size of the font in points.  This size will be scaled
-		/// based on the ratio of the <see cref="PaneBase.Rect"/> dimension to the
-		/// <see cref="PaneBase.BaseDimension"/> of the <see cref="GraphPane"/> object. </param>
-		/// <param name="color">The color with which to render the font</param>
-		/// <param name="isBold">true for a bold typeface, false otherwise</param>
-		/// <param name="isItalic">true for an italic typeface, false otherwise</param>
-		/// <param name="isUnderline">true for an underlined font, false otherwise</param>
-		/// <param name="fillColor">The <see cref="Color"/> to use for filling in the text background</param>
-		/// <param name="fillBrush">The <see cref="Brush"/> to use for filling in the text background</param>
-		/// <param name="fillType">The <see cref="ZedGraph.FillType"/> to use for the
-		/// text background</param>
-		public FontSpec( string family, float size, Color color, bool isBold,
-							bool isItalic, bool isUnderline, Color fillColor, Brush fillBrush,
-							FillType fillType )
-		{
-			Init( family, size, color, isBold, isItalic, isUnderline,
-					fillColor, fillBrush, fillType );
-		}
-
-		private void Init( string family, float size, Color color, bool isBold,
-			bool isItalic, bool isUnderline, Color fillColor, Brush fillBrush,
-			FillType fillType )
-		{
-			_fontColor = color;
-			_family = family;
-			_isBold = isBold;
-			_isItalic = isItalic;
-			_isUnderline = isUnderline;
-			_size = size;
-			_angle = 0F;
-
-			_isAntiAlias = Default.IsAntiAlias;
-			_stringAlignment = Default.StringAlignment;
-			_isDropShadow = Default.IsDropShadow;
-			_dropShadowColor = Default.DropShadowColor;
-			_dropShadowAngle = Default.DropShadowAngle;
-			_dropShadowOffset = Default.DropShadowOffset;
-
-			_fill = new Fill( fillColor, fillBrush, fillType );
-			_border = new Border( true, Color.Black, 1.0F );
-
-			_scaledSize = -1;
-			Remake( 1.0F, _size, ref _scaledSize, ref _font );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The FontSpec object from which to copy</param>
-		public FontSpec( FontSpec rhs )
-		{
-			_fontColor = rhs.FontColor;
-			_family = rhs.Family;
-			_isBold = rhs.IsBold;
-			_isItalic = rhs.IsItalic;
-			_isUnderline = rhs.IsUnderline;
-			_fill = rhs.Fill.Clone();
-			_border = rhs.Border.Clone();
-			_isAntiAlias = rhs._isAntiAlias;
-
-			_stringAlignment = rhs.StringAlignment;
-			_angle = rhs.Angle;
-			_size = rhs.Size;
-
-			_isDropShadow = rhs._isDropShadow;
-			_dropShadowColor = rhs._dropShadowColor;
-			_dropShadowAngle = rhs._dropShadowAngle;
-			_dropShadowOffset = rhs._dropShadowOffset;
-
-			_scaledSize = rhs._scaledSize;
-			Remake( 1.0F, _size, ref _scaledSize, ref _font );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public FontSpec Clone()
-		{
-			return new FontSpec( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		// Change to 2 with addition of isDropShadow, dropShadowColor, dropShadowAngle, dropShadowOffset
-		// changed to 10 with the version 5 refactor -- not backwards compatible
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected FontSpec( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_fontColor = (Color)info.GetValue( "fontColor", typeof( Color ) );
-			_family = info.GetString( "family" );
-			_isBold = info.GetBoolean( "isBold" );
-			_isItalic = info.GetBoolean( "isItalic" );
-			_isUnderline = info.GetBoolean( "isUnderline" );
-			_isAntiAlias = info.GetBoolean( "isAntiAlias" );
-
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_angle = info.GetSingle( "angle" );
-			_stringAlignment = (StringAlignment)info.GetValue( "stringAlignment", typeof( StringAlignment ) );
-			_size = info.GetSingle( "size" );
-
-			_isDropShadow = info.GetBoolean( "isDropShadow" );
-			_dropShadowColor = (Color)info.GetValue( "dropShadowColor", typeof( Color ) );
-			_dropShadowAngle = info.GetSingle( "dropShadowAngle" );
-			_dropShadowOffset = info.GetSingle( "dropShadowOffset" );
-
-			_scaledSize = -1;
-			Remake( 1.0F, _size, ref _scaledSize, ref _font );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "fontColor", _fontColor );
-			info.AddValue( "family", _family );
-			info.AddValue( "isBold", _isBold );
-			info.AddValue( "isItalic", _isItalic );
-			info.AddValue( "isUnderline", _isUnderline );
-			info.AddValue( "isAntiAlias", _isAntiAlias );
-
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "angle", _angle );
-			info.AddValue( "stringAlignment", _stringAlignment );
-			info.AddValue( "size", _size );
-
-			info.AddValue( "isDropShadow", _isDropShadow );
-			info.AddValue( "dropShadowColor", _dropShadowColor );
-			info.AddValue( "dropShadowAngle", _dropShadowAngle );
-			info.AddValue( "dropShadowOffset", _dropShadowOffset );
-		}
-	#endregion
-
-	#region Font Construction Methods
-		/// <summary>
-		/// Recreate the font based on a new scaled size.  The font
-		/// will only be recreated if the scaled size has changed by
-		/// at least 0.1 points.
-		/// </summary>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="size">The unscaled size of the font, in points</param>
-		/// <param name="scaledSize">The scaled size of the font, in points</param>
-		/// <param name="font">A reference to the <see cref="Font"/> object</param>
-		private void Remake( float scaleFactor, float size, ref float scaledSize, ref Font font )
-		{
-			float newSize = size * scaleFactor;
-
-			float oldSize = ( font == null ) ? 0.0f : font.Size;
-
-			// Regenerate the font only if the size has changed significantly
-			if ( font == null ||
-					Math.Abs( newSize - oldSize ) > 0.1 ||
-					font.Name != this.Family ||
-					font.Bold != _isBold ||
-					font.Italic != _isItalic ||
-					font.Underline != _isUnderline )
-			{
-				FontStyle style = FontStyle.Regular;
-				style = ( _isBold ? FontStyle.Bold : style ) |
-							( _isItalic ? FontStyle.Italic : style ) |
-							 ( _isUnderline ? FontStyle.Underline : style );
-
-				scaledSize = size * (float)scaleFactor;
-				font = new Font( _family, scaledSize, style, GraphicsUnit.World );
-			}
-		}
-
-		/// <summary>
-		/// Get the <see cref="Font"/> class for the current scaled font.
-		/// </summary>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>Returns a reference to a <see cref="Font"/> object
-		/// with a size of <see cref="_scaledSize"/>, and font <see cref="Family"/>.
-		/// </returns>
-		public Font GetFont( float scaleFactor )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			return _font;
-		}
-	#endregion
-
-	#region Rendering Methods
-		/// <summary>
-		/// Render the specified <paramref name="text"/> to the specifed
-		/// <see cref="Graphics"/> device.  The text, border, and fill options
-		/// will be rendered as required.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, PaneBase pane, string text, float x,
-			float y, AlignH alignH, AlignV alignV,
-			float scaleFactor )
-		{
-			this.Draw( g, pane, text, x, y, alignH, alignV,
-						scaleFactor, new SizeF() );
-		}
-
-		/// <summary>
-		/// Render the specified <paramref name="text"/> to the specifed
-		/// <see cref="Graphics"/> device.  The text, border, and fill options
-		/// will be rendered as required.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="layoutArea">The limiting area (<see cref="SizeF"/>) into which the text
-		/// must fit.  The actual rectangle may be smaller than this, but the text will be wrapped
-		/// to accomodate the area.</param>
-		public void Draw( Graphics g, PaneBase pane, string text, float x,
-			float y, AlignH alignH, AlignV alignV,
-			float scaleFactor, SizeF layoutArea )
-		{
-			// make sure the font size is properly scaled
-			//Remake( scaleFactor, this.Size, ref this.scaledSize, ref this.font );
-
-			SmoothingMode sModeSave = g.SmoothingMode;
-			TextRenderingHint sHintSave = g.TextRenderingHint;
-			if ( _isAntiAlias )
-			{
-				g.SmoothingMode = SmoothingMode.HighQuality;
-				g.TextRenderingHint = TextRenderingHint.AntiAlias;
-			}
-
-			SizeF sizeF;
-			if ( layoutArea.IsEmpty )
-				sizeF = MeasureString( g, text, scaleFactor );
-			else
-				sizeF = MeasureString( g, text, scaleFactor, layoutArea );
-
-			// Save the old transform matrix for later restoration
-			Matrix saveMatrix = g.Transform;
-			g.Transform = SetupMatrix( g.Transform, x, y, sizeF, alignH, alignV, _angle );
-
-			// Create a rectangle representing the border around the
-			// text.  Note that, while the text is drawn based on the
-			// TopCenter position, the rectangle is drawn based on
-			// the TopLeft position.  Therefore, move the rectangle
-			// width/2 to the left to align it properly
-			RectangleF rectF = new RectangleF( -sizeF.Width / 2.0F, 0.0F,
-								sizeF.Width, sizeF.Height );
-
-			// If the background is to be filled, fill it
-			_fill.Draw( g, rectF );
-
-			// Draw the border around the text if required
-			_border.Draw( g, pane, scaleFactor, rectF );
-
-			// make a center justified StringFormat alignment
-			// for drawing the text
-			StringFormat strFormat = new StringFormat();
-			strFormat.Alignment = _stringAlignment;
-			//			if ( this.stringAlignment == StringAlignment.Far )
-			//				g.TranslateTransform( sizeF.Width / 2.0F, 0F, MatrixOrder.Prepend );
-			//			else if ( this.stringAlignment == StringAlignment.Near )
-			//				g.TranslateTransform( -sizeF.Width / 2.0F, 0F, MatrixOrder.Prepend );
-
-
-			// Draw the drop shadow text.  Note that the coordinate system
-			// is set up such that 0,0 is at the location where the
-			// CenterTop of the text needs to be.
-			if ( _isDropShadow )
-			{
-				float xShift = (float)( Math.Cos( _dropShadowAngle ) *
-							_dropShadowOffset * _font.Height );
-				float yShift = (float)( Math.Sin( _dropShadowAngle ) *
-							_dropShadowOffset * _font.Height );
-				RectangleF rectD = rectF;
-				rectD.Offset( xShift, yShift );
-				// make a solid brush for rendering the font itself
-				using ( SolidBrush brushD = new SolidBrush( _dropShadowColor ) )
-					g.DrawString( text, _font, brushD, rectD, strFormat );
-			}
-
-			// make a solid brush for rendering the font itself
-			using ( SolidBrush brush = new SolidBrush( _fontColor ) )
-			{
-				// Draw the actual text.  Note that the coordinate system
-				// is set up such that 0,0 is at the location where the
-				// CenterTop of the text needs to be.
-				//RectangleF layoutArea = new RectangleF( 0.0F, 0.0F, sizeF.Width, sizeF.Height );
-				g.DrawString( text, _font, brush, rectF, strFormat );
-			}
-
-			// Restore the transform matrix back to original
-			g.Transform = saveMatrix;
-
-			g.SmoothingMode = sModeSave;
-			g.TextRenderingHint = sHintSave;
-		}
-
-		/// <summary>
-		/// Render the specified <paramref name="text"/> to the specifed
-		/// <see cref="Graphics"/> device.  The text, border, and fill options
-		/// will be rendered as required.  This special case method will show the
-		/// specified text as a power of 10, using the <see cref="Default.SuperSize"/>
-		/// and <see cref="Default.SuperShift"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DrawTenPower( Graphics g, GraphPane pane, string text, float x,
-			float y, AlignH alignH, AlignV alignV,
-			float scaleFactor )
-		{
-			SmoothingMode sModeSave = g.SmoothingMode;
-			TextRenderingHint sHintSave = g.TextRenderingHint;
-			if ( _isAntiAlias )
-			{
-				g.SmoothingMode = SmoothingMode.HighQuality;
-				g.TextRenderingHint = TextRenderingHint.AntiAlias;
-			}
-
-			// make sure the font size is properly scaled
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			float scaledSuperSize = _scaledSize * Default.SuperSize;
-			Remake( scaleFactor, this.Size * Default.SuperSize, ref scaledSuperSize,
-				ref _superScriptFont );
-
-			// Get the width and height of the text
-			SizeF size10 = g.MeasureString( "10", _font );
-			SizeF sizeText = g.MeasureString( text, _superScriptFont );
-			SizeF totSize = new SizeF( size10.Width + sizeText.Width,
-									size10.Height + sizeText.Height * Default.SuperShift );
-			float charWidth = g.MeasureString( "x", _superScriptFont ).Width;
-
-			// Save the old transform matrix for later restoration
-			Matrix saveMatrix = g.Transform;
-
-			g.Transform = SetupMatrix( g.Transform, x, y, totSize, alignH, alignV, _angle );
-
-			// make a center justified StringFormat alignment
-			// for drawing the text
-			StringFormat strFormat = new StringFormat();
-			strFormat.Alignment = _stringAlignment;
-
-			// Create a rectangle representing the border around the
-			// text.  Note that, while the text is drawn based on the
-			// TopCenter position, the rectangle is drawn based on
-			// the TopLeft position.  Therefore, move the rectangle
-			// width/2 to the left to align it properly
-			RectangleF rectF = new RectangleF( -totSize.Width / 2.0F, 0.0F,
-				totSize.Width, totSize.Height );
-
-			// If the background is to be filled, fill it
-			_fill.Draw( g, rectF );
-
-			// Draw the border around the text if required
-			_border.Draw( g, pane, scaleFactor, rectF );
-
-			// make a solid brush for rendering the font itself
-			using ( SolidBrush brush = new SolidBrush( _fontColor ) )
-			{
-				// Draw the actual text.  Note that the coordinate system
-				// is set up such that 0,0 is at the location where the
-				// CenterTop of the text needs to be.
-				g.DrawString( "10", _font, brush,
-								( -totSize.Width + size10.Width ) / 2.0F,
-								sizeText.Height * Default.SuperShift, strFormat );
-				g.DrawString( text, _superScriptFont, brush,
-								( totSize.Width - sizeText.Width - charWidth ) / 2.0F,
-								0.0F,
-								strFormat );
-			}
-
-			// Restore the transform matrix back to original
-			g.Transform = saveMatrix;
-
-			g.SmoothingMode = sModeSave;
-			g.TextRenderingHint = sHintSave;
-		}
-	#endregion
-
-	#region Sizing Methods
-		/// <summary>
-		/// Get the height of the scaled font
-		/// </summary>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled font height, in pixels</returns>
-		public float GetHeight( float scaleFactor )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			float height = _font.Height;
-			if ( _isDropShadow )
-				height += (float)( Math.Sin( _dropShadowAngle ) * _dropShadowOffset * _font.Height );
-			return height;
-		}
-		/// <summary>
-		/// Get the average character width of the scaled font.  The average width is
-		/// based on the character 'x'
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled font width, in pixels</returns>
-		public float GetWidth( Graphics g, float scaleFactor )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			return g.MeasureString( "x", _font ).Width;
-		}
-
-		/// <summary>
-		/// Get the total width of the specified text string
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled text width, in pixels</returns>
-		public float GetWidth( Graphics g, string text, float scaleFactor )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			float width = g.MeasureString( text, _font ).Width;
-			if ( _isDropShadow )
-				width += (float)( Math.Cos( _dropShadowAngle ) * _dropShadowOffset * _font.Height );
-			return width;
-		}
-		/// <summary>
-		/// Get a <see cref="SizeF"/> struct representing the width and height
-		/// of the specified text string, based on the scaled font size
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled text dimensions, in pixels, in the form of
-		/// a <see cref="SizeF"/> struct</returns>
-		public SizeF MeasureString( Graphics g, string text, float scaleFactor )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			SizeF size = g.MeasureString( text, _font );
-			if ( _isDropShadow )
-			{
-				size.Width += (float)( Math.Cos( _dropShadowAngle ) *
-								_dropShadowOffset * _font.Height );
-				size.Height += (float)( Math.Sin( _dropShadowAngle ) *
-								_dropShadowOffset * _font.Height );
-			}
-			return size;
-		}
-
-		/// <summary>
-		/// Get a <see cref="SizeF"/> struct representing the width and height
-		/// of the specified text string, based on the scaled font size, and using
-		/// the specified <see cref="SizeF"/> as an outer limit.
-		/// </summary>
-		/// <remarks>
-		/// This method will allow the text to wrap as necessary to fit the 
-		/// <see paramref="layoutArea"/>.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="layoutArea">The limiting area (<see cref="SizeF"/>) into which the text
-		/// must fit.  The actual rectangle may be smaller than this, but the text will be wrapped
-		/// to accomodate the area.</param>
-		/// <returns>The scaled text dimensions, in pixels, in the form of
-		/// a <see cref="SizeF"/> struct</returns>
-		public SizeF MeasureString( Graphics g, string text, float scaleFactor, SizeF layoutArea )
-		{
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-			SizeF size = g.MeasureString( text, _font, layoutArea );
-			if ( _isDropShadow )
-			{
-				size.Width += (float)( Math.Cos( _dropShadowAngle ) *
-								_dropShadowOffset * _font.Height );
-				size.Height += (float)( Math.Sin( _dropShadowAngle ) *
-								_dropShadowOffset * _font.Height );
-			}
-			return size;
-		}
-
-		/// <summary>
-		/// Get a <see cref="SizeF"/> struct representing the width and height
-		/// of the bounding box for the specified text string, based on the scaled font size.
-		/// </summary>
-		/// <remarks>
-		/// This routine differs from <see cref="MeasureString(Graphics,string,float)"/> in that it takes into
-		/// account the rotation angle of the font, and gives the dimensions of the
-		/// bounding box that encloses the text at the specified angle.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled text dimensions, in pixels, in the form of
-		/// a <see cref="SizeF"/> struct</returns>
-		public SizeF BoundingBox( Graphics g, string text, float scaleFactor )
-		{
-			return BoundingBox( g, text, scaleFactor, new SizeF() );
-		}
-
-		/// <summary>
-		/// Get a <see cref="SizeF"/> struct representing the width and height
-		/// of the bounding box for the specified text string, based on the scaled font size.
-		/// </summary>
-		/// <remarks>
-		/// This routine differs from <see cref="MeasureString(Graphics,string,float)"/> in that it takes into
-		/// account the rotation angle of the font, and gives the dimensions of the
-		/// bounding box that encloses the text at the specified angle.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="layoutArea">The limiting area (<see cref="SizeF"/>) into which the text
-		/// must fit.  The actual rectangle may be smaller than this, but the text will be wrapped
-		/// to accomodate the area.</param>
-		/// <returns>The scaled text dimensions, in pixels, in the form of
-		/// a <see cref="SizeF"/> struct</returns>
-		public SizeF BoundingBox( Graphics g, string text, float scaleFactor, SizeF layoutArea )
-		{
-			//Remake( scaleFactor, this.Size, ref this.scaledSize, ref this.font );
-			SizeF s;
-			if ( layoutArea.IsEmpty )
-				s = MeasureString( g, text, scaleFactor );
-			else
-				s = MeasureString( g, text, scaleFactor, layoutArea );
-
-			float cs = (float)Math.Abs( Math.Cos( _angle * Math.PI / 180.0 ) );
-			float sn = (float)Math.Abs( Math.Sin( _angle * Math.PI / 180.0 ) );
-
-			SizeF s2 = new SizeF( s.Width * cs + s.Height * sn,
-				s.Width * sn + s.Height * cs );
-
-			return s2;
-		}
-
-		/// <summary>
-		/// Get a <see cref="SizeF"/> struct representing the width and height
-		/// of the bounding box for the specified text string, based on the scaled font size.
-		/// </summary>
-		/// <remarks>
-		/// This special case method will show the specified string as a power of 10,
-		/// superscripted and downsized according to the
-		/// <see cref="Default.SuperSize"/> and <see cref="Default.SuperShift"/>.
-		/// This routine differs from <see cref="MeasureString(Graphics,string,float)"/> in that it takes into
-		/// account the rotation angle of the font, and gives the dimensions of the
-		/// bounding box that encloses the text at the specified angle.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">The text string for which the width is to be calculated
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled text dimensions, in pixels, in the form of
-		/// a <see cref="SizeF"/> struct</returns>
-		public SizeF BoundingBoxTenPower( Graphics g, string text, float scaleFactor )
-		{
-			//Remake( scaleFactor, this.Size, ref this.scaledSize, ref this.font );
-			float scaledSuperSize = _scaledSize * Default.SuperSize;
-			Remake( scaleFactor, this.Size * Default.SuperSize, ref scaledSuperSize,
-				ref _superScriptFont );
-
-			// Get the width and height of the text
-			SizeF size10 = MeasureString( g, "10", scaleFactor );
-			SizeF sizeText = g.MeasureString( text, _superScriptFont );
-
-			if ( _isDropShadow )
-			{
-				sizeText.Width += (float)( Math.Cos( _dropShadowAngle ) *
-							_dropShadowOffset * _superScriptFont.Height );
-				sizeText.Height += (float)( Math.Sin( _dropShadowAngle ) *
-							_dropShadowOffset * _superScriptFont.Height );
-			}
-
-			SizeF totSize = new SizeF( size10.Width + sizeText.Width,
-				size10.Height + sizeText.Height * Default.SuperShift );
-
-
-			float cs = (float)Math.Abs( Math.Cos( _angle * Math.PI / 180.0 ) );
-			float sn = (float)Math.Abs( Math.Sin( _angle * Math.PI / 180.0 ) );
-
-			SizeF s2 = new SizeF( totSize.Width * cs + totSize.Height * sn,
-				totSize.Width * sn + totSize.Height * cs );
-
-			return s2;
-		}
-
-
-		/// <summary>
-		/// Determines if the specified screen point lies within the bounding box of
-		/// the text, taking into account alignment and rotation parameters.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixel units</param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies within the bounding box, false otherwise</returns>
-		public bool PointInBox( PointF pt, Graphics g, string text, float x,
-			float y, AlignH alignH, AlignV alignV,
-			float scaleFactor )
-		{
-			return PointInBox( pt, g, text, x, y, alignH, alignV, scaleFactor, new SizeF() );
-		}
-
-		/// <summary>
-		/// Determines if the specified screen point lies within the bounding box of
-		/// the text, taking into account alignment and rotation parameters.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixel units</param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="layoutArea">The limiting area (<see cref="SizeF"/>) into which the text
-		/// must fit.  The actual rectangle may be smaller than this, but the text will be wrapped
-		/// to accomodate the area.</param>
-		/// <returns>true if the point lies within the bounding box, false otherwise</returns>
-		public bool PointInBox( PointF pt, Graphics g, string text, float x,
-			float y, AlignH alignH, AlignV alignV,
-			float scaleFactor, SizeF layoutArea )
-		{
-			// make sure the font size is properly scaled
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-
-			// Get the width and height of the text
-			SizeF sizeF;
-			if ( layoutArea.IsEmpty )
-				sizeF = g.MeasureString( text, _font );
-			else
-				sizeF = g.MeasureString( text, _font, layoutArea );
-
-			// Create a bounding box rectangle for the text
-			RectangleF rect = new RectangleF( new PointF( -sizeF.Width / 2.0F, 0.0F ), sizeF );
-
-			// Build a transform matrix that inverts that drawing transform
-			// in this manner, the point is brought back to the box, rather
-			// than vice-versa.  This allows the container check to be a simple
-			// RectangleF.Contains, since the rectangle won't be rotated.
-			Matrix matrix = GetMatrix( x, y, sizeF, alignH, alignV, _angle );
-
-			PointF[] pts = new PointF[1];
-			pts[0] = pt;
-			matrix.TransformPoints( pts );
-
-			return rect.Contains( pts[0] );
-		}
-
-		private Matrix SetupMatrix( Matrix matrix, float x, float y, SizeF sizeF, AlignH alignH,
-				AlignV alignV, float angle )
-		{
-			// Move the coordinate system to local coordinates
-			// of this text object (that is, at the specified
-			// x,y location)
-			matrix.Translate( x, y, MatrixOrder.Prepend );
-
-			// Rotate the coordinate system according to the 
-			// specified angle of the FontSpec
-			if ( _angle != 0.0F )
-				matrix.Rotate( -angle, MatrixOrder.Prepend );
-
-			// Since the text will be drawn by g.DrawString()
-			// assuming the location is the TopCenter
-			// (the Font is aligned using StringFormat to the
-			// center so multi-line text is center justified),
-			// shift the coordinate system so that we are
-			// actually aligned per the caller specified position
-			float xa, ya;
-			if ( alignH == AlignH.Left )
-				xa = sizeF.Width / 2.0F;
-			else if ( alignH == AlignH.Right )
-				xa = -sizeF.Width / 2.0F;
-			else
-				xa = 0.0F;
-
-			if ( alignV == AlignV.Center )
-				ya = -sizeF.Height / 2.0F;
-			else if ( alignV == AlignV.Bottom )
-				ya = -sizeF.Height;
-			else
-				ya = 0.0F;
-
-			// Shift the coordinates to accomodate the alignment
-			// parameters
-			matrix.Translate( xa, ya, MatrixOrder.Prepend );
-
-			return matrix;
-		}
-
-		private Matrix GetMatrix( float x, float y, SizeF sizeF, AlignH alignH, AlignV alignV,
-							float angle )
-		{
-			// Build a transform matrix that inverts that drawing transform
-			// in this manner, the point is brought back to the box, rather
-			// than vice-versa.  This allows the container check to be a simple
-			// RectangleF.Contains, since the rectangle won't be rotated.
-			Matrix matrix = new Matrix();
-
-			// In this case, the bounding box is anchored to the
-			// top-left of the text box.  Handle the alignment
-			// as needed.
-			float xa, ya;
-			if ( alignH == AlignH.Left )
-				xa = sizeF.Width / 2.0F;
-			else if ( alignH == AlignH.Right )
-				xa = -sizeF.Width / 2.0F;
-			else
-				xa = 0.0F;
-
-			if ( alignV == AlignV.Center )
-				ya = -sizeF.Height / 2.0F;
-			else if ( alignV == AlignV.Bottom )
-				ya = -sizeF.Height;
-			else
-				ya = 0.0F;
-
-			// Shift the coordinates to accomodate the alignment
-			// parameters
-			matrix.Translate( -xa, -ya, MatrixOrder.Prepend );
-
-			// Rotate the coordinate system according to the 
-			// specified angle of the FontSpec
-			if ( angle != 0.0F )
-				matrix.Rotate( angle, MatrixOrder.Prepend );
-
-			// Move the coordinate system to local coordinates
-			// of this text object (that is, at the specified
-			// x,y location)
-			matrix.Translate( -x, -y, MatrixOrder.Prepend );
-
-			return matrix;
-		}
-
-		/// <summary>
-		/// Returns a polygon that defines the bounding box of
-		/// the text, taking into account alignment and rotation parameters.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="text">A string value containing the text to be
-		/// displayed.  This can be multiple lines, separated by newline ('\n')
-		/// characters</param>
-		/// <param name="x">The X location to display the text, in screen
-		/// coordinates, relative to the horizontal (<see cref="AlignH"/>)
-		/// alignment parameter <paramref name="alignH"/></param>
-		/// <param name="y">The Y location to display the text, in screen
-		/// coordinates, relative to the vertical (<see cref="AlignV"/>
-		/// alignment parameter <paramref name="alignV"/></param>
-		/// <param name="alignH">A horizontal alignment parameter specified
-		/// using the <see cref="AlignH"/> enum type</param>
-		/// <param name="alignV">A vertical alignment parameter specified
-		/// using the <see cref="AlignV"/> enum type</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="layoutArea">The limiting area (<see cref="SizeF"/>) into which the text
-		/// must fit.  The actual rectangle may be smaller than this, but the text will be wrapped
-		/// to accomodate the area.</param>
-		/// <returns>A polygon of 4 points defining the area of this text</returns>
-		public PointF[] GetBox( Graphics g, string text, float x,
-				float y, AlignH alignH, AlignV alignV,
-				float scaleFactor, SizeF layoutArea )
-		{
-			// make sure the font size is properly scaled
-			Remake( scaleFactor, this.Size, ref _scaledSize, ref _font );
-
-			// Get the width and height of the text
-			SizeF sizeF;
-			if ( layoutArea.IsEmpty )
-				sizeF = g.MeasureString( text, _font );
-			else
-				sizeF = g.MeasureString( text, _font, layoutArea );
-
-			// Create a bounding box rectangle for the text
-			RectangleF rect = new RectangleF( new PointF( -sizeF.Width / 2.0F, 0.0F ), sizeF );
-
-			Matrix matrix = new Matrix();
-			SetupMatrix( matrix, x, y, sizeF, alignH, alignV, _angle );
-
-			PointF[] pts = new PointF[4];
-			pts[0] = new PointF( rect.Left, rect.Top );
-			pts[1] = new PointF( rect.Right, rect.Top );
-			pts[2] = new PointF( rect.Right, rect.Bottom );
-			pts[3] = new PointF( rect.Left, rect.Bottom );
-			matrix.TransformPoints( pts );
-
-			return pts;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/GapLabel.cs b/BDInfo/ZedGraph/GapLabel.cs
deleted file mode 100644
index d00f7d83e0..0000000000
--- a/BDInfo/ZedGraph/GapLabel.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the data associated with a text title and its associated font
-	/// properties.  Inherits from <see cref="Label" />, and adds the <see cref="Gap" />
-	/// property for use by the <see cref="Axis" /> and <see cref="PaneBase" /> objects.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class GapLabel : Label, ICloneable, ISerializable
-	{
-		internal float _gap;
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to build a <see cref="GapLabel" /> from the text and the
-		/// associated font properties.
-		/// </summary>
-		/// <param name="text">The <see cref="string" /> representing the text to be
-		/// displayed</param>
-		/// <param name="fontFamily">The <see cref="String" /> font family name</param>
-		/// <param name="fontSize">The size of the font in points and scaled according
-		/// to the <see cref="PaneBase.CalcScaleFactor" /> logic.</param>
-		/// <param name="color">The <see cref="Color" /> instance representing the color
-		/// of the font</param>
-		/// <param name="isBold">true for a bold font face</param>
-		/// <param name="isItalic">true for an italic font face</param>
-		/// <param name="isUnderline">true for an underline font face</param>
-		public GapLabel( string text, string fontFamily, float fontSize, Color color, bool isBold,
-								bool isItalic, bool isUnderline )
-			: base( text, fontFamily, fontSize, color, isBold, isItalic, isUnderline )
-		{
-			_gap = Default.Gap;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">the <see cref="AxisLabel" /> instance to be copied.</param>
-		public GapLabel( GapLabel rhs )
-			: base( rhs )
-		{
-			_gap = rhs._gap;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new GapLabel Clone()
-		{
-			return new GapLabel( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the gap factor between this label and the opposing <see cref="Axis" />
-		/// or <see cref="Chart" />.
-		/// </summary>
-		/// <remarks>
-		/// This value is expressed as a fraction of the character height for the <see cref="GapLabel" />.
-		/// </remarks>
-		public float Gap
-		{
-			get { return _gap; }
-			set { _gap = value; }
-		}
-
-		/// <summary>
-		/// Calculate the size of the <see cref="Gap" /> based on the <see cref="Label.FontSpec" />
-		/// height, in pixel units and scaled according to <see paramref="scalefactor" />.
-		/// </summary>
-		/// <param name="scaleFactor">The scaling factor to be applied</param>
-		public float GetScaledGap( float scaleFactor )
-		{
-			return _fontSpec.GetHeight( scaleFactor ) * _gap;
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected GapLabel( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch2 = info.GetInt32( "schema2" );
-
-			_gap = info.GetSingle( "gap" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "gap", _gap );
-		}
-	#endregion
-
-	#region Default
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="GapLabel"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default <see cref="GapLabel.Gap" /> setting.
-			/// </summary>
-			public static float Gap = 0.3f;
-		}
-	#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/GasGaugeNeedle.cs b/BDInfo/ZedGraph/GasGaugeNeedle.cs
deleted file mode 100644
index bade14eb4f..0000000000
--- a/BDInfo/ZedGraph/GasGaugeNeedle.cs
+++ /dev/null
@@ -1,594 +0,0 @@
-//============================================================================
-//GasGaugeNeedle Class
-//Copyright © 2006 Jay Mistry
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//=============================================================================
-using System.Runtime.Serialization;
-using System.Drawing.Drawing2D;
-using System;
-using System.Text;
-using System.Drawing;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class representing a needle on the GasGuage chart
-	/// <see cref="GasGaugeNeedle"/>s.
-	/// </summary>
-	/// <author> Jay Mistry </author>
-	/// <version> $Revision: 1.2 $ $Date: 2007/08/11 14:37:47 $ </version>
-	[Serializable]
-	public class GasGaugeNeedle : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Value of this needle
-		/// </summary>
-		private double _needleValue;
-
-		/// <summary>
-		/// Width of the line being drawn
-		/// </summary>
-		private float _needleWidth;
-
-		/// <summary>
-		/// Color of the needle line
-		/// </summary>
-		private Color _color;
-
-		/// <summary>
-		/// Internally calculated angle that places this needle relative to the MinValue and
-		/// MaxValue of 180 degree GasGuage
-		/// </summary>
-		private float _sweepAngle;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="GasGaugeNeedle"/>. Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-
-		/// <summary>
-		/// A <see cref="ZedGraph.TextObj"/> which will customize the label display of this
-		/// <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		private TextObj _labelDetail;
-
-		/// <summary>
-		/// Private field that stores the <see cref="Border"/> class that defines the
-		/// properties of the border around this <see cref="GasGaugeNeedle"/>. Use the public
-		/// property <see cref="Border"/> to access this value.
-		/// </summary>
-		private Border _border;
-
-		/// <summary>
-		/// The bounding rectangle for this <see cref="GasGaugeNeedle"/>.
-		/// </summary>
-		private RectangleF _boundingRectangle;
-
-		/// <summary>
-		/// Private field to hold the GraphicsPath of this <see cref="GasGaugeNeedle"/> to be
-		/// used for 'hit testing'.
-		/// </summary>
-		private GraphicsPath _slicePath;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Create a new <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		/// <param name="label">The value associated with this <see cref="GasGaugeNeedle"/>
-		/// instance.</param>
-		/// <param name="color">The display color for this <see cref="GasGaugeNeedle"/>
-		/// instance.</param>
-		/// <param name="val">The value of this <see cref="GasGaugeNeedle"/>.</param>
-		public GasGaugeNeedle( string label, double val, Color color )
-			: base( label )
-		{
-			NeedleValue = val;
-			NeedleColor = color;
-			NeedleWidth = Default.NeedleWidth;
-			SweepAngle = 0f;
-			_border = new Border( Default.BorderColor, Default.BorderWidth );
-			_labelDetail = new TextObj();
-			_labelDetail.FontSpec.Size = Default.FontSize;
-			_slicePath = null;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="ggn">The <see cref="GasGaugeNeedle"/> object from which to copy</param>
-		public GasGaugeNeedle( GasGaugeNeedle ggn )
-			: base( ggn )
-		{
-			NeedleValue = ggn.NeedleValue;
-			NeedleColor = ggn.NeedleColor;
-			NeedleWidth = ggn.NeedleWidth;
-			SweepAngle = ggn.SweepAngle;
-			_border = ggn.Border.Clone();
-			_labelDetail = ggn.LabelDetail.Clone();
-			_labelDetail.FontSpec.Size = ggn.LabelDetail.FontSpec.Size;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public GasGaugeNeedle Clone()
-		{
-			return new GasGaugeNeedle( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or Sets the NeedleWidth of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public float NeedleWidth
-		{
-			get { return _needleWidth; }
-			set { _needleWidth = value; }
-		}
-
-		/// <summary>
-		/// Gets or Sets the Border of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public Border Border
-		{
-			get { return ( _border ); }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or Sets the SlicePath of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public GraphicsPath SlicePath
-		{
-			get { return _slicePath; }
-		}
-
-		/// <summary>
-		/// Gets or Sets the LableDetail of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public TextObj LabelDetail
-		{
-			get { return _labelDetail; }
-			set { _labelDetail = value; }
-		}
-
-
-		/// <summary>
-		/// Gets or Sets the NeedelColor of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public Color NeedleColor
-		{
-			get { return _color; }
-			set
-			{
-				_color = value;
-				Fill = new Fill( _color );
-			}
-		}
-
-		/// <summary>
-		/// Gets or Sets the Fill of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Private property that Gets or Sets the SweepAngle of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		private float SweepAngle
-		{
-			get { return _sweepAngle; }
-			set { _sweepAngle = value; }
-		}
-
-		/// <summary>
-		/// Gets or Sets the NeedleValue of this <see cref="GasGaugeNeedle"/>
-		/// </summary>
-		public double NeedleValue
-		{
-			get { return ( _needleValue ); }
-			set { _needleValue = value > 0 ? value : 0; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return false;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return true;
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected GasGaugeNeedle( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter. You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_labelDetail = (TextObj)info.GetValue( "labelDetail", typeof( TextObj ) );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_needleValue = info.GetDouble( "needleValue" );
-			_boundingRectangle = (RectangleF)info.GetValue( "boundingRectangle", typeof( RectangleF ) );
-			_slicePath = (GraphicsPath)info.GetValue( "slicePath", typeof( GraphicsPath ) );
-			_sweepAngle = (float)info.GetDouble( "sweepAngle" );
-			_color = (Color)info.GetValue( "color", typeof( Color ) );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "labelDetail", _labelDetail );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "needleValue", _needleValue );
-			info.AddValue( "boundingRectangle", _boundingRectangle );
-			info.AddValue( "slicePath", _slicePath );
-			info.AddValue( "sweepAngle", _sweepAngle );
-		}
-
-	#endregion
-
-	#region Default
-
-		/// <summary>
-		/// Specify the default property values for the <see cref="GasGaugeNeedle"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default width of the gas gauge needle.  Units are points, scaled according
-			/// to <see cref="PaneBase.CalcScaleFactor" />
-			/// </summary>
-			public static float NeedleWidth = 10.0F;
-
-			/// <summary>
-			/// The default pen width to be used for drawing the border around the GasGaugeNeedle
-			/// (<see cref="ZedGraph.LineBase.Width"/> property). Units are points.
-			/// </summary>
-			public static float BorderWidth = 1.0F;
-
-			/// <summary>
-			/// The default border mode for GasGaugeNeedle (<see cref="ZedGraph.LineBase.IsVisible"/>
-			/// property).
-			/// true to display frame around GasGaugeNeedle, false otherwise
-			/// </summary>
-			public static bool IsBorderVisible = true;
-
-			/// <summary>
-			/// The default color for drawing frames around GasGaugeNeedle
-			/// (<see cref="ZedGraph.LineBase.Color"/> property).
-			/// </summary>
-			public static Color BorderColor = Color.Gray;
-
-			/// <summary>
-			/// The default fill type for filling the GasGaugeNeedle.
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-
-			/// <summary>
-			/// The default color for filling in the GasGaugeNeedle
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.Empty;
-
-			/// <summary>
-			/// The default custom brush for filling in the GasGaugeNeedle.
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-
-			/// <summary>
-			///Default value for controlling <see cref="GasGaugeNeedle"/> display.
-			/// </summary>
-			public static bool isVisible = true;
-
-//			/// <summary>
-//			/// Default value for <see cref="GasGaugeNeedle.LabelType"/>.
-//			/// </summary>
-//			public static PieLabelType LabelType = PieLabelType.Name;
-
-			/// <summary>
-			/// The default font size for <see cref="GasGaugeNeedle.LabelDetail"/> entries
-			/// (<see cref="ZedGraph.FontSpec.Size"/> property). Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float FontSize = 10;
-		}
-
-	#endregion Defaults
-
-	#region Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="GasGaugeNeedle"/> item to the specified
-		/// <see cref="Graphics"/> device. This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">Not used for rendering GasGaugeNeedle</param>
-		/// <param name="scaleFactor">Not used for rendering GasGaugeNeedle</param>
-		public override void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor )
-		{
-			if ( pane.Chart._rect.Width <= 0 && pane.Chart._rect.Height <= 0 )
-			{
-				_slicePath = null;
-			}
-			else
-			{
-				CalcRectangle( g, pane, scaleFactor, pane.Chart._rect );
-
-				_slicePath = new GraphicsPath();
-
-				if ( !_isVisible )
-					return;
-
-				RectangleF tRect = _boundingRectangle;
-
-				if ( tRect.Width >= 1 && tRect.Height >= 1 )
-				{
-					SmoothingMode sMode = g.SmoothingMode;
-					g.SmoothingMode = SmoothingMode.AntiAlias;
-
-					Matrix matrix = new Matrix();
-
-					matrix.Translate( tRect.X + ( tRect.Width / 2 ), tRect.Y + ( tRect.Height / 2 ), MatrixOrder.Prepend );
-
-					PointF[] pts = new PointF[2];
-					pts[0] = new PointF( ( ( tRect.Height * .10f ) / 2.0f ) * (float)Math.Cos( -SweepAngle * Math.PI / 180.0f ),
-					( ( tRect.Height * .10f ) / 2.0f ) * (float)Math.Sin( -SweepAngle * Math.PI / 180.0f ) );
-					pts[1] = new PointF( ( tRect.Width / 2.0f ) * (float)Math.Cos( -SweepAngle * Math.PI / 180.0f ),
-					( tRect.Width / 2.0f ) * (float)Math.Sin( -SweepAngle * Math.PI / 180.0f ) );
-
-					matrix.TransformPoints( pts );
-
-					Pen p = new Pen( NeedleColor, ( ( tRect.Height * .10f ) / 2.0f ) );
-					p.EndCap = LineCap.ArrowAnchor;
-					g.DrawLine( p, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y );
-
-					//Fill center 10% with Black dot;
-					Fill f = new Fill( Color.Black );
-					RectangleF r = new RectangleF( ( tRect.X + ( tRect.Width / 2 ) ) - 1.0f, ( tRect.Y + ( tRect.Height / 2 ) ) - 1.0f, 1.0f, 1.0f );
-					r.Inflate( ( tRect.Height * .10f ), ( tRect.Height * .10f ) );
-					Brush b = f.MakeBrush( r );
-					g.FillPie( b, r.X, r.Y, r.Width, r.Height, 0.0f, -180.0f );
-
-					Pen borderPen = new Pen( Color.White, 2.0f );
-					g.DrawPie( borderPen, r.X, r.Y, r.Width, r.Height, 0.0f, -180.0f );
-
-					g.SmoothingMode = sMode;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Render the label for this <see cref="GasGaugeNeedle"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">Bounding rectangle for this <see cref="GasGaugeNeedle"/>.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects. This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param> 
-		public override void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			if ( !_isVisible )
-				return;
-
-			float yMid = rect.Top + rect.Height / 2.0F;
-
-			Pen pen = new Pen( NeedleColor, pane.ScaledPenWidth( NeedleWidth / 2, scaleFactor ) );
-			pen.StartCap = LineCap.Round;
-			pen.EndCap = LineCap.ArrowAnchor;
-			pen.DashStyle = DashStyle.Solid;
-			g.DrawLine( pen, rect.Left, yMid, rect.Right, yMid );
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		public override bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = String.Empty;
-			return false;
-		}
-
-		/// <summary>
-		/// Calculate the values needed to properly display this <see cref="GasGaugeNeedle"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public static void CalculateGasGaugeParameters( GraphPane pane )
-		{
-			//loop thru slices and get total value and maxDisplacement
-			double minVal = double.MaxValue;
-			double maxVal = double.MinValue;
-			foreach ( CurveItem curve in pane.CurveList )
-				if ( curve is GasGaugeRegion )
-				{
-					GasGaugeRegion ggr = (GasGaugeRegion)curve;
-					if ( maxVal < ggr.MaxValue )
-						maxVal = ggr.MaxValue;
-
-					if ( minVal > ggr.MinValue )
-						minVal = ggr.MinValue;
-				}
-
-			//Set Needle Sweep angle values here based on the min and max values of the GasGuage
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( curve is GasGaugeNeedle )
-				{
-					GasGaugeNeedle ggn = (GasGaugeNeedle)curve;
-					float sweep = ( (float)ggn.NeedleValue - (float)minVal ) /
-										( (float)maxVal - (float)minVal ) * 180.0f;
-					ggn.SweepAngle = sweep;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="RectangleF"/> that will be used to define the bounding rectangle of
-		/// the GasGaugeNeedle.
-		/// </summary>
-		/// <remarks>This rectangle always lies inside of the <see cref="Chart.Rect"/>, and it is
-		/// normally a square so that the pie itself is not oval-shaped.</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects. This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param> 
-		/// <param name="chartRect">The <see cref="RectangleF"/> (normally the <see cref="Chart.Rect"/>)
-		/// that bounds this pie.</param>
-		/// <returns></returns>
-		public static RectangleF CalcRectangle( Graphics g, GraphPane pane, float scaleFactor, RectangleF chartRect )
-		{
-			RectangleF nonExpRect = chartRect;
-
-			if ( ( 2 * nonExpRect.Height ) > nonExpRect.Width )
-			{
-				//Scale based on width
-				float percentS = ( ( nonExpRect.Height * 2 ) - nonExpRect.Width ) / ( nonExpRect.Height * 2 );
-				nonExpRect.Height = ( ( nonExpRect.Height * 2 ) - ( ( nonExpRect.Height * 2 ) * percentS ) );
-			}
-			else
-			{
-				nonExpRect.Height = nonExpRect.Height * 2;
-			}
-
-			nonExpRect.Width = nonExpRect.Height;
-
-			float xDelta = ( chartRect.Width / 2 ) - ( nonExpRect.Width / 2 );
-
-			//Align Horizontally
-			nonExpRect.X += xDelta;
-
-			nonExpRect.Inflate( -(float)0.05F * nonExpRect.Height, -(float)0.05 * nonExpRect.Width );
-
-			GasGaugeNeedle.CalculateGasGaugeParameters( pane );
-
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( curve is GasGaugeNeedle )
-				{
-					GasGaugeNeedle ggn = (GasGaugeNeedle)curve;
-					ggn._boundingRectangle = nonExpRect;
-				}
-			}
-
-			return nonExpRect;
-
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/GasGaugeRegion.cs b/BDInfo/ZedGraph/GasGaugeRegion.cs
deleted file mode 100644
index 4a00bc45fb..0000000000
--- a/BDInfo/ZedGraph/GasGaugeRegion.cs
+++ /dev/null
@@ -1,598 +0,0 @@
-//============================================================================
-//GasGaugeRegion Class
-//Copyright © 2006 Jay Mistry
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//=============================================================================
-using System.Runtime.Serialization;
-using System.Drawing.Drawing2D;
-using System;
-using System.Text;
-using System.Drawing;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class representing a region on the GasGuage chart
-	/// <see cref="GasGaugeRegion"/>s.
-	/// </summary>
-	/// <author> Jay Mistry </author>
-	/// <version> $Revision: 1.2 $ $Date: 2007/07/30 05:26:23 $ </version>
-	[Serializable]
-	public class GasGaugeRegion : CurveItem, ICloneable, ISerializable
-	{
-		#region Fields
-
-		/// <summary>
-		/// Defines the minimum value of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private double _minValue;
-
-		/// <summary>
-		/// Defines the maximum value of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private double _maxValue;
-
-		/// <summary>
-		/// Defines the Color of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private Color _color;
-
-		/// <summary>
-		/// Internally calculated; Start angle of this pie that defines this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private float _startAngle;
-
-		/// <summary>
-		/// Internally calculated; Sweep angle of this pie that defines this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private float _sweepAngle;
-
-		/// <summary>
-		/// Private	field	that stores the	<see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="GasGaugeRegion"/>.	 Use the public property <see	cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-
-		/// <summary>
-		/// A <see cref="ZedGraph.TextObj"/> which will customize the label display of this
-		/// <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private TextObj _labelDetail;
-
-		/// <summary>
-		/// Private	field	that stores the	<see cref="Border"/> class that defines	the
-		/// properties of the	border around	this <see cref="GasGaugeRegion"/>. Use the public
-		/// property	<see cref="Border"/> to access this value.
-		/// </summary>
-		private Border _border;
-
-		/// <summary>
-		/// The bounding rectangle for this <see cref="GasGaugeRegion"/>.
-		/// </summary>
-		private RectangleF _boundingRectangle;
-
-		/// <summary>
-		/// Private field to hold the GraphicsPath of this <see cref="GasGaugeRegion"/> to be
-		/// used for 'hit testing'.
-		/// </summary>
-		private GraphicsPath _slicePath;
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected GasGaugeRegion( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter. You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_labelDetail = (TextObj)info.GetValue( "labelDetail", typeof( TextObj ) );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_color = (Color)info.GetValue( "color", typeof( Color ) );
-			_minValue = info.GetDouble( "minValue" );
-			_maxValue = info.GetDouble( "maxValue" );
-			_startAngle = (float)info.GetDouble( "startAngle" );
-			_sweepAngle = (float)info.GetDouble( "sweepAngle" );
-			_boundingRectangle = (RectangleF)info.GetValue( "boundingRectangle", typeof( RectangleF ) );
-			_slicePath = (GraphicsPath)info.GetValue( "slicePath", typeof( GraphicsPath ) );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "labelDetail", _labelDetail );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "color", _color );
-			info.AddValue( "border", _border );
-			info.AddValue( "minVal", _minValue );
-			info.AddValue( "maxVal", _maxValue );
-			info.AddValue( "startAngle", _startAngle );
-			info.AddValue( "sweepAngle", _sweepAngle );
-			info.AddValue( "boundingRectangle", _boundingRectangle );
-			info.AddValue( "slicePath", _slicePath );
-		}
-		#endregion
-
-		#region Constructors
-
-		/// <summary>
-		/// Create a new <see cref="GasGaugeRegion"/>
-		/// </summary>
-		/// <param name="label">The value associated with this <see cref="GasGaugeRegion"/> instance.</param>
-		/// <param name="color">The display color for this <see cref="GasGaugeRegion"/> instance.</param>
-		/// <param name="minVal">The minimum value of this <see cref="GasGaugeNeedle"/>.</param>
-		/// <param name="maxVal">The maximum value of this <see cref="GasGaugeNeedle"/>.</param>
-		public GasGaugeRegion( string label, double minVal, double maxVal, Color color )
-			: base( label )
-		{
-			MinValue = minVal;
-			MaxValue = maxVal;
-			RegionColor = color;
-			StartAngle = 0f;
-			SweepAngle = 0f;
-			_border = new Border( Default.BorderColor, Default.BorderWidth );
-			_labelDetail = new TextObj();
-			_labelDetail.FontSpec.Size = Default.FontSize;
-			_slicePath = null;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="ggr">The <see cref="GasGaugeRegion"/> object from which to copy</param>
-		public GasGaugeRegion( GasGaugeRegion ggr )
-			: base( ggr )
-		{
-			_minValue = ggr._minValue;
-			_maxValue = ggr._maxValue;
-			_color = ggr._color;
-			_startAngle = ggr._startAngle;
-			_sweepAngle = ggr._sweepAngle;
-			_border = ggr._border.Clone();
-			_labelDetail = ggr._labelDetail.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public GasGaugeRegion Clone()
-		{
-			return new GasGaugeRegion( this );
-		}
-		#endregion
-
-		#region Properties
-
-		/// <summary>
-		/// Gets or sets the SlicePath of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public GraphicsPath SlicePath
-		{
-			get { return _slicePath; }
-		}
-
-		/// <summary>
-		/// Gets or sets the LabelDetail of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public TextObj LabelDetail
-		{
-			get { return _labelDetail; }
-			set { _labelDetail = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the Border of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public Border Border
-		{
-			get { return ( _border ); }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the RegionColor of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public Color RegionColor
-		{
-			get { return _color; }
-			set
-			{
-				_color = value;
-				Fill = new Fill( _color );
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets the Fill of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the SweepAngle of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private float SweepAngle
-		{
-			get { return _sweepAngle; }
-			set { _sweepAngle = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the StartAngle of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		private float StartAngle
-		{
-			get { return ( _startAngle ); }
-			set { _startAngle = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the MinValue of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public double MinValue
-		{
-			get { return ( _minValue ); }
-			set { _minValue = value > 0 ? value : 0; }
-		}
-
-		/// <summary>
-		/// Gets or sets the MaxValue of this <see cref="GasGaugeRegion"/>
-		/// </summary>
-		public double MaxValue
-		{
-			get { return ( _maxValue ); }
-			set { _maxValue = value > 0 ? value : 0; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return false;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return true;
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// Specify the default property values for the <see cref="GasGaugeRegion"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default border pen width for the <see cref="GasGaugeRegion"/>
-			/// </summary>
-			public static float BorderWidth = 1.0F;
-
-			/// <summary>
-			/// The default fill type for the <see cref="GasGaugeRegion"/>
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-
-			/// <summary>
-			/// The default value for the visibility of the <see cref="GasGaugeRegion"/> border.
-			/// </summary>
-			public static bool IsBorderVisible = true;
-
-			/// <summary>
-			/// The default value for the color of the <see cref="GasGaugeRegion"/> border
-			/// </summary>
-			public static Color BorderColor = Color.Gray;
-
-			/// <summary>
-			/// The default value for the color of the <see cref="GasGaugeRegion"/> fill
-			/// </summary>
-			public static Color FillColor = Color.Empty;
-
-			/// <summary>
-			/// The default value for the fill brush of the <see cref="GasGaugeRegion"/>
-			/// </summary>
-			public static Brush FillBrush = null;
-
-			/// <summary>
-			/// The default value for the visibility of the <see cref="GasGaugeRegion"/> fill.
-			/// </summary>
-			public static bool isVisible = true;
-
-//			public static PieLabelType LabelType = PieLabelType.Name;
-
-			/// <summary>
-			/// The default value for the font size of the <see cref="GasGaugeRegion"/> labels.
-			/// </summary>
-			public static float FontSize = 10;
-		}
-
-	#endregion Defaults
-
-	#region Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="GasGaugeRegion"/> item to the specified
-		/// <see cref="Graphics"/> device. This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">Not used for rendering GasGaugeNeedle</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects. This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>	
-		public override void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor )
-		{
-			if ( pane.Chart._rect.Width <= 0 && pane.Chart._rect.Height <= 0 )
-			{
-				_slicePath = null;
-			}
-			else
-			{
-				CalcRectangle( g, pane, scaleFactor, pane.Chart._rect );
-
-				_slicePath = new GraphicsPath();
-
-				if ( !_isVisible )
-					return;
-
-				RectangleF tRect = _boundingRectangle;
-
-				if ( tRect.Width >= 1 && tRect.Height >= 1 )
-				{
-					SmoothingMode sMode = g.SmoothingMode;
-					g.SmoothingMode = SmoothingMode.AntiAlias;
-
-					_slicePath.AddPie( tRect.X, tRect.Y, tRect.Width, tRect.Height,
-															 -0.0f, -180.0f );
-
-					g.FillPie( Fill.MakeBrush( _boundingRectangle ), tRect.X, tRect.Y, tRect.Width, tRect.Height, -StartAngle, -SweepAngle );
-
-					if ( this.Border.IsVisible )
-					{
-						Pen borderPen = _border.GetPen( pane, scaleFactor );
-						g.DrawPie( borderPen, tRect.X, tRect.Y, tRect.Width, tRect.Height,
-							 -0.0f, -180.0f );
-						borderPen.Dispose();
-					}
-
-					g.SmoothingMode = sMode;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Render the label for this <see cref="GasGaugeRegion"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">Bounding rectangle for this <see cref="GasGaugeRegion"/>.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects. This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>		
-		public override void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			if ( !_isVisible )
-				return;
-
-			// Fill the slice
-			if ( _fill.IsVisible )
-			{
-				// just avoid height/width being less than 0.1 so GDI+ doesn't cry
-				using ( Brush brush = _fill.MakeBrush( rect ) )
-				{
-					g.FillRectangle( brush, rect );
-					//brush.Dispose();
-				}
-			}
-
-			// Border the bar
-			if ( !_border.Color.IsEmpty )
-				_border.Draw( g, pane, scaleFactor, rect );
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		public override bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = String.Empty;
-			return false;
-		}
-
-		/// <summary>
-		/// Calculate the values needed to properly display this <see cref="GasGaugeRegion"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public static void CalculateGasGuageParameters( GraphPane pane )
-		{
-			//loop thru slices and get total value and maxDisplacement
-			double minVal = double.MaxValue;
-			double maxVal = double.MinValue;
-			foreach ( CurveItem curve in pane.CurveList )
-				if ( curve is GasGaugeRegion )
-				{
-					GasGaugeRegion ggr = (GasGaugeRegion)curve;
-					if ( maxVal < ggr.MaxValue )
-						maxVal = ggr.MaxValue;
-
-					if ( minVal > ggr.MinValue )
-						minVal = ggr.MinValue;
-				}
-
-			//Calculate start and sweep angles for each of the GasGaugeRegion based on teh min and max value
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( curve is GasGaugeRegion )
-				{
-					GasGaugeRegion ggr = (GasGaugeRegion)curve;
-					float start = ( (float)ggr.MinValue - (float)minVal ) / ( (float)maxVal - (float)minVal ) * 180.0f;
-					float sweep = ( (float)ggr.MaxValue - (float)minVal ) / ( (float)maxVal - (float)minVal ) * 180.0f;
-					sweep = sweep - start;
-
-					Fill f = new Fill( Color.White, ggr.RegionColor, -( sweep / 2f ) );
-					ggr.Fill = f;
-
-					ggr.StartAngle = start;
-					ggr.SweepAngle = sweep;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="RectangleF"/> that will be used to define the bounding rectangle of
-		/// the GasGaugeNeedle.
-		/// </summary>
-		/// <remarks>This rectangle always lies inside of the <see cref="Chart.Rect"/>, and it is
-		/// normally a square so that the pie itself is not oval-shaped.</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into. This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects. This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>				
-		/// <param name="chartRect">The <see cref="RectangleF"/> (normally the <see cref="Chart.Rect"/>)
-		/// that bounds this pie.</param>
-		/// <returns></returns>
-		public static RectangleF CalcRectangle( Graphics g, GraphPane pane, float scaleFactor, RectangleF chartRect )
-		{
-			RectangleF nonExpRect = chartRect;
-
-			if ( ( 2 * nonExpRect.Height ) > nonExpRect.Width )
-			{
-				//Scale based on width
-				float percentS = ( ( nonExpRect.Height * 2 ) - nonExpRect.Width ) / ( nonExpRect.Height * 2 );
-				nonExpRect.Height = ( ( nonExpRect.Height * 2 ) - ( ( nonExpRect.Height * 2 ) * percentS ) );
-			}
-			else
-			{
-				nonExpRect.Height = nonExpRect.Height * 2;
-			}
-
-			nonExpRect.Width = nonExpRect.Height;
-
-			float xDelta = ( chartRect.Width / 2 ) - ( nonExpRect.Width / 2 );
-
-			//Align Horizontally
-			nonExpRect.X += xDelta;
-			//nonExpRect.Y += -(float)0.025F * nonExpRect.Height;
-			//nonExpRect.Y += ((chartRect.Height) - (nonExpRect.Height / 2)) - 10.0f;
-
-			nonExpRect.Inflate( -(float)0.05F * nonExpRect.Height, -(float)0.05 * nonExpRect.Width );
-
-			GasGaugeRegion.CalculateGasGuageParameters( pane );
-
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( curve is GasGaugeRegion )
-				{
-					GasGaugeRegion gg = (GasGaugeRegion)curve;
-					gg._boundingRectangle = nonExpRect;
-				}
-			}
-
-			return nonExpRect;
-
-		}
-
-		#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/GraphObj.cs b/BDInfo/ZedGraph/GraphObj.cs
deleted file mode 100644
index c8f79e4724..0000000000
--- a/BDInfo/ZedGraph/GraphObj.cs
+++ /dev/null
@@ -1,505 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An abstract base class that represents a text object on the graph.  A list of
-	/// <see cref="GraphObj"/> objects is maintained by the
-	/// <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	abstract public class GraphObj : ISerializable, ICloneable
-	{
-	#region Fields
-		/// <summary>
-		/// Protected field that stores the location of this <see cref="GraphObj"/>.
-		/// Use the public property <see cref="Location"/> to access this value.
-		/// </summary>
-		protected Location _location;
-
-		/// <summary>
-		/// Protected field that determines whether or not this <see cref="GraphObj"/>
-		/// is visible in the graph.  Use the public property <see cref="IsVisible"/> to
-		/// access this value.
-		/// </summary>
-		protected bool _isVisible;
-		
-		/// <summary>
-		/// Protected field that determines whether or not the rendering of this <see cref="GraphObj"/>
-		/// will be clipped to the ChartRect.  Use the public property <see cref="IsClippedToChartRect"/> to
-		/// access this value.
-		/// </summary>
-		protected bool _isClippedToChartRect;
-		
-		/// <summary>
-		/// A tag object for use by the user.  This can be used to store additional
-		/// information associated with the <see cref="GraphObj"/>.  ZedGraph does
-		/// not use this value for any purpose.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag;
-
-		/// <summary>
-		/// Internal field that determines the z-order "depth" of this
-		/// item relative to other graphic objects.  Use the public property
-		/// <see cref="ZOrder"/> to access this value.
-		/// </summary>
-		internal ZOrder _zOrder;
-
-		/// <summary>
-		/// Internal field that stores the hyperlink information for this object.
-		/// </summary>
-		internal Link _link;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="GraphObj"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default text item properties
-			/// <summary>
-			/// Default value for the vertical <see cref="GraphObj"/>
-			/// text alignment (<see cref="GraphObj.Location"/> property).
-			/// This is specified
-			/// using the <see cref="AlignV"/> enum type.
-			/// </summary>
-			public static AlignV AlignV = AlignV.Center;
-			/// <summary>
-			/// Default value for the horizontal <see cref="GraphObj"/>
-			/// text alignment (<see cref="GraphObj.Location"/> property).
-			/// This is specified
-			/// using the <see cref="AlignH"/> enum type.
-			/// </summary>
-			public static AlignH AlignH = AlignH.Center;
-			/// <summary>
-			/// The default coordinate system to be used for defining the
-			/// <see cref="GraphObj"/> location coordinates
-			/// (<see cref="GraphObj.Location"/> property).
-			/// </summary>
-			/// <value> The coordinate system is defined with the <see cref="CoordType"/>
-			/// enum</value>
-			public static CoordType CoordFrame = CoordType.AxisXYScale;
-			/// <summary>
-			/// The default value for <see cref="GraphObj.IsClippedToChartRect"/>.
-			/// </summary>
-			public static bool IsClippedToChartRect = false;
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// The <see cref="ZedGraph.Location"/> struct that describes the location
-		/// for this <see cref="GraphObj"/>.
-		/// </summary>
-		public Location Location
-		{
-			get { return _location; }
-			set { _location = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines the z-order "depth" of this
-		/// item relative to other graphic objects.
-		/// </summary>
-		/// <remarks>Note that this controls the z-order with respect to
-		/// other elements such as <see cref="CurveItem"/>'s, <see cref="Axis"/>
-		/// objects, etc.  The order of <see cref="GraphObj"/> objects having
-		/// the same <see cref="ZedGraph.ZOrder"/> value is controlled by their order in
-		/// the <see cref="GraphObjList"/>.  The first <see cref="GraphObj"/>
-		/// in the list is drawn in front of other <see cref="GraphObj"/>
-		/// objects having the same <see cref="ZedGraph.ZOrder"/> value.</remarks>
-		public ZOrder ZOrder
-		{
-			get { return _zOrder; }
-			set { _zOrder = value; }
-		}
-		
-		/// <summary>
-		/// Gets or sets a value that determines if this <see cref="GraphObj"/> will be
-		/// visible in the graph.  true displays the item, false hides it.
-		/// </summary>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the rendering of this <see cref="GraphObj"/>
-		/// will be clipped to the <see cref="Chart.Rect"/>.
-		/// </summary>
-		/// <value>true to clip the <see cref="GraphObj"/> to the <see cref="Chart.Rect"/> bounds,
-		/// false to leave it unclipped.</value>
-		public bool IsClippedToChartRect
-		{
-			get { return _isClippedToChartRect; }
-			set { _isClippedToChartRect = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the hyperlink information for this <see cref="GraphObj" />.
-		/// </summary>
-		// /// <seealso cref="ZedGraph.Web.IsImageMap" />
-		public Link Link
-		{
-			get { return _link; }
-			set { _link = value; }
-		}
-
-		/// <summary>
-		/// true if the <see cref="ZOrder" /> of this object is set to put it in front
-		/// of the <see cref="CurveItem" /> data points.
-		/// </summary>
-		public bool IsInFrontOfData
-		{
-			get
-			{
-				return	_zOrder == ZOrder.A_InFront ||
-							_zOrder == ZOrder.B_BehindLegend ||
-							_zOrder == ZOrder.C_BehindChartBorder;
-			}
-		}
-
-	#endregion
-	
-	#region Constructors
-		/// <overloads>
-		/// Constructors for the <see cref="GraphObj"/> class.
-		/// </overloads>
-		/// <summary>
-		/// Default constructor that sets all <see cref="GraphObj"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public GraphObj() :
-			this( 0, 0, Default.CoordFrame, Default.AlignH, Default.AlignV )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that sets all <see cref="GraphObj"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="x">The x position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		public GraphObj( double x, double y ) :
-			this( x, y, Default.CoordFrame, Default.AlignH, Default.AlignV )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a <see cref="GraphObj"/> with the specified
-		/// coordinates and all other properties to defaults as specified
-		/// in the <see cref="Default"/> class..
-		/// </summary>
-		/// <remarks>
-		/// The four coordinates define the starting point and ending point for
-		/// <see cref="ArrowObj"/>'s, or the topleft and bottomright points for
-		/// <see cref="ImageObj"/>'s.  For <see cref="GraphObj"/>'s that only require
-		/// one point, the <see paramref="x2"/> and <see paramref="y2"/> values
-		/// will be ignored.  The units of the coordinates are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.
-		/// </remarks>
-		/// <param name="x">The x position of the item.</param>
-		/// <param name="y">The y position of the item.</param>
-		/// <param name="x2">The x2 position of the item.</param>
-		/// <param name="y2">The x2 position of the item.</param>
-		public GraphObj( double x, double y, double x2, double y2 ) :
-			this( x, y, x2, y2, Default.CoordFrame, Default.AlignH, Default.AlignV )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that creates a <see cref="GraphObj"/> with the specified
-		/// position and <see cref="CoordType"/>.  Other properties are set to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <remarks>
-		/// The two coordinates define the location point for the object.
-		/// The units of the coordinates are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.
-		/// </remarks>
-		/// <param name="x">The x position of the item.  The item will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the item.  The item will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		public GraphObj( double x, double y, CoordType coordType ) :
-			this( x, y, coordType, Default.AlignH, Default.AlignV )
-		{
-		}
-		
-		/// <summary>
-		/// Constructor that creates a <see cref="GraphObj"/> with the specified
-		/// position, <see cref="CoordType"/>, <see cref="AlignH"/>, and <see cref="AlignV"/>.
-		/// Other properties are set to default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <remarks>
-		/// The two coordinates define the location point for the object.
-		/// The units of the coordinates are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.
-		/// </remarks>
-		/// <param name="x">The x position of the item.  The item will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public GraphObj( double x, double y, CoordType coordType, AlignH alignH, AlignV alignV )
-		{
-			_isVisible = true;
-			_isClippedToChartRect = Default.IsClippedToChartRect;
-			this.Tag = null;
-			_zOrder = ZOrder.A_InFront;
-			_location = new Location( x, y, coordType, alignH, alignV );
-			_link = new Link();
-		}
-
-		/// <summary>
-		/// Constructor that creates a <see cref="GraphObj"/> with the specified
-		/// position, <see cref="CoordType"/>, <see cref="AlignH"/>, and <see cref="AlignV"/>.
-		/// Other properties are set to default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <remarks>
-		/// The four coordinates define the starting point and ending point for
-		/// <see cref="ArrowObj"/>'s, or the topleft and bottomright points for
-		/// <see cref="ImageObj"/>'s.  For <see cref="GraphObj"/>'s that only require
-		/// one point, the <see paramref="x2"/> and <see paramref="y2"/> values
-		/// will be ignored.  The units of the coordinates are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.
-		/// </remarks>
-		/// <param name="x">The x position of the item.</param>
-		/// <param name="y">The y position of the item.</param>
-		/// <param name="x2">The x2 position of the item.</param>
-		/// <param name="y2">The x2 position of the item.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public GraphObj( double x, double y, double x2, double y2, CoordType coordType,
-					AlignH alignH, AlignV alignV )
-		{
-			_isVisible = true;
-			_isClippedToChartRect = Default.IsClippedToChartRect;
-			this.Tag = null;
-			_zOrder = ZOrder.A_InFront;
-			_location = new Location( x, y, x2, y2, coordType, alignH, alignV );
-			_link = new Link();
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="GraphObj"/> object from which to copy</param>
-		public GraphObj( GraphObj rhs )
-		{
-			// Copy value types
-			_isVisible = rhs.IsVisible;
-			_isClippedToChartRect = rhs._isClippedToChartRect;
-			_zOrder = rhs.ZOrder;
-
-			// copy reference types by cloning
-			if ( rhs.Tag is ICloneable )
-				this.Tag = ((ICloneable) rhs.Tag).Clone();
-			else
-				this.Tag = rhs.Tag;
-
-			_location = rhs.Location.Clone();
-			_link = rhs._link.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		/// <remarks>
-		/// schema changed to 2 when isClippedToChartRect was added.
-		/// </remarks>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected GraphObj( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_location = (Location) info.GetValue( "location", typeof(Location) );
-			_isVisible = info.GetBoolean( "isVisible" );
-			Tag = info.GetValue( "Tag", typeof(object) );
-			_zOrder = (ZOrder) info.GetValue( "zOrder", typeof(ZOrder) );
-
-			_isClippedToChartRect = info.GetBoolean( "isClippedToChartRect" );
-			_link = (Link) info.GetValue( "link", typeof( Link ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "location", _location );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "Tag", Tag );
-			info.AddValue( "zOrder", _zOrder );
-
-			info.AddValue( "isClippedToChartRect", _isClippedToChartRect );
-			info.AddValue( "link", _link );
-		}
-	#endregion
-
-	#region Rendering Methods
-		/// <summary>
-		/// Render this <see cref="GraphObj"/> object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="PaneBase"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		abstract public void Draw( Graphics g, PaneBase pane, float scaleFactor );
-		
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="GraphObj"/>.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="PaneBase"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		virtual public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			GraphPane gPane = pane as GraphPane;
-
-			if ( gPane != null && _isClippedToChartRect && !gPane.Chart.Rect.Contains( pt ) )
-				return false;
-
-			return true;
-		}
-
-		/// <summary>
-		/// Determines the shape type and Coords values for this GraphObj
-		/// </summary>
-		abstract public void GetCoords( PaneBase pane, Graphics g, float scaleFactor,
-				out string shape, out string coords );
-
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/GraphObjList.cs b/BDInfo/ZedGraph/GraphObjList.cs
deleted file mode 100644
index 4fc00de93c..0000000000
--- a/BDInfo/ZedGraph/GraphObjList.cs
+++ /dev/null
@@ -1,304 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections.Generic;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="TextObj"/> objects
-	/// to be displayed on the graph.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class GraphObjList : List<GraphObj>, ICloneable
-	{
-	#region Constructors
-		/// <summary>
-		/// Default constructor for the <see cref="GraphObjList"/> collection class
-		/// </summary>
-		public GraphObjList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="GraphObjList"/> object from which to copy</param>
-		public GraphObjList( GraphObjList rhs )
-		{
-			foreach ( GraphObj item in rhs )
-				this.Add( (GraphObj) ((ICloneable)item).Clone() );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public GraphObjList Clone()
-		{
-			return new GraphObjList( this );
-		}
-
-		
-	#endregion
-
-	#region Methods
-/*
-		/// <summary>
-		/// Indexer to access the specified <see cref="GraphObj"/> object by its ordinal
-		/// position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="GraphObj"/> object to be accessed.</param>
-		/// <value>A <see cref="GraphObj"/> object reference.</value>
-		public GraphObj this[ int index ]  
-		{
-			get { return( (GraphObj) List[index] ); }
-			set { List[index] = value; }
-		}
-*/
-		/// <summary>
-		/// Indexer to access the specified <see cref="GraphObj"/> object by its <see cref="GraphObj.Tag"/>.
-		/// Note that the <see cref="GraphObj.Tag"/> must be a <see cref="String"/> type for this method
-		/// to work.
-		/// </summary>
-		/// <param name="tag">The <see cref="String"/> type tag to search for.</param>
-		/// <value>A <see cref="GraphObj"/> object reference.</value>
-		/// <seealso cref="IndexOfTag"/>
-		public GraphObj this[string tag]  
-		{
-			get
-			{
-				int index = IndexOfTag( tag );
-				if ( index >= 0 )
-					return( this[index]  );
-				else
-					return null;
-			}
-		}
-/*
-		/// <summary>
-		/// Add a <see cref="GraphObj"/> object to the <see cref="GraphObjList"/>
-		/// collection at the end of the list.
-		/// </summary>
-		/// <param name="item">A reference to the <see cref="GraphObj"/> object to
-		/// be added</param>
-		/// <seealso cref="IList.Add"/>
-		public GraphObj Add( GraphObj item )
-		{
-			List.Add( item );
-			return item;
-		}
-
-		/// <summary>
-		/// Insert a <see cref="GraphObj"/> object into the collection
-		/// at the specified zero-based index location.
-		/// </summary>
-		/// <param name="index">The zero-based index location for insertion.</param>
-		/// <param name="item">The <see cref="GraphObj"/> object that is to be
-		/// inserted.</param>
-		/// <seealso cref="IList.Insert"/>
-		public void Insert( int index, GraphObj item )
-		{
-			List.Insert( index, item );
-		}
-*/
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="GraphObj"/> with the specified <see cref="GraphObj.Tag"/>.
-		/// </summary>
-		/// <remarks>In order for this method to work, the <see cref="GraphObj.Tag"/>
-		/// property must be of type <see cref="String"/>.</remarks>
-		/// <param name="tag">The <see cref="String"/> tag that is in the
-		/// <see cref="GraphObj.Tag"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="GraphObj"/>,
-		/// or -1 if the <see cref="GraphObj"/> is not in the list</returns>
-		public int IndexOfTag( string tag )
-		{
-			int index = 0;
-			foreach ( GraphObj p in this )
-			{
-				if ( p.Tag is string &&
-							String.Compare( (string) p.Tag, tag, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Move the position of the object at the specified index
-		/// to the new relative position in the list.</summary>
-		/// <remarks>For Graphic type objects, this method controls the
-		/// Z-Order of the items.  Objects at the beginning of the list
-		/// appear in front of objects at the end of the list.</remarks>
-		/// <param name="index">The zero-based index of the object
-		/// to be moved.</param>
-		/// <param name="relativePos">The relative number of positions to move
-		/// the object.  A value of -1 will move the
-		/// object one position earlier in the list, a value
-		/// of 1 will move it one position later.  To move an item to the
-		/// beginning of the list, use a large negative value (such as -999).
-		/// To move it to the end of the list, use a large positive value.
-		/// </param>
-		/// <returns>The new position for the object, or -1 if the object
-		/// was not found.</returns>
-		public int Move( int index, int relativePos )
-		{
-			if ( index < 0 || index >= Count )
-				return -1;
-
-			GraphObj graphObj = this[index];
-			this.RemoveAt( index );
-
-			index += relativePos;
-			if ( index < 0 )
-				index = 0;
-			if ( index > Count )
-				index = Count;
-
-			Insert( index, graphObj );
-			return index;
-		}
-
-	#endregion
-
-	#region Render Methods
-
-		/// <summary>
-		/// Render text to the specified <see cref="Graphics"/> device
-		/// by calling the Draw method of each <see cref="GraphObj"/> object in
-		/// the collection.
-		/// </summary>
-		/// <remarks>This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphPane"/> object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="zOrder">A <see cref="ZOrder"/> enumeration that controls
-		/// the placement of this <see cref="GraphObj"/> relative to other
-		/// graphic objects.  The order of <see cref="GraphObj"/>'s with the
-		/// same <see cref="ZOrder"/> value is control by their order in
-		/// this <see cref="GraphObjList"/>.</param>
-		public void Draw( Graphics g, PaneBase pane, float scaleFactor,
-							ZOrder zOrder )
-		{
-			// Draw the items in reverse order, so the last items in the
-			// list appear behind the first items (consistent with
-			// CurveList)
-			for ( int i=this.Count-1; i>=0; i-- )
-			{
-				GraphObj item = this[i];
-				if ( item.ZOrder == zOrder && item.IsVisible )
-				{
-					Region region = null;
-					if ( item.IsClippedToChartRect && pane is GraphPane )
-					{
-						region = g.Clip.Clone();
-						g.SetClip( ((GraphPane)pane).Chart._rect );
-					}
-
-					item.Draw( g, pane, scaleFactor );
-
-					if ( item.IsClippedToChartRect && pane is GraphPane )
-						g.Clip = region;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Determine if a mouse point is within any <see cref="GraphObj"/>, and if so, 
-		/// return the index number of the the <see cref="GraphObj"/>.
-		/// </summary>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="index">The index number of the <see cref="TextObj"/>
-		///  that is under the mouse point.  The <see cref="TextObj"/> object is
-		/// accessible via the <see cref="GraphObjList" /> indexer property.
-		/// </param>
-		/// <returns>true if the mouse point is within a <see cref="GraphObj"/> bounding
-		/// box, false otherwise.</returns>
-		/// <seealso cref="GraphPane.FindNearestObject"/>
-		public bool FindPoint( PointF mousePt, PaneBase pane, Graphics g, float scaleFactor, out int index )
-		{
-			index = -1;
-			
-			// Search in reverse direction to honor the Z-order
-			for ( int i=Count-1; i>=0; i-- )
-			{
-				if ( this[i].PointInBox( mousePt, pane, g, scaleFactor ) )
-				{
-					if ( ( index >= 0 && this[i].ZOrder > this[index].ZOrder ) || index < 0 )
-						index = i;
-				}
-			}
-
-			if ( index >= 0 )
-				return true;
-			else
-				return false;
-		}
-		
-
-	#endregion
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/GraphPane.cs b/BDInfo/ZedGraph/GraphPane.cs
deleted file mode 100644
index 69f882e255..0000000000
--- a/BDInfo/ZedGraph/GraphPane.cs
+++ /dev/null
@@ -1,2330 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Drawing.Imaging;
-using System.Windows.Forms;
-using System.Diagnostics;
-using System.IO;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using System.ComponentModel;
-
-namespace ZedGraph
-{
-	// <summary>
-	// <c>ZedGraph</c> is a class library and UserControl (<see cref="ZedGraphControl"/>) that display
-	// 2D line graphs of user specified data.  The <c>ZedGraph</c> namespace includes all functionality
-	// required to draw, modify, and update the graph.
-	// </summary>
-
-	/// <summary>
-	/// Class <see cref="GraphPane"/> encapsulates the graph pane, which is all display elements
-	/// associated with an individual graph.
-	/// </summary>
-	/// <remarks>This class is the outside "wrapper"
-	/// for the ZedGraph classes, and provides the interface to access the attributes
-	/// of the graph.  You can have multiple graphs in the same document or form,
-	/// just instantiate multiple GraphPane's.
-	/// </remarks>
-	/// 
-	/// <author> John Champion modified by Jerry Vos </author>
-	/// <version> $Revision: 3.81 $ $Date: 2007/09/30 07:44:11 $ </version>
-	[Serializable]
-	public class GraphPane : PaneBase, ICloneable, ISerializable
-	{
-
-	#region Events
-
-		/// <summary>
-		/// A delegate to provide notification through the <see cref="AxisChangeEvent" />
-		/// when <see cref="AxisChange()" /> is called.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> for which AxisChange() has
-		/// been called.</param>
-		/// <seealso cref="AxisChangeEvent" />
-		public delegate void AxisChangeEventHandler( GraphPane pane );
-
-		/// <summary>
-		/// Subscribe to this event to be notified when <see cref="AxisChange()" /> is called.
-		/// </summary>
-		public event AxisChangeEventHandler AxisChangeEvent;
-
-	#endregion
-
-	#region Private Fields
-
-		// Item subclasses ////////////////////////////////////////////////////////////////////
-
-		/// <summary>Private field instance of the <see cref="ZedGraph.XAxis"/> class.  Use the
-		/// public property <see cref="GraphPane.XAxis"/> to access this class.</summary>
-		private XAxis _xAxis;
-		/// <summary>Private field instance of the <see cref="ZedGraph.XAxis"/> class.  Use the
-		/// public property <see cref="GraphPane.X2Axis"/> to access this class.</summary>
-		private X2Axis _x2Axis;
-		/// <summary>Private field instance of the <see cref="ZedGraph.YAxisList"/> class.  Use the
-		/// public property <see cref="GraphPane.YAxisList"/> to access this class.</summary>
-		private YAxisList _yAxisList;
-		/// <summary>Private field instance of the <see cref="ZedGraph.Y2AxisList"/> class.  Use the
-		/// public property <see cref="GraphPane.Y2AxisList"/> to access this class.</summary>
-		private Y2AxisList _y2AxisList;
-		/// <summary>Private field instance of the <see cref="ZedGraph.CurveList"/> class.  Use the
-		/// public property <see cref="GraphPane.CurveList"/> to access this class.</summary>
-		private CurveList _curveList;
-
-		/// <summary>
-		/// private value that contains a <see cref="ZoomStateStack"/>, which stores prior
-		/// <see cref="ZoomState"/> objects containing scale range information.  This enables
-		/// zooming and panning functionality for the <see cref="ZedGraphControl"/>.
-		/// </summary>
-		private ZoomStateStack _zoomStack;
-
-		// Chart Properties //////////////////////////////////////////////////////////////
-
-		internal Chart _chart;
-
-		internal BarSettings _barSettings;
-
-		/// <summary>Private field that determines whether or not initial zero values will
-		/// be included or excluded when determining the Y or Y2 axis scale range.
-		/// Use the public property <see cref="IsIgnoreInitial"/> to access
-		/// this value. </summary>
-		private bool _isIgnoreInitial;
-		/// <summary>Private field that determines whether or not initial
-		/// <see cref="PointPairBase.Missing"/> values will cause the line segments of
-		/// a curve to be discontinuous.  If this field is true, then the curves
-		/// will be plotted as continuous lines as if the Missing values did not
-		/// exist.
-		/// Use the public property <see cref="IsIgnoreMissing"/> to access
-		/// this value. </summary>
-		private bool _isIgnoreMissing;
-		/// <summary> private field that determines if the auto-scaled axis ranges will subset the
-		/// data points based on any manually set scale range values.  Use the public property
-		/// <see cref="IsBoundedRanges"/> to access this value.</summary>
-		/// <remarks>The bounds provide a means to subset the data.  For example, if all the axes are set to
-		/// autoscale, then the full range of data are used.  But, if the XAxis.Min and XAxis.Max values
-		/// are manually set, then the Y data range will reflect the Y values within the bounds of
-		/// XAxis.Min and XAxis.Max.</remarks>
-		private bool _isBoundedRanges;
-
-		/// <summary>
-		/// private field that determines if ZedGraph should modify the scale ranges for the Y and Y2
-		/// axes such that the number of steps, and therefore the grid lines, line up.  Use the
-		/// public property <see cref="IsAlignGrids" /> to acccess this value.
-		/// </summary>
-		private bool _isAlignGrids;
-
-
-		/// <summary>Private field that determines how the <see cref="LineItem"/>
-		/// graphs will be displayed. See the <see cref="ZedGraph.LineType"/> enum
-		/// for the individual types available.
-		/// To access this value, use the public property <see cref="LineType"/>.
-		/// </summary>
-		/// <seealso cref="Default.LineType"/>
-		private LineType _lineType;
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="GraphPane"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			/// <summary>
-			/// The default settings for the <see cref="Axis"/> scale ignore initial
-			/// zero values option (<see cref="GraphPane.IsIgnoreInitial"/> property).
-			/// true to have the auto-scale-range code ignore the initial data points
-			/// until the first non-zero Y value, false otherwise.
-			/// </summary>
-			public static bool IsIgnoreInitial = false;
-			/// <summary>
-			/// The default settings for the <see cref="Axis"/> scale bounded ranges option
-			/// (<see cref="GraphPane.IsBoundedRanges"/> property).
-			/// true to have the auto-scale-range code subset the data according to any
-			/// manually set scale values, false otherwise.
-			/// </summary>
-			public static bool IsBoundedRanges = false;
-
-			/// <summary>The default value for the <see cref="GraphPane.LineType"/> property, which
-			/// determines if the lines are drawn in normal or "stacked" mode.  See the
-			/// <see cref="ZedGraph.LineType"/> for more information.
-			/// </summary>
-			/// <seealso cref="GraphPane.LineType"/>
-			public static LineType LineType = LineType.Normal;
-			/// <summary>
-			/// The default width of a bar cluster 
-			/// on a <see cref="Bar"/> graph.  This value only applies to
-			/// <see cref="Bar"/> graphs, and only when the
-			/// <see cref="Axis.Type"/> is <see cref="AxisType.Linear"/>,
-			/// <see cref="AxisType.Log"/> or <see cref="AxisType.Date"/>.
-			/// This dimension is expressed in terms of X scale user units.
-			/// </summary>
-			/// <seealso cref="ZedGraph.BarSettings.Default.MinClusterGap"/>
-			/// <seealso cref="ZedGraph.BarSettings.MinBarGap"/>
-			public static double ClusterScaleWidth = 1.0;
-			/// <summary>
-			/// The tolerance that is applied to the
-			/// <see cref="GraphPane.FindNearestPoint(PointF,out CurveItem,out int)"/> routine.
-			/// If a given curve point is within this many pixels of the mousePt, the curve
-			/// point is considered to be close enough for selection as a nearest point
-			/// candidate.
-			/// </summary>
-			public static double NearestTol = 7.0;
-
-		}
-	#endregion
-
-	#region Class Instance Properties
-		/// <summary>
-		/// Gets or sets the list of <see cref="CurveItem"/> items for this <see cref="GraphPane"/>
-		/// </summary>
-		/// <value>A reference to a <see cref="CurveList"/> collection object</value>
-		public CurveList CurveList
-		{
-			get { return _curveList; }
-			set { _curveList = value; }
-		}
-		/// <summary>
-		/// Accesses the <see cref="XAxis"/> for this graph
-		/// </summary>
-		/// <value>A reference to a <see cref="XAxis"/> object</value>
-		public XAxis XAxis
-		{
-			get { return _xAxis; }
-		}
-		/// <summary>
-		/// Accesses the <see cref="X2Axis"/> for this graph
-		/// </summary>
-		/// <value>A reference to a <see cref="X2Axis"/> object</value>
-		public X2Axis X2Axis
-		{
-			get { return _x2Axis; }
-		}
-		/// <summary>
-		/// Accesses the primary <see cref="YAxis"/> for this graph
-		/// </summary>
-		/// <value>A reference to a <see cref="YAxis"/> object</value>
-		/// <seealso cref="YAxisList" />
-		/// <seealso cref="Y2AxisList" />
-		public YAxis YAxis
-		{
-			get { return _yAxisList[0] as YAxis; }
-		}
-		/// <summary>
-		/// Accesses the primary <see cref="Y2Axis"/> for this graph
-		/// </summary>
-		/// <value>A reference to a <see cref="Y2Axis"/> object</value>
-		/// <seealso cref="YAxisList" />
-		/// <seealso cref="Y2AxisList" />
-		public Y2Axis Y2Axis
-		{
-			get { return _y2AxisList[0] as Y2Axis; }
-		}
-
-		/// <summary>
-		/// Gets the collection of Y axes that belong to this <see cref="GraphPane" />.
-		/// </summary>
-		public YAxisList YAxisList
-		{
-			get { return _yAxisList; }
-		}
-		/// <summary>
-		/// Gets the collection of Y2 axes that belong to this <see cref="GraphPane" />.
-		/// </summary>
-		public Y2AxisList Y2AxisList
-		{
-			get { return _y2AxisList; }
-		}
-
-		/// <summary>
-		/// Gets the <see cref="Chart" /> instance for this <see cref="GraphPane" />.
-		/// </summary>
-		public Chart Chart
-		{
-			get { return _chart; }
-		}
-
-		/// <summary>
-		/// Gets the <see cref="BarSettings" /> instance for this <see cref="GraphPane" />,
-		/// which stores the global properties for bar type charts.
-		/// </summary>
-		public BarSettings BarSettings
-		{
-			get { return _barSettings; }
-		}
-
-	#endregion
-
-	#region General Properties
-
-		/// <summary>
-		/// Gets or sets a boolean value that affects the data range that is considered
-		/// for the automatic scale ranging.
-		/// </summary>
-		/// <remarks>If true, then initial data points where the Y value
-		/// is zero are not included when automatically determining the scale <see cref="Scale.Min"/>,
-		/// <see cref="Scale.Max"/>, and <see cref="Scale.MajorStep"/> size.
-		/// All data after the first non-zero Y value are included.
-		/// </remarks>
-		/// <seealso cref="Default.IsIgnoreInitial"/>
-		[Bindable( true ), Browsable( true ), Category( "Display" ), NotifyParentProperty( true )]
-		[Description("Determines whether the auto-ranged scale will include all data points" +
-			" or just the visible data points")]
-		public bool IsIgnoreInitial
-		{
-			get { return _isIgnoreInitial; }
-			set { _isIgnoreInitial = value; }
-		}
-		/// <summary> Gets or sets a boolean value that determines if the auto-scaled axis ranges will
-		/// subset the data points based on any manually set scale range values.</summary>
-		/// <remarks>The bounds provide a means to subset the data.  For example, if all the axes are set to
-		/// autoscale, then the full range of data are used.  But, if the XAxis.Min and XAxis.Max values
-		/// are manually set, then the Y data range will reflect the Y values within the bounds of
-		/// XAxis.Min and XAxis.Max.  Set to true to subset the data, or false to always include
-		/// all data points when calculating scale ranges.</remarks>
-		public bool IsBoundedRanges
-		{
-			get { return _isBoundedRanges; }
-			set { _isBoundedRanges = value; }
-		}
-		/// <summary>Gets or sets a value that determines whether or not initial
-		/// <see cref="PointPairBase.Missing"/> values will cause the line segments of
-		/// a curve to be discontinuous.
-		/// </summary>
-		/// <remarks>If this field is true, then the curves
-		/// will be plotted as continuous lines as if the Missing values did not exist.
-		/// Use the public property <see cref="IsIgnoreMissing"/> to access
-		/// this value. </remarks>
-		public bool IsIgnoreMissing
-		{
-			get { return _isIgnoreMissing; }
-			set { _isIgnoreMissing = value; }
-		}
-		
-		/// <summary>
-		/// Gets or sets a value that determines if ZedGraph should modify the scale ranges
-		/// for the Y and Y2 axes such that the number of major steps, and therefore the
-		/// major grid lines, line up.
-		/// </summary>
-		/// <remarks>
-		/// This property affects the way that <see cref="AxisChange()" /> selects the scale
-		/// ranges for the Y and Y2 axes.  It applies to the scale ranges of all Y and Y2 axes,
-		/// but only if the <see cref="Scale.MaxAuto" /> is set to true.<br />
-		/// </remarks>
-		public bool IsAlignGrids
-		{
-			get { return _isAlignGrids; }
-			set { _isAlignGrids = value; }
-		}
-
-		/// <summary>Determines how the <see cref="LineItem"/>
-		/// graphs will be displayed. See the <see cref="ZedGraph.LineType"/> enum
-		/// for the individual types available.
-		/// </summary>
-		/// <seealso cref="Default.LineType"/>
-		public LineType LineType
-		{
-			get { return _lineType; }
-			set { _lineType = value; }
-		}
-
-		/// <summary>
-		/// Gets a value that indicates whether or not the <see cref="ZoomStateStack" /> for
-		/// this <see cref="GraphPane" /> is empty.  Note that this value is only used for
-		/// the <see cref="ZedGraphControl" />.
-		/// </summary>
-		public bool IsZoomed
-		{
-			get { return !_zoomStack.IsEmpty; }
-		}
-
-		/// <summary>
-		/// Gets a reference to the <see cref="ZoomStateStack" /> for this <see cref="GraphPane" />.
-		/// </summary>
-		public ZoomStateStack ZoomStack
-		{
-			get { return _zoomStack; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor.  Sets the <see cref="PaneBase.Rect"/> to (0, 0, 500, 375), and
-		/// sets the <see cref="PaneBase.Title"/> and <see cref="Axis.Title"/> values to empty
-		/// strings.
-		/// </summary>
-		public GraphPane()
-			: this( new RectangleF( 0, 0, 500, 375 ), "", "", "" )
-		{
-		}
-
-		/// <summary>
-		/// Constructor for the <see cref="GraphPane"/> object.  This routine will
-		/// initialize all member variables and classes, setting appropriate default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="rect"> A rectangular screen area where the graph is to be displayed.
-		/// This area can be any size, and can be resize at any time using the
-		/// <see cref="PaneBase.Rect"/> property.
-		/// </param>
-		/// <param name="title">The <see cref="PaneBase.Title"/> for this <see cref="GraphPane"/></param>
-		/// <param name="xTitle">The <see cref="Axis.Title"/> for the <see cref="XAxis"/></param>
-		/// <param name="yTitle">The <see cref="Axis.Title"/> for the <see cref="YAxis"/></param>
-		public GraphPane( RectangleF rect, string title,
-			string xTitle, string yTitle )
-			: base( title, rect )
-		{
-			_xAxis = new XAxis( xTitle );
-			_x2Axis = new X2Axis( "" );
-
-			_yAxisList = new YAxisList();
-			_y2AxisList = new Y2AxisList();
-
-			_yAxisList.Add( new YAxis( yTitle ) );
-			_y2AxisList.Add( new Y2Axis( string.Empty ) );
-
-			_curveList = new CurveList();
-			_zoomStack = new ZoomStateStack();
-
-			_isIgnoreInitial = Default.IsIgnoreInitial;
-			_isBoundedRanges = Default.IsBoundedRanges;
-			_isAlignGrids = false;
-
-			_chart = new Chart();
-
-			_barSettings = new BarSettings( this );
-
-			_lineType = Default.LineType;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The GraphPane object from which to copy</param>
-		public GraphPane( GraphPane rhs )
-			: base( rhs )
-		{
-			// copy values for all the value types
-			_isIgnoreInitial = rhs.IsIgnoreInitial;
-			_isBoundedRanges = rhs._isBoundedRanges;
-			_isAlignGrids = rhs._isAlignGrids;
-
-			_chart = rhs._chart.Clone();
-
-			_barSettings = new BarSettings( rhs._barSettings, this );
-
-			_lineType = rhs.LineType;
-
-
-			// copy all the reference types with deep copies
-			_xAxis = new XAxis( rhs.XAxis );
-			_x2Axis = new X2Axis( rhs.X2Axis );
-
-			_yAxisList = new YAxisList( rhs._yAxisList );
-			_y2AxisList = new Y2AxisList( rhs._y2AxisList );
-
-			_curveList = new CurveList( rhs.CurveList );
-			_zoomStack = new ZoomStateStack( rhs._zoomStack );
-
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public GraphPane Clone()
-		{
-			return new GraphPane( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		//changed to 2 when yAxisList and y2AxisList were added
-		//changed to 3 when chart object was added
-		//changed to 10 when refactored to version 5
-		//changed to 11 when added x2axis
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected GraphPane( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_xAxis = (XAxis)info.GetValue( "xAxis", typeof( XAxis ) );
-			if ( sch >= 11 )
-				_x2Axis = (X2Axis)info.GetValue( "x2Axis", typeof( X2Axis ) );
-			else
-				_x2Axis = new X2Axis( "" );
-
-			_yAxisList = (YAxisList)info.GetValue( "yAxisList", typeof( YAxisList ) );
-			_y2AxisList = (Y2AxisList)info.GetValue( "y2AxisList", typeof( Y2AxisList ) );
-
-			_curveList = (CurveList)info.GetValue( "curveList", typeof( CurveList ) );
-
-			_chart = (Chart) info.GetValue( "chart", typeof( Chart ) );
-
-			_barSettings = (BarSettings)info.GetValue( "barSettings", typeof( BarSettings ) );
-			_barSettings._ownerPane = this;
-
-			_isIgnoreInitial = info.GetBoolean( "isIgnoreInitial" );
-			_isBoundedRanges = info.GetBoolean( "isBoundedRanges" );
-			_isIgnoreMissing = info.GetBoolean( "isIgnoreMissing" );
-			_isAlignGrids = info.GetBoolean( "isAlignGrids" );
-
-			_lineType = (LineType)info.GetValue( "lineType", typeof( LineType ) );
-
-			_zoomStack = new ZoomStateStack();
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-
-			info.AddValue( "xAxis", _xAxis );
-			info.AddValue( "x2Axis", _x2Axis );
-			info.AddValue( "yAxisList", _yAxisList );
-			info.AddValue( "y2AxisList", _y2AxisList );
-			info.AddValue( "curveList", _curveList );
-
-			info.AddValue( "chart", _chart );
-
-			info.AddValue( "barSettings", _barSettings );
-
-			info.AddValue( "isIgnoreInitial", _isIgnoreInitial );
-			info.AddValue( "isBoundedRanges", _isBoundedRanges );
-			info.AddValue( "isIgnoreMissing", _isIgnoreMissing );
-			info.AddValue( "isAlignGrids", _isAlignGrids );
-
-			info.AddValue( "lineType", _lineType );
-		}
-
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// AxisChange causes the axes scale ranges to be recalculated based on the current data range.
-		/// </summary>
-		/// <remarks>
-		/// There is no obligation to call AxisChange() for manually scaled axes.  AxisChange() is only
-		/// intended to handle auto scaling operations.  Call this function anytime you change, add, or
-		/// remove curve data to insure that the scale range of the axes are appropriate for the data range.
-		/// This method calculates
-		/// a scale minimum, maximum, and step size for each axis based on the current curve data.
-		/// Only the axis attributes (min, max, step) that are set to auto-range
-		/// (<see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>, <see cref="Scale.MajorStepAuto"/>)
-		/// will be modified.  You must call <see cref="Control.Invalidate()"/> after calling
-		/// AxisChange to make sure the display gets updated.<br />
-		/// This overload of AxisChange just uses the default Graphics instance for the screen.
-		/// If you have a Graphics instance available from your Windows Form, you should use
-		/// the <see cref="AxisChange(Graphics)" /> overload instead.
-		/// </remarks>
-		public void AxisChange()
-		{
-			using ( Graphics g = Graphics.FromHwnd( IntPtr.Zero ) )
-				AxisChange( g );
-		}
-
-		/// <summary>
-		/// AxisChange causes the axes scale ranges to be recalculated based on the current data range.
-		/// </summary>
-		/// <remarks>
-		/// There is no obligation to call AxisChange() for manually scaled axes.  AxisChange() is only
-		/// intended to handle auto scaling operations.  Call this function anytime you change, add, or
-		/// remove curve data to insure that the scale range of the axes are appropriate for the data range.
-		/// This method calculates
-		/// a scale minimum, maximum, and step size for each axis based on the current curve data.
-		/// Only the axis attributes (min, max, step) that are set to auto-range
-		/// (<see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>, <see cref="Scale.MajorStepAuto"/>)
-		/// will be modified.  You must call
-		/// <see cref="Control.Invalidate()"/> after calling AxisChange to make sure the display gets updated.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public void AxisChange( Graphics g )
-		{
-			//double	xMin, xMax, yMin, yMax, y2Min, y2Max;
-
-			// Get the scale range of the data (all curves)
-			_curveList.GetRange( /* out xMin, out xMax, out yMin,
-				out yMax, out y2Min, out y2Max, */
-				_isIgnoreInitial, _isBoundedRanges, this );
-
-			// Determine the scale factor
-			float scaleFactor = this.CalcScaleFactor();
-
-			// For pie charts, go ahead and turn off the axis displays if it's only pies
-			if ( this.CurveList.IsPieOnly )
-			{
-				//don't want to display axis or border if there's only pies
-				this.XAxis.IsVisible = false;
-				this.X2Axis.IsVisible = false;
-				this.YAxis.IsVisible = false;
-				this.Y2Axis.IsVisible = false;
-				_chart.Border.IsVisible = false;
-				//this.Legend.Position = LegendPos.TopCenter;
-			}
-
-			// Set the ClusterScaleWidth, if needed
-			//_barSettings.CalcClusterScaleWidth();
-			if ( _barSettings._clusterScaleWidthAuto )
-				_barSettings._clusterScaleWidth = 1.0;
-
-			// if the ChartRect is not yet determined, then pick a scale based on a default ChartRect
-			// size (using 75% of Rect -- code is in Axis.CalcMaxLabels() )
-			// With the scale picked, call CalcChartRect() so calculate a real ChartRect
-			// then let the scales re-calculate to make sure that the assumption was ok
-			if ( _chart._isRectAuto )
-			{
-				PickScale( g, scaleFactor );
-
-				_chart._rect = CalcChartRect( g );
-				//this.pieRect = PieItem.CalcPieRect( g, this, scaleFactor, this.chartRect );
-			}
-
-			// Pick new scales based on the range
-			PickScale( g, scaleFactor );
-
-			// Set the ClusterScaleWidth, if needed
-			_barSettings.CalcClusterScaleWidth();
-
-			// Trigger the AxisChangeEvent
-			if ( this.AxisChangeEvent != null )
-				this.AxisChangeEvent( this );
-
-		}
-
-		private void PickScale( Graphics g, float scaleFactor )
-		{
-			int maxTics = 0;
-
-			_xAxis._scale.PickScale( this, g, scaleFactor );
-			_x2Axis._scale.PickScale( this, g, scaleFactor );
-
-			foreach ( Axis axis in _yAxisList )
-			{
-				axis._scale.PickScale( this, g, scaleFactor );
-				if ( axis._scale.MaxAuto )
-				{
-					int nTics = axis._scale.CalcNumTics();
-					maxTics = nTics > maxTics ? nTics : maxTics;
-				}
-			}
-			foreach ( Axis axis in _y2AxisList )
-			{
-				axis._scale.PickScale( this, g, scaleFactor );
-				if ( axis._scale.MaxAuto )
-				{
-					int nTics = axis._scale.CalcNumTics();
-					maxTics = nTics > maxTics ? nTics : maxTics;
-				}
-			}
-
-			if ( _isAlignGrids )
-			{
-				foreach ( Axis axis in _yAxisList )
-					ForceNumTics( axis, maxTics );
-
-				foreach ( Axis axis in _y2AxisList )
-					ForceNumTics( axis, maxTics );
-			}
-
-		}
-
-		private void ForceNumTics( Axis axis, int numTics )
-		{
-			if ( axis._scale.MaxAuto )
-			{
-				int nTics = axis._scale.CalcNumTics();
-				if ( nTics < numTics )
-					axis._scale._maxLinearized += axis._scale._majorStep * ( numTics - nTics );
-			}
-		}
-
-		/// <summary>
-		/// Draw all elements in the <see cref="GraphPane"/> to the specified graphics device.
-		/// </summary>
-		/// <remarks>This method
-		/// should be part of the Paint() update process.  Calling this routine will redraw all
-		/// features of the graph.  No preparation is required other than an instantiated
-		/// <see cref="GraphPane"/> object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public override void Draw( Graphics g )
-		{
-			// Calculate the chart rect, deducting the area for the scales, titles, legend, etc.
-			//int		hStack;
-			//float	legendWidth, legendHeight;
-
-			// Draw the pane border & background fill, the title, and the GraphObj objects that lie at
-			// ZOrder.G_BehindAll
-			base.Draw( g );
-
-			if ( _rect.Width <= 1 || _rect.Height <= 1 )
-				return;
-
-			// Clip everything to the rect
-			g.SetClip( _rect );
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = this.CalcScaleFactor();
-
-
-			// if the size of the ChartRect is determined automatically, then do so
-			// otherwise, calculate the legendrect, scalefactor, hstack, and legendwidth parameters
-			// but leave the ChartRect alone
-			if ( _chart._isRectAuto )
-			{
-				_chart._rect = CalcChartRect( g, scaleFactor );
-				//this.pieRect = PieItem.CalcPieRect( g, this, scaleFactor, this.chartRect );
-			}
-			else
-				CalcChartRect( g, scaleFactor );
-
-			// do a sanity check on the ChartRect
-			if ( _chart._rect.Width < 1 || _chart._rect.Height < 1 )
-				return;
-
-			// Draw the graph features only if there is at least one curve with data
-			// if ( _curveList.HasData() &&
-			// Go ahead and draw the graph, even without data.  This makes the control
-			// version still look like a graph before it is fully set up
-			bool showGraf = AxisRangesValid();
-
-			// Setup the axes for graphing - This setup must be done before
-			// the GraphObj's are drawn so that the Transform functions are
-			// ready.  Also, this should be done before CalcChartRect so that the
-			// Axis.Cross - shift parameter can be calculated.
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			_x2Axis.Scale.SetupScaleData( this, _x2Axis );
-			foreach ( Axis axis in _yAxisList )
-				axis.Scale.SetupScaleData( this, axis );
-			foreach ( Axis axis in _y2AxisList )
-				axis.Scale.SetupScaleData( this, axis );
-
-			// Draw the GraphItems that are behind the Axis objects
-			if ( showGraf )
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.G_BehindChartFill );
-
-			// Fill the axis background
-			_chart.Fill.Draw( g, _chart._rect );
-
-			if ( showGraf )
-			{
-				// Draw the GraphItems that are behind the CurveItems
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.F_BehindGrid );
-
-				DrawGrid( g, scaleFactor );
-
-				// Draw the GraphItems that are behind the CurveItems
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.E_BehindCurves );
-
-				// Clip the points to the actual plot area
-				g.SetClip( _chart._rect );
-				_curveList.Draw( g, this, scaleFactor );
-				g.SetClip( _rect );
-
-			}
-
-			if ( showGraf )
-			{
-				// Draw the GraphItems that are behind the Axis objects
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.D_BehindAxis );
-
-				// Draw the Axes
-				_xAxis.Draw( g, this, scaleFactor, 0.0f );
-				_x2Axis.Draw( g, this, scaleFactor, 0.0f );
-
-				float yPos = 0;
-				foreach ( Axis axis in _yAxisList )
-				{
-					axis.Draw( g, this, scaleFactor, yPos );
-					yPos += axis._tmpSpace;
-				}
-
-				yPos = 0;
-				foreach ( Axis axis in _y2AxisList )
-				{
-					axis.Draw( g, this, scaleFactor, yPos );
-					yPos += axis._tmpSpace;
-				}
-
-				// Draw the GraphItems that are behind the Axis border
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.C_BehindChartBorder );
-			}
-
-			// Border the axis itself
-			_chart.Border.Draw( g, this, scaleFactor, _chart._rect );
-
-			if ( showGraf )
-			{
-				// Draw the GraphItems that are behind the Legend object
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.B_BehindLegend );
-
-				_legend.Draw( g, this, scaleFactor );
-
-				// Draw the GraphItems that are in front of all other items
-				_graphObjList.Draw( g, this, scaleFactor, ZOrder.A_InFront );
-			}
-
-			// Reset the clipping
-			g.ResetClip();
-
-			// Reset scale data
-			// this sets the temp values to NaN to cause an exception if these values are
-			// being used improperly
-			// Don't do this, since the web control needs access
-			/*
-			_xAxis.Scale.ResetScaleData();
-			foreach ( Axis axis in _yAxisList )
-				axis.Scale.ResetScaleData();
-			foreach ( Axis axis in _y2AxisList )
-				axis.Scale.ResetScaleData();
-			*/
-		}
-
-		internal void DrawGrid( Graphics g, float scaleFactor )
-		{
-			_xAxis.DrawGrid( g, this, scaleFactor, 0.0f );
-			_x2Axis.DrawGrid( g, this, scaleFactor, 0.0f );
-
-			float shiftPos = 0.0f;
-			foreach ( YAxis yAxis in _yAxisList )
-			{
-				yAxis.DrawGrid( g, this, scaleFactor, shiftPos );
-				shiftPos += yAxis._tmpSpace;
-			}
-
-			shiftPos = 0.0f;
-			foreach ( Y2Axis y2Axis in _y2AxisList )
-			{
-				y2Axis.DrawGrid( g, this, scaleFactor, shiftPos );
-				shiftPos += y2Axis._tmpSpace;
-			}
-		}
-
-		private bool AxisRangesValid()
-		{
-			bool showGraf = _xAxis._scale._min < _xAxis._scale._max &&
-					_x2Axis._scale._min < _x2Axis._scale._max;
-			foreach ( Axis axis in _yAxisList )
-				if ( axis._scale._min >= axis._scale._max )
-					showGraf = false;
-			foreach ( Axis axis in _y2AxisList )
-				if ( axis._scale._min >= axis._scale._max )
-					showGraf = false;
-
-			return showGraf;
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="ZedGraph.Chart.Rect"/> based on the <see cref="PaneBase.Rect"/>.
-		/// </summary>
-		/// <remarks>The ChartRect
-		/// is the plot area bounded by the axes, and the rect is the total area as
-		/// specified by the client application.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <returns>The calculated chart rect, in pixel coordinates.</returns>
-		public RectangleF CalcChartRect( Graphics g )
-		{
-			// Calculate the chart rect, deducting the area for the scales, titles, legend, etc.
-			//int		hStack;
-			//float	legendWidth, legendHeight;
-
-			return CalcChartRect( g, CalcScaleFactor() );
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="ZedGraph.Chart.Rect"/> based on the <see cref="PaneBase.Rect"/>.
-		/// </summary>
-		/// <remarks>The ChartRect
-		/// is the plot area bounded by the axes, and the rect is the total area as
-		/// specified by the client application.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <returns>The calculated chart rect, in pixel coordinates.</returns>
-
-		public RectangleF CalcChartRect( Graphics g, float scaleFactor )
-		{
-			// chart rect starts out at the full pane rect less the margins
-			//   and less space for the Pane title
-			RectangleF clientRect = this.CalcClientRect( g, scaleFactor );
-
-			//float minSpaceX = 0;
-			//float minSpaceY = 0;
-			//float minSpaceY2 = 0;
-			float totSpaceY = 0;
-			//float spaceY2 = 0;
-
-			// actual minimum axis space for the left side of the chart rect
-			float minSpaceL = 0;
-			// actual minimum axis space for the right side of the chart rect
-			float minSpaceR = 0;
-			// actual minimum axis space for the bottom side of the chart rect
-			float minSpaceB = 0;
-			// actual minimum axis space for the top side of the chart rect
-			float minSpaceT = 0;
-
-			_xAxis.CalcSpace( g, this, scaleFactor, out minSpaceB );
-			_x2Axis.CalcSpace( g, this, scaleFactor, out minSpaceT );
-
-			//minSpaceB = _xAxis.tmpMinSpace;
-
-			foreach ( Axis axis in _yAxisList )
-			{
-				float fixedSpace;
-				float tmp = axis.CalcSpace( g, this, scaleFactor, out fixedSpace );
-				//if ( !axis.CrossAuto || axis.Cross < _xAxis.Min )
-				if ( axis.IsCrossShifted( this ) )
-					totSpaceY += tmp;
-
-				minSpaceL += fixedSpace;
-			}
-			foreach ( Axis axis in _y2AxisList )
-			{
-				float fixedSpace;
-				float tmp = axis.CalcSpace( g, this, scaleFactor, out fixedSpace );
-				//if ( !axis.CrossAuto || axis.Cross < _xAxis.Min )
-				if ( axis.IsCrossShifted( this ) )
-					totSpaceY += tmp;
-
-				minSpaceR += fixedSpace;
-			}
-
-			float spaceB = 0, spaceT = 0, spaceL = 0, spaceR = 0;
-
-			SetSpace( _xAxis, clientRect.Height - _xAxis._tmpSpace, ref spaceB, ref spaceT );
-//			minSpaceT = Math.Max( minSpaceT, spaceT );
-			SetSpace( _x2Axis, clientRect.Height - _x2Axis._tmpSpace, ref spaceT, ref spaceB );
-			_xAxis._tmpSpace = spaceB;
-			_x2Axis._tmpSpace = spaceT;
-
-			float totSpaceL = 0;
-			float totSpaceR = 0;
-
-			foreach ( Axis axis in _yAxisList )
-			{
-				SetSpace( axis, clientRect.Width - totSpaceY, ref spaceL, ref spaceR );
-				minSpaceR = Math.Max( minSpaceR, spaceR );
-				totSpaceL += spaceL;
-				axis._tmpSpace = spaceL;
-			}
-			foreach ( Axis axis in _y2AxisList )
-			{
-				SetSpace( axis, clientRect.Width - totSpaceY, ref spaceR, ref spaceL );
-				minSpaceL = Math.Max( minSpaceL, spaceL );
-				totSpaceR += spaceR;
-				axis._tmpSpace = spaceR;
-			}
-
-			RectangleF tmpRect = clientRect;
-
-			totSpaceL = Math.Max( totSpaceL, minSpaceL );
-			totSpaceR = Math.Max( totSpaceR, minSpaceR );
-			spaceB = Math.Max( spaceB, minSpaceB );
-			spaceT = Math.Max( spaceT, minSpaceT );
-
-			tmpRect.X += totSpaceL;
-			tmpRect.Width -= totSpaceL + totSpaceR;
-			tmpRect.Height -= spaceT + spaceB;
-			tmpRect.Y += spaceT;
-
-			_legend.CalcRect( g, this, scaleFactor, ref tmpRect );
-
-			return tmpRect;
-		}
-
-		private void SetSpace( Axis axis, float clientSize, ref float spaceNorm, ref float spaceAlt )
-		{
-			//spaceNorm = 0;
-			//spaceAlt = 0;
-
-			float crossFrac = axis.CalcCrossFraction( this );
-			float crossPix = crossFrac * ( 1 + crossFrac ) * ( 1 + crossFrac * crossFrac ) * clientSize;
-
-			if ( !axis.IsPrimary( this ) && axis.IsCrossShifted( this ) )
-				axis._tmpSpace = 0;
-
-			if ( axis._tmpSpace < crossPix )
-				axis._tmpSpace = 0;
-			else if ( crossPix > 0 )
-				axis._tmpSpace -= crossPix;
-
-			if ( axis._scale._isLabelsInside && ( axis.IsPrimary( this ) || ( crossFrac != 0.0 && crossFrac != 1.0 ) ) )
-				spaceAlt = axis._tmpSpace;
-			else
-				spaceNorm = axis._tmpSpace;
-		}
-
-		/// <summary>
-		/// This method will set the <see cref="Axis.MinSpace"/> property for all three axes;
-		/// <see cref="XAxis"/>, <see cref="YAxis"/>, and <see cref="Y2Axis"/>.
-		/// </summary>
-		/// <remarks>The <see cref="Axis.MinSpace"/>
-		/// is calculated using the currently required space multiplied by a fraction
-		/// (<paramref>bufferFraction</paramref>).
-		/// The currently required space is calculated using <see cref="Axis.CalcSpace"/>, and is
-		/// based on current data ranges, font sizes, etc.  The "space" is actually the amount of space
-		/// required to fit the tic marks, scale labels, and axis title.
-		/// The calculation is done by calling the <see cref="Axis.SetMinSpaceBuffer"/> method for
-		/// each <see cref="Axis"/>.
-		/// </remarks>
-		/// <param name="g">A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.</param>
-		/// <param name="bufferFraction">The amount of space to allocate for the axis, expressed
-		/// as a fraction of the currently required space.  For example, a value of 1.2 would
-		/// allow for 20% extra above the currently required space.</param>
-		/// <param name="isGrowOnly">If true, then this method will only modify the <see cref="Axis.MinSpace"/>
-		/// property if the calculated result is more than the current value.</param>
-		public void SetMinSpaceBuffer( Graphics g, float bufferFraction, bool isGrowOnly )
-		{
-			_xAxis.SetMinSpaceBuffer( g, this, bufferFraction, isGrowOnly );
-			_x2Axis.SetMinSpaceBuffer( g, this, bufferFraction, isGrowOnly );
-			foreach ( Axis axis in _yAxisList )
-				axis.SetMinSpaceBuffer( g, this, bufferFraction, isGrowOnly );
-			foreach ( Axis axis in _y2AxisList )
-				axis.SetMinSpaceBuffer( g, this, bufferFraction, isGrowOnly );
-		}
-
-	#endregion
-
-	#region AddCurve Methods
-
-		/// <summary>
-		/// Add a curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (double arrays) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddCurve(string,double[],double[],Color)"/> method.</returns>
-		public LineItem AddCurve( string label, double[] x, double[] y, Color color )
-		{
-			LineItem curve = new LineItem( label, x, y, color, SymbolType.Default );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddCurve(string,IPointList,Color)"/> method.</returns>
-		public LineItem AddCurve( string label, IPointList points, Color color )
-		{
-			LineItem curve = new LineItem( label, points, color, SymbolType.Default );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (double arrays) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <param name="symbolType">A symbol type (<see cref="SymbolType"/>)
-		/// that will be used for this curve.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddCurve(string,double[],double[],Color,SymbolType)"/> method.</returns>
-		public LineItem AddCurve( string label, double[] x, double[] y,
-			Color color, SymbolType symbolType )
-		{
-			LineItem curve = new LineItem( label, x, y, color, symbolType );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <param name="symbolType">A symbol type (<see cref="SymbolType"/>)
-		/// that will be used for this curve.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddCurve(string,IPointList,Color,SymbolType)"/> method.</returns>
-		public LineItem AddCurve( string label, IPointList points,
-			Color color, SymbolType symbolType )
-		{
-			LineItem curve = new LineItem( label, points, color, symbolType );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a stick graph (<see cref="StickItem"/> object) to the plot with
-		/// the given data points (double arrays) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>A <see cref="StickItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddStick(string,double[],double[],Color)"/> method.</returns>
-		public StickItem AddStick( string label, double[] x, double[] y, Color color )
-		{
-			StickItem curve = new StickItem( label, x, y, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a stick graph (<see cref="StickItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddStick(string,IPointList,Color)"/> method.</returns>
-		public StickItem AddStick( string label, IPointList points, Color color )
-		{
-			StickItem curve = new StickItem( label, points, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a candlestick graph (<see cref="OHLCBarItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// </summary>
-		/// <remarks>
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// Note that the <see cref="IPointList" />
-		/// should contain <see cref="StockPt" /> objects instead of <see cref="PointPair" />
-		/// objects in order to contain all the data values required for this curve type.
-		/// </remarks>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddOHLCBar(string,IPointList,Color)"/> method.</returns>
-		public OHLCBarItem AddOHLCBar( string label, IPointList points, Color color )
-		{
-			OHLCBarItem curve = new OHLCBarItem( label, points, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a japanesecandlestick graph (<see cref="JapaneseCandleStickItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// </summary>
-		/// <remarks>
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// Note that the <see cref="IPointList" />
-		/// should contain <see cref="StockPt" /> objects instead of <see cref="PointPair" />
-		/// objects in order to contain all the data values required for this curve type.
-		/// </remarks>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddJapaneseCandleStick(string,IPointList)"/> method.</returns>
-		public JapaneseCandleStickItem AddJapaneseCandleStick( string label, IPointList points )
-		{
-			JapaneseCandleStickItem curve = new JapaneseCandleStickItem( label, points );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add an error bar set (<see cref="ErrorBarItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="baseValue">An array of double precision values that define the
-		/// base value (the bottom) of the bars for this curve.
-		/// </param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>An <see cref="ErrorBarItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddErrorBar(string,IPointList,Color)"/> method.</returns>
-		public ErrorBarItem AddErrorBar( string label, double[] x, double[] y,
-			double[] baseValue, Color color )
-		{
-			ErrorBarItem curve = new ErrorBarItem( label, new PointPairList( x, y, baseValue ),
-				color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-		/// <summary>
-		/// Add an error bar set (<see cref="ErrorBarItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used for the curve line,
-		/// symbols, etc.</param>
-		/// <returns>An <see cref="ErrorBarItem"/> class for the newly created curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddErrorBar(string,IPointList,Color)"/> method.</returns>
-		public ErrorBarItem AddErrorBar( string label, IPointList points, Color color )
-		{
-			ErrorBarItem curve = new ErrorBarItem( label, points, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a bar type curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">The color to used to fill the bars</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created bar curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddBar(string,IPointList,Color)"/> method.</returns>
-		public BarItem AddBar( string label, IPointList points, Color color )
-		{
-			BarItem curve = new BarItem( label, points, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a bar type curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (double arrays) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="color">The color to used for the bars</param>
-		/// <returns>A <see cref="CurveItem"/> class for the newly created bar curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddBar(string,double[],double[],Color)"/> method.</returns>
-		public BarItem AddBar( string label, double[] x, double[] y, Color color )
-		{
-			BarItem curve = new BarItem( label, x, y, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a "High-Low" bar type curve (<see cref="HiLowBarItem"/> object) to the plot with
-		/// the given data points (double arrays) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="x">An array of double precision X values (the
-		/// independent values) that define the curve.</param>
-		/// <param name="y">An array of double precision Y values (the
-		/// dependent values) that define the curve.</param>
-		/// <param name="baseVal">An array of double precision values that define the
-		/// base value (the bottom) of the bars for this curve.
-		/// </param>
-		/// <param name="color">The color to used for the bars</param>
-		/// <returns>A <see cref="HiLowBarItem"/> class for the newly created bar curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddHiLowBar(string,double[],double[],double[],Color)"/> method.</returns>
-		public HiLowBarItem AddHiLowBar( string label, double[] x, double[] y,
-			double[] baseVal, Color color )
-		{
-			HiLowBarItem curve = new HiLowBarItem( label, x, y, baseVal, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a hi-low bar type curve (<see cref="CurveItem"/> object) to the plot with
-		/// the given data points (<see cref="IPointList"/>) and properties.
-		/// This is simplified way to add curves without knowledge of the
-		/// <see cref="CurveList"/> class.  An alternative is to use
-		/// the <see cref="ZedGraph.CurveList" /> Add() method.
-		/// </summary>
-		/// <param name="label">The text label (string) for the curve that will be
-		/// used as a <see cref="Legend"/> entry.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value Trio's that define
-		/// the X, Y, and lower dependent values for this curve</param>
-		/// <param name="color">The color to used to fill the bars</param>
-		/// <returns>A <see cref="HiLowBarItem"/> class for the newly created bar curve.
-		/// This can then be used to access all of the curve properties that
-		/// are not defined as arguments to the
-		/// <see cref="AddHiLowBar(string,IPointList,Color)"/> method.</returns>
-		public HiLowBarItem AddHiLowBar( string label, IPointList points, Color color )
-		{
-			HiLowBarItem curve = new HiLowBarItem( label, points, color );
-			_curveList.Add( curve );
-
-			return curve;
-		}
-
-		/// <summary>
-		/// Add a <see cref="PieItem"/> to the display.
-		/// </summary>
-		/// <param name="value">The value associated with this <see cref="PieItem"/>item.</param>
-		/// <param name="color">The display color for this <see cref="PieItem"/>item.</param>
-		/// <param name="displacement">The amount this <see cref="PieItem"/>item will be 
-		/// displaced from the center of the <see cref="PieItem"/>.</param>
-		/// <param name="label">Text label for this <see cref="PieItem"/></param>
-		/// <returns>a reference to the <see cref="PieItem"/> constructed</returns>
-		public PieItem AddPieSlice( double value, Color color, double displacement, string label )
-		{
-			PieItem slice = new PieItem( value, color, displacement, label );
-			this.CurveList.Add( slice );
-			return slice;
-		}
-
-		/// <summary>
-		/// Add a <see cref="PieItem"/> to the display, providing a gradient fill for the pie color.
-		/// </summary>
-		/// <param name="value">The value associated with this <see cref="PieItem"/> instance.</param>
-		/// <param name="color1">The starting display color for the gradient <see cref="Fill"/> for this
-		/// <see cref="PieItem"/> instance.</param>
-		/// <param name="color2">The ending display color for the gradient <see cref="Fill"/> for this
-		/// <see cref="PieItem"/> instance.</param>
-		/// <param name="fillAngle">The angle for the gradient <see cref="Fill"/>.</param>
-		/// <param name="displacement">The amount this <see cref="PieItem"/>  instance will be 
-		/// displaced from the center point.</param>
-		/// <param name="label">Text label for this <see cref="PieItem"/> instance.</param>
-		public PieItem AddPieSlice( double value, Color color1, Color color2, float fillAngle,
-						double displacement, string label )
-		{
-			PieItem slice = new PieItem( value, color1, color2, fillAngle, displacement, label );
-			this.CurveList.Add( slice );
-			return slice;
-		}
-
-		/// <summary>
-		///Creates all the <see cref="PieItem"/>s for a single Pie Chart. 
-		/// </summary>
-		/// <param name="values">double array containing all <see cref="PieItem.Value"/>s
-		/// for a single PieChart.
-		/// </param>
-		/// <param name="labels"> string array containing all <see cref="CurveItem.Label"/>s
-		/// for a single PieChart.
-		/// </param>
-		/// <returns>an array containing references to all <see cref="PieItem"/>s comprising
-		/// the Pie Chart.</returns>
-		public PieItem[] AddPieSlices( double[] values, string[] labels )
-		{
-			PieItem[] slices = new PieItem[values.Length];
-			for ( int x = 0; x < values.Length; x++ )
-			{
-				slices[x] = new PieItem( values[x], labels[x] );
-				this.CurveList.Add( slices[x] );
-			}
-			return slices;
-		}
-
-	#endregion
-
-	#region General Utility Methods
-		/// <summary>
-		/// Transform a data point from the specified coordinate type
-		/// (<see cref="CoordType"/>) to screen coordinates (pixels).
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).</remarks>
-		/// <param name="ptF">The X,Y pair that defines the point in user
-		/// coordinates.</param>
-		/// <param name="coord">A <see cref="CoordType"/> type that defines the
-		/// coordinate system in which the X,Y pair is defined.</param>
-		/// <returns>A point in screen coordinates that corresponds to the
-		/// specified user point.</returns>
-		public PointF GeneralTransform( PointF ptF, CoordType coord )
-		{
-			// Setup the scaling data based on the chart rect
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			foreach ( Axis axis in _yAxisList )
-				axis.Scale.SetupScaleData( this, axis );
-			foreach ( Axis axis in _y2AxisList )
-				axis.Scale.SetupScaleData( this, axis );
-
-			return this.TransformCoord( ptF.X, ptF.Y, coord );
-		}
-
-		/// <summary>
-		/// Transform a data point from the specified coordinate type
-		/// (<see cref="CoordType"/>) to screen coordinates (pixels).
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).
-		/// Note that this method is more accurate than the <see cref="GeneralTransform(PointF,CoordType)" />
-		/// overload, since it uses double types.  This would typically only be significant for
-		/// <see cref="AxisType.Date" /> coordinates.
-		/// </remarks>
-		/// <param name="x">The x coordinate that defines the location in user space</param>
-		/// <param name="y">The y coordinate that defines the location in user space</param>
-		/// <param name="coord">A <see cref="CoordType"/> type that defines the
-		/// coordinate system in which the X,Y pair is defined.</param>
-		/// <returns>A point in screen coordinates that corresponds to the
-		/// specified user point.</returns>
-		public PointF GeneralTransform( double x, double y, CoordType coord )
-		{
-			// Setup the scaling data based on the chart rect
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			foreach ( Axis axis in _yAxisList )
-				axis.Scale.SetupScaleData( this, axis );
-			foreach ( Axis axis in _y2AxisList )
-				axis.Scale.SetupScaleData( this, axis );
-
-			return this.TransformCoord( x, y, coord );
-		}
-
-		/// <summary>
-		/// Return the user scale values that correspond to the specified screen
-		/// coordinate position (pixels).  This overload assumes the default
-		/// <see cref="XAxis" /> and <see cref="YAxis" />.
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).</remarks>
-		/// <param name="ptF">The X,Y pair that defines the screen coordinate
-		/// point of interest</param>
-		/// <param name="x">The resultant value in user coordinates from the
-		/// <see cref="XAxis"/></param>
-		/// <param name="y">The resultant value in user coordinates from the
-		/// primary <see cref="YAxis"/></param>
-		public void ReverseTransform( PointF ptF, out double x, out double y )
-		{
-			// Setup the scaling data based on the chart rect
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			this.YAxis.Scale.SetupScaleData( this, this.YAxis );
-
-			x = this.XAxis.Scale.ReverseTransform( ptF.X );
-			y = this.YAxis.Scale.ReverseTransform( ptF.Y );
-		}
-
-		/// <summary>
-		/// Return the user scale values that correspond to the specified screen
-		/// coordinate position (pixels).
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).</remarks>
-		/// <param name="ptF">The X,Y pair that defines the screen coordinate
-		/// point of interest</param>
-		/// <param name="x">The resultant value in user coordinates from the
-		/// <see cref="XAxis"/></param>
-		/// <param name="x2">The resultant value in user coordinates from the
-		/// <see cref="X2Axis"/></param>
-		/// <param name="y">The resultant value in user coordinates from the
-		/// primary <see cref="YAxis"/></param>
-		/// <param name="y2">The resultant value in user coordinates from the
-		/// primary <see cref="Y2Axis"/></param>
-		public void ReverseTransform( PointF ptF, out double x, out double x2, out double y,
-			out double y2 )
-		{
-			// Setup the scaling data based on the chart rect
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			_x2Axis.Scale.SetupScaleData( this, _x2Axis );
-			this.YAxis.Scale.SetupScaleData( this, this.YAxis );
-			this.Y2Axis.Scale.SetupScaleData( this, this.Y2Axis );
-
-			x = this.XAxis.Scale.ReverseTransform( ptF.X );
-			x2 = this.X2Axis.Scale.ReverseTransform( ptF.X );
-			y = this.YAxis.Scale.ReverseTransform( ptF.Y );
-			y2 = this.Y2Axis.Scale.ReverseTransform( ptF.Y );
-		}
-
-		/// <summary>
-		/// Return the user scale values that correspond to the specified screen
-		/// coordinate position (pixels).
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).</remarks>
-		/// <param name="ptF">The X,Y pair that defines the screen coordinate
-		/// point of interest</param>
-		/// <param name="isX2Axis">true to return data that corresponds to an
-		/// <see cref="X2Axis" />, false for an <see cref="XAxis" />.</param>
-		/// <param name="isY2Axis">true to return data that corresponds to a
-		/// <see cref="Y2Axis" />, false for a <see cref="YAxis" />.</param>
-		/// <param name="yAxisIndex">The ordinal index of the Y or Y2 axis from which
-		/// to return data (see <seealso cref="YAxisList"/>, <seealso cref="Y2AxisList"/>)
-		/// </param>
-		/// <param name="x">The resultant value in user coordinates from the
-		/// <see cref="XAxis"/></param>
-		/// <param name="y">The resultant value in user coordinates from the
-		/// primary <see cref="YAxis"/></param>
-		public void ReverseTransform( PointF ptF, bool isX2Axis, bool isY2Axis, int yAxisIndex,
-					out double x, out double y )
-		{
-			// Setup the scaling data based on the chart rect
-			Axis xAxis = _xAxis;
-			if ( isX2Axis )
-				xAxis = _x2Axis;
-
-			xAxis.Scale.SetupScaleData( this, xAxis );
-			x = xAxis.Scale.ReverseTransform( ptF.X );
-
-			Axis yAxis = null;
-			if ( isY2Axis && Y2AxisList.Count > yAxisIndex )
-				yAxis = Y2AxisList[yAxisIndex];
-			else if ( !isY2Axis && YAxisList.Count > yAxisIndex )
-				yAxis = YAxisList[yAxisIndex];
-
-			if ( yAxis != null )
-			{
-				yAxis.Scale.SetupScaleData( this, yAxis );
-				y = yAxis.Scale.ReverseTransform( ptF.Y );
-			}
-			else
-				y = PointPair.Missing;
-		}
-
-		/// <summary>
-		/// Return the user scale values that correspond to the specified screen
-		/// coordinate position (pixels) for all y axes.
-		/// </summary>
-		/// <remarks>This method implicitly assumes that <see cref="ZedGraph.Chart.Rect"/>
-		/// has already been calculated via <see cref="AxisChange()"/> or
-		/// <see cref="Draw"/> methods, or the <see cref="ZedGraph.Chart.Rect"/> is
-		/// set manually (see <see cref="ZedGraph.Chart.IsRectAuto"/>).</remarks>
-		/// <param name="ptF">The X,Y pair that defines the screen coordinate
-		/// point of interest</param>
-		/// <param name="x">The resultant value in user coordinates from the
-		/// <see cref="XAxis"/></param>
-		/// <param name="x2">The resultant value in user coordinates from the
-		/// <see cref="X2Axis"/></param>
-		/// <param name="y">An array of resultant values in user coordinates from the
-		/// list of <see cref="YAxis"/> instances.  This method allocates the
-		/// array for you, according to the number of <see cref="YAxis" /> objects
-		/// in the list.</param>
-		/// <param name="y2">An array of resultant values in user coordinates from the
-		/// list of <see cref="Y2Axis"/> instances.  This method allocates the
-		/// array for you, according to the number of <see cref="Y2Axis" /> objects
-		/// in the list.</param>
-		public void ReverseTransform( PointF ptF, out double x, out double x2, out double[] y,
-			out double[] y2 )
-		{
-			// Setup the scaling data based on the chart rect
-			_xAxis.Scale.SetupScaleData( this, _xAxis );
-			x = this.XAxis.Scale.ReverseTransform( ptF.X );
-			_x2Axis.Scale.SetupScaleData( this, _x2Axis );
-			x2 = this.X2Axis.Scale.ReverseTransform( ptF.X );
-
-			y = new double[_yAxisList.Count];
-			y2 = new double[_y2AxisList.Count];
-
-			for ( int i = 0; i < _yAxisList.Count; i++ )
-			{
-				Axis axis = _yAxisList[i];
-				axis.Scale.SetupScaleData( this, axis );
-				y[i] = axis.Scale.ReverseTransform( ptF.Y );
-			}
-			for ( int i = 0; i < _y2AxisList.Count; i++ )
-			{
-				Axis axis = _y2AxisList[i];
-				axis.Scale.SetupScaleData( this, axis );
-				y2[i] = axis.Scale.ReverseTransform( ptF.Y );
-			}
-		}
-
-		/// <summary>
-		/// Add a secondary <see cref="YAxis" /> (left side) to the list of axes
-		/// in the Graph.
-		/// </summary>
-		/// <remarks>
-		/// Note that the primary <see cref="YAxis" /> is always included by default.
-		/// This method turns off the <see cref="MajorTic" /> and <see cref="MinorTic" />
-		/// <see cref="MinorTic.IsOpposite" /> and <see cref="MinorTic.IsInside" />
-		/// properties by default.
-		/// </remarks>
-		/// <param name="title">The title for the <see cref="YAxis" />.</param>
-		/// <returns>the ordinal position (index) in the <see cref="YAxisList" />.</returns>
-		public int AddYAxis( string title )
-		{
-			YAxis axis = new YAxis( title );
-			axis.MajorTic.IsOpposite = false;
-			axis.MinorTic.IsOpposite = false;
-			axis.MajorTic.IsInside = false;
-			axis.MinorTic.IsInside = false;
-			_yAxisList.Add( axis );
-			return _yAxisList.Count - 1;
-		}
-
-		/// <summary>
-		/// Add a secondary <see cref="Y2Axis" /> (right side) to the list of axes
-		/// in the Graph.
-		/// </summary>
-		/// <remarks>
-		/// Note that the primary <see cref="Y2Axis" /> is always included by default.
-		/// This method turns off the <see cref="MajorTic" /> and <see cref="MinorTic" />
-		/// <see cref="MinorTic.IsOpposite" /> and <see cref="MinorTic.IsInside" />
-		/// properties by default.
-		/// </remarks>
-		/// <param name="title">The title for the <see cref="Y2Axis" />.</param>
-		/// <returns>the ordinal position (index) in the <see cref="Y2AxisList" />.</returns>
-		public int AddY2Axis( string title )
-		{
-			Y2Axis axis = new Y2Axis( title );
-			axis.MajorTic.IsOpposite = false;
-			axis.MinorTic.IsOpposite = false;
-			axis.MajorTic.IsInside = false;
-			axis.MinorTic.IsInside = false;
-			_y2AxisList.Add( axis );
-			return _y2AxisList.Count - 1;
-		}
-
-		/// <summary>
-		/// Find the object that lies closest to the specified mouse (screen) point.
-		/// </summary>
-		/// <remarks>
-		/// This method will search through all of the graph objects, such as
-		/// <see cref="Axis"/>, <see cref="Legend"/>, <see cref="PaneBase.Title"/>,
-		/// <see cref="GraphObj"/>, and <see cref="CurveItem"/>.
-		/// If the mouse point is within the bounding box of the items (or in the case
-		/// of <see cref="ArrowObj"/> and <see cref="CurveItem"/>, within
-		/// <see cref="Default.NearestTol"/> pixels), then the object will be returned.
-		/// You must check the type of the object to determine what object was
-		/// selected (for example, "if ( object is Legend ) ...").  The
-		/// <see paramref="index"/> parameter returns the index number of the item
-		/// within the selected object (such as the point number within a
-		/// <see cref="CurveItem"/> object.
-		/// </remarks>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="nearestObj">A reference to the nearest object to the
-		/// specified screen point.  This can be any of <see cref="Axis"/>,
-		/// <see cref="Legend"/>, <see cref="PaneBase.Title"/>,
-		/// <see cref="TextObj"/>, <see cref="ArrowObj"/>, or <see cref="CurveItem"/>.
-		/// Note: If the pane title is selected, then the <see cref="GraphPane"/> object
-		/// will be returned.
-		/// </param>
-		/// <param name="index">The index number of the item within the selected object
-		/// (where applicable).  For example, for a <see cref="CurveItem"/> object,
-		/// <see paramref="index"/> will be the index number of the nearest data point,
-		/// accessible via <see cref="CurveItem.Points">CurveItem.Points[index]</see>.
-		/// index will be -1 if no data points are available.</param>
-		/// <returns>true if an object was found, false otherwise.</returns>
-		/// <seealso cref="FindNearestObject"/>
-		public bool FindNearestObject( PointF mousePt, Graphics g, 
-			out object nearestObj, out int index )
-		{
-			nearestObj = null;
-			index = -1;
-
-			// Make sure that the axes & data are being drawn
-			if ( AxisRangesValid() )
-			{
-				float scaleFactor = CalcScaleFactor();
-				//int			hStack;
-				//float		legendWidth, legendHeight;
-				RectangleF tmpRect;
-				GraphObj saveGraphItem = null;
-				int saveIndex = -1;
-				ZOrder saveZOrder = ZOrder.H_BehindAll;
-
-				// Calculate the chart rect, deducting the area for the scales, titles, legend, etc.
-				RectangleF tmpChartRect = CalcChartRect( g, scaleFactor );
-
-				// See if the point is in a GraphObj
-				// If so, just save the object and index so we can see if other overlying objects were
-				// intersected as well.
-				if ( this.GraphObjList.FindPoint( mousePt, this, g, scaleFactor, out index ) )
-				{
-					saveGraphItem = this.GraphObjList[index];
-					saveIndex = index;
-					saveZOrder = saveGraphItem.ZOrder;
-				}
-
-				// See if the point is in the legend
-				if ( saveZOrder <= ZOrder.B_BehindLegend &&
-					this.Legend.FindPoint( mousePt, this, scaleFactor, out index ) )
-				{
-					nearestObj = this.Legend;
-					return true;
-				}
-
-				// See if the point is in the Pane Title
-				SizeF paneTitleBox = _title._fontSpec.BoundingBox( g, _title._text, scaleFactor );
-				if ( saveZOrder <= ZOrder.H_BehindAll && _title._isVisible )
-				{
-					tmpRect = new RectangleF( ( _rect.Left + _rect.Right - paneTitleBox.Width ) / 2,
-						_rect.Top + _margin.Top * scaleFactor,
-						paneTitleBox.Width, paneTitleBox.Height );
-					if ( tmpRect.Contains( mousePt ) )
-					{
-						nearestObj = this;
-						return true;
-					}
-				}
-
-				float left = tmpChartRect.Left;
-
-				// See if the point is in one of the Y Axes
-				for ( int yIndex = 0; yIndex < _yAxisList.Count; yIndex++ )
-				{
-					Axis yAxis = _yAxisList[yIndex];
-					float width = yAxis._tmpSpace;
-					if ( width > 0 )
-					{
-						tmpRect = new RectangleF( left - width, tmpChartRect.Top,
-							width, tmpChartRect.Height );
-						if ( saveZOrder <= ZOrder.D_BehindAxis && tmpRect.Contains( mousePt ) )
-						{
-							nearestObj = yAxis;
-							index = yIndex;
-							return true;
-						}
-
-						left -= width;
-					}
-				}
-
-				left = tmpChartRect.Right;
-
-				// See if the point is in one of the Y2 Axes
-				for ( int yIndex = 0; yIndex < _y2AxisList.Count; yIndex++ )
-				{
-					Axis y2Axis = _y2AxisList[yIndex];
-					float width = y2Axis._tmpSpace;
-					if ( width > 0 )
-					{
-						tmpRect = new RectangleF( left, tmpChartRect.Top,
-							width, tmpChartRect.Height );
-						if ( saveZOrder <= ZOrder.D_BehindAxis && tmpRect.Contains( mousePt ) )
-						{
-							nearestObj = y2Axis;
-							index = yIndex;
-							return true;
-						}
-
-						left += width;
-					}
-				}
-
-				// See if the point is in the X Axis
-				float height = _xAxis._tmpSpace;
-
-				tmpRect = new RectangleF( tmpChartRect.Left, tmpChartRect.Bottom,
-					tmpChartRect.Width, height ); //_rect.Bottom - tmpChartRect.Bottom );
-
-				if ( saveZOrder <= ZOrder.D_BehindAxis && tmpRect.Contains( mousePt ) )
-				{
-					nearestObj = this.XAxis;
-					return true;
-				}
-
-				// See if the point is in the X2 Axis
-				height = _x2Axis._tmpSpace;
-
-				tmpRect = new RectangleF( tmpChartRect.Left,
-						tmpChartRect.Top - height,
-						tmpChartRect.Width,
-						height );
-				if ( saveZOrder <= ZOrder.D_BehindAxis && tmpRect.Contains( mousePt ) )
-				{
-					nearestObj = this.X2Axis;
-					return true;
-				}
-
-				CurveItem curve;
-				// See if it's a data point
-				if ( saveZOrder <= ZOrder.E_BehindCurves && FindNearestPoint( mousePt, out curve, out index ) )
-				{
-					nearestObj = curve;
-					return true;
-				}
-
-				if ( saveGraphItem != null )
-				{
-					index = saveIndex;
-					nearestObj = saveGraphItem;
-					return true;
-				}
-			}
-
-			return false;
-		}
-
-		/// <summary>
-		/// Find the data point that lies closest to the specified mouse (screen)
-		/// point for the specified curve.
-		/// </summary>
-		/// <remarks>
-		/// This method will search only through the points for the specified
-		/// curve to determine which point is
-		/// nearest the mouse point.  It will only consider points that are within
-		/// <see cref="Default.NearestTol"/> pixels of the screen point.
-		/// </remarks>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="nearestCurve">A reference to the <see cref="CurveItem"/>
-		/// instance that contains the closest point.  nearestCurve will be null if
-		/// no data points are available.</param>
-		/// <param name="targetCurve">A <see cref="CurveItem"/> object containing
-		/// the data points to be searched.</param>
-		/// <param name="iNearest">The index number of the closest point.  The
-		/// actual data vpoint will then be <see cref="CurveItem.Points">CurveItem.Points[iNearest]</see>
-		/// .  iNearest will
-		/// be -1 if no data points are available.</param>
-		/// <returns>true if a point was found and that point lies within
-		/// <see cref="Default.NearestTol"/> pixels
-		/// of the screen point, false otherwise.</returns>
-		public bool FindNearestPoint( PointF mousePt, CurveItem targetCurve,
-				out CurveItem nearestCurve, out int iNearest )
-		{
-			CurveList targetCurveList = new CurveList();
-			targetCurveList.Add( targetCurve );
-			return FindNearestPoint( mousePt, targetCurveList,
-				out nearestCurve, out iNearest );
-		}
-
-		/// <summary>
-		/// Find the data point that lies closest to the specified mouse (screen)
-		/// point.
-		/// </summary>
-		/// <remarks>
-		/// This method will search through all curves in
-		/// <see cref="GraphPane.CurveList"/> to find which point is
-		/// nearest.  It will only consider points that are within
-		/// <see cref="Default.NearestTol"/> pixels of the screen point.
-		/// </remarks>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="nearestCurve">A reference to the <see cref="CurveItem"/>
-		/// instance that contains the closest point.  nearestCurve will be null if
-		/// no data points are available.</param>
-		/// <param name="iNearest">The index number of the closest point.  The
-		/// actual data vpoint will then be <see cref="CurveItem.Points">CurveItem.Points[iNearest]</see>
-		/// .  iNearest will
-		/// be -1 if no data points are available.</param>
-		/// <returns>true if a point was found and that point lies within
-		/// <see cref="Default.NearestTol"/> pixels
-		/// of the screen point, false otherwise.</returns>
-		public bool FindNearestPoint( PointF mousePt,
-			out CurveItem nearestCurve, out int iNearest )
-		{
-			return FindNearestPoint( mousePt, _curveList,
-				out nearestCurve, out iNearest );
-		}
-
-		/// <summary>
-		/// Find the data point that lies closest to the specified mouse (screen)
-		/// point.
-		/// </summary>
-		/// <remarks>
-		/// This method will search through the specified list of curves to find which point is
-		/// nearest.  It will only consider points that are within
-		/// <see cref="Default.NearestTol"/> pixels of the screen point, and it will
-		/// only consider <see cref="CurveItem"/>'s that are in 
-		/// <paramref name="targetCurveList"/>.
-		/// </remarks>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="targetCurveList">A <see cref="CurveList"/> object containing
-		/// a subset of <see cref="CurveItem"/>'s to be searched.</param>
-		/// <param name="nearestCurve">A reference to the <see cref="CurveItem"/>
-		/// instance that contains the closest point.  nearestCurve will be null if
-		/// no data points are available.</param>
-		/// <param name="iNearest">The index number of the closest point.  The
-		/// actual data vpoint will then be <see cref="CurveItem.Points">CurveItem.Points[iNearest]</see>
-		/// .  iNearest will
-		/// be -1 if no data points are available.</param>
-		/// <returns>true if a point was found and that point lies within
-		/// <see cref="Default.NearestTol"/> pixels
-		/// of the screen point, false otherwise.</returns>
-		public bool FindNearestPoint( PointF mousePt, CurveList targetCurveList,
-			out CurveItem nearestCurve, out int iNearest )
-		{
-			CurveItem nearestBar = null;
-			int iNearestBar = -1;
-			nearestCurve = null;
-			iNearest = -1;
-
-			// If the point is outside the ChartRect, always return false
-			if ( !_chart._rect.Contains( mousePt ) )
-				return false;
-
-			double x, x2;
-			double[] y;
-			double[] y2;
-
-			//ReverseTransform( mousePt, out x, out y, out y2 );
-			ReverseTransform( mousePt, out x, out x2, out y, out y2 );
-
-			if ( !AxisRangesValid() )
-				return false;
-
-			ValueHandler valueHandler = new ValueHandler( this, false );
-
-			//double	yPixPerUnit = chartRect.Height / ( yAxis.Max - yAxis.Min );
-			//double	y2PixPerUnit; // = chartRect.Height / ( y2Axis.Max - y2Axis.Min );
-
-			double yPixPerUnitAct, yAct, yMinAct, yMaxAct, xAct;
-			double minDist = 1e20;
-			double xVal, yVal, dist = 99999, distX, distY;
-			double tolSquared = Default.NearestTol * Default.NearestTol;
-
-			int iBar = 0;
-
-			foreach ( CurveItem curve in targetCurveList )
-			{
-				//test for pie first...if it's a pie rest of method superfluous
-				if ( curve is PieItem && curve.IsVisible )
-				{
-					if ( ( (PieItem)curve ).SlicePath != null &&
-							( (PieItem)curve ).SlicePath.IsVisible( mousePt ) )
-					{
-						nearestBar = curve;
-						iNearestBar = 0;
-					}
-
-					continue;
-				}
-				else if ( curve.IsVisible )
-				{
-					int yIndex = curve.GetYAxisIndex( this );
-					Axis yAxis = curve.GetYAxis( this );
-					Axis xAxis = curve.GetXAxis( this );
-
-					if ( curve.IsY2Axis )
-					{
-						yAct = y2[yIndex];
-						yMinAct = _y2AxisList[yIndex]._scale._min;
-						yMaxAct = _y2AxisList[yIndex]._scale._max;
-					}
-					else
-					{
-						yAct = y[yIndex];
-						yMinAct = _yAxisList[yIndex]._scale._min;
-						yMaxAct = _yAxisList[yIndex]._scale._max;
-					}
-
-					yPixPerUnitAct = _chart._rect.Height / ( yMaxAct - yMinAct );
-
-					double xPixPerUnit = _chart._rect.Width / ( xAxis._scale._max - xAxis._scale._min );
-					xAct = xAxis is XAxis ? x : x2;
-
-					IPointList points = curve.Points;
-					float barWidth = curve.GetBarWidth( this );
-					double barWidthUserHalf;
-					Axis baseAxis = curve.BaseAxis( this );
-					bool isXBaseAxis = ( baseAxis is XAxis || baseAxis is X2Axis );
-					if ( isXBaseAxis )
-						barWidthUserHalf = barWidth / xPixPerUnit / 2.0;
-					else
-						barWidthUserHalf = barWidth / yPixPerUnitAct / 2.0;
-
-					if ( points != null )
-					{
-						for ( int iPt = 0; iPt < curve.NPts; iPt++ )
-						{
-							// xVal is the user scale X value of the current point
-							if ( xAxis._scale.IsAnyOrdinal && !curve.IsOverrideOrdinal )
-								xVal = (double)iPt + 1.0;
-							else
-								xVal = points[iPt].X;
-
-							// yVal is the user scale Y value of the current point
-							if ( yAxis._scale.IsAnyOrdinal && !curve.IsOverrideOrdinal )
-								yVal = (double)iPt + 1.0;
-							else
-								yVal = points[iPt].Y;
-
-							if ( xVal != PointPair.Missing &&
-									yVal != PointPair.Missing )
-							{
-
-								if ( curve.IsBar || curve is ErrorBarItem ||
-									curve is HiLowBarItem || curve is OHLCBarItem ||
-									curve is JapaneseCandleStickItem )
-								{
-									double baseVal, lowVal, hiVal;
-									valueHandler.GetValues( curve, iPt, out baseVal,
-											out lowVal, out hiVal );
-
-									if ( lowVal > hiVal )
-									{
-										double tmpVal = lowVal;
-										lowVal = hiVal;
-										hiVal = tmpVal;
-									}
-
-									if ( isXBaseAxis )
-									{
-
-										double centerVal = valueHandler.BarCenterValue( curve, barWidth, iPt, xVal, iBar );
-
-										if ( xAct < centerVal - barWidthUserHalf ||
-												xAct > centerVal + barWidthUserHalf ||
-												yAct < lowVal || yAct > hiVal )
-											continue;
-									}
-									else
-									{
-										double centerVal = valueHandler.BarCenterValue( curve, barWidth, iPt, yVal, iBar );
-
-										if ( yAct < centerVal - barWidthUserHalf ||
-												yAct > centerVal + barWidthUserHalf ||
-												xAct < lowVal || xAct > hiVal )
-											continue;
-									}
-
-									if ( nearestBar == null )
-									{
-										iNearestBar = iPt;
-										nearestBar = curve;
-									}
-								}
-								else if ( xVal >= xAxis._scale._min && xVal <= xAxis._scale._max &&
-											yVal >= yMinAct && yVal <= yMaxAct )
-								{
-									if ( curve is LineItem && _lineType == LineType.Stack )
-									{
-										double zVal;
-										valueHandler.GetValues( curve, iPt, out xVal, out zVal, out yVal );
-									}
-
-									distX = ( xVal - xAct ) * xPixPerUnit;
-									distY = ( yVal - yAct ) * yPixPerUnitAct;
-									dist = distX * distX + distY * distY;
-
-									if ( dist >= minDist )
-										continue;
-
-									minDist = dist;
-									iNearest = iPt;
-									nearestCurve = curve;
-								}
-
-							}
-						}
-
-						if ( curve.IsBar )
-							iBar++;
-					}
-				}
-			}
-
-			if ( nearestCurve is LineItem )
-			{
-				float halfSymbol = (float)( ( (LineItem)nearestCurve ).Symbol.Size *
-					CalcScaleFactor() / 2 );
-				minDist -= halfSymbol * halfSymbol;
-				if ( minDist < 0 )
-					minDist = 0;
-			}
-
-			if ( minDist >= tolSquared && nearestBar != null )
-			{
-				// if no point met the tolerance, but a bar was found, use it
-				nearestCurve = nearestBar;
-				iNearest = iNearestBar;
-				return true;
-			}
-			else if ( minDist < tolSquared )
-			{
-				// Did we find a close point, and is it within the tolerance?
-				// (minDist is the square of the distance in pixel units)
-				return true;
-			}
-			else  // otherwise, no valid point found
-				return false;
-		}
-
-		/// <summary>
-		/// Search through the <see cref="GraphObjList" /> and <see cref="CurveList" /> for
-		/// items that contain active <see cref="Link" /> objects.
-		/// </summary>
-		/// <param name="mousePt">The mouse location where the click occurred</param>
-		/// <param name="g">An appropriate <see cref="Graphics" /> instance</param>
-		/// <param name="scaleFactor">The current scaling factor for drawing operations.</param>
-		/// <param name="source">The clickable object that was found.  Typically a type of
-		/// <see cref="GraphObj" /> or a type of <see cref="CurveItem" />.</param>
-		/// <param name="link">The <see cref="Link" /> instance that is contained within
-		/// the <see paramref="source" /> object.</param>
-		/// <param name="index">An index value, indicating which point was clicked for
-		/// <see cref="CurveItem" /> type objects.</param>
-		/// <returns>returns true if a clickable link was found under the
-		/// <see paramref="mousePt" />, or false otherwise.
-		/// </returns>
-		public bool FindLinkableObject( PointF mousePt, Graphics g, float scaleFactor,
-				out object source, out Link link, out int index )
-		{
-			index = -1;
-
-			// First look for graph objects that lie in front of the data points
-			foreach ( GraphObj graphObj in _graphObjList )
-			{
-				link = graphObj._link;
-				bool inFront = graphObj.IsInFrontOfData;
-
-				if ( link.IsActive )
-				{
-					if ( graphObj.PointInBox( mousePt, this, g, scaleFactor ) )
-					{
-						source = graphObj;
-						return true;
-					}
-				}
-			}
-
-			// Second, look at the curve data points
-			foreach ( CurveItem curve in _curveList )
-			{
-				link = curve._link;
-
-				if ( link.IsActive )
-				{
-					CurveItem nearestCurve;
-
-					if ( FindNearestPoint( mousePt, curve, out nearestCurve, out index ) )
-					{
-						source = curve;
-						return true;
-					}
-				}
-			}
-
-			// Third, look for graph objects that lie behind the data points
-			foreach ( GraphObj graphObj in _graphObjList )
-			{
-				link = graphObj._link;
-				bool inFront = graphObj.IsInFrontOfData;
-
-				if ( link.IsActive )
-				{
-					if ( graphObj.PointInBox( mousePt, this, g, scaleFactor ) )
-					{
-						source = graphObj;
-						return true;
-					}
-				}
-			}
-
-			source = null;
-			link = null;
-			index = -1;
-			return false;
-
-		}
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Find any objects that exist within the specified (screen) rectangle.
-		/// This method will search through all of the graph objects, such as
-		/// <see cref="Axis"/>, <see cref="Legend"/>, <see cref="PaneBase.Title"/>,
-		/// <see cref="GraphObj"/>, and <see cref="CurveItem"/>.
-		/// and see if the objects' bounding boxes are within the specified (screen) rectangle
-		/// This method returns true if any are found.
-		/// </summary>
-		public bool FindContainedObjects( RectangleF rectF, Graphics g,
-			 out CurveList containedObjs )
-		{
-			containedObjs = new CurveList();
-
-			foreach ( CurveItem ci in this.CurveList )
-			{
-				for ( int i = 0; i < ci.Points.Count; i++ )
-				{
-					if ( ci.Points[i].X > rectF.Left &&
-						 ci.Points[i].X < rectF.Right &&
-						 ci.Points[i].Y > rectF.Bottom &&
-						 ci.Points[i].Y < rectF.Top )
-					{
-						containedObjs.Add( ci );
-					}
-				}
-			}
-			return ( containedObjs.Count > 0 );
-		}
-
-	#endregion
-
-	}
-}
-
diff --git a/BDInfo/ZedGraph/HSBColor.cs b/BDInfo/ZedGraph/HSBColor.cs
deleted file mode 100644
index 4c8c1d2ac2..0000000000
--- a/BDInfo/ZedGraph/HSBColor.cs
+++ /dev/null
@@ -1,225 +0,0 @@
-using System;
-using System.Text;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Hue-Saturation-Brightness Color class to store a color value, and to manage conversions
-	/// to and from RGB colors in the <see cref="Color" /> struct.
-	/// </summary>
-	/// <remarks>
-	/// This class is based on code from http://www.cs.rit.edu/~ncs/color/ by Eugene Vishnevsky.
-	/// This struct stores the hue, saturation, brightness, and alpha values internally as
-	/// <see cref="byte" /> values from 0 to 255.  The hue represents a fraction of the 360 degrees
-	/// of color space available. The saturation is the color intensity, where 0 represents gray scale
-	/// and 255 is the most colored.  For the brightness, 0 represents black and 255
-	/// represents white.
-	/// </remarks>
-	[Serializable]
-	public struct HSBColor
-	{
-		/// <summary>
-		/// The color hue value, ranging from 0 to 255.
-		/// </summary>
-		/// <remarks>
-		/// This property is actually a rescaling of the 360 degrees on the color wheel to 255
-		/// possible values.  Therefore, every 42.5 units is a new sector, with the following
-		/// convention:  red=0, yellow=42.5, green=85, cyan=127.5, blue=170, magenta=212.5
-		/// </remarks>
-		public byte H;
-		/// <summary>
-		/// The color saturation (intensity) value, ranging from 0 (gray scale) to 255 (most colored).
-		/// </summary>
-		public byte S;
-		/// <summary>
-		/// The brightness value, ranging from 0 (black) to 255 (white).
-		/// </summary>
-		public byte B;
-		/// <summary>
-		/// The alpha value (opacity), ranging from 0 (transparent) to 255 (opaque).
-		/// </summary>
-		public byte A;
-
-		/// <summary>
-		/// Constructor to load an <see cref="HSBColor" /> struct from hue, saturation and
-		/// brightness values
-		/// </summary>
-		/// <param name="h">The color hue value, ranging from 0 to 255</param>
-		/// <param name="s">The color saturation (intensity) value, ranging from 0 (gray scale)
-		/// to 255 (most colored)</param>
-		/// <param name="b">The brightness value, ranging from 0 (black) to 255 (white)</param>
-		public HSBColor( int h, int s, int b )
-		{
-			this.H = (byte)h;
-			this.S = (byte)s;
-			this.B = (byte)b;
-			this.A = 255;
-		}
-
-		/// <summary>
-		/// Constructor to load an <see cref="HSBColor" /> struct from hue, saturation,
-		/// brightness, and alpha values
-		/// </summary>
-		/// <param name="h">The color hue value, ranging from 0 to 255</param>
-		/// <param name="s">The color saturation (intensity) value, ranging from 0 (gray scale)
-		/// to 255 (most colored)</param>
-		/// <param name="b">The brightness value, ranging from 0 (black) to 255 (white)</param>
-		/// <param name="a">The alpha value (opacity), ranging from 0 (transparent) to
-		/// 255 (opaque)</param>
-		public HSBColor( int a, int h, int s, int b )
-			: this( h, s, b )
-		{
-			this.A = (byte)a;
-		}
-
-		/// <summary>
-		/// Constructor to load an <see cref="HSBColor" /> struct from a system
-		/// <see cref="Color" /> struct.
-		/// </summary>
-		/// <param name="color">An rgb <see cref="Color" /> struct containing the equivalent
-		/// color you want to generate</param>
-		public HSBColor( Color color )
-		{
-			this = FromRGB( color );
-		}
-
-
-		/// <summary>
-		/// Implicit conversion operator to convert directly from an <see cref="HSBColor" /> to
-		/// a <see cref="Color" /> struct.
-		/// </summary>
-		/// <param name="hsbColor">The <see cref="HSBColor" /> struct to be converted</param>
-		/// <returns>An equivalent <see cref="Color" /> struct that can be used in the GDI+
-		/// graphics library</returns>
-		public static implicit operator Color( HSBColor hsbColor )
-		{
-			return ToRGB( hsbColor );
-		}
-
-		/// <summary>
-		/// Convert an <see cref="HSBColor" /> value to an equivalent <see cref="Color" /> value.
-		/// </summary>
-		/// <remarks>
-		/// This method is based on code from http://www.cs.rit.edu/~ncs/color/ by Eugene Vishnevsky.
-		/// </remarks>
-		/// <param name="hsbColor">The <see cref="HSBColor" /> struct to be converted</param>
-		/// <returns>An equivalent <see cref="Color" /> struct, compatible with the GDI+ library</returns>
-		public static Color ToRGB( HSBColor hsbColor )
-		{
-			Color rgbColor = Color.Black;
-
-			// Determine which sector of the color wheel contains this hue
-			// hsbColor.H ranges from 0 to 255, and there are 6 sectors, so 42.5 per sector
-			int sector = (int) Math.Floor( (double) hsbColor.H / 42.5 );
-			// Calculate where the hue lies within the sector for interpolation purpose
-			double fraction = (double) hsbColor.H / 42.5 - (double) sector;
-
-			double sFrac = (double) hsbColor.S / 255.0;
-			byte p = (byte) (( (double) hsbColor.B * ( 1.0 - sFrac ) ) + 0.5);
-			byte q = (byte) (( (double) hsbColor.B * ( 1.0 - sFrac * fraction ) ) + 0.5);
-			byte t = (byte) (( (double) hsbColor.B * ( 1.0 - sFrac * ( 1.0 - fraction ) ) ) + 0.5);
-
-
-			switch( sector )
-			{
-				case 0:			// red - yellow
-					rgbColor = Color.FromArgb( hsbColor.A, hsbColor.B, t, p );
-					break;
-				case 1:			// yellow - green
-					rgbColor = Color.FromArgb( hsbColor.A, q, hsbColor.B, p );
-					break;
-				case 2:			// green - cyan
-					rgbColor = Color.FromArgb( hsbColor.A, p, hsbColor.B, t );
-					break;
-				case 3:			// cyan - blue
-					rgbColor = Color.FromArgb( hsbColor.A, p, q, hsbColor.B );
-					break;
-				case 4:			// blue - magenta
-					rgbColor = Color.FromArgb( hsbColor.A, t, p, hsbColor.B );
-					break;
-				case 5:
-				default:		// magenta - red
-					rgbColor = Color.FromArgb( hsbColor.A, hsbColor.B, p, q );
-					break;
-			}
-
-			return rgbColor;
-		}
-
-		/// <summary>
-		/// Convert this <see cref="HSBColor" /> value to an equivalent <see cref="Color" /> value.
-		/// </summary>
-		/// <remarks>
-		/// This method is based on code from http://www.cs.rit.edu/~ncs/color/ by Eugene Vishnevsky.
-		/// </remarks>
-		/// <returns>An equivalent <see cref="Color" /> struct, compatible with the GDI+ library</returns>
-		public Color ToRGB()
-		{
-			return ToRGB( this );
-		}
-			
-		/// <summary>
-		/// Convert a <see cref="Color" /> value to an equivalent <see cref="HSBColor" /> value.
-		/// </summary>
-		/// <remarks>
-		/// This method is based on code from http://www.cs.rit.edu/~ncs/color/ by Eugene Vishnevsky.
-		/// </remarks>
-		/// <returns>An equivalent <see cref="HSBColor" /> struct</returns>
-		public HSBColor FromRGB()
-		{
-			return FromRGB( this );
-		}
-
-		/// <summary>
-		/// Convert a <see cref="Color" /> value to an equivalent <see cref="HSBColor" /> value.
-		/// </summary>
-		/// <remarks>
-		/// This method is based on code from http://www.cs.rit.edu/~ncs/color/ by Eugene Vishnevsky.
-		/// </remarks>
-		/// <param name="rgbColor">The <see cref="Color" /> struct to be converted</param>
-		/// <returns>An equivalent <see cref="HSBColor" /> struct</returns>
-		public static HSBColor FromRGB( Color rgbColor )
-		{
-			double r = (double) rgbColor.R / 255.0;
-			double g = (double) rgbColor.G / 255.0;
-			double b = (double) rgbColor.B / 255.0;
-
-			double min = Math.Min( Math.Min( r, g ), b );
-			double max = Math.Max( Math.Max( r, g ), b );
-
-			HSBColor hsbColor = new HSBColor( rgbColor.A, 0, 0, 0 );
-
-			hsbColor.B = (byte) ( max * 255.0 + 0.5 );
-
-			double delta = max - min;
-
-			if ( max != 0.0 )
-			{
-				hsbColor.S = (byte) ( delta / max * 255.0 + 0.5 );
-			}
-			else
-			{
-				hsbColor.S = 0;
-				hsbColor.H = 0;
-				return hsbColor;
-			}
-
-			double h;
-			if ( r == max )
-				h = ( g - b ) / delta;		// between yellow & magenta
-			else if ( g == max )
-				h = 2 + ( b - r ) / delta;	// between cyan & yellow
-			else
-				h = 4 + ( r - g ) / delta;	// between magenta & cyan
-
-			hsbColor.H = (byte) ( h * 42.5 );	
-			if ( hsbColor.H < 0 )
-				hsbColor.H += 255;
-
-			return hsbColor;
-		}
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/HiLowBar.cs b/BDInfo/ZedGraph/HiLowBar.cs
deleted file mode 100644
index 081a5acaef..0000000000
--- a/BDInfo/ZedGraph/HiLowBar.cs
+++ /dev/null
@@ -1,378 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class handles the drawing of the curve <see cref="HiLowBar"/> objects.
-	/// The Hi-Low Bars are the "floating" bars that have a lower and upper value and
-	/// appear at each defined point.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.18 $ $Date: 2007/10/26 08:19:49 $ </version>
-	[Serializable]
-	public class HiLowBar : Bar, ICloneable, ISerializable
-	{
-
-	#region Fields
-		/// <summary>
-		/// Private field that stores the size (width) of this
-        /// <see cref="HiLowBar"/> in points (1/72 inch).  Use the public
-        /// property <see cref="Size"/> to access this value.
-		/// </summary>
-		private float		_size;
-
-		/// <summary>
-		/// Private field that determines whether the bar width will be based on
-		/// the <see cref="Size"/> value, or it will be based on available
-		/// space similar to <see cref="BarItem"/> objects.  Use the public property
-		/// <see cref="IsAutoSize"/> to access this value.
-		/// </summary>
-		private bool _isAutoSize;
-
-		/// <summary>
-		/// The result of the autosize calculation, which is the size of the bars in
-		/// user scale units.  This is converted to pixels at draw time.
-		/// </summary>
-		internal double _userScaleSize = 1.0;
-
-	#endregion
-
-	#region Default
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ZedGraph.HiLowBar"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			// Default HiLowBar properties
-			/// <summary>
-			/// The default size (width) for the bars (<see cref="HiLowBar.Size"/> property),
-			/// in units of points.
-			/// </summary>
-			public static float Size = 7;
-
-			/// <summary>
-			/// Default value for the <see cref="HiLowBar.IsAutoSize" /> property.
-			/// </summary>
-			public static bool IsAutoSize = true;
-		}
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Default constructor that sets all <see cref="HiLowBar"/> properties to default
-		/// values as defined in the <see cref="Bar.Default"/> class.
-		/// </summary>
-		public HiLowBar() : this( Color.Empty )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the 
-		/// <see cref="Color"/> as specified, and the remaining
-		/// <see cref="HiLowBar"/> properties to default
-		/// values as defined in the <see cref="Bar.Default"/> class.
-		/// The specified color is only applied to the
-		/// <see cref="ZedGraph.Fill.Color"/>, and the <see cref="ZedGraph.LineBase.Color"/>
-		/// will be defaulted.
-		/// </summary>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the <see cref="ZedGraph.Fill.Color"/>
-		/// of the Bar.
-		/// </param>
-		public HiLowBar( Color color ) : this( color, Default.Size )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the 
-		/// <see cref="Color"/> and <see cref="Size"/> as specified, and the remaining
-		/// <see cref="HiLowBar"/> properties to default
-		/// values as defined in the <see cref="Bar.Default"/> class.
-		/// The specified color is only applied to the
-		/// <see cref="ZedGraph.Fill.Color"/>, and the <see cref="ZedGraph.LineBase.Color"/>
-		/// will be defaulted.
-		/// </summary>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the <see cref="ZedGraph.Fill.Color"/>
-		/// of the Bar.
-		/// </param>
-		/// <param name="size">The size (width) of the <see cref="HiLowBar"/>'s, in points
-		/// (1/72nd inch)</param>
-		public HiLowBar( Color color, float size ) : base( color )
-		{
-			_size = size;
-			_isAutoSize = Default.IsAutoSize;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="HiLowBar"/> object from which to copy</param>
-		public HiLowBar( HiLowBar rhs ) : base( rhs )
-		{
-			_size = rhs._size;
-			_isAutoSize = rhs._isAutoSize;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		new public HiLowBar Clone()
-		{
-			return new HiLowBar( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected HiLowBar( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_size = info.GetSingle( "size" );
-			_isAutoSize = info.GetBoolean( "isAutoSize" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "size", _size );
-			info.AddValue( "isAutoSize", _isAutoSize );
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets or sets the size of the <see cref="HiLowBar"/>
-		/// </summary>
-		/// <remarks>The size of the bars can be set by this value, which
-		/// is then scaled according to the scaleFactor (see
-		/// <see cref="PaneBase.CalcScaleFactor"/>).  Alternatively,
-		/// if <see cref="IsAutoSize"/> is true, the bar width will
-		/// be set according to the maximum available cluster width less
-		/// the cluster gap (see <see cref="BarSettings.GetClusterWidth"/>
-		/// and <see cref="BarSettings.MinClusterGap"/>).  That is, if
-		/// <see cref="IsAutoSize"/> is true, then the value of
-		/// <see cref="Size"/> will be ignored.  If you modify the value of Size,
-		/// then <see cref="IsAutoSize" /> will be automatically set to false.
-		/// </remarks>
-      /// <value>Size in points (1/72 inch)</value>
-      /// <seealso cref="Default.Size"/>
-		public float Size
-		{
-			get { return _size; }
-			set { _size = value; _isAutoSize = false; }
-		}
-
-		/// <summary>
-		/// Determines whether the bar width will be based on
-		/// the <see cref="Size"/> value, or it will be based on available
-		/// space similar to <see cref="BarItem"/> objects.
-		/// </summary>
-		/// <remarks>If true, then the value of <see cref="Size"/> is ignored. 
-		/// If this value is true, then <see cref="BarSettings.MinClusterGap"/> will be used to
-		/// determine the total space between each bar.  If the base axis is non-ordinal, then
-		/// <see cref="BarSettings.ClusterScaleWidth" /> will be active.  In this case, you may
-		/// want to make sure that <see cref="BarSettings.ClusterScaleWidthAuto" /> is true.
-		/// </remarks>
-		public bool IsAutoSize
-		{
-			get { return _isAutoSize; }
-			set { _isAutoSize = value; }
-		}
-	#endregion
-
-	#region Methods
-		/*
-		/// <summary>
-		/// Protected internal routine that draws the specified single bar (an individual "point")
-		/// of this series to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> object representing the
-		/// <see cref="Bar"/>'s to be drawn.</param>
-		/// <param name="index">
-		/// The zero-based index number for the single bar to be drawn.
-		/// </param>
-		/// <param name="pos">
-		/// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.)
-		/// in the cluster of bars.
-		/// </param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="Bar"/></param>
-		/// <param name="barWidth">
-		/// The width of each bar, in pixels.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override protected void DrawSingleBar( Graphics g, GraphPane pane,
-							CurveItem curve,
-							int index, int pos, Axis baseAxis, Axis valueAxis,
-							float barWidth, float scaleFactor )
-		{
-			//float	scaledSize = GetBarWidth( pane, baseAxis, scaleFactor );
-
-			// pixBase = pixel value for the bar center on the base axis
-			// pixValue = pixel value for the bar top on the value axis
-			// pixLow = pixel value for the bar bottom on the value axis
-			float pixBase, pixHiVal, pixLowVal;
-
-			// curBase = the scale value on the base axis of the current bar
-			// curValue = the scale value on the value axis of the current bar
-
-			double curBase, curLowVal, curHiVal;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			valueHandler.GetValues( curve, index, out curBase,
-					out curLowVal, out curHiVal );
-
-			barWidth = GetBarWidth( pane, baseAxis, scaleFactor );
-
-			// curLow = the scale value on the value axis for the bottom of the current bar
-			// Get a "low" value for the bottom of the bar and verify validity
-
-			if (	curLowVal == PointPair.Missing ||
-					System.Double.IsNaN( curLowVal ) ||
-					System.Double.IsInfinity( curLowVal ) )
-				curLowVal = 0;
-
-			// Any value set to double max is invalid and should be skipped
-			// This is used for calculated values that are out of range, divide
-			//   by zero, etc.
-			// Also, any value <= zero on a log scale is invalid
-
-			if ( !curve.Points[index].IsInvalid )
-			{
-				// calculate a pixel value for the top of the bar on value axis
-				pixHiVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curHiVal );
-				// calculate a pixel value for the center of the bar on the base axis
-				pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curBase );
-
-				pixLowVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curLowVal );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - barWidth / 2.0F;
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F +
-								pos * ( barWidth + barGap );
-
-				// Draw the bar
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					this.Draw( g, pane, pixSide, pixSide + barWidth, pixLowVal,
-								pixHiVal, scaleFactor, true, curve.IsSelected,
-								curve.Points[index] );
-				else
-					this.Draw( g, pane, pixLowVal, pixHiVal, pixSide, pixSide + barWidth,
-								scaleFactor, true, curve.IsSelected,
-								curve.Points[index] );
-		   }
-	   }
-		*/
-
-		/// <summary>
-		/// Returns the width of the bar, in pixels, based on the settings for
-		/// <see cref="Size"/> and <see cref="IsAutoSize"/>.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> object that
-		/// represents the bar base (independent axis).</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The width of each bar, in pixel units</returns>
-		public float GetBarWidth( GraphPane pane, Axis baseAxis, float scaleFactor )
-		{
-			float width;
-
-			if ( _isAutoSize )
-				width = baseAxis._scale.GetClusterWidth( _userScaleSize ) /
-								( 1.0F + pane._barSettings.MinClusterGap );
-			else
-				width = (float) ( _size * scaleFactor );
-
-			// use integral size
-			return (int)( width + 0.5f );
-		}
-		
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/HiLowBarItem.cs b/BDInfo/ZedGraph/HiLowBarItem.cs
deleted file mode 100644
index 50e2ea20fa..0000000000
--- a/BDInfo/ZedGraph/HiLowBarItem.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates an "High-Low" Bar curve type that displays a bar in which both
-	/// the bottom and the top of the bar are set by data valuesfrom the
-	/// <see cref="PointPair"/> struct.
-	/// </summary>
-	/// <remarks>The <see cref="HiLowBarItem"/> type is intended for displaying
-	/// bars that cover a band of data, such as a confidence interval, "waterfall"
-	/// chart, etc.  The position of each bar is set
-	/// according to the <see cref="PointPair"/> values.  The independent axis
-	/// is assigned with <see cref="BarSettings.Base"/>, and is a
-	/// <see cref="BarBase"/> enum type.  If <see cref="BarSettings.Base"/>
-	/// is set to <see cref="ZedGraph.BarBase.Y"/> or <see cref="ZedGraph.BarBase.Y2"/>, then
-	/// the bars will actually be horizontal, since the X axis becomes the
-	/// value axis and the Y or Y2 axis becomes the independent axis.</remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.18 $ $Date: 2007/11/03 04:41:28 $ </version>
-	[Serializable]
-	public class HiLowBarItem : BarItem, ICloneable, ISerializable
-	{
-
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="HiLowBarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="baseVal">An array of double precision values that define the
-		/// base value (the bottom) of the bars for this curve.
-		/// </param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="ZedGraph.Bar.Fill"/> and <see cref="ZedGraph.Bar.Border"/> properties.
-		/// </param>
-		public HiLowBarItem( string label, double[] x, double[] y, double[] baseVal, Color color ) :
-			this( label, new PointPairList( x, y, baseVal ), color )
-		{
-		}
-		
-		/// <summary>
-		/// Create a new <see cref="HiLowBarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value trio's that define
-		/// the X, Y, and lower dependent values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="ZedGraph.Bar.Fill"/> and <see cref="ZedGraph.Bar.Border"/> properties.
-		/// </param>
-		public HiLowBarItem( string label, IPointList points, Color color )
-			: base( label, points, color )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="HiLowBarItem"/> object from which to copy</param>
-		public HiLowBarItem( HiLowBarItem rhs ) : base( rhs )
-		{
-			_bar = rhs._bar.Clone(); // new HiLowBar( rhs.Bar );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		new public HiLowBarItem Clone()
-		{
-			return new HiLowBarItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected HiLowBarItem( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/IPointList.cs b/BDInfo/ZedGraph/IPointList.cs
deleted file mode 100644
index 8f59c54883..0000000000
--- a/BDInfo/ZedGraph/IPointList.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-//============================================================================
-//IPointList interface
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-using System;
-using System.Text;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An interface to a collection class containing data
-	/// that define the set of points to be displayed on the curve.
-	/// </summary>
-	/// <remarks>
-	/// This interface is designed to allow customized data abstraction.  The default data
-	/// collection class is <see cref="PointPairList" />, however, you can define your own
-	/// data collection class using the <see cref="IPointList" /> interface.
-	/// </remarks>
-	/// <seealso cref="PointPairList" />
-	/// <seealso cref="BasicArrayPointList" />
-	/// 
-	/// <author> John Champion</author>
-	/// <version> $Revision: 1.6 $ $Date: 2007/11/11 07:29:43 $ </version>
-	public interface IPointList : ICloneable
-	{
-		/// <summary>
-		/// Indexer to access a data point by its ordinal position in the collection.
-		/// </summary>
-		/// <remarks>
-		/// This is the standard interface that ZedGraph uses to access the data.  Although
-		/// you must pass a <see cref="PointPair" /> here, your internal data storage format
-		/// can be anything.
-		/// </remarks>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// data point to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object instance.</value>
-		PointPair this[ int index ]  { get; }
-		/// <summary>
-		/// Gets the number of points available in the list.
-		/// </summary>
-		int Count { get; }
-	}
-}
diff --git a/BDInfo/ZedGraph/IPointListEdit.cs b/BDInfo/ZedGraph/IPointListEdit.cs
deleted file mode 100644
index f1d629bb55..0000000000
--- a/BDInfo/ZedGraph/IPointListEdit.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-//============================================================================
-//IPointListEdit interface
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-using System;
-using System.Text;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An interface to a collection class containing data
-	/// that define the set of points to be displayed on the curve.
-	/// </summary>
-	/// <remarks>
-	/// This interface is designed to allow customized data abstraction.  The default data
-	/// collection class is <see cref="PointPairList" />, however, you can define your own
-	/// data collection class using the <see cref="IPointList" /> interface.  This
-	/// <see cref="IPointListEdit" /> interface adds the ability to remove and add points
-	/// to the list, and so is used by the <see cref="CurveItem" /> class for the
-	/// <see cref="CurveItem.AddPoint(double,double)" />, <see cref="CurveItem.RemovePoint" />, and
-	/// <see cref="CurveItem.Clear" /> methods.
-	/// </remarks>
-	/// <seealso cref="PointPairList" />
-	/// <seealso cref="BasicArrayPointList" />
-	/// <seealso cref="IPointList" />
-	/// <seealso cref="FilteredPointList" />
-	/// 
-	/// <author> John Champion</author>
-	/// <version> $Revision: 3.6 $ $Date: 2006/10/19 04:40:14 $ </version>
-	public interface IPointListEdit : IPointList
-	{
-		/// <summary>
-		/// Indexer to access a data point by its ordinal position in the collection.
-		/// </summary>
-		/// <remarks>
-		/// This is the standard interface that ZedGraph uses to access the data.  Although
-		/// you must pass a <see cref="PointPair" /> here, your internal data storage format
-		/// can be anything.
-		/// </remarks>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// data point to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object instance.</value>
-		new PointPair this[int index] { get; set; }
-
-		/// <summary>
-		/// Appends a point to the end of the list.  The data are passed in as a <see cref="PointPair" />
-		/// object.
-		/// </summary>
-		/// <param name="point">The <see cref="PointPair" /> object containing the data to be added.</param>
-		void Add( PointPair point );
-
-		/// <summary>
-		/// Appends a point to the end of the list.  The data are passed in as two <see cref="Double" />
-		/// types.
-		/// </summary>
-		/// <param name="x">The <see cref="Double" /> value containing the X data to be added.</param>
-		/// <param name="y">The <see cref="Double" /> value containing the Y data to be added.</param>
-		/// <returns>The ordinal position (zero-based), at which the new point was added.</returns>
-		void Add( double x, double y );
-
-		/// <summary>
-		/// Removes a single data point from the list at the specified ordinal location
-		/// (zero based).
-		/// </summary>
-		void RemoveAt( int index );
-
-		/// <summary>
-		/// Clears all data points from the list.  After calling this method,
-		/// <see cref="IPointList.Count" /> will be zero.
-		/// </summary>
-		void Clear();
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ImageObj.cs b/BDInfo/ZedGraph/ImageObj.cs
deleted file mode 100644
index 217f6ce8d3..0000000000
--- a/BDInfo/ZedGraph/ImageObj.cs
+++ /dev/null
@@ -1,342 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents an image object on the graph.  A list of
-	/// <see cref="GraphObj"/> objects is maintained by the <see cref="GraphObjList"/>
-	/// collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.2 $ $Date: 2006/09/09 17:32:01 $ </version>
-	[Serializable]
-	public class ImageObj : GraphObj, ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores the image.  Use the public property <see cref="Image"/>
-		/// to access this value.
-		/// </summary>
-		private Image		_image;
-		/// <summary>
-		/// Private field that determines if the image will be scaled to the output rectangle.
-		/// </summary>
-		/// <value>true to scale the image, false to draw the image unscaled, but clipped
-		/// to the destination rectangle</value>
-		private bool		_isScaled;
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ImageObj"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			// Default text item properties
-			/// <summary>
-			/// Default value for the <see cref="ImageObj"/>
-			/// <see cref="ImageObj.IsScaled"/> property.
-			/// </summary>
-			public static bool IsScaled = true;
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// The <see cref="System.Drawing.Image"/> object.
-		/// </summary>
-        /// <value> A <see cref="System.Drawing.Image"/> class reference. </value>
-		public Image Image
-		{
-			get { return _image; }
-			set { _image = value; }
-		}
-		/// <summary>
-		/// Gets or sets a property that determines if the image will be scaled to the
-		/// output rectangle (see <see cref="Location"/>).
-		/// </summary>
-		/// <value>true to scale the image, false to draw the image unscaled, but clipped
-		/// to the destination rectangle</value>
-		public bool IsScaled
-		{
-			get { return _isScaled; }
-			set { _isScaled = value; }
-		}
-	#endregion
-	
-	#region Constructors
-		/// <overloads>Constructors for the <see cref="ImageObj"/> object</overloads>
-		/// <summary>
-		/// A default constructor that places a null <see cref="System.Drawing.Image"/> at a
-		/// default <see cref="RectangleF"/> of (0,0,1,1)
-		/// </summary>
-		public ImageObj() :
-			this( null, 0, 0, 1, 1 )
-		{
-		}
-
-		/// <summary>
-		/// A constructor that allows the <see cref="System.Drawing.Image"/> and
-		/// <see cref="RectangleF"/> location for the
-		/// <see cref="ImageObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="image">A <see cref="System.Drawing.Image"/> class that defines
-		/// the image</param>
-		/// <param name="rect">A <see cref="RectangleF"/> struct that defines the
-		/// image location, specifed in units based on the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public ImageObj( Image image, RectangleF rect ) :
-			this( image, rect.X, rect.Y, rect.Width, rect.Height )
-		{
-		}
-
-		/// <overloads>Constructors for the <see cref="ImageObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the <see cref="System.Drawing.Image"/> and
-		/// <see cref="RectangleF"/> location for the
-		/// <see cref="ImageObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="image">A <see cref="System.Drawing.Image"/> class that defines
-		/// the image</param>
-		/// <param name="rect">A <see cref="RectangleF"/> struct that defines the
-		/// image location, specifed in units based on the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public ImageObj( Image image, RectangleF rect, CoordType coordType,
-					AlignH alignH, AlignV alignV ) :
-				base( rect.X, rect.Y, rect.Width, rect.Height, coordType,
-					alignH, alignV )
-		{
-			_image = image;
-			_isScaled = Default.IsScaled;
-		}
-
-		/// <overloads>Constructors for the <see cref="ImageObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the <see cref="System.Drawing.Image"/> and
-		/// individual <see cref="System.Single"/> coordinate locations for the
-		/// <see cref="ImageObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="image">A <see cref="System.Drawing.Image"/> class that defines
-		/// the image</param>
-		/// <param name="left">The position of the left side of the rectangle that defines the
-		/// <see cref="ImageObj"/> location.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="top">The position of the top side of the rectangle that defines the
-		/// <see cref="ImageObj"/> location.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="width">The width of the rectangle that defines the
-		/// <see cref="ImageObj"/> location.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="height">The height of the rectangle that defines the
-		/// <see cref="ImageObj"/> location.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public ImageObj( Image image, double left, double top,
-					double width, double height ) :
-				base( left, top, width, height )
-		{
-			_image = image;
-			_isScaled = Default.IsScaled;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ImageObj"/> object from which to copy</param>
-		public ImageObj( ImageObj rhs ) : base( rhs )
-		{
-			_image = rhs._image;
-			_isScaled = rhs.IsScaled;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ImageObj Clone()
-		{
-			return new ImageObj( this );
-		}
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected ImageObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_image = (Image) info.GetValue( "image", typeof(Image) );
-			_isScaled = info.GetBoolean( "isScaled" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "image", _image );
-			info.AddValue( "isScaled", _isScaled );
-		}
-	#endregion
-	
-	#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			if ( _image != null )
-			{
-				// Convert the rectangle coordinates from the user coordinate system
-				// to the screen coordinate system
-				RectangleF tmpRect = _location.TransformRect( pane );
-
-				if ( _isScaled )
-					g.DrawImage( _image, tmpRect );
-				else
-				{
-					Region clip = g.Clip;
-					g.SetClip( tmpRect );
-					g.DrawImageUnscaled( _image, Rectangle.Round( tmpRect ) );
-					g.SetClip( clip, CombineMode.Replace );
-					//g.DrawImageUnscaledAndClipped( image, Rectangle.Round( tmpRect ) );
-				}
-			}
-
-		}
-		
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="ArrowObj"/>.  The bounding box is calculated assuming a distance
-		/// of <see cref="GraphPane.Default.NearestTol"/> pixels around the arrow segment.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( _image != null )
-			{
-				if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-					return false;
-
-				// transform the x,y location from the user-defined
-				// coordinate frame to the screen pixel location
-				RectangleF tmpRect = _location.TransformRect( pane );
-
-				return tmpRect.Contains( pt );
-			}
-			else
-				return false;
-		}
-
-		/// <summary>
-		/// Determines the shape type and Coords values for this GraphObj
-		/// </summary>
-		override public void GetCoords( PaneBase pane, Graphics g, float scaleFactor,
-				out string shape, out string coords )
-		{
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			RectangleF pixRect = _location.TransformRect( pane );
-
-			shape = "rect";
-			coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-						pixRect.Left, pixRect.Top, pixRect.Right, pixRect.Bottom );
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/JapaneseCandleStick.cs b/BDInfo/ZedGraph/JapaneseCandleStick.cs
deleted file mode 100644
index 75efbaeedb..0000000000
--- a/BDInfo/ZedGraph/JapaneseCandleStick.cs
+++ /dev/null
@@ -1,485 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class handles the drawing of the curve <see cref="JapaneseCandleStick"/> objects.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.10 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class JapaneseCandleStick : OHLCBar, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field to store the <see cref="Fill" /> class to be used for filling the
-		/// candlestick "bars" when the <see cref="StockPt.Close" /> value is greater than
-		/// the <see cref="StockPt.Open" /> value.  See the public property
-		/// <see cref="RisingFill" /> to access this value.
-		/// </summary>
-		private Fill _risingFill;
-		/// <summary>
-		/// Private field to store the <see cref="Fill" /> class to be used for filling the
-		/// candlestick "bars" when the <see cref="StockPt.Close" /> value is less than
-		/// the <see cref="StockPt.Open" /> value.  See the public property
-		/// <see cref="FallingFill" /> to access this value.
-		/// </summary>
-		private Fill _fallingFill;
-
-		/// <summary>
-		/// Private field to store the <see cref="Border" /> class to be used for drawing the
-		/// candlestick "bars" when the <see cref="StockPt.Close" /> value is greater than
-		/// the <see cref="StockPt.Open" /> value.  See the public property
-		/// <see cref="RisingBorder" /> to access this value.
-		/// </summary>
-		private Border _risingBorder;
-		/// <summary>
-		/// Private field to store the <see cref="Border" /> class to be used for drawing the
-		/// candlestick "bars" when the <see cref="StockPt.Close" /> value is less than
-		/// the <see cref="StockPt.Open" /> value.  See the public property
-		/// <see cref="FallingBorder" /> to access this value.
-		/// </summary>
-		private Border _fallingBorder;
-
-		/// <summary>
-		/// Private field that stores the CandleStick color when the <see cref="StockPt.Close" /> 
-		/// value is less than the <see cref="StockPt.Open" /> value.  Use the public
-		/// property <see cref="FallingColor"/> to access this value.
-		/// </summary>
-		protected Color _fallingColor;
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ZedGraph.JapaneseCandleStick"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			/// <summary>
-			/// The default fillcolor for drawing the rising case CandleSticks
-			/// (<see cref="JapaneseCandleStick.RisingFill"/> property).
-			/// </summary>
-			public static Color RisingColor = Color.White;
-			/// <summary>
-			/// The default fillcolor for drawing the falling case CandleSticks
-			/// (<see cref="JapaneseCandleStick.FallingFill"/> property).
-			/// </summary>
-			public static Color FallingColor = Color.Black;
-
-			/// <summary>
-			/// The default color for the border of the rising CandleSticks
-			/// (<see cref="JapaneseCandleStick.RisingBorder" /> property).
-			/// </summary>
-			public static Color RisingBorder = Color.Black;
-			/// <summary>
-			/// The default color for the border of the falling CandleSticks
-			/// (<see cref="JapaneseCandleStick.FallingBorder" /> property).
-			/// </summary>
-			public static Color FallingBorder = Color.Black;
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="Fill" /> class that is used to fill the candlestick
-		/// "bars" when the <see cref="StockPt.Close" /> value is greater than the
-		/// <see cref="StockPt.Open" /> value.
-		/// </summary>
-		public Fill RisingFill
-		{
-			get { return _risingFill; }
-			set { _risingFill = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="Fill" /> class that is used to fill the candlestick
-		/// "bars" when the <see cref="StockPt.Close" /> value is less than the
-		/// <see cref="StockPt.Open" /> value.
-		/// </summary>
-		public Fill FallingFill
-		{
-			get { return _fallingFill; }
-			set { _fallingFill = value; }
-		}
-
-		/// <summary>
-		/// The <see cref="Border" /> instance to be used for drawing the border frame of
-		/// the candlestick "bars" when the <see cref="StockPt.Close" /> value is greater than the
-		/// <see cref="StockPt.Open" /> value.
-		/// </summary>
-		public Border RisingBorder
-		{
-			get { return _risingBorder; }
-			set { _risingBorder = value; }
-		}
-		/// <summary>
-		/// The <see cref="Border" /> instance to be used for drawing the border frame of
-		/// the candlestick "bars" when the <see cref="StockPt.Close" /> value is less than the
-		/// <see cref="StockPt.Open" /> value.
-		/// </summary>
-		public Border FallingBorder
-		{
-			get { return _fallingBorder; }
-			set { _fallingBorder = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="System.Drawing.Color"/> data for this
-		/// <see cref="JapaneseCandleStick"/> when the value of the candlestick is
-		/// falling.
-		/// </summary>
-		/// <remarks>This property only controls the color of
-		/// the vertical line when the value is falling.  The rising color is controlled
-		/// by the <see cref="LineBase.Color" /> property.
-		/// </remarks>
-		public Color FallingColor
-		{
-			get { return _fallingColor; }
-			set { _fallingColor = value; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="JapaneseCandleStick"/> properties to
-		/// default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public JapaneseCandleStick() : base()
-		{
-			_risingFill = new Fill( Default.RisingColor );
-			_fallingFill = new Fill( Default.FallingColor );
-
-			_risingBorder = new Border( Default.RisingBorder, LineBase.Default.Width );
-			_fallingBorder = new Border( Default.FallingBorder, LineBase.Default.Width );
-
-			_fallingColor = Default.FallingColor;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="JapaneseCandleStick"/> object from which to copy</param>
-		public JapaneseCandleStick( JapaneseCandleStick rhs ) : base( rhs )
-		{
-			_risingFill = rhs._risingFill.Clone();
-			_fallingFill = rhs._fallingFill.Clone();
-
-			_risingBorder = rhs._risingBorder.Clone();
-			_fallingBorder = rhs._fallingBorder.Clone();
-
-			_fallingColor = rhs._fallingColor;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new JapaneseCandleStick Clone()
-		{
-			return new JapaneseCandleStick( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected JapaneseCandleStick( SerializationInfo info, StreamingContext context ) :
-			base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_risingFill = (Fill)info.GetValue( "risingFill", typeof( Fill ) );
-			_fallingFill = (Fill)info.GetValue( "fallingFill", typeof( Fill ) );
-			_risingBorder = (Border)info.GetValue( "risingBorder", typeof( Border ) );
-			_fallingBorder = (Border)info.GetValue( "fallingBorder", typeof( Border ) );
-
-			if ( schema2 >= 11 )
-				_fallingColor = (Color) info.GetValue( "fallingColor", typeof( Color ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "risingFill", _risingFill );
-			info.AddValue( "fallingFill", _fallingFill );
-			info.AddValue( "risingBorder", _risingBorder );
-			info.AddValue( "fallingBorder", _fallingBorder );
-			info.AddValue( "fallingColor", _fallingColor );
-		}
-
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Draw the <see cref="JapaneseCandleStick"/> to the specified <see cref="Graphics"/>
-		/// device at the specified location.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="isXBase">boolean value that indicates if the "base" axis for this
-		/// <see cref="JapaneseCandleStick"/> is the X axis.  True for an <see cref="XAxis"/> base,
-		/// false for a <see cref="YAxis"/> or <see cref="Y2Axis"/> base.</param>
-		/// <param name="pixBase">The independent axis position of the center of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixHigh">The high value position of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixLow">The low value position of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixOpen">The opening value position of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixClose">The closing value position of the candlestick in
-		/// pixel units</param>
-		/// <param name="halfSize">The scaled width of one-half of a bar, in pixels</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.</param>
-		/// <param name="pen">A pen with the <see cref="Color"/> attribute for this
-		/// <see cref="JapaneseCandleStick"/></param>
-		/// <param name="fill">
-		/// The <see cref="Fill" /> instance to be used for filling this
-		/// <see cref="JapaneseCandleStick" />
-		/// </param>
-		/// <param name="border">The <see cref="Border" /> instance to be used for drawing the
-		/// border around the <see cref="JapaneseCandleStick" /> filled box</param>
-		/// <param name="pt">The <see cref="PointPair" /> to be used for determining the
-		/// <see cref="Fill" />, just in case it's a <see cref="FillType.GradientByX" />,
-		/// <see cref="FillType.GradientByY" />, or
-		/// <see cref="FillType.GradientByZ" /> <see cref="FillType" /></param>
-		public void Draw( Graphics g, GraphPane pane, bool isXBase,
-								float pixBase, float pixHigh, float pixLow,
-								float pixOpen, float pixClose, float halfSize,
-								float scaleFactor, Pen pen, Fill fill, Border border, PointPair pt )
-		{
-			//float halfSize = (int) ( _size * scaleFactor / 2.0f + 0.5f );
-
-			if ( pixBase != PointPair.Missing && Math.Abs( pixLow ) < 1000000 &&
-						Math.Abs( pixHigh ) < 1000000)
-			{
-				RectangleF rect;
-				if ( isXBase )
-				{
-					rect = new RectangleF( pixBase - halfSize, Math.Min( pixOpen, pixClose ),
-								halfSize * 2.0f, Math.Abs( pixOpen - pixClose ) );
-
-					g.DrawLine( pen, pixBase, pixHigh, pixBase, pixLow );
-				}
-				else
-				{
-					rect = new RectangleF( Math.Min( pixOpen, pixClose ), pixBase - halfSize,
-								Math.Abs( pixOpen - pixClose ), halfSize * 2.0f );
-
-					g.DrawLine( pen, pixHigh, pixBase, pixLow, pixBase );
-				}
-
-				if ( _isOpenCloseVisible && Math.Abs( pixOpen ) < 1000000 &&
-							Math.Abs( pixClose ) < 1000000 )
-				{
-					if ( rect.Width == 0 )
-						rect.Width = 1;
-					if ( rect.Height == 0 )
-						rect.Height = 1;
-
-					fill.Draw( g, rect, pt );
-					border.Draw( g, pane, scaleFactor, rect );
-				}
-			}
-		}
-
-
-		/// <summary>
-		/// Draw all the <see cref="JapaneseCandleStick"/>'s to the specified <see cref="Graphics"/>
-		/// device as a candlestick at each defined point.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="JapaneseCandleStickItem"/> object representing the
-		/// <see cref="JapaneseCandleStick"/>'s to be drawn.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="JapaneseCandleStick"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="JapaneseCandleStick"/></param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, JapaneseCandleStickItem curve,
-							Axis baseAxis, Axis valueAxis, float scaleFactor )
-		{
-			//ValueHandler valueHandler = new ValueHandler( pane, false );
-
-			float pixBase, pixHigh, pixLow, pixOpen, pixClose;
-
-			if ( curve.Points != null )
-			{
-				//float halfSize = _size * scaleFactor;
-				float halfSize = GetBarWidth( pane, baseAxis, scaleFactor );
-
-				Color tColor = _color;
-				Color tFallingColor = _fallingColor;
-				float tPenWidth = _width;
-				Fill tRisingFill = _risingFill;
-				Fill tFallingFill = _fallingFill;
-				Border tRisingBorder = _risingBorder;
-				Border tFallingBorder = _fallingBorder;
-				if ( curve.IsSelected )
-				{
-					tColor = Selection.Border.Color;
-					tFallingColor = Selection.Border.Color;
-					tPenWidth = Selection.Border.Width;
-					tRisingFill = Selection.Fill;
-					tFallingFill = Selection.Fill;
-					tRisingBorder = Selection.Border;
-					tFallingBorder = Selection.Border;
-
-				}
-
-				using ( Pen risingPen = new Pen(  tColor, tPenWidth ) )
-				using ( Pen fallingPen = new Pen( tFallingColor, tPenWidth ) )
-				{
-					// Loop over each defined point							
-					for ( int i = 0; i < curve.Points.Count; i++ )
-					{
-						PointPair pt = curve.Points[i];
-						double date = pt.X;
-						double high = pt.Y;
-						double low = pt.Z;
-						double open = PointPair.Missing;
-						double close = PointPair.Missing;
-						if ( pt is StockPt )
-						{
-							open = ( pt as StockPt ).Open;
-							close = ( pt as StockPt ).Close;
-						}
-
-						// Any value set to double max is invalid and should be skipped
-						// This is used for calculated values that are out of range, divide
-						//   by zero, etc.
-						// Also, any value <= zero on a log scale is invalid
-
-						if ( !curve.Points[i].IsInvalid3D &&
-								( date > 0 || !baseAxis._scale.IsLog ) &&
-								( ( high > 0 && low > 0 ) || !valueAxis._scale.IsLog ) )
-						{
-							pixBase = (int) ( baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, date ) + 0.5 );
-							//pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, date );
-							pixHigh = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, high );
-							pixLow = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, low );
-							if ( PointPair.IsValueInvalid( open ) )
-								pixOpen = Single.MaxValue;
-							else
-								pixOpen = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, open );
-
-							if ( PointPair.IsValueInvalid( close ) )
-								pixClose = Single.MaxValue;
-							else
-								pixClose = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, close );
-
-							if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-							{
-								using ( Pen tPen = GetPen( pane, scaleFactor, pt ) )
-									Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis,
-										pixBase, pixHigh, pixLow, pixOpen,
-										pixClose, halfSize, scaleFactor,
-										( tPen ),
-										( close > open ? tRisingFill : tFallingFill ),
-										( close > open ? tRisingBorder : tFallingBorder ), pt );
-							}
-							else
-								Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis,
-									pixBase, pixHigh, pixLow, pixOpen,
-									pixClose, halfSize, scaleFactor,
-									( close > open ? risingPen : fallingPen ),
-									( close > open ? tRisingFill : tFallingFill ),
-									( close > open ? tRisingBorder : tFallingBorder ), pt );
-						}
-					}
-				}
-			}
-		}
-
-		#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/JapaneseCandleStickItem.cs b/BDInfo/ZedGraph/JapaneseCandleStickItem.cs
deleted file mode 100644
index bb24b9ea8f..0000000000
--- a/BDInfo/ZedGraph/JapaneseCandleStickItem.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates a Japanese CandleStick curve type that displays a vertical (or horizontal)
-	/// line displaying the range of data values at each sample point, plus a filled bar
-	/// signifying the opening and closing value for the sample.
-	/// </summary>
-	/// <remarks>For this type to work properly, your <see cref="IPointList" /> must contain
-	/// <see cref="StockPt" /> objects, rather than ordinary <see cref="PointPair" /> types.
-	/// This is because the <see cref="OHLCBarItem"/> type actually displays 5 data values
-	/// but the <see cref="PointPair" /> only stores 3 data values.  The <see cref="StockPt" />
-	/// stores <see cref="StockPt.Date" />, <see cref="StockPt.Close" />,
-	/// <see cref="StockPt.Open" />, <see cref="StockPt.High" />, and
-	/// <see cref="StockPt.Low" /> members.
-	/// For a JapaneseCandleStick chart, the range between opening and closing values
-	/// is drawn as a filled bar, with the filled color different
-	/// (<see cref="ZedGraph.JapaneseCandleStick.RisingFill" />) for the case of
-	/// <see cref="StockPt.Close" />
-	/// higher than <see cref="StockPt.Open" />, and
-	/// <see cref="ZedGraph.JapaneseCandleStick.FallingFill" />
-	/// for the reverse.  The width of the bar is controlled
-	/// by the <see cref="ZedGraph.OHLCBar.Size" /> property, which is specified in
-	/// points (1/72nd inch), and scaled according to <see cref="PaneBase.CalcScaleFactor" />.
-	/// The candlesticks are drawn horizontally or vertically depending on the
-	/// value of <see cref="BarSettings.Base"/>, which is a
-	/// <see cref="ZedGraph.BarBase"/> enum type.</remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class JapaneseCandleStickItem : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.OHLCBar"/>
-		/// class defined for this <see cref="OHLCBarItem"/>.  Use the public
-		/// property <see cref="OHLCBar"/> to access this value.
-		/// </summary>
-		/// 
-		private JapaneseCandleStick _stick;
-
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets a reference to the <see cref="JapaneseCandleStick"/> class defined
-		/// for this <see cref="JapaneseCandleStickItem"/>.
-		/// </summary>
-		public JapaneseCandleStick Stick
-		{
-			get { return _stick; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return pane._barSettings.Base == BarBase.X;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <remarks>
-		/// IsZIncluded is true for <see cref="JapaneseCandleStickItem" /> objects, since the Y and Z
-		/// values are defined as the High and Low values for the day.</remarks>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return true;
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Create a new <see cref="OHLCBarItem"/>, specifying only the legend label.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		public JapaneseCandleStickItem( string label )
-			: base( label )
-		{
-			_stick = new JapaneseCandleStick();
-		}
-
-		/// <summary>
-		/// Create a new <see cref="JapaneseCandleStickItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">An <see cref="IPointList"/> of double precision values that define
-		/// the Date, Close, Open, High, and Low values for the curve.  Note that this
-		/// <see cref="IPointList" /> should contain <see cref="StockPt" /> items rather
-		/// than <see cref="PointPair" /> items.
-		/// </param>
-		public JapaneseCandleStickItem( string label, IPointList points )
-			: base( label, points )
-		{
-			_stick = new JapaneseCandleStick();
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="JapaneseCandleStickItem"/> object from which to copy</param>
-		public JapaneseCandleStickItem( JapaneseCandleStickItem rhs )
-			: base( rhs )
-		{
-			_stick = rhs._stick.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public JapaneseCandleStickItem Clone()
-		{
-			return new JapaneseCandleStickItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected JapaneseCandleStickItem( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_stick = (JapaneseCandleStick) info.GetValue( "stick",
-						typeof( JapaneseCandleStick ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "stick", _stick );
-		}
-
-		#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="OHLCBarItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="OHLCBarItem"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor )
-		{
-			if ( _isVisible )
-			{
-				_stick.Draw( g, pane, this, this.BaseAxis( pane ),
-									this.ValueAxis( pane ), scaleFactor );
-			}
-		}
-
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="OHLCBarItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-		/// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect,
-									float scaleFactor )
-		{
-			float pixBase, pixHigh, pixLow, pixOpen, pixClose;
-
-			if ( pane._barSettings.Base == BarBase.X )
-			{
-				pixBase = rect.Left + rect.Width / 2.0F;
-				pixHigh = rect.Top;
-				pixLow = rect.Bottom;
-				pixOpen = pixHigh + rect.Height / 3;
-				pixClose = pixLow - rect.Height / 3;
-			}
-			else
-			{
-				pixBase = rect.Top + rect.Height / 2.0F;
-				pixHigh = rect.Right;
-				pixLow = rect.Left;
-				pixOpen = pixHigh - rect.Width / 3;
-				pixClose = pixLow + rect.Width / 3;
-			}
-
-			Axis baseAxis = BaseAxis( pane );
-			float halfSize = _stick.GetBarWidth( pane, baseAxis, scaleFactor );
-
-			using ( Pen pen = new Pen( _stick.Color, _stick._width ) )
-			{
-				_stick.Draw( g, pane, pane._barSettings.Base == BarBase.X, pixBase, pixHigh,
-									pixLow, pixOpen, pixClose, halfSize, scaleFactor, pen,
-									_stick.RisingFill,
-									_stick.RisingBorder, null );
-			}
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			if ( i < 0 || i >= _points.Count )
-				return false;
-
-			Axis valueAxis = ValueAxis( pane );
-			Axis baseAxis = BaseAxis( pane );
-
-			float halfSize = _stick.Size * pane.CalcScaleFactor();
-
-			PointPair pt = _points[i];
-			double date = pt.X;
-			double high = pt.Y;
-			double low = pt.Z;
-
-			if ( !pt.IsInvalid3D &&
-					( date > 0 || !baseAxis._scale.IsLog ) &&
-					( ( high > 0 && low > 0 ) || !valueAxis._scale.IsLog ) )
-			{
-				float pixBase, pixHigh, pixLow;
-				pixBase = baseAxis.Scale.Transform( _isOverrideOrdinal, i, date );
-				pixHigh = valueAxis.Scale.Transform( _isOverrideOrdinal, i, high );
-				pixLow = valueAxis.Scale.Transform( _isOverrideOrdinal, i, low );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - halfSize;
-
-				// Draw the bar
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixSide, pixLow,
-								pixSide + halfSize * 2, pixHigh );
-				else
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixLow, pixSide,
-								pixHigh, pixSide + halfSize * 2 );
-
-				return true;
-			}
-
-			return false;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Label.cs b/BDInfo/ZedGraph/Label.cs
deleted file mode 100644
index fa4e5aada1..0000000000
--- a/BDInfo/ZedGraph/Label.cs
+++ /dev/null
@@ -1,202 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the data associated with text title and its associated font
-	/// properties
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.2 $ $Date: 2007/03/11 02:08:16 $ </version>
-	[Serializable]
-	public class Label : ICloneable, ISerializable
-	{
-		/// <summary>
-		/// private field that stores the <see cref="string" /> text for this label
-		/// </summary>
-		internal string _text;
-		/// <summary>
-		/// private field that stores the <see cref="FontSpec" /> font properties for this label
-		/// </summary>
-		internal FontSpec _fontSpec;
-		/// <summary>
-		/// private field that determines if this label will be displayed.
-		/// </summary>
-		internal bool _isVisible;
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to build an <see cref="AxisLabel" /> from the text and the
-		/// associated font properties.
-		/// </summary>
-		/// <param name="text">The <see cref="string" /> representing the text to be
-		/// displayed</param>
-		/// <param name="fontFamily">The <see cref="String" /> font family name</param>
-		/// <param name="fontSize">The size of the font in points and scaled according
-		/// to the <see cref="PaneBase.CalcScaleFactor" /> logic.</param>
-		/// <param name="color">The <see cref="Color" /> instance representing the color
-		/// of the font</param>
-		/// <param name="isBold">true for a bold font face</param>
-		/// <param name="isItalic">true for an italic font face</param>
-		/// <param name="isUnderline">true for an underline font face</param>
-		public Label( string text, string fontFamily, float fontSize, Color color, bool isBold,
-			bool isItalic, bool isUnderline )
-		{
-			_text = ( text == null ) ? string.Empty : text;
-
-			_fontSpec = new FontSpec( fontFamily, fontSize, color, isBold, isItalic, isUnderline );
-			_isVisible = true;
-		}
-
-		/// <summary>
-		/// Constructor that builds a <see cref="Label" /> from a text <see cref="string" />
-		/// and a <see cref="FontSpec" /> instance.
-		/// </summary>
-		/// <param name="text"></param>
-		/// <param name="fontSpec"></param>
-		public Label( string text, FontSpec fontSpec )
-		{
-			_text = (text == null) ? string.Empty : text;
-
-			_fontSpec = fontSpec;
-			_isVisible = true;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">the <see cref="Label" /> instance to be copied.</param>
-		public Label( Label rhs )
-		{
-			if (rhs._text != null)
-				_text = (string)rhs._text.Clone();
-			else
-				_text = string.Empty;
-
-			_isVisible = rhs._isVisible;
-			if ( rhs._fontSpec != null )
-				_fontSpec = rhs._fontSpec.Clone();
-			else
-				_fontSpec = null;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Label Clone()
-		{
-			return new Label( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// The <see cref="String" /> text to be displayed
-		/// </summary>
-		public string Text
-		{
-			get { return _text; }
-			set { _text = value; }
-		}
-
-		/// <summary>
-		/// A <see cref="ZedGraph.FontSpec" /> instance representing the font properties
-		/// for the displayed text.
-		/// </summary>
-		public FontSpec FontSpec
-		{
-			get { return _fontSpec; }
-			set { _fontSpec = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a boolean value that determines whether or not this label will be displayed.
-		/// </summary>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Label( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_text = info.GetString( "text" );
-			_isVisible = info.GetBoolean( "isVisible" );
-			_fontSpec = (FontSpec) info.GetValue( "fontSpec", typeof( FontSpec ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "text", _text );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "fontSpec", _fontSpec );
-		}
-	#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Legend.cs b/BDInfo/ZedGraph/Legend.cs
deleted file mode 100644
index 92d23ff421..0000000000
--- a/BDInfo/ZedGraph/Legend.cs
+++ /dev/null
@@ -1,1038 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class encapsulates the chart <see cref="Legend"/> that is displayed
-	/// in the <see cref="GraphPane"/>
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.41 $ $Date: 2007/08/11 19:24:55 $ </version>
-	[Serializable]
-	public class Legend : ICloneable, ISerializable
-	{
-	#region private Fields
-
-		/// <summary> Private field to hold the bounding rectangle around the legend.
-		/// This bounding rectangle varies with the number of legend entries, font sizes,
-		/// etc., and is re-calculated by <see cref="Legend.CalcRect"/> at each redraw.
-		/// Use the public readonly property <see cref="Legend.Rect"/> to access this
-		/// rectangle.
-		/// </summary>
-		private RectangleF _rect;
-		/// <summary>Private field to hold the legend location setting.  This field
-		/// contains the <see cref="LegendPos"/> enum type to specify the area of
-		/// the graph where the legend will be positioned.  Use the public property
-		/// <see cref="LegendPos"/> to access this value.
-		/// </summary>
-		/// <seealso cref="Default.Position"/>
-		private LegendPos _position;
-		/// <summary>
-		/// Private field to enable/disable horizontal stacking of the legend entries.
-		/// If this value is false, then the legend entries will always be a single column.
-		/// Use the public property <see cref="IsHStack"/> to access this value.
-		/// </summary>
-		/// <seealso cref="Default.IsHStack"/>
-		private bool _isHStack;
-		/// <summary>
-		/// Private field to enable/disable drawing of the entire legend.
-		/// If this value is false, then the legend will not be drawn.
-		/// Use the public property <see cref="IsVisible"/> to access this value.
-		/// </summary>
-		private bool _isVisible;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Legend"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Border"/> data for this
-		/// <see cref="Legend"/>.  Use the public property <see cref="Border"/> to
-		/// access this value.
-		/// </summary>
-		private Border _border;
-		/// <summary>
-		/// Private field to maintain the <see cref="FontSpec"/> class that
-		/// maintains font attributes for the entries in this legend.  Use
-		/// the <see cref="FontSpec"/> property to access this class.
-		/// </summary>
-		private FontSpec _fontSpec;
-		/// <summary>
-		/// Private field to maintain the <see cref="Legend"/> location.  This object
-		/// is only applicable if the <see cref="Position"/> property is set to
-		/// <see cref="LegendPos.Float"/>.
-		/// </summary>
-		private Location _location;
-
-		/// <summary>
-		/// Private temporary field to maintain the number of columns (horizontal stacking) to be used
-		/// for drawing the <see cref="Legend"/>.  This value is only valid during a draw operation.
-		/// </summary>
-		private int _hStack;
-		/// <summary>
-		/// Private temporary field to maintain the width of each column in the
-		/// <see cref="Legend"/>.  This value is only valid during a draw operation.
-		/// </summary>
-		private float _legendItemWidth;
-		/// <summary>
-		/// Private temporary field to maintain the height of each row in the
-		/// <see cref="Legend"/>.  This value is only valid during a draw operation.
-		/// </summary>
-		private float _legendItemHeight;
-
-		/// <summary>
-		/// Private field to store the gap between the legend and the chart rectangle.
-		/// </summary>
-		private float _gap;
-
-		// CJBL
-		/// <summary>
-		/// Private field to select output order of legend entries.
-		/// </summary>
-		private bool _isReverse;
-
-		/// <summary>
-		/// Private temporary field to maintain the characteristic "gap" for the legend.
-		/// This is normal the height of the largest font in the legend.
-		/// This value is only valid during a draw operation.
-		/// </summary>
-		private float _tmpSize;
-
-		/// <summary>
-		/// Private field to enable/diable drawing the line and symbol samples in the
-		/// legend.
-		/// </summary>
-		private bool _isShowLegendSymbols;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Legend"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default Legend properties
-			/// <summary>
-			/// The default pen width for the <see cref="Legend"/> border border.
-			/// (<see cref="ZedGraph.LineBase.Width"/> property).  Units are in pixels.
-			/// </summary>
-			public static float BorderWidth = 1;
-			/// <summary>
-			/// The default color for the <see cref="Legend"/> border border.
-			/// (<see cref="ZedGraph.LineBase.Color"/> property). 
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color for the <see cref="Legend"/> background.
-			/// (<see cref="ZedGraph.Fill.Color"/> property).  Use of this
-			/// color depends on the status of the <see cref="ZedGraph.Fill.Type"/>
-			/// property.
-			/// </summary>
-			public static Color FillColor = Color.White;
-			/// <summary>
-			/// The default custom brush for filling in this <see cref="Legend"/>.
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default fill mode for the <see cref="Legend"/> background.
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-			/// <summary>
-			/// The default location for the <see cref="Legend"/> on the graph
-			/// (<see cref="Legend.Location"/> property).  This property is
-			/// defined as a <see cref="LegendPos"/> enumeration.
-			/// </summary>
-			public static LegendPos Position = LegendPos.Top;
-			/// <summary>
-			/// The default border mode for the <see cref="Legend"/>.
-			/// (<see cref="ZedGraph.LineBase.IsVisible"/> property). true
-			/// to draw a border around the <see cref="Legend.Rect"/>,
-			/// false otherwise.
-			/// </summary>
-			public static bool IsBorderVisible = true;
-			/// <summary>
-			/// The default display mode for the <see cref="Legend"/>.
-			/// (<see cref="Legend.IsVisible"/> property). true
-			/// to show the legend,
-			/// false to hide it.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// The default fill mode for the <see cref="Legend"/> background
-			/// (<see cref="ZedGraph.Fill.Type"/> property).
-			/// true to fill-in the background with color,
-			/// false to leave the background transparent.
-			/// </summary>
-			public static bool IsFilled = true;
-			/// <summary>
-			/// The default horizontal stacking mode for the <see cref="Legend"/>
-			/// (<see cref="Legend.IsHStack"/> property).
-			/// true to allow horizontal legend item stacking, false to allow
-			/// only vertical legend orientation.
-			/// </summary>
-			public static bool IsHStack = true;
-
-			/// <summary>
-			/// The default font family for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.Family"/> property).
-			/// </summary>
-			public static string FontFamily = "Arial";
-			/// <summary>
-			/// The default font size for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.Size"/> property).  Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float FontSize = 12;
-			/// <summary>
-			/// The default font color for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.FontColor"/> property).
-			/// </summary>
-			public static Color FontColor = Color.Black;
-			/// <summary>
-			/// The default font bold mode for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.IsBold"/> property). true
-			/// for a bold typeface, false otherwise.
-			/// </summary>
-			public static bool FontBold = false;
-			/// <summary>
-			/// The default font italic mode for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.IsItalic"/> property). true
-			/// for an italic typeface, false otherwise.
-			/// </summary>
-			public static bool FontItalic = false;
-			/// <summary>
-			/// The default font underline mode for the <see cref="Legend"/> entries
-			/// (<see cref="ZedGraph.FontSpec.IsUnderline"/> property). true
-			/// for an underlined typeface, false otherwise.
-			/// </summary>
-			public static bool FontUnderline = false;
-			/// <summary>
-			/// The default color for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FontFillColor = Color.White;
-			/// <summary>
-			/// The default custom brush for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FontFillBrush = null;
-			/// <summary>
-			/// The default fill mode for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FontFillType = FillType.None;
-
-			/// <summary>
-			/// The default gap size between the legend and the <see cref="Chart.Rect" />.
-			/// This is the default value of <see cref="Legend.Gap" />.
-			/// </summary>
-			public static float Gap = 0.5f;
-
-			/// <summary>
-			/// Default value for the <see cref="Legend.IsReverse" /> property.
-			/// </summary>
-			public static bool IsReverse = false;
-
-			/// <summary>
-			/// Default value for the <see cref="Legend.IsShowLegendSymbols" /> property.
-			/// </summary>
-			public static bool IsShowLegendSymbols = true;
-		}
-		#endregion
-
-		#region Properties
-		/// <summary>
-		/// Get the bounding rectangle for the <see cref="Legend"/> in screen coordinates
-		/// </summary>
-		/// <value>A screen rectangle in pixel units</value>
-		public RectangleF Rect
-		{
-			get { return _rect; }
-		}
-		/// <summary>
-		/// Access to the <see cref="ZedGraph.FontSpec"/> class used to render
-		/// the <see cref="Legend"/> entries
-		/// </summary>
-		/// <value>A reference to a <see cref="Legend"/> object</value>
-		/// <seealso cref="Default.FontColor"/>
-		/// <seealso cref="Default.FontBold"/>
-		/// <seealso cref="Default.FontItalic"/>
-		/// <seealso cref="Default.FontUnderline"/>
-		/// <seealso cref="Default.FontFamily"/>
-		/// <seealso cref="Default.FontSize"/>
-		public FontSpec FontSpec
-		{
-			get { return _fontSpec; }
-			set
-			{
-				if ( value == null )
-					throw new ArgumentNullException( "Uninitialized FontSpec in Legend" );
-				_fontSpec = value;
-			}
-		}
-		/// <summary>
-		/// Gets or sets a property that shows or hides the <see cref="Legend"/> entirely
-		/// </summary>
-		/// <value> true to show the <see cref="Legend"/>, false to hide it </value>
-		/// <seealso cref="Default.IsVisible"/>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-		/// <summary>
-		/// The <see cref="Border"/> class used to draw the border border around this <see cref="Legend"/>.
-		/// </summary>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Legend"/> background.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Sets or gets a property that allows the <see cref="Legend"/> items to
-		/// stack horizontally in addition to the vertical stacking
-		/// </summary>
-		/// <value>true to allow horizontal stacking, false otherwise
-		/// </value>
-		/// <seealso cref="Default.IsHStack"/>
-		public bool IsHStack
-		{
-			get { return _isHStack; }
-			set { _isHStack = value; }
-		}
-		/// <summary>
-		/// Sets or gets the location of the <see cref="Legend"/> on the
-		/// <see cref="GraphPane"/> using the <see cref="LegendPos"/> enum type
-		/// </summary>
-		/// <seealso cref="Default.Position"/>
-		public LegendPos Position
-		{
-			get { return _position; }
-			set { _position = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="Location"/> data for the <see cref="Legend"/>.
-		/// This property is only applicable if <see cref="Position"/> is set
-		/// to <see cref="LegendPos.Float"/>.
-		/// </summary>
-		public Location Location
-		{
-			get { return _location; }
-			set { _location = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the gap size between the legend and the <see cref="Chart.Rect" />.
-		/// </summary>
-		/// <remarks>
-		/// This is expressed as a fraction of the largest scaled character height for any
-		/// of the fonts used in the legend.  Each <see cref="CurveItem" /> in the legend can
-		/// optionally have its own <see cref="FontSpec" /> specification.
-		/// </remarks>
-		public float Gap
-		{
-			get { return _gap; }
-			set { _gap = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the legend entries are displayed in normal order
-		/// (matching the order in the <see cref="CurveList" />, or in reverse order.
-		/// </summary>
-		public bool IsReverse
-		{
-			get { return _isReverse; }
-			set { _isReverse = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether the line and symbol keys will be displayed
-		/// in the legend.
-		/// </summary>
-		/// <remarks>
-		/// Note: If this value is set to false (so that only the curve label text is displayed
-		/// with no legend keys), then the color of the font for the legend entry of each curve
-		/// will automatically be set to match the <see cref="CurveItem.Color"/> setting for that curve.
-		/// You can override this behavior by specifying a specific font to be used for each
-		/// individual curve with the <see cref="ZedGraph.Label.FontSpec">CurveItem.Label.FontSpec</see>
-		/// property.
-		/// </remarks>
-		public bool IsShowLegendSymbols
-		{
-			get { return _isShowLegendSymbols; }
-			set { _isShowLegendSymbols = value; }
-		}
-
-		#endregion
-
-		#region Constructors
-		/// <summary>
-		/// Default constructor that sets all <see cref="Legend"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public Legend()
-		{
-			_position = Default.Position;
-			_isHStack = Default.IsHStack;
-			_isVisible = Default.IsVisible;
-			this.Location = new Location( 0, 0, CoordType.PaneFraction );
-
-			_fontSpec = new FontSpec( Default.FontFamily, Default.FontSize,
-				Default.FontColor, Default.FontBold,
-				Default.FontItalic, Default.FontUnderline,
-				Default.FontFillColor, Default.FontFillBrush,
-				Default.FontFillType );
-			_fontSpec.Border.IsVisible = false;
-
-			_border = new Border( Default.IsBorderVisible, Default.BorderColor, Default.BorderWidth );
-			_fill = new Fill( Default.FillColor, Default.FillBrush, Default.FillType );
-
-			_gap = Default.Gap;
-
-			_isReverse = Default.IsReverse;
-
-			_isShowLegendSymbols = Default.IsShowLegendSymbols;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The XAxis object from which to copy</param>
-		public Legend( Legend rhs )
-		{
-			_rect = rhs.Rect;
-			_position = rhs.Position;
-			_isHStack = rhs.IsHStack;
-			_isVisible = rhs.IsVisible;
-
-			_location = rhs.Location;
-			_border = rhs.Border.Clone();
-			_fill = rhs.Fill.Clone();
-
-			_fontSpec = rhs.FontSpec.Clone();
-
-			_gap = rhs._gap;
-
-			_isReverse = rhs._isReverse;
-
-			_isShowLegendSymbols = rhs._isShowLegendSymbols;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Legend Clone()
-		{
-			return new Legend( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 12;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Legend( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_position = (LegendPos)info.GetValue( "position", typeof( LegendPos ) );
-			_isHStack = info.GetBoolean( "isHStack" );
-			_isVisible = info.GetBoolean( "isVisible" );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_fontSpec = (FontSpec)info.GetValue( "fontSpec", typeof( FontSpec ) );
-			_location = (Location)info.GetValue( "location", typeof( Location ) );
-
-			_gap = info.GetSingle( "gap" );
-
-			if ( schema >= 11 )
-				_isReverse = info.GetBoolean( "isReverse" );
-
-			if ( schema >= 12 )
-				_isShowLegendSymbols = info.GetBoolean( "isShowLegendSymbols" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "position", _position );
-			info.AddValue( "isHStack", _isHStack );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "fontSpec", _fontSpec );
-			info.AddValue( "location", _location );
-
-			info.AddValue( "gap", _gap );
-			info.AddValue( "isReverse", _isReverse );
-			info.AddValue( "isShowLegendSymbols", _isShowLegendSymbols );
-		}
-		#endregion
-
-		#region Rendering Methods
-
-		/// <summary>
-		/// Render the <see cref="Legend"/> to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphPane"/> object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// if the legend is not visible, do nothing
-			if ( !_isVisible )
-				return;
-
-			// Fill the background with the specified color if required
-			_fill.Draw( g, _rect );
-
-			PaneList paneList = GetPaneList( pane );
-
-			float halfGap = _tmpSize / 2.0F;
-
-			// Check for bad data values
-			if ( _hStack <= 0 )
-				_hStack = 1;
-			if ( _legendItemWidth <= 0 )
-				_legendItemWidth = 100;
-			if ( _legendItemHeight <= 0 )
-				_legendItemHeight = _tmpSize;
-
-			//float gap = pane.ScaledGap( scaleFactor );
-
-			int iEntry = 0;
-			float x, y;
-
-			// Get a brush for the legend label text
-			using ( SolidBrush brushB = new SolidBrush( Color.Black ) )
-			{
-				foreach ( GraphPane tmpPane in paneList )
-				{
-					// Loop for each curve in the CurveList collection
-					//foreach ( CurveItem curve in tmpPane.CurveList )
-					int count = tmpPane.CurveList.Count;
-					for ( int i = 0; i < count; i++ )
-					{
-						CurveItem curve = tmpPane.CurveList[_isReverse ? count - i - 1 : i];
-
-						if ( curve._label._text != "" && curve._label._isVisible )
-						{
-							// Calculate the x,y (TopLeft) location of the current
-							// curve legend label
-							// assuming:
-							//  charHeight/2 for the left margin, plus legendWidth for each
-							//    horizontal column
-							//  legendHeight is the line spacing, with no extra margin above
-
-							x = _rect.Left + halfGap / 2.0F +
-								( iEntry % _hStack ) * _legendItemWidth;
-							y = _rect.Top + (int)( iEntry / _hStack ) * _legendItemHeight;
-
-							// Draw the legend label for the current curve
-							FontSpec tmpFont = ( curve._label._fontSpec != null ) ?
-										curve._label._fontSpec : this.FontSpec;
-
-							// This is required because, for long labels, the centering can affect the
-							// position in GDI+.
-							tmpFont.StringAlignment = StringAlignment.Near;
-
-							if ( _isShowLegendSymbols )
-							{
-								tmpFont.Draw( g, pane, curve._label._text,
-										x + 2.5F * _tmpSize, y + _legendItemHeight / 2.0F,
-										AlignH.Left, AlignV.Center, scaleFactor );
-
-								RectangleF rect = new RectangleF( x, y + _legendItemHeight / 4.0F,
-									2 * _tmpSize, _legendItemHeight / 2.0F );
-								curve.DrawLegendKey( g, tmpPane, rect, scaleFactor );
-							}
-							else
-							{
-								if ( curve._label._fontSpec == null )
-									tmpFont.FontColor = curve.Color;
-
-								tmpFont.Draw(g, pane, curve._label._text,
-									x + 0.0F * _tmpSize, y + _legendItemHeight / 2.0F,
-									AlignH.Left, AlignV.Center, scaleFactor);
-							}
-
-							// maintain a curve count for positioning
-							iEntry++;
-						}
-					}
-					if ( pane is MasterPane && ( (MasterPane)pane ).IsUniformLegendEntries )
-						break;
-				}
-
-				// Draw a border around the legend if required
-				if ( iEntry > 0 )
-					this.Border.Draw( g, pane, scaleFactor, _rect );
-			}
-		}
-
-		private float GetMaxHeight( PaneList paneList, Graphics g, float scaleFactor )
-		{
-			// Set up some scaled dimensions for calculating sizes and locations
-			float defaultCharHeight = this.FontSpec.GetHeight( scaleFactor );
-			float maxCharHeight = defaultCharHeight;
-
-			// Find the largest charHeight, just in case the curves have individual fonts defined
-			foreach ( GraphPane tmpPane in paneList )
-			{
-				foreach ( CurveItem curve in tmpPane.CurveList )
-				{
-					if ( curve._label._text != string.Empty && curve._label._isVisible )
-					{
-						float tmpHeight = defaultCharHeight;
-						if ( curve._label._fontSpec != null )
-							tmpHeight = curve._label._fontSpec.GetHeight( scaleFactor );
-
-						// Account for multiline legend entries
-						tmpHeight *= curve._label._text.Split( '\n' ).Length;
-
-						if ( tmpHeight > maxCharHeight )
-							maxCharHeight = tmpHeight;
-					}
-				}
-			}
-
-			return maxCharHeight;
-		}
-
-		/// <summary>
-		/// Determine if a mouse point is within the legend, and if so, which legend
-		/// entry (<see cref="CurveItem"/>) is nearest.
-		/// </summary>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="index">The index number of the <see cref="CurveItem"/> legend
-		/// entry that is under the mouse point.  The <see cref="CurveItem"/> object is
-		/// accessible via <see cref="GraphPane.CurveList">CurveList[index]</see>.
-		/// </param>
-		/// <returns>true if the mouse point is within the <see cref="Legend"/> bounding
-		/// box, false otherwise.</returns>
-		/// <seealso cref="GraphPane.FindNearestObject"/>
-		public bool FindPoint( PointF mousePt, PaneBase pane, float scaleFactor, out int index )
-		{
-			index = -1;
-
-			if ( _rect.Contains( mousePt ) )
-			{
-				int j = (int)( ( mousePt.Y - _rect.Top ) / _legendItemHeight );
-				int i = (int)( ( mousePt.X - _rect.Left - _tmpSize / 2.0f ) / _legendItemWidth );
-				if ( i < 0 )
-					i = 0;
-				if ( i >= _hStack )
-					i = _hStack - 1;
-
-				int pos = i + j * _hStack;
-				index = 0;
-
-				PaneList paneList = GetPaneList( pane );
-
-				foreach ( GraphPane tmpPane in paneList )
-				{
-					foreach ( CurveItem curve in tmpPane.CurveList )
-					{
-						if ( curve._label._isVisible && curve._label._text != string.Empty )
-						{
-							if ( pos == 0 )
-								return true;
-							pos--;
-						}
-						index++;
-					}
-				}
-
-				return true;
-			}
-			else
-				return false;
-		}
-
-		private PaneList GetPaneList( PaneBase pane )
-		{
-			// For a single GraphPane, create a PaneList to contain it
-			// Otherwise, just use the paneList from the MasterPane
-			PaneList paneList;
-
-			if ( pane is GraphPane )
-			{
-				paneList = new PaneList();
-				paneList.Add( (GraphPane)pane );
-			}
-			else
-				paneList = ( (MasterPane)pane ).PaneList;
-
-			return paneList;
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="Legend"/> rectangle (<see cref="Rect"/>),
-		/// taking into account the number of required legend
-		/// entries, and the legend drawing preferences.
-		/// </summary>
-		/// <remarks>Adjust the size of the
-		/// <see cref="Chart.Rect"/> for the parent <see cref="GraphPane"/> to accomodate the
-		/// space required by the legend.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="tChartRect">
-		/// The rectangle that contains the area bounded by the axes, in pixel units.
-		/// <seealso cref="Chart.Rect" />
-		/// </param>
-		public void CalcRect( Graphics g, PaneBase pane, float scaleFactor,
-			ref RectangleF tChartRect )
-		{
-			// Start with an empty rectangle
-			_rect = Rectangle.Empty;
-			_hStack = 1;
-			_legendItemWidth = 1;
-			_legendItemHeight = 0;
-
-			RectangleF clientRect = pane.CalcClientRect( g, scaleFactor );
-
-			// If the legend is invisible, don't do anything
-			if ( !_isVisible )
-				return;
-
-			int nCurve = 0;
-
-			PaneList paneList = GetPaneList( pane );
-			_tmpSize = GetMaxHeight( paneList, g, scaleFactor );
-
-			float halfGap = _tmpSize / 2.0F,
-					maxWidth = 0,
-					tmpWidth,
-					gapPix = _gap * _tmpSize;
-
-			foreach ( GraphPane tmpPane in paneList )
-			{
-				// Loop through each curve in the curve list
-				// Find the maximum width of the legend labels
-				//foreach ( CurveItem curve in tmpPane.CurveList )
-				//foreach ( CurveItem curve in GetIterator( tmpPane.CurveList, _isReverse ) )
-				int count = tmpPane.CurveList.Count;
-				for ( int i = 0; i < count; i++ )
-				{
-					CurveItem curve = tmpPane.CurveList[_isReverse ? count - i - 1 : i];
-					if ( curve._label._text != string.Empty && curve._label._isVisible )
-					{
-						// Calculate the width of the label save the max width
-						FontSpec tmpFont = ( curve._label._fontSpec != null ) ?
-										curve._label._fontSpec : this.FontSpec;
-
-						tmpWidth = tmpFont.GetWidth( g, curve._label._text, scaleFactor );
-
-						if ( tmpWidth > maxWidth )
-							maxWidth = tmpWidth;
-
-						// Save the maximum symbol height for line-type curves
-						if ( curve is LineItem && ( (LineItem)curve ).Symbol.Size > _legendItemHeight )
-							_legendItemHeight = ( (LineItem)curve ).Symbol.Size;
-
-						nCurve++;
-					}
-				}
-
-				if ( pane is MasterPane && ( (MasterPane)pane ).IsUniformLegendEntries )
-					break;
-			}
-
-			float widthAvail;
-
-			// Is this legend horizontally stacked?
-
-			if ( _isHStack )
-			{
-				// Determine the available space for horizontal stacking
-				switch ( _position )
-				{
-					// Never stack if the legend is to the right or left
-					case LegendPos.Right:
-					case LegendPos.Left:
-						widthAvail = 0;
-						break;
-
-					// for the top & bottom, the axis border width is available
-					case LegendPos.Top:
-					case LegendPos.TopCenter:
-					case LegendPos.Bottom:
-					case LegendPos.BottomCenter:
-						widthAvail = tChartRect.Width;
-						break;
-
-					// for the top & bottom flush left, the panerect less margins is available
-					case LegendPos.TopFlushLeft:
-					case LegendPos.BottomFlushLeft:
-						widthAvail = clientRect.Width;
-						break;
-
-					// for inside the axis area or Float, use 1/2 of the axis border width
-					case LegendPos.InsideTopRight:
-					case LegendPos.InsideTopLeft:
-					case LegendPos.InsideBotRight:
-					case LegendPos.InsideBotLeft:
-					case LegendPos.Float:
-						widthAvail = tChartRect.Width / 2;
-						break;
-
-					// shouldn't ever happen
-					default:
-						widthAvail = 0;
-						break;
-				}
-
-				// width of one legend entry
-				if ( _isShowLegendSymbols )
-					_legendItemWidth = 3.0f * _tmpSize + maxWidth;
-				else
-					_legendItemWidth = 0.5f * _tmpSize + maxWidth;
-
-				// Calculate the number of columns in the legend
-				// Normally, the legend is:
-				//     available width / ( max width of any entry + space for line&symbol )
-				if ( maxWidth > 0 )
-					_hStack = (int)( ( widthAvail - halfGap ) / _legendItemWidth );
-
-				// You can never have more columns than legend entries
-				if ( _hStack > nCurve )
-					_hStack = nCurve;
-
-				// a saftey check
-				if ( _hStack == 0 )
-					_hStack = 1;
-			}
-			else
-			{
-				if ( _isShowLegendSymbols )
-					_legendItemWidth = 3.0F * _tmpSize + maxWidth;
-				else
-					_legendItemWidth = 0.5F * _tmpSize + maxWidth;
-			}
-
-			// legend is:
-			//   item:     space  line  space  text   space
-			//   width:     wid  4*wid   wid  maxWid   wid 
-			// The symbol is centered on the line
-			//
-			// legend begins 3 * wid to the right of the plot rect
-			//
-			// The height of the legend is the actual height of the lines of text
-			//   (nCurve * hite) plus wid on top and wid on the bottom
-
-			// total legend width
-			float totLegWidth = _hStack * _legendItemWidth;
-
-			// The total legend height
-			_legendItemHeight = _legendItemHeight * (float)scaleFactor + halfGap;
-			if ( _tmpSize > _legendItemHeight )
-				_legendItemHeight = _tmpSize;
-			float totLegHeight = (float)Math.Ceiling( (double)nCurve / (double)_hStack )
-				* _legendItemHeight;
-
-			RectangleF newRect = new RectangleF();
-
-			// Now calculate the legend rect based on the above determined parameters
-			// Also, adjust the ChartRect to reflect the space for the legend
-			if ( nCurve > 0 )
-			{
-				newRect = new RectangleF( 0, 0, totLegWidth, totLegHeight );
-
-				// The switch statement assigns the left and top edges, and adjusts the ChartRect
-				// as required.  The right and bottom edges are calculated at the bottom of the switch.
-				switch ( _position )
-				{
-					case LegendPos.Right:
-						newRect.X = clientRect.Right - totLegWidth;
-						newRect.Y = tChartRect.Top;
-
-						tChartRect.Width -= totLegWidth + gapPix;
-						break;
-					case LegendPos.Top:
-						newRect.X = tChartRect.Left;
-						newRect.Y = clientRect.Top;
-
-						tChartRect.Y += totLegHeight + gapPix;
-						tChartRect.Height -= totLegHeight + gapPix;
-						break;
-					case LegendPos.TopFlushLeft:
-						newRect.X = clientRect.Left;
-						newRect.Y = clientRect.Top;
-
-						tChartRect.Y += totLegHeight + gapPix * 1.5f;
-						tChartRect.Height -= totLegHeight + gapPix * 1.5f;
-						break;
-					case LegendPos.TopCenter:
-						newRect.X = tChartRect.Left + ( tChartRect.Width - totLegWidth ) / 2;
-						newRect.Y = tChartRect.Top;
-
-						tChartRect.Y += totLegHeight + gapPix;
-						tChartRect.Height -= totLegHeight + gapPix;
-						break;
-					case LegendPos.Bottom:
-						newRect.X = tChartRect.Left;
-						newRect.Y = clientRect.Bottom - totLegHeight;
-
-						tChartRect.Height -= totLegHeight + gapPix;
-						break;
-					case LegendPos.BottomFlushLeft:
-						newRect.X = clientRect.Left;
-						newRect.Y = clientRect.Bottom - totLegHeight;
-
-						tChartRect.Height -= totLegHeight + gapPix;
-						break;
-					case LegendPos.BottomCenter:
-						newRect.X = tChartRect.Left + ( tChartRect.Width - totLegWidth ) / 2;
-						newRect.Y = clientRect.Bottom - totLegHeight;
-
-						tChartRect.Height -= totLegHeight + gapPix;
-						break;
-					case LegendPos.Left:
-						newRect.X = clientRect.Left;
-						newRect.Y = tChartRect.Top;
-
-						tChartRect.X += totLegWidth + halfGap;
-						tChartRect.Width -= totLegWidth + gapPix;
-						break;
-					case LegendPos.InsideTopRight:
-						newRect.X = tChartRect.Right - totLegWidth;
-						newRect.Y = tChartRect.Top;
-						break;
-					case LegendPos.InsideTopLeft:
-						newRect.X = tChartRect.Left;
-						newRect.Y = tChartRect.Top;
-						break;
-					case LegendPos.InsideBotRight:
-						newRect.X = tChartRect.Right - totLegWidth;
-						newRect.Y = tChartRect.Bottom - totLegHeight;
-						break;
-					case LegendPos.InsideBotLeft:
-						newRect.X = tChartRect.Left;
-						newRect.Y = tChartRect.Bottom - totLegHeight;
-						break;
-					case LegendPos.Float:
-						newRect.Location = this.Location.TransformTopLeft( pane, totLegWidth, totLegHeight );
-						break;
-				}
-			}
-
-			_rect = newRect;
-		}
-
-		//		/// <summary>
-		//		/// Private method to the render region that gives the iterator depending on the attribute
-		//		/// </summary>
-		//		/// <param name="c"></param>
-		//		/// <param name="forward"></param>
-		//		/// <returns></returns>
-		//		private IEnumerable<CurveItem> GetIterator(CurveList c, bool forward)
-		//		{
-		//			return forward ? c.Forward : c.Backward;
-		//		}
-
-		#endregion
-	}
-}
-
diff --git a/BDInfo/ZedGraph/Line.cs b/BDInfo/ZedGraph/Line.cs
deleted file mode 100644
index 22762616ff..0000000000
--- a/BDInfo/ZedGraph/Line.cs
+++ /dev/null
@@ -1,1455 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class representing all the characteristics of the Line
-	/// segments that make up a curve on the graph.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.48 $ $Date: 2007/11/28 02:38:22 $ </version>
-	[Serializable]
-	public class Line : LineBase, ICloneable, ISerializable
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the smoothing flag for this
-		/// <see cref="Line"/>.  Use the public
-		/// property <see cref="IsSmooth"/> to access this value.
-		/// </summary>
-		private bool _isSmooth;
-		/// <summary>
-		/// Private field that stores the smoothing tension
-		/// for this <see cref="Line"/>.  Use the public property
-		/// <see cref="SmoothTension"/> to access this value.
-		/// </summary>
-		/// <value>A floating point value indicating the level of smoothing.
-		/// 0.0F for no smoothing, 1.0F for lots of smoothing, >1.0 for odd
-		/// smoothing.</value>
-		/// <seealso cref="IsSmooth"/>
-		/// <seealso cref="Default.IsSmooth"/>
-		/// <seealso cref="Default.SmoothTension"/>
-		private float _smoothTension;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.StepType"/> for this
-		/// <see cref="CurveItem"/>.  Use the public
-		/// property <see cref="StepType"/> to access this value.
-		/// </summary>
-		private StepType _stepType;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Line"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-		/// <summary>
-		/// Private field that determines if this <see cref="Line"/> will be drawn with
-		/// optimizations enabled.  Use the public
-		/// property <see cref="IsOptimizedDraw"/> to access this value.
-		/// </summary>
-		private bool _isOptimizedDraw;
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Line"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			// Default Line properties
-			/// <summary>
-			/// The default color for curves (line segments connecting the points).
-			/// This is the default value for the <see cref="LineBase.Color"/> property.
-			/// </summary>
-			public static Color Color = Color.Red;
-			/// <summary>
-			/// The default color for filling in the area under the curve
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.Red;
-			/// <summary>
-			/// The default custom brush for filling in the area under the curve
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default fill mode for the curve (<see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.None;
-
-			/// <summary>
-			/// The default value for the <see cref="Line.IsSmooth"/>
-			/// property.
-			/// </summary>
-			public static bool IsSmooth = false;
-			/// <summary>
-			/// The default value for the <see cref="Line.SmoothTension"/> property.
-			/// </summary>
-			public static float SmoothTension = 0.5F;
-			/// <summary>
-			/// The default value for the <see cref="Line.IsOptimizedDraw"/> property.
-			/// </summary>
-			public static bool IsOptimizedDraw = false;
-
-			/// <summary>
-			/// Default value for the curve type property
-			/// (<see cref="Line.StepType"/>).  This determines if the curve
-			/// will be drawn by directly connecting the points from the
-			/// <see cref="CurveItem.Points"/> data collection,
-			/// or if the curve will be a "stair-step" in which the points are
-			/// connected by a series of horizontal and vertical lines that
-			/// represent discrete, staticant values.  Note that the values can
-			/// be forward oriented <code>ForwardStep</code> (<see cref="StepType"/>) or
-			/// rearward oriented <code>RearwardStep</code>.
-			/// That is, the points are defined at the beginning or end
-			/// of the staticant value for which they apply, respectively.
-			/// </summary>
-			/// <value><see cref="StepType"/> enum value</value>
-			public static StepType StepType = StepType.NonStep;
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a property that determines if this <see cref="Line"/>
-		/// will be drawn smooth.  The "smoothness" is controlled by
-		/// the <see cref="SmoothTension"/> property.
-		/// </summary>
-		/// <value>true to smooth the line, false to just connect the dots
-		/// with linear segments</value>
-		/// <seealso cref="SmoothTension"/>
-		/// <seealso cref="Default.IsSmooth"/>
-		/// <seealso cref="Default.SmoothTension"/>
-		public bool IsSmooth
-		{
-			get { return _isSmooth; }
-			set { _isSmooth = value; }
-		}
-		/// <summary>
-		/// Gets or sets a property that determines the smoothing tension
-		/// for this <see cref="Line"/>.  This property is only used if
-		/// <see cref="IsSmooth"/> is true.  A tension value 0.0 will just
-		/// draw ordinary line segments like an unsmoothed line.  A tension
-		/// value of 1.0 will be smooth.  Values greater than 1.0 will generally
-		/// give odd results.
-		/// </summary>
-		/// <value>A floating point value indicating the level of smoothing.
-		/// 0.0F for no smoothing, 1.0F for lots of smoothing, >1.0 for odd
-		/// smoothing.</value>
-		/// <seealso cref="IsSmooth"/>
-		/// <seealso cref="Default.IsSmooth"/>
-		/// <seealso cref="Default.SmoothTension"/>
-		public float SmoothTension
-		{
-			get { return _smoothTension; }
-			set { _smoothTension = value; }
-		}
-		/// <summary>
-		/// Determines if the <see cref="CurveItem"/> will be drawn by directly connecting the
-		/// points from the <see cref="CurveItem.Points"/> data collection,
-		/// or if the curve will be a "stair-step" in which the points are
-		/// connected by a series of horizontal and vertical lines that
-		/// represent discrete, constant values.  Note that the values can
-		/// be forward oriented <c>ForwardStep</c> (<see cref="ZedGraph.StepType"/>) or
-		/// rearward oriented <c>RearwardStep</c>.
-		/// That is, the points are defined at the beginning or end
-		/// of the constant value for which they apply, respectively.
-		/// The <see cref="StepType"/> property is ignored for lines
-		/// that have <see cref="IsSmooth"/> set to true.
-		/// </summary>
-		/// <value><see cref="ZedGraph.StepType"/> enum value</value>
-		/// <seealso cref="Default.StepType"/>
-		public StepType StepType
-		{
-			get { return _stepType; }
-			set { _stepType = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Line"/>.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a boolean value that determines if this <see cref="Line"/> will be drawn with
-		/// optimizations enabled.
-		/// </summary>
-		/// <remarks>
-		/// Normally, the optimizations can be used without a problem, especially if the data
-		/// are sorted.  The optimizations are particularly helpful with very large datasets.
-		/// However, if the data are very discontinuous (for example, a curve that doubles back
-		/// on itself), then the optimizations can cause drawing artifacts in the form of
-		/// missing line segments.  The default option for this mode is false, so you must
-		/// explicitly enable it for each <see cref="LineItem.Line">LineItem.Line</see>.
-		/// Also note that, even if the optimizations are enabled explicitly, no actual
-		/// optimization will be done for datasets of less than 1000 points.
-		/// </remarks>
-		public bool IsOptimizedDraw
-		{
-			get { return _isOptimizedDraw; }
-			set { _isOptimizedDraw = value; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="Line"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public Line()
-			: this( Color.Empty )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that sets the color property to the specified value, and sets
-		/// the remaining <see cref="Line"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="color">The color to assign to this new Line object</param>
-		public Line( Color color )
-		{
-			_color = color.IsEmpty ? Default.Color : color;
-			_stepType = Default.StepType;
-			_isSmooth = Default.IsSmooth;
-			_smoothTension = Default.SmoothTension;
-			_fill = new Fill( Default.FillColor, Default.FillBrush, Default.FillType );
-			_isOptimizedDraw = Default.IsOptimizedDraw;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Line object from which to copy</param>
-		public Line( Line rhs )
-		{
-			_color = rhs._color;
-			_stepType = rhs._stepType;
-			_isSmooth = rhs._isSmooth;
-			_smoothTension = rhs._smoothTension;
-			_fill = rhs._fill.Clone();
-			_isOptimizedDraw = rhs._isOptimizedDraw;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Line Clone()
-		{
-			return new Line( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 14;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Line( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			if ( sch >= 14 )
-				_color = (Color) info.GetValue( "color", typeof( Color ) );
-			_stepType = (StepType)info.GetValue( "stepType", typeof( StepType ) );
-			_isSmooth = info.GetBoolean( "isSmooth" );
-			_smoothTension = info.GetSingle( "smoothTension" );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-
-			if ( sch >= 13 )
-				_isOptimizedDraw = info.GetBoolean( "isOptimizedDraw" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema", schema );
-			info.AddValue( "color", _color );
-			info.AddValue( "stepType", _stepType );
-			info.AddValue( "isSmooth", _isSmooth );
-			info.AddValue( "smoothTension", _smoothTension );
-			info.AddValue( "fill", _fill );
-
-			info.AddValue( "isOptimizedDraw", _isOptimizedDraw );
-		}
-
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="Line"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="LineItem"/> object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		public void Draw( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor )
-		{
-			// If the line is being shown, draw it
-			if ( this.IsVisible )
-			{
-				//How to handle fill vs nofill?
-				//if ( isSelected )
-				//	GraphPane.Default.SelectedLine.
-
-				SmoothingMode sModeSave = g.SmoothingMode;
-				if ( _isAntiAlias )
-					g.SmoothingMode = SmoothingMode.HighQuality;
-
-				if ( curve is StickItem )
-					DrawSticks( g, pane, curve, scaleFactor );
-				else if ( this.IsSmooth || this.Fill.IsVisible )
-					DrawSmoothFilledCurve( g, pane, curve, scaleFactor );
-				else
-					DrawCurve( g, pane, curve, scaleFactor );
-
-				g.SmoothingMode = sModeSave;
-			}
-		}
-
-		/// <summary>
-		/// Render a single <see cref="Line"/> segment to the specified
-		/// <see cref="Graphics"/> device.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="x1">The x position of the starting point that defines the
-		/// line segment in screen pixel units</param>
-		/// <param name="y1">The y position of the starting point that defines the
-		/// line segment in screen pixel units</param>
-		/// <param name="x2">The x position of the ending point that defines the
-		/// line segment in screen pixel units</param>
-		/// <param name="y2">The y position of the ending point that defines the
-		/// line segment in screen pixel units</param>
-		public void DrawSegment( Graphics g, GraphPane pane, float x1, float y1,
-								  float x2, float y2, float scaleFactor )
-		{
-			if ( _isVisible && !this.Color.IsEmpty )
-			{
-				using ( Pen pen = GetPen( pane, scaleFactor ) )
-				{
-					g.DrawLine( pen, x1, y1, x2, y2 );
-				}
-			}
-		}
-
-		/// <summary>
-		/// Render the <see cref="Line"/>'s as vertical sticks (from a <see cref="StickItem" />) to
-		/// the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="CurveItem"/> representing this
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DrawSticks( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor )
-		{
-			Line source = this;
-			if ( curve.IsSelected )
-				source = Selection.Line;
-
-			Axis yAxis = curve.GetYAxis( pane );
-			Axis xAxis = curve.GetXAxis( pane );
-
-			float basePix = yAxis.Scale.Transform( 0.0 );
-			using ( Pen pen = source.GetPen( pane, scaleFactor ) )
-			{
-				for ( int i = 0; i < curve.Points.Count; i++ )
-				{
-					PointPair pt = curve.Points[i];
-
-					if ( pt.X != PointPair.Missing &&
-							pt.Y != PointPair.Missing &&
-							!System.Double.IsNaN( pt.X ) &&
-							!System.Double.IsNaN( pt.Y ) &&
-							!System.Double.IsInfinity( pt.X ) &&
-							!System.Double.IsInfinity( pt.Y ) &&
-							( !xAxis._scale.IsLog || pt.X > 0.0 ) &&
-							( !yAxis._scale.IsLog || pt.Y > 0.0 ) )
-					{
-						float pixY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.Y );
-						float pixX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.X );
-
-						if ( pixX >= pane.Chart._rect.Left && pixX <= pane.Chart._rect.Right )
-						{
-							if ( pixY > pane.Chart._rect.Bottom )
-								pixY = pane.Chart._rect.Bottom;
-							if ( pixY < pane.Chart._rect.Top )
-								pixY = pane.Chart._rect.Top;
-
-							if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-							{
-								using ( Pen tPen = GetPen( pane, scaleFactor, pt ) )
-									g.DrawLine( tPen, pixX, pixY, pixX, basePix );
-							}
-							else
-								g.DrawLine( pen, pixX, pixY, pixX, basePix );
-
-						}
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
-		/// device using the specified smoothing property (<see cref="ZedGraph.Line.SmoothTension"/>).
-		/// The routine draws the line segments and the area fill (if any, see <see cref="FillType"/>;
-		/// the symbols are drawn by the <see cref="Symbol.Draw"/> method.  This method
-		/// is normally only called by the Draw method of the
-		/// <see cref="CurveItem"/> object.  Note that the <see cref="StepType"/> property
-		/// is ignored for smooth lines (e.g., when <see cref="ZedGraph.Line.IsSmooth"/> is true).
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		public void DrawSmoothFilledCurve( Graphics g, GraphPane pane,
-                                CurveItem curve, float scaleFactor )
-		{
-			Line source = this;
-			if ( curve.IsSelected )
-				source = Selection.Line;
-
-			PointF[] arrPoints;
-			int count;
-			IPointList points = curve.Points;
-
-			if ( this.IsVisible && !this.Color.IsEmpty && points != null &&
-				BuildPointsArray( pane, curve, out arrPoints, out count ) &&
-				count > 2 )
-			{
-				float tension = _isSmooth ? _smoothTension : 0f;
-
-				// Fill the curve if needed
-				if ( this.Fill.IsVisible )
-				{
-					Axis yAxis = curve.GetYAxis( pane );
-
-					using ( GraphicsPath path = new GraphicsPath( FillMode.Winding ) )
-					{
-						path.AddCurve( arrPoints, 0, count - 2, tension );
-
-						double yMin = yAxis._scale._min < 0 ? 0.0 : yAxis._scale._min;
-						CloseCurve( pane, curve, arrPoints, count, yMin, path );
-
-						RectangleF rect = path.GetBounds();
-						using ( Brush brush = source._fill.MakeBrush( rect ) )
-						{
-							if ( pane.LineType == LineType.Stack && yAxis.Scale._min < 0 &&
-									this.IsFirstLine( pane, curve ) )
-							{
-								float zeroPix = yAxis.Scale.Transform( 0 );
-								RectangleF tRect = pane.Chart._rect;
-								tRect.Height = zeroPix - tRect.Top;
-								if ( tRect.Height > 0 )
-								{
-									Region reg = g.Clip;
-									g.SetClip( tRect );
-									g.FillPath( brush, path );
-									g.SetClip( pane.Chart._rect );
-								}
-							}
-							else
-								g.FillPath( brush, path );
-							//brush.Dispose();
-						}
-
-						// restore the zero line if needed (since the fill tends to cover it up)
-						yAxis.FixZeroLine( g, pane, scaleFactor, rect.Left, rect.Right );
-					}
-				}
-
-				// If it's a smooth curve, go ahead and render the path.  Otherwise, use the
-				// standard drawcurve method just in case there are missing values.
-				if ( _isSmooth )
-				{
-					using ( Pen pen = GetPen( pane, scaleFactor ) )
-					{
-						// Stroke the curve
-						g.DrawCurve( pen, arrPoints, 0, count - 2, tension );
-
-						//pen.Dispose();
-					}
-				}
-				else
-					DrawCurve( g, pane, curve, scaleFactor );
-			}
-		}
-
-		private bool IsFirstLine( GraphPane pane, CurveItem curve )
-		{
-			CurveList curveList = pane.CurveList;
-
-			for ( int j = 0; j < curveList.Count; j++ )
-			{
-				CurveItem tCurve = curveList[j];
-
-				if ( tCurve is LineItem && tCurve.IsY2Axis == curve.IsY2Axis &&
-						tCurve.YAxisIndex == curve.YAxisIndex )
-				{
-					return tCurve == curve;
-				}
-			}
-
-			return false;
-		}
-
-		/// <summary>
-		/// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
-		/// device.  The format (stair-step or line) of the curve is
-		/// defined by the <see cref="StepType"/> property.  The routine
-		/// only draws the line segments; the symbols are drawn by the
-		/// <see cref="Symbol.Draw"/> method.  This method
-		/// is normally only called by the Draw method of the
-		/// <see cref="CurveItem"/> object
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		public void DrawCurve( Graphics g, GraphPane pane,
-                                CurveItem curve, float scaleFactor )
-		{
-			Line source = this;
-			if ( curve.IsSelected )
-				source = Selection.Line;
-
-			// switch to int to optimize drawing speed (per Dale-a-b)
-			int	tmpX, tmpY,
-					lastX = int.MaxValue,
-					lastY = int.MaxValue;
-
-			double curX, curY, lowVal;
-			PointPair curPt, lastPt = new PointPair();
-
-			bool lastBad = true;
-			IPointList points = curve.Points;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			Axis yAxis = curve.GetYAxis( pane );
-			Axis xAxis = curve.GetXAxis( pane );
-
-			bool xIsLog = xAxis._scale.IsLog;
-			bool yIsLog = yAxis._scale.IsLog;
-
-			// switch to int to optimize drawing speed (per Dale-a-b)
-			int minX = (int)pane.Chart.Rect.Left;
-			int maxX = (int)pane.Chart.Rect.Right;
-			int minY = (int)pane.Chart.Rect.Top;
-			int maxY = (int)pane.Chart.Rect.Bottom;
-
-			using ( Pen pen = source.GetPen( pane, scaleFactor ) )
-			{
-				if ( points != null && !_color.IsEmpty && this.IsVisible )
-				{
-					//bool lastOut = false;
-					bool isOut;
-
-					bool isOptDraw = _isOptimizedDraw && points.Count > 1000;
-
-					// (Dale-a-b) we'll set an element to true when it has been drawn	
-					bool[,] isPixelDrawn = null;
-					
-					if ( isOptDraw )
-						isPixelDrawn = new bool[maxX + 1, maxY + 1]; 
-					
-					// Loop over each point in the curve
-					for ( int i = 0; i < points.Count; i++ )
-					{
-						curPt = points[i];
-						if ( pane.LineType == LineType.Stack )
-						{
-							if ( !valueHandler.GetValues( curve, i, out curX, out lowVal, out curY ) )
-							{
-								curX = PointPair.Missing;
-								curY = PointPair.Missing;
-							}
-						}
-						else
-						{
-							curX = curPt.X;
-							curY = curPt.Y;
-						}
-
-						// Any value set to double max is invalid and should be skipped
-						// This is used for calculated values that are out of range, divide
-						//   by zero, etc.
-						// Also, any value <= zero on a log scale is invalid
-						if ( curX == PointPair.Missing ||
-								curY == PointPair.Missing ||
-								System.Double.IsNaN( curX ) ||
-								System.Double.IsNaN( curY ) ||
-								System.Double.IsInfinity( curX ) ||
-								System.Double.IsInfinity( curY ) ||
-								( xIsLog && curX <= 0.0 ) ||
-								( yIsLog && curY <= 0.0 ) )
-						{
-							// If the point is invalid, then make a linebreak only if IsIgnoreMissing is false
-							// LastX and LastY are always the last valid point, so this works out
-							lastBad = lastBad || !pane.IsIgnoreMissing;
-							isOut = true;
-						}
-						else
-						{
-							// Transform the current point from user scale units to
-							// screen coordinates
-							tmpX = (int) xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curX );
-							tmpY = (int) yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curY );
-
-							// Maintain an array of "used" pixel locations to avoid duplicate drawing operations
-							// contributed by Dale-a-b
-							if ( isOptDraw && tmpX >= minX && tmpX <= maxX &&
-										tmpY >= minY && tmpY <= maxY ) // guard against the zoom-in case
-							{
-								if ( isPixelDrawn[tmpX, tmpY] )
-									continue;
-								isPixelDrawn[tmpX, tmpY] = true;
-							}
-
-							isOut = ( tmpX < minX && lastX < minX ) || ( tmpX > maxX && lastX > maxX ) ||
-								( tmpY < minY && lastY < minY ) || ( tmpY > maxY && lastY > maxY );
-
-							if ( !lastBad )
-							{
-								try
-								{
-									// GDI+ plots the data wrong and/or throws an exception for
-									// outrageous coordinates, so we do a sanity check here
-									if ( lastX > 5000000 || lastX < -5000000 ||
-											lastY > 5000000 || lastY < -5000000 ||
-											tmpX > 5000000 || tmpX < -5000000 ||
-											tmpY > 5000000 || tmpY < -5000000 )
-										InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen,
-														lastX, lastY, tmpX, tmpY );
-									else if ( !isOut )
-									{
-										if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-										{
-											using ( Pen tPen = GetPen( pane, scaleFactor, lastPt ) )
-											{
-												if ( this.StepType == StepType.NonStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.ForwardStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-													g.DrawLine( tPen, tmpX, lastY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.RearwardStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, lastX, tmpY );
-													g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.ForwardSegment )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-												}
-												else
-												{
-													g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-												}
-											}
-										}
-										else
-										{
-											if ( this.StepType == StepType.NonStep )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.ForwardStep )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-												g.DrawLine( pen, tmpX, lastY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.RearwardStep )
-											{
-												g.DrawLine( pen, lastX, lastY, lastX, tmpY );
-												g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.ForwardSegment )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-											}
-											else if ( this.StepType == StepType.RearwardSegment )
-											{
-												g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-											}
-										}
-									}
-
-								}
-								catch
-								{
-									InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen,
-												lastX, lastY, tmpX, tmpY );
-								}
-
-							}
-
-							lastPt = curPt;
-							lastX = tmpX;
-							lastY = tmpY;
-							lastBad = false;
-							//lastOut = isOut;
-						}
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
-		/// device.  The format (stair-step or line) of the curve is
-		/// defined by the <see cref="StepType"/> property.  The routine
-		/// only draws the line segments; the symbols are drawn by the
-		/// <see cref="Symbol.Draw"/> method.  This method
-		/// is normally only called by the Draw method of the
-		/// <see cref="CurveItem"/> object
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		public void DrawCurveOriginal( Graphics g, GraphPane pane,
-										  CurveItem curve, float scaleFactor )
-		{
-			Line source = this;
-			if ( curve.IsSelected )
-				source = Selection.Line;
-
-			float tmpX, tmpY,
-					lastX = float.MaxValue,
-					lastY = float.MaxValue;
-			double curX, curY, lowVal;
-			PointPair curPt, lastPt = new PointPair();
-
-			bool lastBad = true;
-			IPointList points = curve.Points;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			Axis yAxis = curve.GetYAxis( pane );
-			Axis xAxis = curve.GetXAxis( pane );
-
-			bool xIsLog = xAxis._scale.IsLog;
-			bool yIsLog = yAxis._scale.IsLog;
-
-			float minX = pane.Chart.Rect.Left;
-			float maxX = pane.Chart.Rect.Right;
-			float minY = pane.Chart.Rect.Top;
-			float maxY = pane.Chart.Rect.Bottom;
-
-			using ( Pen pen = source.GetPen( pane, scaleFactor ) )
-			{
-				if ( points != null && !_color.IsEmpty && this.IsVisible )
-				{
-					//bool lastOut = false;
-					bool isOut;
-
-					// Loop over each point in the curve
-					for ( int i = 0; i < points.Count; i++ )
-					{
-						curPt = points[i];
-						if ( pane.LineType == LineType.Stack )
-						{
-							if ( !valueHandler.GetValues( curve, i, out curX, out lowVal, out curY ) )
-							{
-								curX = PointPair.Missing;
-								curY = PointPair.Missing;
-							}
-						}
-						else
-						{
-							curX = curPt.X;
-							curY = curPt.Y;
-						}
-
-						// Any value set to double max is invalid and should be skipped
-						// This is used for calculated values that are out of range, divide
-						//   by zero, etc.
-						// Also, any value <= zero on a log scale is invalid
-						if ( curX == PointPair.Missing ||
-								curY == PointPair.Missing ||
-								System.Double.IsNaN( curX ) ||
-								System.Double.IsNaN( curY ) ||
-								System.Double.IsInfinity( curX ) ||
-								System.Double.IsInfinity( curY ) ||
-								( xIsLog && curX <= 0.0 ) ||
-								( yIsLog && curY <= 0.0 ) )
-						{
-							// If the point is invalid, then make a linebreak only if IsIgnoreMissing is false
-							// LastX and LastY are always the last valid point, so this works out
-							lastBad = lastBad || !pane.IsIgnoreMissing;
-							isOut = true;
-						}
-						else
-						{
-							// Transform the current point from user scale units to
-							// screen coordinates
-							tmpX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curX );
-							tmpY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curY );
-							isOut = ( tmpX < minX && lastX < minX ) || ( tmpX > maxX && lastX > maxX ) ||
-								( tmpY < minY && lastY < minY ) || ( tmpY > maxY && lastY > maxY );
-
-							if ( !lastBad )
-							{
-								try
-								{
-									// GDI+ plots the data wrong and/or throws an exception for
-									// outrageous coordinates, so we do a sanity check here
-									if ( lastX > 5000000 || lastX < -5000000 ||
-											lastY > 5000000 || lastY < -5000000 ||
-											tmpX > 5000000 || tmpX < -5000000 ||
-											tmpY > 5000000 || tmpY < -5000000 )
-										InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen,
-														lastX, lastY, tmpX, tmpY );
-									else if ( !isOut )
-									{
-										if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-										{
-											using ( Pen tPen = GetPen( pane, scaleFactor, lastPt ) )
-											{
-												if ( this.StepType == StepType.NonStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.ForwardStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-													g.DrawLine( tPen, tmpX, lastY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.RearwardStep )
-												{
-													g.DrawLine( tPen, lastX, lastY, lastX, tmpY );
-													g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-												}
-												else if ( this.StepType == StepType.ForwardSegment )
-												{
-													g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-												}
-												else
-												{
-													g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-												}
-											}
-										}
-										else
-										{
-											if ( this.StepType == StepType.NonStep )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.ForwardStep )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-												g.DrawLine( pen, tmpX, lastY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.RearwardStep )
-											{
-												g.DrawLine( pen, lastX, lastY, lastX, tmpY );
-												g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-											}
-											else if ( this.StepType == StepType.ForwardSegment )
-											{
-												g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-											}
-											else if ( this.StepType == StepType.RearwardSegment )
-											{
-												g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-											}
-										}
-									}
-
-								}
-								catch
-								{
-									InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen,
-												lastX, lastY, tmpX, tmpY );
-								}
-
-							}
-
-							lastPt = curPt;
-							lastX = tmpX;
-							lastY = tmpY;
-							lastBad = false;
-							//lastOut = isOut;
-						}
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// This method just handles the case where one or more of the coordinates are outrageous,
-		/// or GDI+ threw an exception.  This method attempts to correct the outrageous coordinates by
-		/// interpolating them to a point (along the original line) that lies at the edge of the ChartRect
-		/// so that GDI+ will handle it properly.  GDI+ will throw an exception, or just plot the data
-		/// incorrectly if the coordinates are too large (empirically, this appears to be when the
-		/// coordinate value is greater than 5,000,000 or less than -5,000,000).  Although you typically
-		/// would not see coordinates like this, if you repeatedly zoom in on a ZedGraphControl, eventually
-		/// all your points will be way outside the bounds of the plot.
-		/// </summary>
-		private void InterpolatePoint( Graphics g, GraphPane pane, CurveItem curve, PointPair lastPt,
-						float scaleFactor, Pen pen, float lastX, float lastY, float tmpX, float tmpY )
-		{
-			try
-			{
-				RectangleF chartRect = pane.Chart._rect;
-				// try to interpolate values
-				bool lastIn = chartRect.Contains( lastX, lastY );
-				bool curIn = chartRect.Contains( tmpX, tmpY );
-
-				// If both points are outside the ChartRect, make a new point that is on the LastX/Y
-				// side of the ChartRect, and fall through to the code that handles lastIn == true
-				if ( !lastIn )
-				{
-					float newX, newY;
-
-					if ( Math.Abs( lastX ) > Math.Abs( lastY ) )
-					{
-						newX = lastX < 0 ? chartRect.Left : chartRect.Right;
-						newY = lastY + ( tmpY - lastY ) * ( newX - lastX ) / ( tmpX - lastX );
-					}
-					else
-					{
-						newY = lastY < 0 ? chartRect.Top : chartRect.Bottom;
-						newX = lastX + ( tmpX - lastX ) * ( newY - lastY ) / ( tmpY - lastY );
-					}
-
-					lastX = newX;
-					lastY = newY;
-				}
-
-				if ( !curIn )
-				{
-					float newX, newY;
-
-					if ( Math.Abs( tmpX ) > Math.Abs( tmpY ) )
-					{
-						newX = tmpX < 0 ? chartRect.Left : chartRect.Right;
-						newY = tmpY + ( lastY - tmpY ) * ( newX - tmpX ) / ( lastX - tmpX );
-					}
-					else
-					{
-						newY = tmpY < 0 ? chartRect.Top : chartRect.Bottom;
-						newX = tmpX + ( lastX - tmpX ) * ( newY - tmpY ) / ( lastY - tmpY );
-					}
-
-					tmpX = newX;
-					tmpY = newY;
-				}
-
-				/*
-				if ( this.StepType == StepType.ForwardStep )
-				{
-					g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-					g.DrawLine( pen, tmpX, lastY, tmpX, tmpY );
-				}
-				else if ( this.StepType == StepType.RearwardStep )
-				{
-					g.DrawLine( pen, lastX, lastY, lastX, tmpY );
-					g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-				}
-				else 		// non-step
-					g.DrawLine( pen, lastX, lastY, tmpX, tmpY );
-				*/
-				if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-				{
-					using ( Pen tPen = GetPen( pane, scaleFactor, lastPt ) )
-					{
-						if ( this.StepType == StepType.NonStep )
-						{
-							g.DrawLine( tPen, lastX, lastY, tmpX, tmpY );
-						}
-						else if ( this.StepType == StepType.ForwardStep )
-						{
-							g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-							g.DrawLine( tPen, tmpX, lastY, tmpX, tmpY );
-						}
-						else if ( this.StepType == StepType.RearwardStep )
-						{
-							g.DrawLine( tPen, lastX, lastY, lastX, tmpY );
-							g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-						}
-						else if ( this.StepType == StepType.ForwardSegment )
-						{
-							g.DrawLine( tPen, lastX, lastY, tmpX, lastY );
-						}
-						else
-						{
-							g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY );
-						}
-					}
-				}
-				else
-				{
-					if ( this.StepType == StepType.NonStep )
-					{
-						g.DrawLine( pen, lastX, lastY, tmpX, tmpY );
-					}
-					else if ( this.StepType == StepType.ForwardStep )
-					{
-						g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-						g.DrawLine( pen, tmpX, lastY, tmpX, tmpY );
-					}
-					else if ( this.StepType == StepType.RearwardStep )
-					{
-						g.DrawLine( pen, lastX, lastY, lastX, tmpY );
-						g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-					}
-					else if ( this.StepType == StepType.ForwardSegment )
-					{
-						g.DrawLine( pen, lastX, lastY, tmpX, lastY );
-					}
-					else if ( this.StepType == StepType.RearwardSegment )
-					{
-						g.DrawLine( pen, lastX, tmpY, tmpX, tmpY );
-					}
-				}
-
-			}
-
-			catch { }
-		}
-
-		/// <summary>
-		/// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents
-		/// the current curve.  Note that this drawing routine ignores <see cref="PointPairBase.Missing"/>
-		/// values, but it does not "break" the line to indicate values are missing.
-		/// </summary>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.</param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		/// <param name="arrPoints">An array of <see cref="PointF"/> values in pixel
-		/// coordinates representing the current curve.</param>
-		/// <param name="count">The number of points contained in the "arrPoints"
-		/// parameter.</param>
-		/// <returns>true for a successful points array build, false for data problems</returns>
-		public bool BuildPointsArray( GraphPane pane, CurveItem curve,
-			out PointF[] arrPoints, out int count )
-		{
-			arrPoints = null;
-			count = 0;
-			IPointList points = curve.Points;
-
-			if ( this.IsVisible && !this.Color.IsEmpty && points != null )
-			{
-				int index = 0;
-				float curX, curY,
-							lastX = 0,
-							lastY = 0;
-				double x, y, lowVal;
-				ValueHandler valueHandler = new ValueHandler( pane, false );
-
-				// Step type plots get twice as many points.  Always add three points so there is
-				// room to close out the curve for area fills.
-				arrPoints = new PointF[( _stepType == ZedGraph.StepType.NonStep ? 1 : 2 ) *
-											points.Count + 1];
-
-				// Loop over all points in the curve
-				for ( int i = 0; i < points.Count; i++ )
-				{
-					// make sure that the current point is valid
-					if ( !points[i].IsInvalid )
-					{
-						// Get the user scale values for the current point
-						// use the valueHandler only for stacked types
-						if ( pane.LineType == LineType.Stack )
-						{
-							valueHandler.GetValues( curve, i, out x, out lowVal, out y );
-						}
-						// otherwise, just access the values directly.  Avoiding the valueHandler for
-						// non-stacked types is an optimization to minimize overhead in case there are
-						// a large number of points.
-						else
-						{
-							x = points[i].X;
-							y = points[i].Y;
-						}
-
-						if ( x == PointPair.Missing || y == PointPair.Missing )
-							continue;
-
-						// Transform the user scale values to pixel locations
-						Axis xAxis = curve.GetXAxis( pane );
-						curX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, x );
-						Axis yAxis = curve.GetYAxis( pane );
-						curY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, y );
-
-						if ( curX < -1000000 || curY < -1000000 || curX > 1000000 || curY > 1000000 )
-							continue;
-
-						// Add the pixel value pair into the points array
-						// Two points are added for step type curves
-						// ignore step-type setting for smooth curves
-						if ( _isSmooth || index == 0 || this.StepType == StepType.NonStep )
-						{
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-						else if ( this.StepType == StepType.ForwardStep ||
-										this.StepType == StepType.ForwardSegment )
-						{
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = lastY;
-							index++;
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-						else if ( this.StepType == StepType.RearwardStep ||
-										this.StepType == StepType.RearwardSegment )
-						{
-							arrPoints[index].X = lastX;
-							arrPoints[index].Y = curY;
-							index++;
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-
-						lastX = curX;
-						lastY = curY;
-						index++;
-
-					}
-
-				}
-
-				// Make sure there is at least one valid point
-				if ( index == 0 )
-					return false;
-
-				// Add an extra point at the end, since the smoothing algorithm requires it
-				arrPoints[index] = arrPoints[index - 1];
-				index++;
-
-				count = index;
-				return true;
-			}
-			else
-			{
-				return false;
-			}
-		}
-
-		/// <summary>
-		/// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents
-		/// the low values for the current curve.
-		/// </summary>
-		/// <remarks>Note that this drawing routine ignores <see cref="PointPairBase.Missing"/>
-		/// values, but it does not "break" the line to indicate values are missing.
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.</param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		/// <param name="arrPoints">An array of <see cref="PointF"/> values in pixel
-		/// coordinates representing the current curve.</param>
-		/// <param name="count">The number of points contained in the "arrPoints"
-		/// parameter.</param>
-		/// <returns>true for a successful points array build, false for data problems</returns>
-		public bool BuildLowPointsArray( GraphPane pane, CurveItem curve,
-						out PointF[] arrPoints, out int count )
-		{
-			arrPoints = null;
-			count = 0;
-			IPointList points = curve.Points;
-
-			if ( this.IsVisible && !this.Color.IsEmpty && points != null )
-			{
-				int index = 0;
-				float curX, curY,
-						lastX = 0,
-						lastY = 0;
-				double x, y, hiVal;
-				ValueHandler valueHandler = new ValueHandler( pane, false );
-
-				// Step type plots get twice as many points.  Always add three points so there is
-				// room to close out the curve for area fills.
-				arrPoints = new PointF[( _stepType == ZedGraph.StepType.NonStep ? 1 : 2 ) *
-					( pane.LineType == LineType.Stack ? 2 : 1 ) *
-					points.Count + 1];
-
-				// Loop backwards over all points in the curve
-				// In this case an array of points was already built forward by BuildPointsArray().
-				// This time we build backwards to complete a loop around the area between two curves.
-				for ( int i = points.Count - 1; i >= 0; i-- )
-				{
-					// Make sure the current point is valid
-					if ( !points[i].IsInvalid )
-					{
-						// Get the user scale values for the current point
-						valueHandler.GetValues( curve, i, out x, out y, out hiVal );
-
-						if ( x == PointPair.Missing || y == PointPair.Missing )
-							continue;
-
-						// Transform the user scale values to pixel locations
-						Axis xAxis = curve.GetXAxis( pane );
-						curX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, x );
-						Axis yAxis = curve.GetYAxis( pane );
-						curY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, y );
-
-						// Add the pixel value pair into the points array
-						// Two points are added for step type curves
-						// ignore step-type setting for smooth curves
-						if ( _isSmooth || index == 0 || this.StepType == StepType.NonStep )
-						{
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-						else if ( this.StepType == StepType.ForwardStep )
-						{
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = lastY;
-							index++;
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-						else if ( this.StepType == StepType.RearwardStep )
-						{
-							arrPoints[index].X = lastX;
-							arrPoints[index].Y = curY;
-							index++;
-							arrPoints[index].X = curX;
-							arrPoints[index].Y = curY;
-						}
-
-						lastX = curX;
-						lastY = curY;
-						index++;
-
-					}
-
-				}
-
-				// Make sure there is at least one valid point
-				if ( index == 0 )
-					return false;
-
-				// Add an extra point at the end, since the smoothing algorithm requires it
-				arrPoints[index] = arrPoints[index - 1];
-				index++;
-
-				count = index;
-				return true;
-			}
-			else
-			{
-				return false;
-			}
-		}
-
-		/// <summary>
-		/// Close off a <see cref="GraphicsPath"/> that defines a curve
-		/// </summary>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.</param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		/// <param name="arrPoints">An array of <see cref="PointF"/> values in screen pixel
-		/// coordinates representing the current curve.</param>
-		/// <param name="count">The number of points contained in the "arrPoints"
-		/// parameter.</param>
-		/// <param name="yMin">The Y axis value location where the X axis crosses.</param>
-		/// <param name="path">The <see cref="GraphicsPath"/> class that represents the curve.</param>
-		public void CloseCurve( GraphPane pane, CurveItem curve, PointF[] arrPoints,
-									int count, double yMin, GraphicsPath path )
-		{
-			// For non-stacked lines, the fill area is just the area between the curve and the X axis
-			if ( pane.LineType != LineType.Stack )
-			{
-				// Determine the current value for the bottom of the curve (usually the Y value where
-				// the X axis crosses)
-				float yBase;
-				Axis yAxis = curve.GetYAxis( pane );
-				yBase = yAxis.Scale.Transform( yMin );
-
-				// Add three points to the path to move from the end of the curve (as defined by
-				// arrPoints) to the X axis, from there to the start of the curve at the X axis,
-				// and from there back up to the beginning of the curve.
-				path.AddLine( arrPoints[count - 1].X, arrPoints[count - 1].Y, arrPoints[count - 1].X, yBase );
-				path.AddLine( arrPoints[count - 1].X, yBase, arrPoints[0].X, yBase );
-				path.AddLine( arrPoints[0].X, yBase, arrPoints[0].X, arrPoints[0].Y );
-			}
-			// For stacked line types, the fill area is the area between this curve and the curve below it
-			else
-			{
-				PointF[] arrPoints2;
-				int count2;
-
-				float tension = _isSmooth ? _smoothTension : 0f;
-
-				// Find the next lower curve in the curveList that is also a LineItem type, and use
-				// its smoothing properties for the lower side of the filled area.
-				int index = pane.CurveList.IndexOf( curve );
-				if ( index > 0 )
-				{
-					CurveItem tmpCurve;
-					for ( int i = index - 1; i >= 0; i-- )
-					{
-						tmpCurve = pane.CurveList[i];
-						if ( tmpCurve is LineItem )
-						{
-							tension = ( (LineItem)tmpCurve ).Line.IsSmooth ? ( (LineItem)tmpCurve ).Line.SmoothTension : 0f;
-							break;
-						}
-					}
-				}
-
-				// Build another points array consisting of the low points (which are actually the points for
-				// the curve below the current curve)
-				BuildLowPointsArray( pane, curve, out arrPoints2, out count2 );
-
-				// Add the new points to the GraphicsPath
-				path.AddCurve( arrPoints2, 0, count2 - 2, tension );
-			}
-
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/LineBase.cs b/BDInfo/ZedGraph/LineBase.cs
deleted file mode 100644
index ccd7a60965..0000000000
--- a/BDInfo/ZedGraph/LineBase.cs
+++ /dev/null
@@ -1,474 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that handles the basic attributes of a line segment.
-	/// </summary>
-	/// <remarks>
-	/// This is the base class for <see cref="Line" /> and <see cref="Border" /> classes.
-	/// </remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.2 $ $Date: 2007/03/17 18:43:44 $ </version>
-	[Serializable]
-	public class LineBase : ICloneable, ISerializable
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the pen width for this line.
-		/// Use the public property <see cref="Width"/> to access this value.
-		/// </summary>
-		internal float _width;
-		/// <summary>
-		/// Private field that stores the <see cref="DashStyle"/> for this
-		/// line.  Use the public
-		/// property <see cref="Style"/> to access this value.
-		/// </summary>
-		internal DashStyle _style;
-		/// <summary>
-		/// private field that stores the "Dash On" length for drawing the line.  Use the
-		/// public property <see cref="DashOn" /> to access this value.
-		/// </summary>
-		internal float _dashOn;
-		/// <summary>
-		/// private field that stores the "Dash Off" length for drawing the line.  Use the
-		/// public property <see cref="DashOff" /> to access this value.
-		/// </summary>
-		internal float _dashOff;
-
-		/// <summary>
-		/// Private field that stores the visibility of this line.  Use the public
-		/// property <see cref="IsVisible"/> to access this value.
-		/// </summary>
-		internal bool _isVisible;
-
-		/// <summary>
-		/// private field that determines if the line is drawn using
-		/// Anti-Aliasing capabilities from the <see cref="Graphics" /> class.
-		/// Use the public property <see cref="IsAntiAlias" /> to access
-		/// this value.
-		/// </summary>
-		internal bool _isAntiAlias;
-		/// <summary>
-		/// Private field that stores the color of this line.  Use the public
-		/// property <see cref="Color"/> to access this value.  If this value is
-		/// false, the line will not be shown (but the <see cref="Symbol"/> may
-		/// still be shown).
-		/// </summary>
-		internal Color _color;
-
-		/// <summary>
-		/// Internal field that stores a custom <see cref="Fill" /> class.  This
-		/// fill is used strictly for <see cref="FillType.GradientByX" />,
-		/// <see cref="FillType.GradientByY" />, <see cref="FillType.GradientByZ" />,
-		/// and <see cref="FillType.GradientByColorValue" /> calculations to determine
-		/// the color of the line.
-		/// </summary>
-		internal Fill _gradientFill;
-
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="LineBase"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default mode for displaying line segments (<see cref="LineBase.IsVisible"/>
-			/// property).  True to show the line segments, false to hide them.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// The default width for line segments (<see cref="LineBase.Width"/> property).
-			/// Units are points (1/72 inch).
-			/// </summary>
-			public static float Width = 1;
-			/// <summary>
-			/// The default value for the <see cref="LineBase.IsAntiAlias"/>
-			/// property.
-			/// </summary>
-			public static bool IsAntiAlias = false;
-
-			/// <summary>
-			/// The default drawing style for line segments (<see cref="LineBase.Style"/> property).
-			/// This is defined with the <see cref="DashStyle"/> enumeration.
-			/// </summary>
-			public static DashStyle Style = DashStyle.Solid;
-			/// <summary>
-			/// The default "dash on" size for drawing the line
-			/// (<see cref="LineBase.DashOn"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOn = 1.0F;
-			/// <summary>
-			/// The default "dash off" size for drawing the the line
-			/// (<see cref="LineBase.DashOff"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOff = 1.0F;
-
-			/// <summary>
-			/// The default color for the line.
-			/// This is the default value for the <see cref="LineBase.Color"/> property.
-			/// </summary>
-			public static Color Color = Color.Black;
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// The color of the <see cref="Line"/>.  Note that this color value can be
-		/// overridden if the <see cref="Fill.Type">GradientFill.Type</see> is one of the
-		/// <see cref="FillType.GradientByX" />,
-		/// <see cref="FillType.GradientByY" />, <see cref="FillType.GradientByZ" />,
-		/// and <see cref="FillType.GradientByColorValue" /> types.
-		/// </summary>
-		/// <seealso cref="GradientFill"/>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-		/// <summary>
-		/// The style of the <see cref="Line"/>, defined as a <see cref="DashStyle"/> enum.
-		/// This allows the line to be solid, dashed, or dotted.
-		/// </summary>
-		/// <seealso cref="Default.Style"/>
-		/// <seealso cref="DashOn" />
-		/// <seealso cref="DashOff" />
-		public DashStyle Style
-		{
-			get { return _style; }
-			set { _style = value; }
-		}
-
-		/// <summary>
-		/// The "Dash On" mode for drawing the line.
-		/// </summary>
-		/// <remarks>
-		/// This is the distance, in points (1/72 inch), of the dash segments that make up
-		/// the dashed grid lines.  This setting is only valid if 
-		/// <see cref="Style" /> is set to <see cref="DashStyle.Custom" />.
-		/// </remarks>
-		/// <value>The dash on length is defined in points (1/72 inch)</value>
-		/// <seealso cref="DashOff"/>
-		/// <seealso cref="IsVisible"/>
-		/// <seealso cref="Default.DashOn"/>.
-		public float DashOn
-		{
-			get { return _dashOn; }
-			set { _dashOn = value; }
-		}
-		/// <summary>
-		/// The "Dash Off" mode for drawing the line.
-		/// </summary>
-		/// <remarks>
-		/// This is the distance, in points (1/72 inch), of the spaces between the dash
-		/// segments that make up the dashed grid lines.  This setting is only valid if 
-		/// <see cref="Style" /> is set to <see cref="DashStyle.Custom" />.
-		/// </remarks>
-		/// <value>The dash off length is defined in points (1/72 inch)</value>
-		/// <seealso cref="DashOn"/>
-		/// <seealso cref="IsVisible"/>
-		/// <seealso cref="Default.DashOff"/>.
-		public float DashOff
-		{
-			get { return _dashOff; }
-			set { _dashOff = value; }
-		}
-
-		/// <summary>
-		/// The pen width used to draw the <see cref="Line"/>, in points (1/72 inch)
-		/// </summary>
-		/// <seealso cref="Default.Width"/>
-		public float Width
-		{
-			get { return _width; }
-			set { _width = value; }
-		}
-		/// <summary>
-		/// Gets or sets a property that shows or hides the <see cref="Line"/>.
-		/// </summary>
-		/// <value>true to show the line, false to hide it</value>
-		/// <seealso cref="Default.IsVisible"/>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines if the lines are drawn using
-		/// Anti-Aliasing capabilities from the <see cref="Graphics" /> class.
-		/// </summary>
-		/// <remarks>
-		/// If this value is set to true, then the <see cref="Graphics.SmoothingMode" />
-		/// property will be set to <see cref="SmoothingMode.HighQuality" /> only while
-		/// this <see cref="Line" /> is drawn.  A value of false will leave the value of
-		/// <see cref="Graphics.SmoothingMode" /> unchanged.
-		/// </remarks>
-		public bool IsAntiAlias
-		{
-			get { return _isAntiAlias; }
-			set { _isAntiAlias = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a custom <see cref="Fill" /> class.
-		/// </summary>
-		/// <remarks>This fill is used strictly for <see cref="FillType.GradientByX" />,
-		/// <see cref="FillType.GradientByY" />, <see cref="FillType.GradientByZ" />,
-		/// and <see cref="FillType.GradientByColorValue" /> calculations to determine
-		/// the color of the line.  It overrides the <see cref="Color" /> property if
-		/// one of the above <see cref="FillType" /> values are selected.
-		/// </remarks>
-		/// <seealso cref="Color"/>
-		public Fill GradientFill
-		{
-			get { return _gradientFill; }
-			set { _gradientFill = value; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="LineBase"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public LineBase()
-			: this( Color.Empty )
-		{
-		}
-
-		/// <summary>
-		/// Constructor that sets the color property to the specified value, and sets
-		/// the remaining <see cref="LineBase"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="color">The color to assign to this new Line object</param>
-		public LineBase( Color color )
-		{
-			_width = Default.Width;
-			_style = Default.Style;
-			_dashOn = Default.DashOn;
-			_dashOff = Default.DashOff;
-			_isVisible = Default.IsVisible;
-			_color = color.IsEmpty ? Default.Color : color;
-			_isAntiAlias = Default.IsAntiAlias;
-			_gradientFill = new Fill( Color.Red, Color.White );
-			_gradientFill.Type = FillType.None;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The LineBase object from which to copy</param>
-		public LineBase( LineBase rhs )
-		{
-			_width = rhs._width;
-			_style = rhs._style;
-			_dashOn = rhs._dashOn;
-			_dashOff = rhs._dashOff;
-
-			_isVisible = rhs._isVisible;
-			_color = rhs._color;
-
-			_isAntiAlias = rhs._isAntiAlias;
-			_gradientFill = new Fill( rhs._gradientFill );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-
-		// /// <summary>
-		// /// Typesafe, deep-copy clone method.
-		// /// </summary>
-		// /// <returns>A new, independent copy of this class</returns>
-		//public LineBase Clone()
-		//{
-		//	return new LineBase( this );
-		//}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema0 = 12;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the
-		/// serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains
-		/// the serialized data
-		/// </param>
-		protected LineBase( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema0" );
-
-			_width = info.GetSingle( "width" );
-			_style = (DashStyle)info.GetValue( "style", typeof( DashStyle ) );
-			_dashOn = info.GetSingle( "dashOn" );
-			_dashOff = info.GetSingle( "dashOff" );
-			_isVisible = info.GetBoolean( "isVisible" );
-			_isAntiAlias = info.GetBoolean( "isAntiAlias" );
-			_color = (Color)info.GetValue( "color", typeof( Color ) );
-			_gradientFill = (Fill)info.GetValue( "gradientFill", typeof( Fill ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize
-		/// the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the
-		/// serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the
-		/// serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema0", schema0 );
-
-			info.AddValue( "width", _width );
-			info.AddValue( "style", _style );
-			info.AddValue( "dashOn", _dashOn );
-			info.AddValue( "dashOff", _dashOff );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "isAntiAlias", _isAntiAlias );
-			info.AddValue( "color", _color );
-			info.AddValue( "gradientFill", _gradientFill );
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Create a <see cref="Pen" /> object based on the properties of this
-		/// <see cref="LineBase" />.
-		/// </summary>
-		/// <param name="pane">The owner <see cref="GraphPane" /> of this
-		/// <see cref="LineBase" />.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>A <see cref="Pen" /> object with the properties of this <see cref="LineBase" />
-		/// </returns>
-		public Pen GetPen( PaneBase pane, float scaleFactor )
-		{
-			return GetPen( pane, scaleFactor, null );
-		}
-
-		/// <summary>
-		/// Create a <see cref="Pen" /> object based on the properties of this
-		/// <see cref="LineBase" />.
-		/// </summary>
-		/// <param name="pane">The owner <see cref="GraphPane" /> of this
-		/// <see cref="LineBase" />.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable if <see cref="Fill.Type">GradientFill.Type</see>
-		/// is one of <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/>, <see cref="FillType.GradientByZ"/>,
-		/// or <see cref="FillType.GradientByColorValue" />.
-		/// </param>
-		/// <returns>A <see cref="Pen" /> object with the properties of this <see cref="LineBase" />
-		/// </returns>
-		public Pen GetPen( PaneBase pane, float scaleFactor, PointPair dataValue )
-		{
-			Color color = _color;
-			if ( _gradientFill.IsGradientValueType )
-				color = _gradientFill.GetGradientColor( dataValue );
-
-			Pen pen = new Pen( color,
-						pane.ScaledPenWidth( _width, scaleFactor ) );
-
-			pen.DashStyle = _style;
-
-			if ( _style == DashStyle.Custom )
-			{
-				if ( _dashOff > 1e-10 && _dashOn > 1e-10 )
-				{
-					pen.DashStyle = DashStyle.Custom;
-					float[] pattern = new float[2];
-					pattern[0] = _dashOn;
-					pattern[1] = _dashOff;
-					pen.DashPattern = pattern;
-				}
-				else
-					pen.DashStyle = DashStyle.Solid;
-			}
-
-			return pen;
-		}
-
-	#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/LineItem.cs b/BDInfo/ZedGraph/LineItem.cs
deleted file mode 100644
index 712b819384..0000000000
--- a/BDInfo/ZedGraph/LineItem.cs
+++ /dev/null
@@ -1,394 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates a curve type that is displayed as a line and/or a set of
-	/// symbols at each point.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.22 $ $Date: 2007/08/10 16:22:54 $ </version>
-	[Serializable]
-	public class LineItem : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.Symbol"/>
-		/// class defined for this <see cref="LineItem"/>.  Use the public
-		/// property <see cref="Symbol"/> to access this value.
-		/// </summary>
-		protected Symbol	_symbol;
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.Line"/>
-		/// class defined for this <see cref="LineItem"/>.  Use the public
-		/// property <see cref="Line"/> to access this value.
-		/// </summary>
-		protected Line		_line;
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Symbol"/> class instance defined
-		/// for this <see cref="LineItem"/>.
-		/// </summary>
-		public Symbol Symbol
-		{
-			get { return _symbol; }
-			set { _symbol = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Line"/> class instance defined
-		/// for this <see cref="LineItem"/>.
-		/// </summary>
-		public Line Line
-		{
-			get { return _line; }
-			set { _line = value; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return false;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return true;
-		}
-		
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="LineItem"/>, specifying only the legend <see cref="CurveItem.Label" />.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		public LineItem( string label ) : base( label )
-		{
-			_symbol = new Symbol();
-			_line = new Line();
-		}
-		
-		/// <summary>
-		/// Create a new <see cref="LineItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
-		/// type of symbol to use for this <see cref="LineItem"/>.  Use <see cref="SymbolType.None"/>
-		/// to hide the symbols.</param>
-		/// <param name="lineWidth">The width (in points) to be used for the <see cref="Line"/>.  This
-		/// width is scaled based on <see cref="PaneBase.CalcScaleFactor"/>.  Use a value of zero to
-		/// hide the line (see <see cref="ZedGraph.LineBase.IsVisible"/>).</param>
-		public LineItem( string label, double[] x, double[] y, Color color, SymbolType symbolType, float lineWidth )
-			: this( label, new PointPairList( x, y ), color, symbolType, lineWidth )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="LineItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
-		/// type of symbol to use for this <see cref="LineItem"/>.  Use <see cref="SymbolType.None"/>
-		/// to hide the symbols.</param>
-		public LineItem( string label, double[] x, double[] y, Color color, SymbolType symbolType )
-			: this( label, new PointPairList( x, y ), color, symbolType )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="LineItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
-		/// type of symbol to use for this <see cref="LineItem"/>.  Use <see cref="SymbolType.None"/>
-		/// to hide the symbols.</param>
-		/// <param name="lineWidth">The width (in points) to be used for the <see cref="Line"/>.  This
-		/// width is scaled based on <see cref="PaneBase.CalcScaleFactor"/>.  Use a value of zero to
-		/// hide the line (see <see cref="ZedGraph.LineBase.IsVisible"/>).</param>
-		public LineItem( string label, IPointList points, Color color, SymbolType symbolType, float lineWidth )
-			: base( label, points )
-		{
-			_line = new Line( color );
-			if ( lineWidth == 0 )
-				_line.IsVisible = false;
-			else
-				_line.Width = lineWidth;
-
-			_symbol = new Symbol( symbolType, color );
-		}
-
-		/// <summary>
-		/// Create a new <see cref="LineItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="symbolType">A <see cref="SymbolType"/> enum specifying the
-		/// type of symbol to use for this <see cref="LineItem"/>.  Use <see cref="SymbolType.None"/>
-		/// to hide the symbols.</param>
-		public LineItem( string label, IPointList points, Color color, SymbolType symbolType )
-			: this( label, points, color, symbolType, ZedGraph.LineBase.Default.Width )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="LineItem"/> object from which to copy</param>
-		public LineItem( LineItem rhs ) : base( rhs )
-		{
-			_symbol = new Symbol( rhs.Symbol );
-			_line = new Line( rhs.Line );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public LineItem Clone()
-		{
-			return new LineItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected LineItem( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_symbol = (Symbol) info.GetValue( "symbol", typeof(Symbol) );
-			_line = (Line) info.GetValue( "line", typeof(Line) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "symbol", _symbol );
-			info.AddValue( "line", _line );
-		}
-	#endregion
-
-	#region Methods
-		/// <summary>
-		/// Do all rendering associated with this <see cref="LineItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="Bar"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor  )
-		{
-			if ( _isVisible )
-			{
-				Line.Draw( g, pane, this, scaleFactor );
-				
-				Symbol.Draw( g, pane, this, scaleFactor, IsSelected );
-			}
-		}		
-
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="LineItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-        /// <param name="pane">
-        /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-        /// owner of this object.
-        /// </param>
-        /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-        /// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			// Draw a sample curve to the left of the label text
-			int xMid = (int)( rect.Left + rect.Width / 2.0F );
-			int yMid = (int) (rect.Top + rect.Height / 2.0F);
-			//RectangleF rect2 = rect;
-			//rect2.Y = yMid;
-			//rect2.Height = rect.Height / 2.0f;
-
-			_line.Fill.Draw( g, rect );
-
-			_line.DrawSegment( g, pane, rect.Left, yMid, rect.Right, yMid, scaleFactor );
-
-            // Draw a sample symbol to the left of the label text				
-			_symbol.DrawSymbol( g, pane, xMid, yMid, scaleFactor, false, null );
-
-		}
-	
-		/// <summary>
-		/// Loads some pseudo unique colors/symbols into this LineItem.  This
-		/// is mainly useful for differentiating a set of new LineItems without
-		/// having to pick your own colors/symbols.
-		/// <seealso cref="CurveItem.MakeUnique( ColorSymbolRotator )"/>
-		/// </summary>
-		/// <param name="rotator">
-		/// The <see cref="ColorSymbolRotator"/> that is used to pick the color
-		///  and symbol for this method call.
-		/// </param>
-		override public void MakeUnique( ColorSymbolRotator rotator )
-		{
-			this.Color			= rotator.NextColor;
-			this.Symbol.Type	= rotator.NextSymbol;
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			if ( i < 0 || i >= _points.Count )
-				return false;
-
-			PointPair pt = _points[i];
-			if ( pt.IsInvalid )
-				return false;
-
-			double x, y, z;
-			ValueHandler valueHandler = new ValueHandler( pane, false );
-			valueHandler.GetValues( this, i, out x, out z, out y );
-
-			Axis yAxis = GetYAxis( pane );
-			Axis xAxis = GetXAxis( pane );
-
-			PointF pixPt = new PointF( xAxis.Scale.Transform( _isOverrideOrdinal, i, x ),
-							yAxis.Scale.Transform( _isOverrideOrdinal, i, y ) );
-			
-			if ( !pane.Chart.Rect.Contains( pixPt ) )
-				return false;
-
-			float halfSize = _symbol.Size * pane.CalcScaleFactor();
-
-			coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-					pixPt.X - halfSize, pixPt.Y - halfSize,
-					pixPt.X + halfSize, pixPt.Y + halfSize );
-
-			return true;
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/LineObj.cs b/BDInfo/ZedGraph/LineObj.cs
deleted file mode 100644
index 38e6b35168..0000000000
--- a/BDInfo/ZedGraph/LineObj.cs
+++ /dev/null
@@ -1,338 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a line segment object on the graph.  A list of
-	/// GraphObj objects is maintained by the <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// <remarks>
-	/// This should not be confused with the <see cref="LineItem" /> class, which represents
-	/// a set of points plotted together as a "curve".  The <see cref="LineObj" /> class is
-	/// a single line segment, drawn as a "decoration" on the chart.</remarks>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/01/25 07:56:09 $ </version>
-	[Serializable]
-	public class LineObj : GraphObj, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// protected field that maintains the attributes of the line using an
-		/// instance of the <see cref="LineBase" /> class.
-		/// </summary>
-		protected LineBase _line;
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// A <see cref="LineBase" /> class that contains the attributes for drawing this
-		/// <see cref="LineObj" />.
-		/// </summary>
-		public LineBase Line
-		{
-			get { return _line; }
-			set { _line = value; }
-		}
-
-	#endregion
-
-
-	#region Constructors
-
-		/// <overloads>Constructors for the <see cref="LineObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the position, color, and size of the
-		/// <see cref="LineObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="color">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the arrow</param>
-		/// <param name="x1">The x position of the starting point that defines the
-		/// line.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y1">The y position of the starting point that defines the
-		/// line.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="x2">The x position of the ending point that defines the
-		/// line.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y2">The y position of the ending point that defines the
-		/// line.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public LineObj( Color color, double x1, double y1, double x2, double y2 )
-			: base( x1, y1, x2 - x1, y2 - y1 )
-		{
-			_line = new LineBase( color );
-			this.Location.AlignH = AlignH.Left;
-			this.Location.AlignV = AlignV.Top;
-		}
-
-		/// <summary>
-		/// A constructor that allows only the position of the
-		/// line to be pre-specified.  All other properties are set to
-		/// default values
-		/// </summary>
-		/// <param name="x1">The x position of the starting point that defines the
-		/// <see cref="LineObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y1">The y position of the starting point that defines the
-		/// <see cref="LineObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="x2">The x position of the ending point that defines the
-		/// <see cref="LineObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		/// <param name="y2">The y position of the ending point that defines the
-		/// <see cref="LineObj"/>.  The units of this position are specified by the
-		/// <see cref="Location.CoordinateFrame"/> property.</param>
-		public LineObj( double x1, double y1, double x2, double y2 )
-			: this( LineBase.Default.Color, x1, y1, x2, y2 )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor -- places the <see cref="LineObj"/> at location
-		/// (0,0) to (1,1).  All other values are defaulted.
-		/// </summary>
-		public LineObj() : this( LineBase.Default.Color, 0, 0, 1, 1 )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="LineObj"/> object from which to copy</param>
-		public LineObj( LineObj rhs ) : base( rhs )
-		{
-			_line = new LineBase( rhs._line );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public LineObj Clone()
-		{
-			return new LineObj( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		// changed to 2 with addition of Style property
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected LineObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_line = (LineBase)info.GetValue( "line", typeof( LineBase ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-
-			info.AddValue( "line", _line );
-		}
-	#endregion
-
-	#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// Convert the arrow coordinates from the user coordinate system
-			// to the screen coordinate system
-			PointF pix1 = this.Location.TransformTopLeft( pane );
-			PointF pix2 = this.Location.TransformBottomRight( pane );
-
-			if ( pix1.X > -10000 && pix1.X < 100000 && pix1.Y > -100000 && pix1.Y < 100000 &&
-				pix2.X > -10000 && pix2.X < 100000 && pix2.Y > -100000 && pix2.Y < 100000 )
-			{
-				// calculate the length and the angle of the arrow "vector"
-				double dy = pix2.Y - pix1.Y;
-				double dx = pix2.X - pix1.X;
-				float angle = (float)Math.Atan2( dy, dx ) * 180.0F / (float)Math.PI;
-				float length = (float)Math.Sqrt( dx * dx + dy * dy );
-
-				// Save the old transform matrix
-				Matrix transform = g.Transform;
-				// Move the coordinate system so it is located at the starting point
-				// of this arrow
-				g.TranslateTransform( pix1.X, pix1.Y );
-				// Rotate the coordinate system according to the angle of this arrow
-				// about the starting point
-				g.RotateTransform( angle );
-
-				// get a pen according to this arrow properties
-				using ( Pen pen = _line.GetPen( pane, scaleFactor ) )
-				//new Pen( _line._color, pane.ScaledPenWidth( _line._width, scaleFactor ) ) )
-				{
-					//pen.DashStyle = _style;
-
-					g.DrawLine( pen, 0, 0, length, 0 );
-				}
-
-				// Restore the transform matrix back to its original state
-				g.Transform = transform;
-			}
-		}
-
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="LineObj"/>.
-		/// </summary>
-		/// <remarks>The bounding box is calculated assuming a distance
-		/// of <see cref="GraphPane.Default.NearestTol"/> pixels around the arrow segment.
-		/// </remarks>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-				return false;
-
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			PointF pix = _location.TransformTopLeft( pane );
-			PointF pix2 = _location.TransformBottomRight( pane );
-
-			using ( Pen pen = new Pen( Color.Black, (float)GraphPane.Default.NearestTol * 2.0F ) )
-			{
-				using ( GraphicsPath path = new GraphicsPath() )
-				{
-					path.AddLine( pix, pix2 );
-					return path.IsOutlineVisible( pt, pen );
-				}
-			}
-		}
-
-		/// <summary>
-		/// Determines the shape type and Coords values for this GraphObj
-		/// </summary>
-		override public void GetCoords( PaneBase pane, Graphics g, float scaleFactor,
-				out string shape, out string coords )
-		{
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			RectangleF pixRect = _location.TransformRect( pane );
-
-			Matrix matrix = new Matrix();
-			if ( pixRect.Right == 0 )
-				pixRect.Width = 1;
-			float angle = (float) Math.Atan( ( pixRect.Top - pixRect.Bottom ) /
-					( pixRect.Left - pixRect.Right ) );
-			matrix.Rotate( angle, MatrixOrder.Prepend );
-
-			// Move the coordinate system to local coordinates
-			// of this text object (that is, at the specified
-			// x,y location)
-			matrix.Translate( -pixRect.Left, -pixRect.Top, MatrixOrder.Prepend );
-
-			PointF[] pts = new PointF[4];
-			pts[0] = new PointF( 0, 3 );
-			pts[1] = new PointF( pixRect.Width, 3 );
-			pts[2] = new PointF( pixRect.Width, -3 );
-			pts[3] = new PointF( 0, -3 );
-			matrix.TransformPoints( pts );
-
-			shape = "poly";
-			coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0},{4:f0},{5:f0},{6:f0},{7:f0},",
-						pts[0].X, pts[0].Y, pts[1].X, pts[1].Y,
-						pts[2].X, pts[2].Y, pts[3].X, pts[3].Y );
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/LinearAsOrdinalScale.cs b/BDInfo/ZedGraph/LinearAsOrdinalScale.cs
deleted file mode 100644
index d0373374b8..0000000000
--- a/BDInfo/ZedGraph/LinearAsOrdinalScale.cs
+++ /dev/null
@@ -1,244 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The LinearAsOrdinalScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.LinearAsOrdinal" />.
-	/// </summary>
-	/// <remarks>
-	/// LinearAsOrdinal is an ordinal axis that will have labels formatted with values from the actual data
-	/// values of the first <see cref="CurveItem" /> in the <see cref="CurveList" />.
-	/// Although the tics are labeled with real data values, the actual points will be
-	/// evenly-spaced in spite of the data values.  For example, if the X values of the first curve
-	/// are 1, 5, and 100, then the tic labels will show 1, 5, and 100, but they will be equal
-	/// distance from each other.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.10 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	class LinearAsOrdinalScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public LinearAsOrdinalScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="LinearAsOrdinalScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="LinearAsOrdinalScale" /></param>
-		public LinearAsOrdinalScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new LinearAsOrdinalScale( this, owner );
-		}
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.LinearAsOrdinal" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.LinearAsOrdinal; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Select a reasonable ordinal axis scale given a range of data values, with the expectation that
-		/// linear values will be displayed.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.DateAsOrdinal"/> type axes, and it
-		/// is called by the general <see cref="Scale.PickScale"/> method.  For this type,
-		/// the first curve is the "master", which contains the dates to be applied.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="PickScale"/>
-		/// <seealso cref="AxisType.Ordinal"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// First, get the date ranges from the first curve in the list
-			double xMin; // = Double.MaxValue;
-			double xMax; // = Double.MinValue;
-			double yMin; // = Double.MaxValue;
-			double yMax; // = Double.MinValue;
-			double tMin = 0;
-			double tMax = 1;
-
-			foreach ( CurveItem curve in pane.CurveList )
-			{
-				if ( ( _ownerAxis is Y2Axis && curve.IsY2Axis ) ||
-						( _ownerAxis is YAxis && !curve.IsY2Axis ) ||
-						( _ownerAxis is X2Axis && curve.IsX2Axis ) ||
-						( _ownerAxis is XAxis && !curve.IsX2Axis ) )
-				{
-					curve.GetRange( out xMin, out xMax, out yMin, out yMax, false, false, pane );
-					if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-					{
-						tMin = xMin;
-						tMax = xMax;
-					}
-					else
-					{
-						tMin = yMin;
-						tMax = yMax;
-					}
-				}
-			}
-
-			double range = Math.Abs( tMax - tMin );
-
-			// Now, set the axis range based on a ordinal scale
-			base.PickScale( pane, g, scaleFactor );
-			OrdinalScale.PickScale( pane, g, scaleFactor, this );
-
-			SetScaleMag( tMin, tMax, range / Default.TargetXSteps );
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.LinearAsOrdinal" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			double val;
-
-			int tmpIndex = (int) dVal - 1;
-
-			if ( pane.CurveList.Count > 0 && pane.CurveList[0].Points.Count > tmpIndex )
-			{
-				val = pane.CurveList[0].Points[tmpIndex].X;
-				double scaleMult = Math.Pow( (double) 10.0, _mag );
-				return ( val / scaleMult ).ToString( _format );
-			}
-			else
-				return string.Empty;
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected LinearAsOrdinalScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/LinearScale.cs b/BDInfo/ZedGraph/LinearScale.cs
deleted file mode 100644
index cdd4b6c8a4..0000000000
--- a/BDInfo/ZedGraph/LinearScale.cs
+++ /dev/null
@@ -1,234 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The LinearScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Linear" />.
-	/// </summary>
-	/// <remarks>
-	/// LinearScale is the normal, default cartesian axis.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.10 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	class LinearScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public LinearScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="LinearScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="LinearScale" /></param>
-		public LinearScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new LinearScale( this, owner );
-		}
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.Linear" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.Linear; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Select a reasonable linear axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Linear"/> type axes, and it
-		/// is called by the general <see cref="Scale.PickScale"/> method.  The scale range is chosen
-		/// based on increments of 1, 2, or 5 (because they are even divisors of 10).  This
-		/// method honors the <see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min"/>, <see cref="Scale.Max"/>, or <see cref="Scale.MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  The basic defaults for
-		/// scale selection are defined using <see cref="Scale.Default.ZeroLever"/>,
-		/// <see cref="Scale.Default.TargetXSteps"/>, and <see cref="Scale.Default.TargetYSteps"/>
-		/// from the <see cref="Scale.Default"/> default class.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="PickScale"/>
-		/// <seealso cref="AxisType.Linear"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( _max - _min < 1.0e-30 )
-			{
-				if ( _maxAuto )
-					_max = _max + 0.2 * ( _max == 0 ? 1.0 : Math.Abs( _max ) );
-				if ( _minAuto )
-					_min = _min - 0.2 * ( _min == 0 ? 1.0 : Math.Abs( _min ) );
-			}
-
-			// This is the zero-lever test.  If minVal is within the zero lever fraction
-			// of the data range, then use zero.
-
-			if ( _minAuto && _min > 0 &&
-				_min / ( _max - _min ) < Default.ZeroLever )
-				_min = 0;
-
-			// Repeat the zero-lever test for cases where the maxVal is less than zero
-			if ( _maxAuto && _max < 0 &&
-				Math.Abs( _max / ( _max - _min ) ) <
-				Default.ZeroLever )
-				_max = 0;
-
-			// Calculate the new step size
-			if ( _majorStepAuto )
-			{
-				double targetSteps = ( _ownerAxis is XAxis || _ownerAxis is X2Axis ) ?
-							Default.TargetXSteps : Default.TargetYSteps;
-
-				// Calculate the step size based on target steps
-				_majorStep = CalcStepSize( _max - _min, targetSteps );
-
-				if ( _isPreventLabelOverlap )
-				{
-					// Calculate the maximum number of labels
-					double maxLabels = (double) this.CalcMaxLabels( g, pane, scaleFactor );
-
-					if ( maxLabels < ( _max - _min ) / _majorStep )
-						_majorStep = CalcBoundedStepSize( _max - _min, maxLabels );
-				}
-			}
-
-			// Calculate the new step size
-			if ( _minorStepAuto )
-				_minorStep = CalcStepSize( _majorStep,
-					( _ownerAxis is XAxis || _ownerAxis is X2Axis ) ?
-							Default.TargetMinorXSteps : Default.TargetMinorYSteps );
-
-			// Calculate the scale minimum
-			if ( _minAuto )
-				_min = _min - MyMod( _min, _majorStep );
-
-			// Calculate the scale maximum
-			if ( _maxAuto )
-				_max = MyMod( _max, _majorStep ) == 0.0 ? _max :
-					_max + _majorStep - MyMod( _max, _majorStep );
-
-			SetScaleMag( _min, _max, _majorStep );
-		}
-
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected LinearScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Link.cs b/BDInfo/ZedGraph/Link.cs
deleted file mode 100644
index cdf7fb724b..0000000000
--- a/BDInfo/ZedGraph/Link.cs
+++ /dev/null
@@ -1,304 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that maintains hyperlink information for a clickable object on the graph.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.6 $ $Date: 2007/04/16 00:03:02 $ </version>
-	// /// <seealso cref="ZedGraph.Web.IsImageMap"/>
-	[Serializable]
-	public class Link : ISerializable, ICloneable
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// Internal field that stores the title string for this link.  
-		/// </summary>
-		internal string _title;
-
-		/// <summary>
-		/// Internal field that stores the url string for this link
-		/// </summary>
-		internal string _url;
-
-		/// <summary>
-		/// Internal field that stores the target string for this link
-		/// </summary>
-		internal string _target;
-
-		/// <summary>
-		/// Internal field that determines if this link is "live".
-		/// </summary>
-		internal bool _isEnabled;
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the title string for this link.
-		/// </summary>
-		/// <remarks>
-		/// For web controls, this title will be shown as a tooltip when the mouse
-		/// hovers over the area of the object that owns this link.  Set the value to
-		/// <see cref="String.Empty" /> to have no title.
-		/// </remarks>
-		public string Title
-		{
-			get { return _title; }
-			set { _title = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the url string for this link.
-		/// </summary>
-		/// <remarks>
-		/// Set this value to <see cref="String.Empty" /> if you don't want to have
-		/// a hyperlink associated with the object to which this link belongs.
-		/// </remarks>
-		public string Url
-		{
-			get { return _url; }
-			set { _url = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the target string for this link.
-		/// </summary>
-		/// <remarks>
-		/// This value should be set to a valid target associated with the "Target"
-		/// property of an html hyperlink.  Typically, this would be "_blank" to open
-		/// a new browser window, or "_self" to open in the current browser.
-		/// </remarks>
-		public string Target
-		{
-			get { return _target != string.Empty ? _target : "_self"; }
-			set { _target = value; }
-		}
-
-		/// <summary>
-		/// A tag object for use by the user.  This can be used to store additional
-		/// information associated with the <see cref="Link"/>.  ZedGraph does
-		/// not use this value for any purpose.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag;
-
-		/// <summary>
-		/// Gets or sets a property that determines if this link is active.  True to have
-		/// a clickable link, false to ignore the link.
-		/// </summary>
-		public bool IsEnabled
-		{
-			get { return _isEnabled; }
-			set { _isEnabled = value; }
-		}
-
-		/// <summary>
-		/// Gets a value that indicates if this <see cref="Link" /> is enabled
-		/// (see <see cref="IsEnabled" />), and that either the
-		/// <see cref="Url" /> or the <see cref="Title" /> is non-null.
-		/// </summary>
-		public bool IsActive
-		{
-			get { return _isEnabled && ( _url != null || _title != null ); }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor.  Set all properties to string.Empty, or null.
-		/// </summary>
-		public Link()
-		{
-			_title = string.Empty;
-			_url = string.Empty;
-			_target = string.Empty;
-			this.Tag = null;
-			_isEnabled = false;
-		}
-
-		/// <summary>
-		/// Construct a Link instance from a specified title, url, and target.
-		/// </summary>
-		/// <param name="title">The title for the link (which shows up in the tooltip).</param>
-		/// <param name="url">The URL destination for the link.</param>
-		/// <param name="target">The target for the link (typically "_blank" or "_self").</param>
-		public Link( string title, string url, string target )
-		{
-			_title = title;
-			_url = url;
-			_target = target;
-			Tag = null;
-			_isEnabled = true;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="Link"/> object from which to copy</param>
-		public Link( Link rhs )
-		{
-			// Copy value types
-			_title = rhs._title;
-			_url = rhs._url;
-			_target = rhs._target;
-			_isEnabled = false;
-
-			// copy reference types by cloning
-			if ( rhs.Tag is ICloneable )
-				this.Tag = ((ICloneable) rhs.Tag).Clone();
-			else
-				this.Tag = rhs.Tag;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Link Clone()
-		{
-			return new Link( this );
-		}
-
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Create a URL for a <see cref="CurveItem" /> that includes the index of the
-		/// point that was selected.
-		/// </summary>
-		/// <remarks>
-		/// An "index" parameter is added to the <see cref="Url" /> property for this
-		/// link to indicate which point was selected.  Further, if the 
-		/// X or Y axes that correspond to this <see cref="CurveItem" /> are of
-		/// <see cref="AxisType.Text" />, then an
-		/// additional parameter will be added containing the text value that
-		/// corresponds to the <paramref name="index" /> of the selected point.
-		/// The <see cref="XAxis" /> text parameter will be labeled "xtext", and
-		/// the <see cref="YAxis" /> text parameter will be labeled "ytext".
-		/// </remarks>
-		/// <param name="index">The zero-based index of the selected point</param>
-		/// <param name="pane">The <see cref="GraphPane" /> of interest</param>
-		/// <param name="curve">The <see cref="CurveItem" /> for which to
-		/// make the url string.</param>
-		/// <returns>A string containing the url with an index parameter added.</returns>
-		public virtual string MakeCurveItemUrl( GraphPane pane, CurveItem curve, int index )
-		{
-			string url = _url;
-
-			if ( url.IndexOf( '?' ) >= 0 )
-				url += "&index=" + index.ToString();
-			else
-				url += "?index=" + index.ToString();
-
-			Axis xAxis = curve.GetXAxis( pane );
-			if (	xAxis.Type == AxisType.Text && index >= 0 &&
-					xAxis.Scale.TextLabels != null &&
-					index <= xAxis.Scale.TextLabels.Length )
-				url += "&xtext=" + xAxis.Scale.TextLabels[index];
-
-			Axis yAxis = curve.GetYAxis( pane );
-			if (	yAxis != null && yAxis.Type == AxisType.Text && index >= 0 &&
-					yAxis.Scale.TextLabels != null &&
-					index <= yAxis.Scale.TextLabels.Length )
-				url += "&ytext=" + yAxis.Scale.TextLabels[index];
-
-			return url;
-		}
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		/// <remarks>
-		/// schema started with 10 for ZedGraph version 5
-		/// </remarks>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Link( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_title = info.GetString( "title" );
-			_url = info.GetString( "url" );
-			_target = info.GetString( "target" );
-			_isEnabled = info.GetBoolean( "isEnabled" );
-			Tag = info.GetValue( "Tag", typeof(object) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "title", _title );
-			info.AddValue( "url", _url );
-			info.AddValue( "target", _target );
-			info.AddValue( "isEnabled", _isEnabled );
-			info.AddValue( "Tag", Tag );
-		}
-
-	#endregion
-
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/Location.cs b/BDInfo/ZedGraph/Location.cs
deleted file mode 100644
index c24d383b03..0000000000
--- a/BDInfo/ZedGraph/Location.cs
+++ /dev/null
@@ -1,566 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class than contains information about the position of an object on the graph.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.14 $ $Date: 2006/06/24 20:26:43 $ </version>
-	[Serializable]
-	public class Location : ICloneable, ISerializable
-	{
-	#region Private Fields
-		/// <summary> Private field to store the vertical alignment property for
-		/// this object.  Use the public property <see cref="Location.AlignV"/>
-		/// to access this value.  The value of this field is a <see cref="AlignV"/> enum.
-		/// </summary>
-		private AlignV	_alignV;
-		/// <summary> Private field to store the horizontal alignment property for
-		/// this object.  Use the public property <see cref="Location.AlignH"/>
-		/// to access this value.  The value of this field is a <see cref="AlignH"/> enum.
-		/// </summary>
-		private AlignH	_alignH;
-
-		/// <summary> Private fields to store the X and Y coordinate positions for
-		/// this object.  Use the public properties <see cref="X"/> and
-		/// <see cref="Y"/> to access these values.  The coordinate type stored here is
-		/// dependent upon the setting of <see cref="CoordinateFrame"/>.
-		/// </summary>
-		private double	_x,
-							_y,
-							_width,
-							_height;
-							
-		/// <summary>
-		/// Private field to store the coordinate system to be used for defining the
-		/// object position.  Use the public property
-		/// <see cref="CoordinateFrame"/> to access this value. The coordinate system
-		/// is defined with the <see cref="CoordType"/> enum.
-		/// </summary>
-		private CoordType	_coordinateFrame;
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// A horizontal alignment parameter for this object specified
-		/// using the <see cref="AlignH"/> enum type.
-		/// </summary>
-		public AlignH AlignH
-		{
-			get { return _alignH; }
-			set { _alignH = value; }
-		}
-		/// <summary>
-		/// A vertical alignment parameter for this object specified
-		/// using the <see cref="AlignV"/> enum type.
-		/// </summary>
-		public AlignV AlignV
-		{
-			get { return _alignV; }
-			set { _alignV = value; }
-		}
-		/// <summary>
-		/// The coordinate system to be used for defining the object position
-		/// </summary>
-		/// <value> The coordinate system is defined with the <see cref="CoordType"/>
-		/// enum</value>
-		public CoordType CoordinateFrame
-		{
-			get { return _coordinateFrame; }
-			set { _coordinateFrame = value; }
-		}
-		/// <summary>
-		/// The x position of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position
-		/// are specified by the <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignH"/> property.
-		/// </remarks>
-		public double X
-		{
-			get { return _x; }
-			set { _x = value; }
-		}
-		/// <summary>
-		/// The y position of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position
-		/// are specified by the <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignV"/> property.
-		/// </remarks>
-		public double Y
-		{
-			get { return _y; }
-			set { _y = value; }
-		}
-		/// <summary>
-		/// The x1 position of the object (an alias for the x position).
-		/// </summary>
-		/// <remarks>
-		/// The units of this position
-		/// are specified by the <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignH"/> property.
-		/// </remarks>
-		public double X1
-		{
-			get { return _x; }
-			set { _x = value; }
-		}
-		/// <summary>
-		/// The y1 position of the object (an alias for the y position).
-		/// </summary>
-		/// <remarks>
-		/// The units of this position
-		/// are specified by the <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignV"/> property.
-		/// </remarks>
-		public double Y1
-		{
-			get { return _y; }
-			set { _y = value; }
-		}
-		/// <summary>
-		/// The width of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position are specified by the
-		/// <see cref="CoordinateFrame"/> property.
-		/// </remarks>
-		public double Width
-		{
-			get { return _width; }
-			set { _width = value; }
-		}
-		/// <summary>
-		/// The height of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position are specified by the
-		/// <see cref="CoordinateFrame"/> property.
-		/// </remarks>
-		public double Height
-		{
-			get { return _height; }
-			set { _height = value; }
-		}
-		/// <summary>
-		/// The x2 position of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position are specified by the
-		/// <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignH"/> property.  This position is only used for
-		/// objects such as <see cref="ArrowObj"/>, where it makes sense
-		/// to have a second coordinate.  Note that the X2 position is stored
-		/// internally as a <see cref="Width"/> offset from <see cref="X"/>.
-		/// </remarks>
-		public double X2
-		{
-			get { return _x+_width; }
-			//set { width = value-x; }
-		}
-		/// <summary>
-		/// The y2 position of the object.
-		/// </summary>
-		/// <remarks>
-		/// The units of this position
-		/// are specified by the <see cref="CoordinateFrame"/> property.
-		/// The object will be aligned to this position based on the
-		/// <see cref="AlignV"/> property.  This position is only used for
-		/// objects such as <see cref="ArrowObj"/>, where it makes sense
-		/// to have a second coordinate.  Note that the Y2 position is stored
-		/// internally as a <see cref="Height"/> offset from <see cref="Y"/>.
-		/// </remarks>
-		public double Y2
-		{
-			get { return _y+_height; }
-			//set { height = value-y; }
-		}
-
-		/// <summary>
-		/// The <see cref="RectangleF"/> for this object as defined by the
-		/// <see cref="X"/>, <see cref="Y"/>, <see cref="Width"/>, and
-		/// <see cref="Height"/> properties.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method reduces the precision of the location coordinates from double
-		/// precision to single precision.  In some cases, such as <see cref="AxisType.Date" />, it
-		/// may affect the resolution of the point location.
-		/// </remarks>
-		/// <value>A <see cref="RectangleF"/> in <see cref="CoordinateFrame"/>
-		/// units.</value>
-		public RectangleF Rect
-		{
-			get { return new RectangleF( (float)_x, (float)_y, (float)_width, (float)_height ); }
-			set
-			{
-				_x = value.X;
-				_y = value.Y;
-				_width = value.Width;
-				_height = value.Height;
-			}
-		}
-
-		/// <summary>
-		/// The top-left <see cref="PointF"/> for this <see cref="Location"/>.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method reduces the precision of the location coordinates from double
-		/// precision to single precision.  In some cases, such as <see cref="AxisType.Date" />, it
-		/// may affect the resolution of the point location.
-		/// </remarks>
-		/// <value>A <see cref="PointF"/> in <see cref="CoordinateFrame"/> units.</value>
-		public PointF TopLeft
-		{
-			get { return new PointF( (float)_x, (float)_y ); }
-			set { _x = value.X; _y = value.Y; }
-		}
-
-		/// <summary>
-		/// The bottom-right <see cref="PointF"/> for this <see cref="Location"/>.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method reduces the precision of the location coordinates from double
-		/// precision to single precision.  In some cases, such as <see cref="AxisType.Date" />, it
-		/// may affect the resolution of the point location.
-		/// </remarks>
-		/// <value>A <see cref="PointF"/> in <see cref="CoordinateFrame"/> units.</value>
-		public PointF BottomRight
-		{
-			get { return new PointF( (float)this.X2, (float)this.Y2 ); }
-			//set { this.X2 = value.X; this.Y2 = value.Y; }
-		}
-	#endregion
-	
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the <see cref="Location"/> class.
-		/// </summary>
-		public Location() : this( 0, 0, CoordType.ChartFraction )
-		{
-		}
-
-		/// <summary>
-		/// Constructor for the <see cref="Location"/> class that specifies the
-		/// x, y position and the <see cref="CoordType"/>.
-		/// </summary>
-		/// <remarks>
-		/// The (x,y) position corresponds to the top-left corner;
-		/// </remarks>
-		/// <param name="x">The x position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="y">The y position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum that specifies the
-		/// units for <see paramref="x"/> and <see paramref="y"/></param>
-		public Location( double x, double y, CoordType coordType ) :
-				this( x, y, coordType, AlignH.Left, AlignV.Top )
-		{
-		}
-		
-		/// <summary>
-		/// Constructor for the <see cref="Location"/> class that specifies the
-		/// x, y position and the <see cref="CoordType"/>.
-		/// </summary>
-		/// <remarks>
-		/// The (x,y) position corresponds to the top-left corner;
-		/// </remarks>
-		/// <param name="x">The x position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="y">The y position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum that specifies the
-		/// units for <see paramref="x"/> and <see paramref="y"/></param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public Location( double x, double y, CoordType coordType, AlignH alignH, AlignV alignV )
-		{
-			_x = x;
-			_y = y;
-			_width = 0;
-			_height = 0;
-			_coordinateFrame = coordType;
-			_alignH = alignH;
-			_alignV = alignV;
-		}
-		
-		/// <summary>
-		/// Constructor for the <see cref="Location"/> class that specifies the
-		/// (x, y), (width, height), and the <see cref="CoordType"/>.
-		/// </summary>
-		/// <remarks>
-		/// The (x,y) position
-		/// corresponds to the starting position, the (x2, y2) coorresponds to the ending position
-		/// (typically used for <see cref="ArrowObj"/>'s).
-		/// </remarks>
-		/// <param name="x">The x position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="y">The y position, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="width">The width, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="height">The height, specified in units of <see paramref="coordType"/>.
-		/// </param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum that specifies the
-		/// units for <see paramref="x"/> and <see paramref="y"/></param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public Location( double x, double y, double width, double height,
-			CoordType coordType, AlignH alignH, AlignV alignV ) :
-				this( x, y, coordType, alignH, alignV )
-		{
-			_width = width;
-			_height = height;
-		}
-		
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="Location"/> object from which to copy</param>
-		public Location( Location rhs )
-		{
-			_x = rhs._x;
-			_y = rhs._y;
-			_width = rhs._width;
-			_height = rhs._height;
-			_coordinateFrame = rhs.CoordinateFrame;
-			_alignH = rhs.AlignH;
-			_alignV = rhs.AlignV;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Location Clone()
-		{
-			return new Location( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Location( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_alignV = (AlignV) info.GetValue( "alignV", typeof(AlignV) );
-			_alignH = (AlignH) info.GetValue( "alignH", typeof(AlignH) );
-			_x = info.GetDouble( "x" );
-			_y = info.GetDouble( "y" );
-			_width = info.GetDouble( "width" );
-			_height = info.GetDouble( "height" );
-			_coordinateFrame = (CoordType) info.GetValue( "coordinateFrame", typeof(CoordType) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "alignV", _alignV );
-			info.AddValue( "alignH", _alignH );
-			info.AddValue( "x", _x );
-			info.AddValue( "y", _y );
-			info.AddValue( "width", _width );
-			info.AddValue( "height", _height );
-			info.AddValue( "coordinateFrame", _coordinateFrame );
-		}
-	#endregion
-
-	#region Methods
-		/// <summary>
-		/// Transform this <see cref="Location"/> object to display device
-		/// coordinates using the properties of the specified <see cref="GraphPane"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that contains
-		/// the <see cref="Axis"/> classes which will be used for the transform.
-		/// </param>
-		/// <returns>A point in display device coordinates that corresponds to the
-		/// specified user point.</returns>
-		public PointF Transform( PaneBase pane )
-		{
-			return Transform( pane, _x, _y,
-						_coordinateFrame );
-		}
-		
-		/// <summary>
-		/// Transform a data point from the specified coordinate type
-		/// (<see cref="CoordType"/>) to display device coordinates (pixels).
-		/// </summary>
-		/// <remarks>
-		/// If <see paramref="pane"/> is not of type <see cref="GraphPane"/>, then
-		/// only the <see cref="CoordType.PaneFraction"/> transformation is available.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that contains
-		/// the <see cref="Axis"/> classes which will be used for the transform.
-		/// </param>
-		/// <param name="x">The x coordinate that defines the point in user
-		/// space.</param>
-		/// <param name="y">The y coordinate that defines the point in user
-		/// space.</param>
-		/// <param name="coord">A <see cref="CoordType"/> type that defines the
-		/// coordinate system in which the X,Y pair is defined.</param>
-		/// <returns>A point in display device coordinates that corresponds to the
-		/// specified user point.</returns>
-		public static PointF Transform( PaneBase pane, double x, double y, CoordType coord )
-		{
-			return pane.TransformCoord( x, y, coord );
-		}
-		
-		/// <summary>
-		/// Transform this <see cref="Location"/> from the coordinate system
-		/// as specified by <see cref="CoordinateFrame"/> to the device coordinates
-		/// of the specified <see cref="PaneBase"/> object.
-		/// </summary>
-		/// <remarks>
-		/// The returned
-		/// <see cref="PointF"/> struct represents the top-left corner of the
-		/// object that honors the <see cref="Location"/> properties.
-		/// The <see cref="AlignH"/> and <see cref="AlignV"/> properties are honored in 
-		/// this transformation.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that contains
-		/// the <see cref="Axis"/> classes which will be used for the transform.
-		/// </param>
-		/// <param name="width">The width of the object in device pixels</param>
-		/// <param name="height">The height of the object in device pixels</param>
-		/// <returns>The top-left corner of the object</returns>
-		public PointF TransformTopLeft( PaneBase pane, float width, float height )
-		{
-			PointF pt = Transform( pane );
-			
-			if ( _alignH == AlignH.Right )
-				pt.X -= width;
-			else if ( _alignH == AlignH.Center )
-				pt.X -= width / 2.0F;
-				
-			if ( _alignV == AlignV.Bottom )
-				pt.Y -= height;
-			else if ( _alignV == AlignV.Center )
-				pt.Y -= height / 2.0F;
-			
-			return pt;
-		}
-
-		/// <summary>
-		/// The <see cref="PointF"/> for this object as defined by the
-		/// <see cref="X"/> and <see cref="Y"/>
-		/// properties.
-		/// </summary>
-		/// <remarks>
-		/// This method transforms the location to output device pixel units.
-		/// The <see cref="AlignH"/> and <see cref="AlignV"/> properties are ignored for
-		/// this transformation (see <see cref="TransformTopLeft(PaneBase,float,float)"/>).
-		/// </remarks>
-		/// <value>A <see cref="PointF"/> in pixel units.</value>
-		public PointF TransformTopLeft( PaneBase pane )
-		{
-			return Transform( pane );
-		}
-
-		/// <summary>
-		/// The <see cref="PointF"/> for this object as defined by the
-		/// <see cref="X2"/> and <see cref="Y2"/> properties.
-		/// </summary>
-		/// <remarks>
-		/// This method transforms the location to output device pixel units.
-		/// The <see cref="AlignH"/> and <see cref="AlignV"/> properties are ignored for
-		/// this transformation (see <see cref="TransformTopLeft(PaneBase,float,float)"/>).
-		/// </remarks>
-		/// <value>A <see cref="PointF"/> in pixel units.</value>
-		public PointF TransformBottomRight( PaneBase pane )
-		{
-			return Transform( pane, this.X2, this.Y2, _coordinateFrame );
-		}
-
-		/// <summary>
-		/// Transform the <see cref="RectangleF"/> for this object as defined by the
-		/// <see cref="X"/>, <see cref="Y"/>, <see cref="Width"/>, and
-		/// <see cref="Height"/> properties.
-		/// </summary>
-		/// <remarks>
-		/// This method transforms the location to output device pixel units.
-		/// The <see cref="AlignH"/> and <see cref="AlignV"/> properties are honored in 
-		/// this transformation.
-		/// </remarks>
-		/// <value>A <see cref="RectangleF"/> in pixel units.</value>
-		public RectangleF TransformRect( PaneBase pane )
-		{
-			PointF pix1 = TransformTopLeft( pane );
-			PointF pix2 = TransformBottomRight( pane );
-			//PointF pix3 = TransformTopLeft( pane, pix2.X - pix1.X, pix2.Y - pix1.Y );
-
-			return new RectangleF( pix1.X, pix1.Y, Math.Abs(pix2.X - pix1.X), Math.Abs(pix2.Y - pix1.Y) );
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/LogScale.cs b/BDInfo/ZedGraph/LogScale.cs
deleted file mode 100644
index f41d2218c9..0000000000
--- a/BDInfo/ZedGraph/LogScale.cs
+++ /dev/null
@@ -1,443 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The LogScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Log" />.
-	/// </summary>
-	/// <remarks>
-	/// LogScale is a non-linear axis in which the values are scaled using the base 10
-	/// <see cref="Math.Log(double)" />
-	/// function.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.12 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	class LogScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public LogScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="LogScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="LogScale" /></param>
-		public LogScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new LogScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.Log" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.Log; }
-		}
-
-		/// <summary>
-		/// Gets or sets the minimum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.Log" /> scales,
-		/// in that it automatically limits the setting to values greater than zero.
-		/// </remarks>
-		public override double Min
-		{
-			get { return _min; }
-			set { if ( value > 0 ) _min = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the maximum value for this scale.
-		/// </summary>
-		/// <remarks>
-		/// The set property is specifically adapted for <see cref="AxisType.Log" /> scales,
-		/// in that it automatically limits the setting to values greater than zero.
-		/// <see cref="XDate" /> struct.
-		/// </remarks>
-		public override double Max
-		{
-			get { return _max; }
-			set { if ( value > 0 ) _max = value; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Setup some temporary transform values in preparation for rendering the <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// This method is typically called by the parent <see cref="GraphPane"/>
-		/// object as part of the <see cref="GraphPane.Draw"/> method.  It is also
-		/// called by <see cref="GraphPane.GeneralTransform(double,double,CoordType)"/> and
-		/// <see cref="GraphPane.ReverseTransform( PointF, out double, out double )"/>
-		/// methods to setup for coordinate transformations.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="axis">
-		/// The parent <see cref="Axis" /> for this <see cref="Scale" />
-		/// </param>
-		override public void SetupScaleData( GraphPane pane, Axis axis )
-		{
-			base.SetupScaleData( pane, axis );
-
-			_minLinTemp = Linearize( _min );
-			_maxLinTemp = Linearize( _max );
-		}
-
-		/// <summary>
-		/// Convert a value to its linear equivalent for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the log or power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		override public double Linearize( double val )
-		{
-			return SafeLog( val );
-		}
-
-		/// <summary>
-		/// Convert a value from its linear equivalent to its actual scale value
-		/// for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the anti-log or inverse-power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		override public double DeLinearize( double val )
-		{
-			return Math.Pow( 10.0, val );
-		}
-
-		/// <summary>
-		/// Determine the value for any major tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double)
-		/// </param>
-		/// <param name="tic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified major tic value (floating point double).
-		/// </returns>
-		override internal double CalcMajorTicValue( double baseVal, double tic )
-		{
-			return baseVal + (double)tic * CyclesPerStep;
-
-		//	double val = baseVal + (double)tic * CyclesPerStep;
-		//	double frac = val - Math.Floor( val );
-		}
-
-		/// <summary>
-		/// Determine the value for any minor tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double).  This tic value is the base
-		/// reference for all tics (including minor ones).
-		/// </param>
-		/// <param name="iTic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified minor tic value (floating point double).
-		/// </returns>
-		override internal double CalcMinorTicValue( double baseVal, int iTic )
-		{
-			double[] dLogVal = { 0, 0.301029995663981, 0.477121254719662, 0.602059991327962,
-									0.698970004336019, 0.778151250383644, 0.845098040014257,
-									0.903089986991944, 0.954242509439325, 1 };
-
-			return baseVal + Math.Floor( (double) iTic / 9.0 ) + dLogVal[( iTic + 9 ) % 9];
-		}
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first minor tic mark
-		/// </summary>
-		/// <param name="baseVal">
-		/// The value of the first major tic for the axis.
-		/// </param>
-		/// <returns>
-		/// The ordinal position of the first minor tic, relative to the first major tic.
-		/// This value can be negative (e.g., -3 means the first minor tic is 3 minor step
-		/// increments before the first major tic.
-		/// </returns>
-		override internal int CalcMinorStart( double baseVal )
-		{
-			return -9;
-		}
-
-		/// <summary>
-		/// Determine the value for the first major tic.
-		/// </summary>
-		/// <remarks>
-		/// This is done by finding the first possible value that is an integral multiple of
-		/// the step size, taking into account the date/time units if appropriate.
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <returns>
-		/// First major tic value (floating point double).
-		/// </returns>
-		override internal double CalcBaseTic()
-		{
-			if ( _baseTic != PointPair.Missing )
-				return _baseTic;
-			else
-			{
-				// go to the nearest even multiple of the step size
-				return Math.Ceiling( Scale.SafeLog( _min ) - 0.00000001 );
-			}
-
-		}
-		
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first and last major axis label.
-		/// </summary>
-		/// <returns>
-		/// This is the total number of major tics for this axis.
-		/// </returns>
-		override internal int CalcNumTics()
-		{
-			int nTics = 1;
-
-			//iStart = (int) ( Math.Ceiling( SafeLog( this.min ) - 1.0e-12 ) );
-			//iEnd = (int) ( Math.Floor( SafeLog( this.max ) + 1.0e-12 ) );
-
-			//nTics = (int)( ( Math.Floor( Scale.SafeLog( _max ) + 1.0e-12 ) ) -
-			//		( Math.Ceiling( Scale.SafeLog( _min ) - 1.0e-12 ) ) + 1 ) / CyclesPerStep;
-			nTics = (int)( ( Scale.SafeLog( _max ) - Scale.SafeLog( _min ) ) / CyclesPerStep ) + 1;
-
-			if ( nTics < 1 )
-				nTics = 1;
-			else if ( nTics > 1000 )
-				nTics = 1000;
-
-			return nTics;
-		}
-
-		private double CyclesPerStep
-		{
-			//get { return (int)Math.Max( Math.Floor( Scale.SafeLog( _majorStep ) ), 1 ); }
-			get { return _majorStep; }
-		}
-
-		/// <summary>
-		/// Select a reasonable base 10 logarithmic axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Log"/> type axes, and it
-		/// is called by the general <see cref="PickScale"/> method.  The scale range is chosen
-		/// based always on powers of 10 (full log cycles).  This
-		/// method honors the <see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min"/>, <see cref="Scale.Max"/>, or <see cref="Scale.MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  For log axes, the MinorStep
-		/// value is not used.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="PickScale"/>
-		/// <seealso cref="AxisType.Log"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// Majorstep is always 1 for log scales
-			if ( _majorStepAuto )
-				_majorStep = 1.0;
-
-			_mag = 0;		// Never use a magnitude shift for log scales
-			//this.numDec = 0;		// The number of decimal places to display is not used
-
-			// Check for bad data range
-			if ( _min <= 0.0 && _max <= 0.0 )
-			{
-				_min = 1.0;
-				_max = 10.0;
-			}
-			else if ( _min <= 0.0 )
-			{
-				_min = _max / 10.0;
-			}
-			else if ( _max <= 0.0 )
-			{
-				_max = _min * 10.0;
-			}
-
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( _max - _min < 1.0e-20 )
-			{
-				if ( _maxAuto )
-					_max = _max * 2.0;
-				if ( _minAuto )
-					_min = _min / 2.0;
-			}
-
-			// Get the nearest power of 10 (no partial log cycles allowed)
-			if ( _minAuto )
-				_min = Math.Pow( (double) 10.0,
-					Math.Floor( Math.Log10( _min ) ) );
-			if ( _maxAuto )
-				_max = Math.Pow( (double) 10.0,
-					Math.Ceiling( Math.Log10( _max ) ) );
-
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.Log" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			if ( _isUseTenPower )
-				return string.Format( "{0:F0}", dVal );
-			else
-				return Math.Pow( 10.0, dVal ).ToString( _format );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected LogScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/MajorGrid.cs b/BDInfo/ZedGraph/MajorGrid.cs
deleted file mode 100644
index 7d1ea6f6c5..0000000000
--- a/BDInfo/ZedGraph/MajorGrid.cs
+++ /dev/null
@@ -1,200 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles the data associated with the major grid lines on the chart.
-	/// Inherits from <see cref="MinorGrid" />.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class MajorGrid : MinorGrid, ICloneable, ISerializable
-	{
-		internal bool _isZeroLine;
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor
-		/// </summary>
-		public MajorGrid()
-		{
-			_dashOn = Default.DashOn;
-			_dashOff = Default.DashOff;
-			_penWidth = Default.PenWidth;
-			_isVisible = Default.IsVisible;
-			_color = Default.Color;
-			_isZeroLine = Default.IsZeroLine;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">The source <see cref="MajorGrid" /> to be copied.</param>
-		public MajorGrid( MajorGrid rhs ) : base( rhs )
-		{
-			_isZeroLine = rhs._isZeroLine;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new MajorGrid Clone()
-		{
-			return new MajorGrid( this );
-		}
-
-		#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a boolean value that determines if a line will be drawn at the
-		/// zero value for the axis.
-		/// </summary>
-		/// <remarks>
-		/// The zero line is a line that divides the negative values from the positive values.
-		/// The default is set according to
-		/// <see cref="XAxis.Default.IsZeroLine"/>, <see cref="YAxis.Default.IsZeroLine"/>,
-		/// <see cref="Y2Axis.Default.IsZeroLine"/>,
-		/// </remarks>
-		/// <value>true to show the zero line, false otherwise</value>
-		public bool IsZeroLine
-		{
-			get { return _isZeroLine; }
-			set { _isZeroLine = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected MajorGrid( SerializationInfo info, StreamingContext context ) :
-			base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_isZeroLine = info.GetBoolean( "isZeroLine" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-
-			info.AddValue( "isZeroLine", _isZeroLine );
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="MajorGrid"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			/// <summary>
-			/// The default "dash on" size for drawing the <see cref="Axis"/> grid
-			/// (<see cref="MinorGrid.DashOn"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOn = 1.0F;
-			/// <summary>
-			/// The default "dash off" size for drawing the <see cref="Axis"/> grid
-			/// (<see cref="MinorGrid.DashOff"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOff = 5.0F;
-			/// <summary>
-			/// The default pen width for drawing the <see cref="Axis"/> grid
-			/// (<see cref="MinorGrid.PenWidth"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The default color for the <see cref="Axis"/> grid lines
-			/// (<see cref="MinorGrid.Color"/> property).  This color only affects the
-			/// grid lines.
-			/// </summary>
-			public static Color Color = Color.Black;
-
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> grid lines
-			/// (<see cref="MinorGrid.IsVisible"/> property). true
-			/// to show the grid lines, false to hide them.
-			/// </summary>
-			public static bool IsVisible = false;
-
-			/// <summary>
-			/// The default boolean value that determines if a line will be drawn at the
-			/// zero value for the axis.
-			/// </summary>
-			/// <remarks>
-			/// The zero line is a line that divides the negative values from the positive values.
-			/// The default is set according to
-			/// <see cref="XAxis.Default.IsZeroLine"/>, <see cref="YAxis.Default.IsZeroLine"/>,
-			/// <see cref="Y2Axis.Default.IsZeroLine"/>,
-			/// </remarks>
-			/// <value>true to show the zero line, false otherwise</value>
-			public static bool IsZeroLine = false;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/MajorTic.cs b/BDInfo/ZedGraph/MajorTic.cs
deleted file mode 100644
index adf62b5810..0000000000
--- a/BDInfo/ZedGraph/MajorTic.cs
+++ /dev/null
@@ -1,244 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that holds the specific properties for the major tics.  Inherits from
-	/// <see cref="MinorTic" />.
-	/// </summary>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class MajorTic : MinorTic, ICloneable, ISerializable
-	{
-		internal bool	_isBetweenLabels;
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for <see cref="MajorTic" />.
-		/// </summary>
-		public MajorTic()
-		{
-			_size = Default.Size;
-			_color = Default.Color;
-			_penWidth = Default.PenWidth;
-
-			this.IsOutside = Default.IsOutside;
-			this.IsInside = Default.IsInside;
-			this.IsOpposite = Default.IsOpposite;
-			_isCrossOutside = Default.IsCrossOutside;
-			_isCrossInside = Default.IsCrossInside;
-
-			_isBetweenLabels = false;
-		}
-
-		/// <summary>
-		/// Copy constructor.
-		/// </summary>
-		/// <param name="rhs">The <see cref="MajorTic" /> that is to be copied.</param>
-		public MajorTic( MajorTic rhs )
-			: base( rhs )
-		{
-			_isBetweenLabels = rhs._isBetweenLabels;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new MajorTic Clone()
-		{
-			return new MajorTic( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the major tics will be drawn
-		/// inbetween the labels, rather than right at the labels.
-		/// </summary>
-		/// <remarks>
-		/// Note that this setting is only
-		/// applicable if <see cref="Axis.Type"/> = <see cref="AxisType.Text"/>.
-		/// </remarks>
-		/// <value>true to place the text between the labels for text axes, false otherwise</value>
-		/// <seealso cref="MinorTic.IsOutside"/>
-		/// <seealso cref="MinorTic.IsInside"/>
-		/// <seealso cref="MinorTic.IsOpposite"/>
-		/// <seealso cref="MinorTic.IsCrossOutside"/>
-		/// <seealso cref="MinorTic.IsCrossInside"/>
-		public bool IsBetweenLabels
-		{
-			get { return _isBetweenLabels; }
-			set { _isBetweenLabels = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected MajorTic( SerializationInfo info, StreamingContext context ) :
-			base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch2 = info.GetInt32( "schema2" );
-
-			_isBetweenLabels = info.GetBoolean( "isBetweenLabels" );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-
-			info.AddValue( "isBetweenLabels", _isBetweenLabels );
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="MinorTic"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			// Default Axis Properties
-			/// <summary>
-			/// The default size for the <see cref="Axis"/> tic marks.
-			/// (<see cref="MinorTic.Size"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float Size = 5;
-			/// <summary>
-			/// The default pen width for drawing the <see cref="Axis"/> tic marks.
-			/// (<see cref="MinorTic.PenWidth"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> major outside tic marks
-			/// (<see cref="MinorTic.IsOutside"/> property).
-			/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-			/// </summary>
-			/// <value>true to show the major tic marks (outside the axis),
-			/// false otherwise</value>
-			public static bool IsOutside = true;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> major inside tic marks
-			/// (<see cref="MinorTic.IsInside"/> property).
-			/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-			/// </summary>
-			/// <value>true to show the major tic marks (inside the axis),
-			/// false otherwise</value>
-			public static bool IsInside = true;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> major opposite tic marks
-			/// (<see cref="MinorTic.IsOpposite"/> property).
-			/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-			/// </summary>
-			/// <value>true to show the major tic marks
-			/// (inside the axis on the opposite side),
-			/// false otherwise</value>
-			public static bool IsOpposite = true;
-
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> major outside 
-			/// "cross" tic marks (<see cref="MinorTic.IsCrossOutside"/> property).
-			/// </summary>
-			/// <remarks>
-			/// The "cross" tics are a special, additional set of tic marks that
-			/// always appear on the actual axis, even if it has been shifted due
-			/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-			/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-			/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-			/// they will exactly overlay the "normal" and "inside" tics.  If
-			/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-			/// enable the cross tics.
-			/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-			/// </remarks>
-			/// <value>true to show the major cross tic marks, false otherwise</value>
-			public static bool IsCrossOutside = false;
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> major inside 
-			/// "cross" tic marks (<see cref="MinorTic.IsCrossInside"/> property).
-			/// </summary>
-			/// <remarks>
-			/// The "cross" tics are a special, additional set of tic marks that
-			/// always appear on the actual axis, even if it has been shifted due
-			/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-			/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-			/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-			/// they will exactly overlay the "normal" and "inside" tics.  If
-			/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-			/// enable the cross tics.
-			/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-			/// </remarks>
-			/// <value>true to show the major cross tic marks, false otherwise</value>
-			public static bool IsCrossInside = false;
-
-			/// <summary>
-			/// The default color for major tics (<see cref="MinorTic.Color"/> property).
-			/// </summary>
-			public static Color Color = Color.Black;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Margin.cs b/BDInfo/ZedGraph/Margin.cs
deleted file mode 100644
index 7fd38c2300..0000000000
--- a/BDInfo/ZedGraph/Margin.cs
+++ /dev/null
@@ -1,264 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that handles that stores the margin properties for the GraphPane
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class Margin : ICloneable, ISerializable
-	{
-		/// <summary>
-		/// Private fields that store the size of the margin around the edge of the pane which will be
-		/// kept blank.  Use the public properties <see cref="Margin.Left"/>, <see cref="Margin.Right"/>,
-		/// <see cref="Margin.Top"/>, <see cref="Margin.Bottom"/> to access these values.
-		/// </summary>
-		/// <value>Units are points (1/72 inch)</value>
-		protected float	_left,
-								_right,
-								_top,
-								_bottom;
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructor to build a <see cref="Margin" /> from the default values.
-		/// </summary>
-		public Margin()
-		{
-			_left = Default.Left;
-			_right = Default.Right;
-			_top = Default.Top;
-			_bottom = Default.Bottom;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">the <see cref="Margin" /> instance to be copied.</param>
-		public Margin( Margin rhs )
-		{
-			_left = rhs._left;
-			_right = rhs._right;
-			_top = rhs._top;
-			_bottom = rhs._bottom;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Margin Clone()
-		{
-			return new Margin( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a float value that determines the margin area between the left edge of the
-		/// <see cref="PaneBase.Rect"/> rectangle and the features of the graph.
-		/// </summary>
-		/// <value>This value is in units of points (1/72 inch), and is scaled
-		/// linearly with the graph size.</value>
-		/// <seealso cref="Default.Left"/>
-		/// <seealso cref="PaneBase.IsFontsScaled"/>
-		/// <seealso cref="Right"/>
-		/// <seealso cref="Top"/>
-		/// <seealso cref="Bottom"/>
-		public float Left
-		{
-			get { return _left; }
-			set { _left = value; }
-		}
-		/// <summary>
-		/// Gets or sets a float value that determines the margin area between the right edge of the
-		/// <see cref="PaneBase.Rect"/> rectangle and the features of the graph.
-		/// </summary>
-		/// <value>This value is in units of points (1/72 inch), and is scaled
-		/// linearly with the graph size.</value>
-		/// <seealso cref="Default.Right"/>
-		/// <seealso cref="PaneBase.IsFontsScaled"/>
-		/// <seealso cref="Left"/>
-		/// <seealso cref="Top"/>
-		/// <seealso cref="Bottom"/>
-		public float Right
-		{
-			get { return _right; }
-			set { _right = value; }
-		}
-		/// <summary>
-		/// Gets or sets a float value that determines the margin area between the top edge of the
-		/// <see cref="PaneBase.Rect"/> rectangle and the features of the graph.
-		/// </summary>
-		/// <value>This value is in units of points (1/72 inch), and is scaled
-		/// linearly with the graph size.</value>
-		/// <seealso cref="Default.Top"/>
-		/// <seealso cref="PaneBase.IsFontsScaled"/>
-		/// <seealso cref="Left"/>
-		/// <seealso cref="Right"/>
-		/// <seealso cref="Bottom"/>
-		public float Top
-		{
-			get { return _top; }
-			set { _top = value; }
-		}
-		/// <summary>
-		/// Gets or sets a float value that determines the margin area between the bottom edge of the
-		/// <see cref="PaneBase.Rect"/> rectangle and the features of the graph.
-		/// </summary>
-		/// <value>This value is in units of points (1/72 inch), and is scaled
-		/// linearly with the graph size.</value>
-		/// <seealso cref="Default.Bottom"/>
-		/// <seealso cref="PaneBase.IsFontsScaled"/>
-		/// <seealso cref="Left"/>
-		/// <seealso cref="Right"/>
-		/// <seealso cref="Top"/>
-		public float Bottom
-		{
-			get { return _bottom; }
-			set { _bottom = value; }
-		}
-
-		/// <summary>
-		/// Concurrently sets all outer margin values to a single value.
-		/// </summary>
-		/// <value>This value is in units of points (1/72 inch), and is scaled
-		/// linearly with the graph size.</value>
-		/// <seealso cref="PaneBase.IsFontsScaled"/>
-		/// <seealso cref="Bottom"/>
-		/// <seealso cref="Left"/>
-		/// <seealso cref="Right"/>
-		/// <seealso cref="Top"/>
-		public float All
-		{
-			set
-			{
-				_bottom = value;
-				_top = value;
-				_left = value;
-				_right = value;
-			}
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Margin( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_left = info.GetSingle( "left" );
-			_right = info.GetSingle( "right" );
-			_top = info.GetSingle( "top" );
-			_bottom = info.GetSingle( "bottom" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "left", _left );
-			info.AddValue( "right", _right );
-			info.AddValue( "top", _top );
-			info.AddValue( "bottom", _bottom );
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the default property values for the <see cref="Margin"/> class.
-		/// </summary>
-		public class Default
-		{
-			/// <summary>
-			/// The default value for the <see cref="Margin.Left"/> property, which is
-			/// the size of the space on the left side of the <see cref="PaneBase.Rect"/>.
-			/// </summary>
-			/// <value>Units are points (1/72 inch)</value>
-			public static float Left = 10.0F;
-			/// <summary>
-			/// The default value for the <see cref="Margin.Right"/> property, which is
-			/// the size of the space on the right side of the <see cref="PaneBase.Rect"/>.
-			/// </summary>
-			/// <value>Units are points (1/72 inch)</value>
-			public static float Right = 10.0F;
-			/// <summary>
-			/// The default value for the <see cref="Margin.Top"/> property, which is
-			/// the size of the space on the top side of the <see cref="PaneBase.Rect"/>.
-			/// </summary>
-			/// <value>Units are points (1/72 inch)</value>
-			public static float Top = 10.0F;
-			/// <summary>
-			/// The default value for the <see cref="Margin.Bottom"/> property, which is
-			/// the size of the space on the bottom side of the <see cref="PaneBase.Rect"/>.
-			/// </summary>
-			/// <value>Units are points (1/72 inch)</value>
-			public static float Bottom = 10.0F;
-
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/MasterPane.cs b/BDInfo/ZedGraph/MasterPane.cs
deleted file mode 100644
index 2ad6b1879f..0000000000
--- a/BDInfo/ZedGraph/MasterPane.cs
+++ /dev/null
@@ -1,1179 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Text;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Drawing.Text;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="GraphPane"/> objects
-	/// organized together in some form.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.26 $ $Date: 2007/11/05 18:28:56 $ </version>
-	[Serializable]
-	public class MasterPane : PaneBase, ICloneable, ISerializable, IDeserializationCallback
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// Private field that holds a collection of <see cref="GraphPane"/> objects for inclusion
-		/// in this <see cref="MasterPane"/>.  Use the public property <see cref="PaneList"/>
-		/// to access this collection.
-		/// </summary>
-		internal PaneList _paneList;
-		/// <summary>
-		/// Private field that sets the amount of space between the GraphPanes.  Use the public property
-		/// <see cref="InnerPaneGap"/> to access this value;
-		/// </summary>
-		internal float _innerPaneGap;
-		/// <summary>
-		///Private field that stores a boolean value which signifies whether all 
-		///<see cref="ZedGraph.GraphPane"/>s in the chart use the same entries in their 
-		///<see cref="Legend"/>  If set to true, only one set of entries will be displayed in 
-		///this <see cref="Legend"/> instance.  If set to false, this instance will display all 
-		///entries from all <see cref="ZedGraph.GraphPane"/>s.
-		/// </summary>
-		private bool _isUniformLegendEntries;
-		/// <summary>
-		/// private field that determines if the
-		/// <see cref="DoLayout(Graphics)" />
-		/// function will automatically set
-		/// the <see cref="PaneBase.BaseDimension" /> of each <see cref="GraphPane" /> in the
-		/// <see cref="PaneList" /> such that the scale factors have the same value.
-		/// </summary>
-		private bool _isCommonScaleFactor;
-
-		/// <summary>
-		/// private field that saves the paneLayout format specified when
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/> was called. This value will
-		/// default to <see cref="MasterPane.Default.PaneLayout"/> if
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/> (or an overload) was never called.
-		/// </summary>
-		internal PaneLayout _paneLayout;
-
-		/// <summary>
-		/// Private field that stores the boolean value that determines whether
-		/// <see cref="_countList"/> is specifying rows or columns.
-		/// </summary>
-		internal bool _isColumnSpecified;
-		/// <summary>
-		/// private field that stores the row/column item count that was specified to the
-		/// <see cref="SetLayout(Graphics,bool,int[],float[])"/> method.  This values will be
-		/// null if <see cref="SetLayout(Graphics,bool,int[],float[])"/> was never called.
-		/// </summary>
-		internal int[] _countList;
-
-		/// <summary>
-		/// private field that stores the row/column size proportional values as specified
-		/// to the <see cref="SetLayout(Graphics,bool,int[],float[])"/> method.  This
-		/// value will be null if <see cref="SetLayout(Graphics,bool,int[],float[])"/>
-		/// was never called.  
-		/// </summary>
-		internal float[] _prop;
-
-/*		/// <summary>
-		/// private field to store the <see cref="PaneLayoutMgr" /> instance, which
-		/// manages the persistence and handling of pane layout information.
-		/// </summary>
-		private PaneLayoutMgr _paneLayoutMgr;
-*/
-		/// <summary>
-		/// private field that determines if anti-aliased drawing will be forced on.  Use the
-		/// public property <see cref="IsAntiAlias"/> to access this value.
-		/// </summary>
-		private bool _isAntiAlias = false;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="MasterPane"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			/// <summary>
-			/// The default pane layout for
-			/// <see cref="DoLayout(Graphics)"/>
-			/// method calls.
-			/// </summary>
-			/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-			/// <seealso cref="SetLayout(Graphics,int,int)" />
-			/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-			/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-			/// <seealso cref="ReSize(Graphics,RectangleF)" />
-			public static PaneLayout PaneLayout = PaneLayout.SquareColPreferred;
-
-			/// <summary>
-			/// The default value for the <see cref="Default.InnerPaneGap"/> property.
-			/// This is the size of the margin between adjacent <see cref="GraphPane"/>
-			/// objects, in units of points (1/72 inch).
-			/// </summary>
-			/// <seealso cref="MasterPane.InnerPaneGap"/>
-			public static float InnerPaneGap = 10;
-			
-			/// <summary>
-			/// The default value for the <see cref="Legend.IsVisible"/> property for
-			/// the <see cref="MasterPane"/> class.
-			/// </summary>
-			public static bool IsShowLegend = false;
-			/// <summary>
-			/// The default value for the <see cref="IsUniformLegendEntries"/> property.
-			/// </summary>
-			public static bool IsUniformLegendEntries = false;
-			/// <summary>
-			/// The default value for the <see cref="IsCommonScaleFactor"/> property.
-			/// </summary>
-			public static bool IsCommonScaleFactor = false;
-		}
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="PaneList"/> collection instance that holds the list of
-		/// <see cref="GraphPane"/> objects that are included in this <see cref="MasterPane"/>.
-		/// </summary>
-		/// <seealso cref="Add"/>
-		/// <seealso cref="MasterPane.this[int]"/>
-		public PaneList PaneList
-		{
-			get { return _paneList; }
-			set { _paneList = value; }
-		}
-/*
-		/// <summary>
-		/// Gets the <see cref="PaneLayoutMgr" /> instance, which manages the pane layout
-		/// settings, and handles the layout functions.
-		/// </summary>
-		/// <seealso cref="ZedGraph.PaneLayoutMgr.SetLayout(PaneLayout)" />
-		/// <seealso cref="ZedGraph.PaneLayoutMgr.SetLayout(int,int)" />
-		/// <seealso cref="ZedGraph.PaneLayoutMgr.SetLayout(bool,int[])" />
-		/// <seealso cref="ZedGraph.PaneLayoutMgr.SetLayout(bool,int[],float[])" />
-		/// <seealso cref="ReSize" />
-		public PaneLayoutMgr PaneLayoutMgr
-		{
-			get { return _paneLayoutMgr; }
-		}
-*/
-		/// <summary>
-		/// Gets or sets the size of the margin between adjacent <see cref="GraphPane"/>
-		/// objects.
-		/// </summary>
-		/// <remarks>This property is scaled according to <see cref="PaneBase.CalcScaleFactor"/>,
-		/// based on <see cref="PaneBase.BaseDimension"/>.  The default value comes from
-		/// <see cref="Default.InnerPaneGap"/>.
-		/// </remarks>
-		/// <value>The value is in points (1/72nd inch).</value>
-		public float InnerPaneGap
-		{
-			get { return _innerPaneGap; }
-			set { _innerPaneGap = value; }
-		}
-		/// <summary>
-		/// Gets or set the value of the	 <see cref="IsUniformLegendEntries"/>
-		/// </summary>
-		public bool IsUniformLegendEntries
-		{
-			get { return (_isUniformLegendEntries); }
-			set { _isUniformLegendEntries = value; } 
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the
-		/// <see cref="DoLayout(Graphics)" /> method will automatically set the
-		/// <see cref="PaneBase.BaseDimension" />
-		/// of each <see cref="GraphPane" /> in the <see cref="PaneList" /> such that the
-		/// scale factors have the same value.
-		/// </summary>
-		/// <remarks>
-		/// The scale factors, calculated by <see cref="PaneBase.CalcScaleFactor" />, determine
-		/// scaled font sizes, tic lengths, etc.  This function will insure that for
-		/// multiple graphpanes, a certain specified font size will be the same for
-		/// all the panes.
-		/// </remarks>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		/// <seealso cref="ReSize(Graphics,RectangleF)" />
-		public bool IsCommonScaleFactor
-		{
-			get { return _isCommonScaleFactor; }
-			set { _isCommonScaleFactor = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if all drawing operations for this
-		/// <see cref="MasterPane" /> will be forced to operate in Anti-alias mode.
-		/// Note that if this value is set to "true", it overrides the setting for sub-objects.
-		/// Otherwise, the sub-object settings (such as <see cref="FontSpec.IsAntiAlias"/>)
-		/// will be honored.
-		/// </summary>
-		public bool IsAntiAlias
-		{
-			get { return _isAntiAlias; }
-			set { _isAntiAlias = value; }
-		}
-
-	#endregion
-	
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the class.  Sets the <see cref="PaneBase.Rect"/> to (0, 0, 500, 375).
-		/// </summary>
-		public MasterPane() : this( "", new RectangleF( 0, 0, 500, 375 ) )
-		{
-		}
-		
-		/// <summary>
-		/// Default constructor for the class.  Specifies the <see cref="PaneBase.Title"/> of
-		/// the <see cref="MasterPane"/>, and the size of the <see cref="PaneBase.Rect"/>.
-		/// </summary>
-		public MasterPane( string title, RectangleF paneRect ) : base( title, paneRect )
-		{
-			_innerPaneGap = Default.InnerPaneGap;
-
-			//_paneLayoutMgr = new PaneLayoutMgr();
-
-			_isUniformLegendEntries = Default.IsUniformLegendEntries ;
-			_isCommonScaleFactor = Default.IsCommonScaleFactor;
-
-			_paneList = new PaneList();
-
-			_legend.IsVisible = Default.IsShowLegend;
-
-			_isAntiAlias = false;
-
-			InitLayout();
-		}
-
-		private void InitLayout()
-		{
-			_paneLayout = Default.PaneLayout;
-			_countList = null;
-			_isColumnSpecified = false;
-			_prop = null;
-		}
-
-		/// <summary>
-		/// The Copy Constructor - Make a deep-copy clone of this class instance.
-		/// </summary>
-		/// <param name="rhs">The <see cref="MasterPane"/> object from which to copy</param>
-		public MasterPane( MasterPane rhs ) : base( rhs )
-		{
-			// copy all the value types
-			//_paneLayoutMgr = rhs._paneLayoutMgr.Clone();
-			_innerPaneGap = rhs._innerPaneGap;
-			_isUniformLegendEntries = rhs._isUniformLegendEntries;
-			_isCommonScaleFactor = rhs._isCommonScaleFactor;
-
-			// Then, fill in all the reference types with deep copies
-			_paneList = rhs._paneList.Clone();
-
-			_paneLayout = rhs._paneLayout;
-			_countList = rhs._countList;
-			_isColumnSpecified = rhs._isColumnSpecified;
-			_prop = rhs._prop;
-			_isAntiAlias = rhs._isAntiAlias;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" /> to make a deep copy.
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public MasterPane Clone()
-		{
-			return new MasterPane( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		// schema changed to 2 with addition of 'prop'
-		// schema changed to 11 with addition of 'isAntiAlias'
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected MasterPane( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_paneList = (PaneList) info.GetValue( "paneList", typeof(PaneList) );
-			//_paneLayoutMgr = (PaneLayoutMgr) info.GetValue( "paneLayoutMgr", typeof(PaneLayoutMgr) );
-			_innerPaneGap = info.GetSingle( "innerPaneGap" );
-
-			_isUniformLegendEntries = info.GetBoolean( "isUniformLegendEntries" );
-			_isCommonScaleFactor = info.GetBoolean( "isCommonScaleFactor" );
-
-			_paneLayout = (PaneLayout)info.GetValue( "paneLayout", typeof( PaneLayout ) );
-			_countList = (int[])info.GetValue( "countList", typeof( int[] ) );
-
-			_isColumnSpecified = info.GetBoolean( "isColumnSpecified" );
-			_prop = (float[])info.GetValue( "prop", typeof( float[] ) );
-
-			if ( sch >= 11 )
-				_isAntiAlias = info.GetBoolean( "isAntiAlias" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-
-			info.AddValue( "paneList", _paneList );
-			//info.AddValue( "paneLayoutMgr", _paneLayoutMgr );
-			info.AddValue( "innerPaneGap", _innerPaneGap );
-
-			info.AddValue( "isUniformLegendEntries", _isUniformLegendEntries );
-			info.AddValue( "isCommonScaleFactor", _isCommonScaleFactor );
-
-			info.AddValue( "paneLayout", _paneLayout );
-			info.AddValue( "countList", _countList );
-			info.AddValue( "isColumnSpecified", _isColumnSpecified );
-			info.AddValue( "prop", _prop );
-
-			info.AddValue( "isAntiAlias", _isAntiAlias );
-		}
-
-		/// <summary>
-		/// Respond to the callback when the MasterPane objects are fully initialized.
-		/// </summary>
-		/// <param name="sender"></param>
-		public void OnDeserialization(object sender)
-		{
-			Bitmap bitmap = new Bitmap( 10, 10 );
-			Graphics g = Graphics.FromImage( bitmap );
-			ReSize( g, _rect );
-		}
-	#endregion
-
-	#region List Methods
-		/// <summary>
-		/// Indexer to access the specified <see cref="GraphPane"/> object from <see cref="PaneList"/>
-		/// by its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="GraphPane"/> object to be accessed.</param>
-		/// <value>A <see cref="GraphPane"/> object reference.</value>
-		public GraphPane this[ int index ]  
-		{
-			get { return( (GraphPane) _paneList[index] ); }
-			set { _paneList[index] = value; }
-		}
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="GraphPane"/> object from <see cref="PaneList"/>
-		/// by its <see cref="PaneBase.Title"/> string.
-		/// </summary>
-		/// <param name="title">The string title of the
-		/// <see cref="GraphPane"/> object to be accessed.</param>
-		/// <value>A <see cref="GraphPane"/> object reference.</value>
-		public GraphPane this[ string title ]  
-		{
-			get { return _paneList[title]; }
-		}
-
-		/// <summary>
-		/// Add a <see cref="GraphPane"/> object to the <see cref="PaneList"/> collection at the end of the list.
-		/// </summary>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object to
-		/// be added</param>
-		/// <seealso cref="IList.Add"/>
-		public void Add( GraphPane pane )
-		{
-			_paneList.Add( pane );
-		}
-
-		/// <summary>
-		/// Call <see cref="GraphPane.AxisChange()"/> for all <see cref="GraphPane"/> objects in the
-		/// <see cref="PaneList"/> list.
-		/// </summary>
-		/// <remarks>
-		/// This overload of AxisChange just uses the default Graphics instance for the screen.
-		/// If you have a Graphics instance available from your Windows Form, you should use
-		/// the <see cref="AxisChange(Graphics)" /> overload instead.
-		/// </remarks>
-		public void AxisChange()
-		{
-			using ( Graphics g = Graphics.FromHwnd( IntPtr.Zero ) )
-				AxisChange( g );
-		}
-
-		/// <summary>
-		/// Call <see cref="GraphPane.AxisChange()"/> for all <see cref="GraphPane"/> objects in the
-		/// <see cref="PaneList"/> list.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public void AxisChange( Graphics g )
-		{
-			foreach ( GraphPane pane in _paneList )
-				pane.AxisChange( g );
-		}
-
-		/// <summary>
-		/// Redo the layout using the current size of the <see cref="PaneBase.Rect"/>,
-		/// and also handle resizing the
-		/// contents by calling <see cref="DoLayout(Graphics)"/>.
-		/// </summary>
-		/// <remarks>This method will use the pane layout that was specified by a call to
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/>.  If
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/> has not previously been called,
-		/// it will default to <see cref="Default.PaneLayout"/>.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public void ReSize( Graphics g )
-		{
-			ReSize( g, _rect );
-		}
-
-		/// <summary>
-		/// Change the size of the <see cref="PaneBase.Rect"/>, and also handle resizing the
-		/// contents by calling <see cref="DoLayout(Graphics)"/>.
-		/// </summary>
-		/// <remarks>This method will use the pane layout that was specified by a call to
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/>.  If
-		/// <see cref="SetLayout(Graphics,PaneLayout)"/> has not previously been called,
-		/// it will default to <see cref="Default.PaneLayout"/>.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect"></param>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public override void ReSize( Graphics g, RectangleF rect )
-		{
-			_rect = rect;
-			DoLayout( g );
-			CommonScaleFactor();
-		}
-
-		/// <summary>
-		/// Method that forces the scale factor calculations
-		/// (via <see cref="PaneBase.CalcScaleFactor" />),
-		/// to give a common scale factor for all <see cref="GraphPane" /> objects in the
-		/// <see cref="PaneList" />.
-		/// </summary>
-		/// <remarks>
-		/// This will make it such that a given font size will result in the same output font
-		/// size for all <see cref="GraphPane" />'s.  Note that this does not make the scale
-		/// factor for the <see cref="GraphPane" />'s the same as that of the
-		/// <see cref="MasterPane" />.
-		/// </remarks>
-		/// <seealso cref="IsCommonScaleFactor" />
-		public void CommonScaleFactor()
-		{
-			if ( _isCommonScaleFactor )
-			{
-				// Find the maximum scaleFactor of all the GraphPanes
-				float maxFactor = 0;
-				foreach ( GraphPane pane in PaneList )
-				{
-					pane.BaseDimension = PaneBase.Default.BaseDimension;
-					float scaleFactor = pane.CalcScaleFactor();
-					maxFactor = scaleFactor > maxFactor ? scaleFactor : maxFactor;
-				}
-
-				// Now, calculate the base dimension
-				foreach ( GraphPane pane in PaneList )
-				{
-					float scaleFactor = pane.CalcScaleFactor();
-					pane.BaseDimension *= scaleFactor / maxFactor;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Render all the <see cref="GraphPane"/> objects in the <see cref="PaneList"/> to the
-		/// specified graphics device.
-		/// </summary>
-		/// <remarks>This method should be part of the Paint() update process.  Calling this routine
-		/// will redraw all
-		/// features of all the <see cref="GraphPane"/> items.  No preparation is required other than
-		/// instantiated <see cref="GraphPane"/> objects that have been added to the list with the
-		/// <see cref="Add"/> method.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public override void Draw( Graphics g )
-		{
-			// Save current AntiAlias mode
-			SmoothingMode sModeSave = g.SmoothingMode;
-			TextRenderingHint sHintSave = g.TextRenderingHint;
-			CompositingQuality sCompQual = g.CompositingQuality;
-			InterpolationMode sInterpMode = g.InterpolationMode;
-
-			SetAntiAliasMode( g, _isAntiAlias );
-
-			// Draw the pane border & background fill, the title, and the GraphObj objects that lie at
-			// ZOrder.GBehindAll
-			base.Draw( g );
-
-			if ( _rect.Width <= 1 || _rect.Height <= 1 )
-				return;
-
-			float scaleFactor = CalcScaleFactor();
-
-			// Clip everything to the rect
-			g.SetClip( _rect );
-
-			// For the MasterPane, All GraphItems go behind the GraphPanes, except those that
-			// are explicity declared as ZOrder.AInFront
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.G_BehindChartFill );
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.E_BehindCurves );
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.D_BehindAxis );
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.C_BehindChartBorder );
-
-			// Reset the clipping
-			g.ResetClip();
-
-			foreach ( GraphPane pane in _paneList )
-				pane.Draw( g );
-
-			// Clip everything to the rect
-			g.SetClip( _rect );
-
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.B_BehindLegend );
-			
-			// Recalculate the legend rect, just in case it has not yet been done
-			// innerRect is the area for the GraphPane's
-			RectangleF innerRect = CalcClientRect( g, scaleFactor );
-			_legend.CalcRect( g, this, scaleFactor, ref innerRect );
-			//this.legend.SetLocation( this, 
-			
-			_legend.Draw( g, this, scaleFactor );
-
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.A_InFront );
-			
-			// Reset the clipping
-			g.ResetClip();
-
-			// Restore original anti-alias mode
-			g.SmoothingMode = sModeSave;
-			g.TextRenderingHint = sHintSave;
-			g.CompositingQuality = sCompQual;
-			g.InterpolationMode = sInterpMode;
-
-		}
-
-		/// <summary>
-		/// Find the pane and the object within that pane that lies closest to the specified
-		/// mouse (screen) point.
-		/// </summary>
-		/// <remarks>
-		/// This method first finds the <see cref="GraphPane"/> within the list that contains
-		/// the specified mouse point.  It then calls the <see cref="GraphPane.FindNearestObject"/>
-		/// method to determine which object, if any, was clicked.  With the exception of the
-		/// <see paramref="pane"/>, all the parameters in this method are identical to those
-		/// in the <see cref="GraphPane.FindNearestObject"/> method.
-		/// If the mouse point lies within the <see cref="PaneBase.Rect"/> of any 
-		/// <see cref="GraphPane"/> item, then that pane will be returned (otherwise it will be
-		/// null).  Further, within the selected pane, if the mouse point is within the
-		/// bounding box of any of the items (or in the case
-		/// of <see cref="ArrowObj"/> and <see cref="CurveItem"/>, within
-		/// <see cref="GraphPane.Default.NearestTol"/> pixels), then the object will be returned.
-		/// You must check the type of the object to determine what object was
-		/// selected (for example, "if ( object is Legend ) ...").  The
-		/// <see paramref="index"/> parameter returns the index number of the item
-		/// within the selected object (such as the point number within a
-		/// <see cref="CurveItem"/> object.
-		/// </remarks>
-		/// <param name="mousePt">The screen point, in pixel coordinates.</param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that was clicked.</param>
-		/// <param name="nearestObj">A reference to the nearest object to the
-		/// specified screen point.  This can be any of <see cref="Axis"/>,
-		/// <see cref="Legend"/>, <see cref="PaneBase.Title"/>,
-		/// <see cref="TextObj"/>, <see cref="ArrowObj"/>, or <see cref="CurveItem"/>.
-		/// Note: If the pane title is selected, then the <see cref="GraphPane"/> object
-		/// will be returned.
-		/// </param>
-		/// <param name="index">The index number of the item within the selected object
-		/// (where applicable).  For example, for a <see cref="CurveItem"/> object,
-		/// <see paramref="index"/> will be the index number of the nearest data point,
-		/// accessible via <see cref="CurveItem.Points">CurveItem.Points[index]</see>.
-		/// index will be -1 if no data points are available.</param>
-		/// <returns>true if a <see cref="GraphPane"/> was found, false otherwise.</returns>
-		/// <seealso cref="GraphPane.FindNearestObject"/>
-		public bool FindNearestPaneObject( PointF mousePt, Graphics g, out GraphPane pane,
-			out object nearestObj, out int index )
-		{
-			pane = null;
-			nearestObj = null;
-			index = -1;
-
-			GraphObj	saveGraphItem = null;
-			int			saveIndex = -1;
-			float		scaleFactor = CalcScaleFactor();
-
-			// See if the point is in a GraphObj
-			// If so, just save the object and index so we can see if other overlying objects were
-			// intersected as well.
-			if ( this.GraphObjList.FindPoint( mousePt, this, g, scaleFactor, out index ) )
-			{
-				saveGraphItem = this.GraphObjList[index];
-				saveIndex = index;
-
-				// If it's an "In-Front" item, then just return it
-				if ( saveGraphItem.ZOrder == ZOrder.A_InFront )
-				{
-					nearestObj = saveGraphItem;
-					index = saveIndex;
-					return true;
-				}
-			}
-
-			foreach ( GraphPane tPane in _paneList )
-			{
-				if ( tPane.Rect.Contains( mousePt ) )
-				{
-					pane = tPane;
-					return tPane.FindNearestObject( mousePt, g, out nearestObj, out index );
-				}
-			}
-
-			// If no items were found in the GraphPanes, then return the item found on the MasterPane (if any)
-			if ( saveGraphItem != null )
-			{
-				nearestObj = saveGraphItem;
-				index = saveIndex;
-				return true;
-			}
-
-			return false;
-		}
-
-		/// <summary>
-		/// Find the <see cref="GraphPane"/> within the <see cref="PaneList"/> that contains the
-		/// <see paramref="mousePt"/> within its <see cref="PaneBase.Rect"/>.
-		/// </summary>
-		/// <param name="mousePt">The mouse point location where you want to search</param>
-		/// <returns>A <see cref="GraphPane"/> object that contains the mouse point, or
-		/// null if no <see cref="GraphPane"/> was found.</returns>
-		public GraphPane FindPane( PointF mousePt )
-		{
-			foreach ( GraphPane pane in _paneList )
-			{
-				if ( pane.Rect.Contains( mousePt ) )
-					return pane;
-			}
-			
-			return null;
-		}
-
-		/// <summary>
-		/// Find the <see cref="GraphPane"/> within the <see cref="PaneList"/> that contains the
-		/// <see paramref="mousePt"/> within its <see cref="Chart.Rect"/>.
-		/// </summary>
-		/// <param name="mousePt">The mouse point location where you want to search</param>
-		/// <returns>A <see cref="GraphPane"/> object that contains the mouse point, or
-		/// null if no <see cref="GraphPane"/> was found.</returns>
-		public GraphPane FindChartRect( PointF mousePt )
-		{
-			foreach ( GraphPane pane in _paneList )
-			{
-				if ( pane.Chart._rect.Contains( mousePt ) )
-					return pane;
-			}
-			
-			return null;
-		}
-
-	#endregion
-
-	#region Layout Methods
-
-		/// <overloads>The SetLayout() methods setup the desired layout of the
-		/// <see cref="GraphPane" /> objects within a <see cref="MasterPane" />.  These functions
-		/// do not make any changes, they merely set the parameters so that future calls
-		/// to <see cref="PaneBase.ReSize" /> or <see cref="DoLayout(Graphics)" />
-		/// will use the desired layout.<br /><br />
-		/// The layout options include a set of "canned" layouts provided by the
-		/// <see cref="ZedGraph.PaneLayout" /> enumeration, options to just set a specific
-		/// number of rows and columns of panes (and all pane sizes are the same), and more
-		/// customized options of specifying the number or rows in each column or the number of
-		/// columns in each row, along with proportional values that determine the size of each
-		/// individual column or row.
-		/// </overloads>
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a pre-defined layout configuration from a <see cref="PaneLayout" />
-		/// enumeration.
-		/// </summary>
-		/// <remarks>This method uses a <see cref="PaneLayout"/> enumeration to describe the type of layout
-		/// to be used.  Overloads are available that provide other layout options</remarks>
-		/// <param name="paneLayout">A <see cref="PaneLayout"/> enumeration that describes how
-		/// the panes should be laid out within the <see cref="PaneBase.Rect"/>.</param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally created with a call to
-		/// the CreateGraphics() method of the Control or Form.
-		/// </param>
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public void SetLayout( Graphics g, PaneLayout paneLayout )
-		{
-			InitLayout();
-
-			_paneLayout = paneLayout;
-
-			DoLayout( g );
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a reasonable configuration.
-		/// </summary>
-		/// <remarks>This method explicitly specifies the number of rows and columns to use
-		/// in the layout, and all <see cref="GraphPane" /> objects will have the same size.
-		/// Overloads are available that provide other layout options</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally created with a call to
-		/// the CreateGraphics() method of the Control or Form.
-		/// </param>
-		/// <param name="rows">The number of rows of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <param name="columns">The number of columns of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public void SetLayout( Graphics g, int rows, int columns )
-		{
-			InitLayout();
-
-			if ( rows < 1 )
-				rows = 1;
-			if ( columns < 1 )
-				columns = 1;
-
-			int[] countList = new int[rows];
-
-			for ( int i = 0; i < rows; i++ )
-				countList[i] = columns;
-
-			SetLayout( g, true, countList, null );
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to the specified configuration.
-		/// </summary>
-		/// <remarks>This method specifies the number of rows in each column, or the number of
-		/// columns in each row, allowing for irregular layouts.  Overloads are available that
-		/// provide other layout options.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally created with a call to
-		/// the CreateGraphics() method of the Control or Form.
-		/// </param>
-		/// <param name="isColumnSpecified">Specifies whether the number of columns in each row, or
-		/// the number of rows in each column will be specified.  A value of true indicates the
-		/// number of columns in each row are specified in <see paramref="countList"/>.</param>
-		/// <param name="countList">An integer array specifying either the number of columns in
-		/// each row or the number of rows in each column, depending on the value of
-		/// <see paramref="isColumnSpecified"/>.</param>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public void SetLayout( Graphics g, bool isColumnSpecified, int[] countList )
-		{
-			SetLayout( g, isColumnSpecified, countList, null );
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to the specified configuration.
-		/// </summary>
-		/// <remarks>This method specifies the number of panes in each row or column, allowing for
-		/// irregular layouts.</remarks>
-		/// <remarks>This method specifies the number of rows in each column, or the number of
-		/// columns in each row, allowing for irregular layouts.  Additionally, a
-		/// <see paramref="proportion" /> parameter is provided that allows varying column or
-		/// row sizes.  Overloads for SetLayout() are available that provide other layout options.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally created with a call to
-		/// the CreateGraphics() method of the Control or Form.
-		/// </param>
-		/// <param name="isColumnSpecified">Specifies whether the number of columns in each row, or
-		/// the number of rows in each column will be specified.  A value of true indicates the
-		/// number of columns in each row are specified in <see paramref="_countList"/>.</param>
-		/// <param name="countList">An integer array specifying either the number of columns in
-		/// each row or the number of rows in each column, depending on the value of
-		/// <see paramref="isColumnSpecified"/>.</param>
-		/// <param name="proportion">An array of float values specifying proportional sizes for each
-		/// row or column.  Note that these proportions apply to the non-specified dimension -- that is,
-		/// if <see paramref="isColumnSpecified"/> is true, then these proportions apply to the row
-		/// heights, and if <see paramref="isColumnSpecified"/> is false, then these proportions apply
-		/// to the column widths.  The values in this array are arbitrary floats -- the dimension of
-		/// any given row or column is that particular proportional value divided by the sum of all
-		/// the values.  For example, let <see paramref="isColumnSpecified"/> be true, and
-		/// <see paramref="proportion"/> is an array with values of { 1.0, 2.0, 3.0 }.  The sum of
-		/// those values is 6.0.  Therefore, the first row is 1/6th of the available height, the
-		/// second row is 2/6th's of the available height, and the third row is 3/6th's of the
-		/// available height.
-		/// </param>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		public void SetLayout( Graphics g, bool isColumnSpecified, int[] countList, float[] proportion )
-		{
-			InitLayout();
-
-			// use defaults if the parameters are invalid
-			if ( countList != null && countList.Length > 0 )
-			{
-				_prop = new float[countList.Length];
-
-				// Sum up the total proportional factors
-				float sumProp = 0.0f;
-				for ( int i = 0; i < countList.Length; i++ )
-				{
-					_prop[i] = ( proportion == null || proportion.Length <= i || proportion[i] < 1e-10 ) ?
-												1.0f : proportion[i];
-					sumProp += _prop[i];
-				}
-
-				// Make prop sum to 1.0
-				for ( int i = 0; i < countList.Length; i++ )
-					_prop[i] /= sumProp;
-
-				_isColumnSpecified = isColumnSpecified;
-				_countList = countList;
-
-				DoLayout( g );
-			}
-		}
-
-		/// <summary>
-		/// Modify the <see cref="GraphPane" /> <see cref="PaneBase.Rect" /> sizes of each
-		/// <see cref="GraphPane" /> such that they fit within the <see cref="MasterPane" />
-		/// in a pre-configured layout.
-		/// </summary>
-		/// <remarks>The <see cref="SetLayout(Graphics,PaneLayout)" /> method (and overloads) is
-		/// used for setting the layout configuration.</remarks>
-		/// <seealso cref="SetLayout(Graphics,PaneLayout)" />
-		/// <seealso cref="SetLayout(Graphics,int,int)" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[])" />
-		/// <seealso cref="SetLayout(Graphics,bool,int[],float[])" />
-		public void DoLayout( Graphics g )
-		{
-			if ( _countList != null )
-				DoLayout( g, _isColumnSpecified, _countList, _prop );
-			else
-			{
-				int count = _paneList.Count;
-				if ( count == 0 )
-					return;
-
-				int rows,
-						cols,
-						root = (int)( Math.Sqrt( (double)count ) + 0.9999999 );
-
-				//float[] widthList = new float[5];
-
-				switch ( _paneLayout )
-				{
-					case PaneLayout.ForceSquare:
-						rows = root;
-						cols = root;
-						DoLayout( g, rows, cols );
-						break;
-					case PaneLayout.SingleColumn:
-						rows = count;
-						cols = 1;
-						DoLayout( g, rows, cols );
-						break;
-					case PaneLayout.SingleRow:
-						rows = 1;
-						cols = count;
-						DoLayout( g, rows, cols );
-						break;
-					default:
-					case PaneLayout.SquareColPreferred:
-						rows = root;
-						cols = root;
-						if ( count <= root * ( root - 1 ) )
-							rows--;
-						DoLayout( g, rows, cols );
-						break;
-					case PaneLayout.SquareRowPreferred:
-						rows = root;
-						cols = root;
-						if ( count <= root * ( root - 1 ) )
-							cols--;
-						DoLayout( g, rows, cols );
-						break;
-					case PaneLayout.ExplicitCol12:
-						DoLayout( g, true, new int[2] { 1, 2 }, null );
-						break;
-					case PaneLayout.ExplicitCol21:
-						DoLayout( g, true, new int[2] { 2, 1 }, null );
-						break;
-					case PaneLayout.ExplicitCol23:
-						DoLayout( g, true, new int[2] { 2, 3 }, null );
-						break;
-					case PaneLayout.ExplicitCol32:
-						DoLayout( g, true, new int[2] { 3, 2 }, null );
-						break;
-					case PaneLayout.ExplicitRow12:
-						DoLayout( g, false, new int[2] { 1, 2 }, null );
-						break;
-					case PaneLayout.ExplicitRow21:
-						DoLayout( g, false, new int[2] { 2, 1 }, null );
-						break;
-					case PaneLayout.ExplicitRow23:
-						DoLayout( g, false, new int[2] { 2, 3 }, null );
-						break;
-					case PaneLayout.ExplicitRow32:
-						DoLayout( g, false, new int[2] { 3, 2 }, null );
-						break;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Internal method that applies a previously set layout with a specific
-		/// row and column count.  This method is only called by
-		/// <see cref="DoLayout(Graphics)" />.
-		/// </summary>
-		internal void DoLayout( Graphics g, int rows, int columns )
-		{
-			if ( rows < 1 )
-				rows = 1;
-			if ( columns < 1 )
-				columns = 1;
-
-			int[] countList = new int[rows];
-
-			for ( int i = 0; i < rows; i++ )
-				countList[i] = columns;
-
-			DoLayout( g, true, countList, null );
-		}
-
-		/// <summary>
-		/// Internal method that applies a previously set layout with a rows per column or
-		/// columns per row configuration.  This method is only called by
-		/// <see cref="DoLayout(Graphics)" />.
-		/// </summary>
-		internal void DoLayout( Graphics g, bool isColumnSpecified, int[] countList,
-					float[] proportion )
-		{
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = CalcScaleFactor();
-
-			// innerRect is the area for the GraphPane's
-			RectangleF innerRect = CalcClientRect( g, scaleFactor );
-			_legend.CalcRect( g, this, scaleFactor, ref innerRect );
-
-			// scaled InnerGap is the area between the GraphPane.Rect's
-			float scaledInnerGap = (float)( _innerPaneGap * scaleFactor );
-
-			int iPane = 0;
-
-			if ( isColumnSpecified )
-			{
-				int rows = countList.Length;
-
-				float y = 0.0f;
-
-				for ( int rowNum = 0; rowNum < rows; rowNum++ )
-				{
-					float propFactor = _prop == null ? 1.0f / rows : _prop[rowNum];
-
-					float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) *
-									propFactor;
-
-					int columns = countList[rowNum];
-					if ( columns <= 0 )
-						columns = 1;
-					float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) /
-									(float)columns;
-
-					for ( int colNum = 0; colNum < columns; colNum++ )
-					{
-						if ( iPane >= _paneList.Count )
-							return;
-
-						this[iPane].Rect = new RectangleF(
-											innerRect.X + colNum * ( width + scaledInnerGap ),
-											innerRect.Y + y,
-											width,
-											height );
-						iPane++;
-					}
-
-					y += height + scaledInnerGap;
-				}
-			}
-			else
-			{
-				int columns = countList.Length;
-
-				float x = 0.0f;
-
-				for ( int colNum = 0; colNum < columns; colNum++ )
-				{
-					float propFactor = _prop == null ? 1.0f / columns : _prop[colNum];
-
-					float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) *
-									propFactor;
-
-					int rows = countList[colNum];
-					if ( rows <= 0 )
-						rows = 1;
-					float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) / (float)rows;
-
-					for ( int rowNum = 0; rowNum < rows; rowNum++ )
-					{
-						if ( iPane >= _paneList.Count )
-							return;
-
-						this[iPane].Rect = new RectangleF(
-											innerRect.X + x,
-											innerRect.Y + rowNum * ( height + scaledInnerGap ),
-											width,
-											height );
-						iPane++;
-					}
-
-					x += width + scaledInnerGap;
-				}
-			}
-		}
-
-		/*
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a reasonable configuration.
-		/// </summary>
-		/// <remarks>This method explicitly specifies the number of rows and columns to use in the layout.
-		/// A more automatic overload, using a <see cref="PaneLayout"/> enumeration, is available.</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rows">The number of rows of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <param name="columns">The number of columns of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		public void DoPaneLayout( Graphics g, int rows, int columns )
-		{
-			// save the layout settings for future reference
-			_countList = null;
-			_rows = rows;
-			_columns = columns;
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = this.CalcScaleFactor();
-
-			// innerRect is the area for the GraphPane's
-			RectangleF innerRect = CalcClientRect( g, scaleFactor );
-			_legend.CalcRect( g, this, scaleFactor, ref innerRect );
-
-			// scaled InnerGap is the area between the GraphPane.Rect's
-			float scaledInnerGap = (float)( _innerPaneGap * scaleFactor );
-
-			float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) / (float)columns;
-			float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) / (float)rows;
-
-			int i = 0;
-			foreach ( GraphPane pane in _paneList )
-			{
-				float rowNum = (float)( i / columns );
-				float colNum = (float)( i % columns );
-
-				pane.Rect = new RectangleF(
-									innerRect.X + colNum * ( width + scaledInnerGap ),
-									innerRect.Y + rowNum * ( height + scaledInnerGap ),
-									width,
-									height );
-
-				i++;
-			}
-		}
-		*/
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/MinorGrid.cs b/BDInfo/ZedGraph/MinorGrid.cs
deleted file mode 100644
index e430f0a36f..0000000000
--- a/BDInfo/ZedGraph/MinorGrid.cs
+++ /dev/null
@@ -1,294 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that holds the specific properties for the minor grid.
-	/// </summary>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class MinorGrid : ICloneable, ISerializable
-	{
-		internal bool	_isVisible;
-
-		internal float _dashOn,
-							_dashOff,
-							_penWidth;
-
-		internal Color _color;
-
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor
-		/// </summary>
-		public MinorGrid()
-		{
-			_dashOn = Default.DashOn;
-			_dashOff = Default.DashOff;
-			_penWidth = Default.PenWidth;
-			_isVisible = Default.IsVisible;
-			_color = Default.Color;
-		}
-
-		/// <summary>
-		/// Copy constructor
-		/// </summary>
-		/// <param name="rhs">The source <see cref="MinorGrid" /> to be copied.</param>
-		public MinorGrid( MinorGrid rhs )
-		{
-			_dashOn = rhs._dashOn;
-			_dashOff = rhs._dashOff;
-			_penWidth = rhs._penWidth;
-
-			_isVisible = rhs._isVisible;
-
-			_color = rhs._color;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public MinorGrid Clone()
-		{
-			return new MinorGrid( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a value that determines if the major <see cref="Axis"/> gridlines
-		/// (at each labeled value) will be visible
-		/// </summary>
-		/// <value>true to show the gridlines, false otherwise</value>
-		/// <seealso cref="Default.IsVisible">Default.IsShowGrid</seealso>.
-		/// <seealso cref="Color"/>
-		/// <seealso cref="PenWidth"/>
-		/// <seealso cref="DashOn"/>
-		/// <seealso cref="DashOff"/>
-		/// <seealso cref="IsVisible"/>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-		/// <summary>
-		/// The "Dash On" mode for drawing the grid.
-		/// </summary>
-		/// <remarks>
-		/// This is the distance,
-		/// in points (1/72 inch), of the dash segments that make up the dashed grid lines.
-		/// </remarks>
-		/// <value>The dash on length is defined in points (1/72 inch)</value>
-		/// <seealso cref="DashOff"/>
-		/// <seealso cref="IsVisible"/>
-		/// <seealso cref="Default.DashOn"/>.
-		public float DashOn
-		{
-			get { return _dashOn; }
-			set { _dashOn = value; }
-		}
-		/// <summary>
-		/// The "Dash Off" mode for drawing the grid.
-		/// </summary>
-		/// <remarks>
-		/// This is the distance,
-		/// in points (1/72 inch), of the spaces between the dash segments that make up
-		/// the dashed grid lines.
-		/// </remarks>
-		/// <value>The dash off length is defined in points (1/72 inch)</value>
-		/// <seealso cref="DashOn"/>
-		/// <seealso cref="IsVisible"/>
-		/// <seealso cref="Default.DashOff"/>.
-		public float DashOff
-		{
-			get { return _dashOff; }
-			set { _dashOff = value; }
-		}
-		/// <summary>
-		/// The pen width used for drawing the grid lines.
-		/// </summary>
-		/// <value>The grid pen width is defined in points (1/72 inch)</value>
-		/// <seealso cref="IsVisible"/>
-		/// <seealso cref="Default.PenWidth"/>.
-		/// <seealso cref="Color"/>
-		public float PenWidth
-		{
-			get { return _penWidth; }
-			set { _penWidth = value; }
-		}
-		/// <summary>
-		/// The color to use for drawing this <see cref="Axis"/> grid.
-		/// </summary>
-		/// <value> The color is defined using the
-		/// <see cref="System.Drawing.Color"/> class</value>
-		/// <seealso cref="Default.Color"/>.
-		/// <seealso cref="PenWidth"/>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected MinorGrid( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_isVisible = info.GetBoolean( "isVisible" );
-
-			_dashOn = info.GetSingle( "dashOn" );
-			_dashOff = info.GetSingle( "dashOff" );
-			_penWidth = info.GetSingle( "penWidth" );
-
-			_color = (Color)info.GetValue( "color", typeof( Color ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "isVisible", _isVisible );
-
-			info.AddValue( "dashOn", _dashOn );
-			info.AddValue( "dashOff", _dashOff );
-			info.AddValue( "penWidth", _penWidth );
-
-			info.AddValue( "color", _color );
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="MinorGrid"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default "dash on" size for drawing the <see cref="Axis"/> minor grid
-			/// (<see cref="MinorGrid.DashOn"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOn = 1.0F;
-			/// <summary>
-			/// The default "dash off" size for drawing the <see cref="Axis"/> minor grid
-			/// (<see cref="MinorGrid.DashOff"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float DashOff = 10.0F;
-			/// <summary>
-			/// The default pen width for drawing the <see cref="Axis"/> minor grid
-			/// (<see cref="MinorGrid.PenWidth"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The default color for the <see cref="Axis"/> minor grid lines
-			/// (<see cref="MinorGrid.Color"/> property).  This color only affects the
-			/// minor grid lines.
-			/// </summary>
-			public static Color Color = Color.Gray;
-
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> minor grid lines
-			/// (<see cref="MinorGrid.IsVisible"/> property). true
-			/// to show the minor grid lines, false to hide them.
-			/// </summary>
-			public static bool IsVisible = false;
-
-		}
-
-	#endregion
-
-	#region Methods
-
-		internal void Draw( Graphics g, Pen pen, float pixVal, float topPix )
-		{
-			// draw the minor grid
-			if ( _isVisible )
-				g.DrawLine( pen, pixVal, 0.0F, pixVal, topPix );
-		}
-
-		internal Pen GetPen( GraphPane pane, float scaleFactor )
-		{
-			Pen pen = new Pen( _color,
-						pane.ScaledPenWidth( _penWidth, scaleFactor ) );
-
-			if ( _dashOff > 1e-10 && _dashOn > 1e-10 )
-			{
-				pen.DashStyle = DashStyle.Custom;
-				float[] pattern = new float[2];
-				pattern[0] = _dashOn;
-				pattern[1] = _dashOff;
-				pen.DashPattern = pattern;
-			}
-
-			return pen;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/MinorTic.cs b/BDInfo/ZedGraph/MinorTic.cs
deleted file mode 100644
index 4ba6ede369..0000000000
--- a/BDInfo/ZedGraph/MinorTic.cs
+++ /dev/null
@@ -1,501 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Class that holds the specific properties for the minor tics.
-	/// </summary>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class MinorTic : ICloneable, ISerializable
-	{
-		internal bool	_isOutside,
-							_isInside,
-							_isOpposite,
-							_isCrossOutside,
-							_isCrossInside;
-
-		internal float _penWidth,
-							_size;
-
-		internal Color _color;
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public MinorTic()
-		{
-			_size = Default.Size;
-			_color = Default.Color;
-			_penWidth = Default.PenWidth;
-
-			this.IsOutside = Default.IsOutside;
-			this.IsInside = Default.IsInside;
-			this.IsOpposite = Default.IsOpposite;
-			_isCrossOutside = Default.IsCrossOutside;
-			_isCrossInside = Default.IsCrossInside;
-		}
-
-		/// <summary>
-		/// Copy constructor.
-		/// </summary>
-		/// <param name="rhs">The <see cref="MinorTic" /> that is to be copied.</param>
-		public MinorTic( MinorTic rhs )
-		{
-			_size = rhs._size;
-			_color = rhs._color;
-			_penWidth = rhs._penWidth;
-
-			this.IsOutside = rhs.IsOutside;
-			this.IsInside = rhs.IsInside;
-			this.IsOpposite = rhs.IsOpposite;
-			_isCrossOutside = rhs._isCrossOutside;
-			_isCrossInside = rhs._isCrossInside;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public MinorTic Clone()
-		{
-			return new MinorTic( this );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// The color to use for drawing the tics of this class instance
-		/// </summary>
-		/// <value> The color is defined using the
-		/// <see cref="System.Drawing.Color"/> class</value>
-		/// <seealso cref="Default.Color"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="Axis.IsVisible"/>
-		public Color Color
-		{
-			get { return _color; }
-			set { _color = value; }
-		}
-
-		/// <summary>
-		/// The length of the major tic marks.
-		/// </summary>
-		/// <remarks>
-		/// This length will be scaled
-		/// according to the <see cref="PaneBase.CalcScaleFactor"/> for the
-		/// <see cref="GraphPane"/>
-		/// </remarks>
-		/// <value>The tic size is measured in points (1/72 inch)</value>
-		/// <seealso cref="Default.Size"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="Axis.IsVisible"/>
-		/// <seealso cref="Color"/>
-		public float Size
-		{
-			get { return _size; }
-			set { _size = value; }
-		}
-		/// <summary>
-		/// Calculate the scaled tic size for this <see cref="Axis"/>
-		/// </summary>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The scaled tic size, in points (1/72 inch)</returns>
-		/// <seealso cref="Size"/>
-		/// <seealso cref="Scale.FontSpec"/>
-		/// <seealso cref="PaneBase.CalcScaleFactor"/>
-		public float ScaledTic( float scaleFactor )
-		{
-			return (float)( _size * scaleFactor );
-		}
-
-		/// <summary>
-		/// This is convenience property sets the status of all the different
-		/// tic properties in this instance to the same value.  true to activate all tics,
-		/// false to clear all tics.
-		/// </summary>
-		/// <remarks>
-		/// This setting does not persist.  That is, you can clear all the tics with
-		/// <see cref="IsAllTics" /> = false, then activate them individually (example:
-		/// <see cref="IsOutside" /> = true).
-		/// </remarks>
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="IsInside"/>
-		/// <seealso cref="IsOpposite"/>
-		/// <seealso cref="IsCrossInside"/>
-		/// <seealso cref="IsCrossOutside"/>
-		public bool IsAllTics
-		{
-			set
-			{
-				this.IsOutside = value;
-				this.IsInside = value;
-				this.IsOpposite = value;
-				_isCrossOutside = value;
-				_isCrossInside = value;
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the minor outside tic marks
-		/// are shown.
-		/// </summary>
-		/// <remarks>
-		/// These are the tic marks on the outside of the <see cref="Axis"/> border.
-		/// The minor tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-		/// </remarks>
-		/// <value>true to show the minor outside tic marks, false otherwise</value>
-		/// <seealso cref="Default.IsOutside"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="IsInside"/>
-		/// <seealso cref="IsOpposite"/>
-		/// <seealso cref="IsCrossInside"/>
-		/// <seealso cref="IsCrossOutside"/>
-		public bool IsOutside
-		{
-			get { return _isOutside; }
-			set { _isOutside = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the major inside tic marks
-		/// are shown.
-		/// </summary>
-		/// <remarks>
-		/// These are the tic marks on the inside of the <see cref="Axis"/> border.
-		/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-		/// </remarks>
-		/// <value>true to show the major inside tic marks, false otherwise</value>
-		/// <seealso cref="Default.IsInside"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="IsInside"/>
-		/// <seealso cref="IsOpposite"/>
-		/// <seealso cref="IsCrossInside"/>
-		/// <seealso cref="IsCrossOutside"/>
-		public bool IsInside
-		{
-			get { return _isInside; }
-			set { _isInside = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the major opposite tic marks
-		/// are shown.
-		/// </summary>
-		/// <remarks>
-		/// These are the tic marks on the inside of the <see cref="Axis"/> border on
-		/// the opposite side from the axis.
-		/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-		/// </remarks>
-		/// <value>true to show the major opposite tic marks, false otherwise</value>
-		/// <seealso cref="Default.IsOpposite"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="IsInside"/>
-		/// <seealso cref="IsOpposite"/>
-		/// <seealso cref="IsCrossInside"/>
-		/// <seealso cref="IsCrossOutside"/>
-		public bool IsOpposite
-		{
-			get { return _isOpposite; }
-			set { _isOpposite = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the display mode for the <see cref="Axis"/> major outside 
-		/// "cross" tic marks.
-		/// </summary>
-		/// <remarks>
-		/// The "cross" tics are a special, additional set of tic marks that
-		/// always appear on the actual axis, even if it has been shifted due
-		/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-		/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-		/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-		/// they will exactly overlay the "normal" and "inside" tics.  If
-		/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-		/// enable the cross tics.
-		/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-		/// </remarks>
-		/// <value>true to show the major cross tic marks, false otherwise</value>
-		public bool IsCrossOutside
-		{
-			get { return _isCrossOutside; }
-			set { _isCrossOutside = value; }
-		}
-		/// <summary>
-		/// Gets or sets the display mode for the <see cref="Axis"/> major inside 
-		/// "cross" tic marks.
-		/// </summary>
-		/// <remarks>
-		/// The "cross" tics are a special, additional set of tic marks that
-		/// always appear on the actual axis, even if it has been shifted due
-		/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-		/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-		/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-		/// they will exactly overlay the "normal" and "inside" tics.  If
-		/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-		/// enable the cross tics.
-		/// The major tic spacing is controlled by <see cref="Scale.MajorStep"/>.
-		/// </remarks>
-		/// <value>true to show the major cross tic marks, false otherwise</value>
-		public bool IsCrossInside
-		{
-			get { return _isCrossInside; }
-			set { _isCrossInside = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the pen width to be used when drawing the tic marks for
-		/// this <see cref="Axis"/>
-		/// </summary>
-		/// <value>The pen width is defined in points (1/72 inch)</value>
-		/// <seealso cref="Default.PenWidth"/>.
-		/// <seealso cref="IsOutside"/>
-		/// <seealso cref="Color"/>
-		public float PenWidth
-		{
-			get { return _penWidth; }
-			set { _penWidth = value; }
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected MinorTic( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_color = (Color) info.GetValue( "color", typeof( Color ) );
-			_size = info.GetSingle( "size" );
-			_penWidth = info.GetSingle( "penWidth" );
-
-			IsOutside = info.GetBoolean( "IsOutside" );
-			IsInside = info.GetBoolean( "IsInside" );
-			IsOpposite = info.GetBoolean( "IsOpposite" );
-			_isCrossOutside = info.GetBoolean( "isCrossOutside" );
-			_isCrossInside = info.GetBoolean( "isCrossInside" );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "color", _color );
-			info.AddValue( "size", _size );
-			info.AddValue( "penWidth", _penWidth );
-
-			info.AddValue( "IsOutside", IsOutside );
-			info.AddValue( "IsInside", IsInside );
-			info.AddValue( "IsOpposite", IsOpposite );
-			info.AddValue( "isCrossOutside", _isCrossOutside );
-			info.AddValue( "isCrossInside", _isCrossInside );
-
-		}
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="MinorTic"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default size for the <see cref="Axis"/> minor tic marks.
-			/// (<see cref="MinorTic.Size"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float Size = 2.5F;
-			/// <summary>
-			/// The default pen width for drawing the <see cref="Axis"/> tic marks.
-			/// (<see cref="MinorTic.PenWidth"/> property). Units are in points (1/72 inch).
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> minor outside tic marks
-			/// (<see cref="MinorTic.IsOutside"/> property).
-			/// The minor tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-			/// </summary>
-			/// <value>true to show the minor tic marks (outside the axis),
-			/// false otherwise</value>
-			public static bool IsOutside = true;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> minor inside tic marks
-			/// (<see cref="MinorTic.IsInside"/> property).
-			/// The minor tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-			/// </summary>
-			/// <value>true to show the minor tic marks (inside the axis),
-			/// false otherwise</value>
-			public static bool IsInside = true;
-			/// <summary>
-			/// The display mode for the <see cref="Axis"/> minor opposite tic marks
-			/// (<see cref="MinorTic.IsOpposite"/> property).
-			/// The minor tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-			/// </summary>
-			/// <value>true to show the minor tic marks
-			/// (inside the axis on the opposite side),
-			/// false otherwise</value>
-			public static bool IsOpposite = true;
-
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> minor outside 
-			/// "cross" tic marks (<see cref="MinorTic.IsCrossOutside"/> property).
-			/// </summary>
-			/// <remarks>
-			/// The "cross" tics are a special, additional set of tic marks that
-			/// always appear on the actual axis, even if it has been shifted due
-			/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-			/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-			/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-			/// they will exactly overlay the "normal" and "inside" tics.  If
-			/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-			/// enable the cross tics.
-			/// The minor tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-			/// </remarks>
-			/// <value>true to show the major cross tic marks, false otherwise</value>
-			public static bool IsCrossOutside = false;
-			/// <summary>
-			/// The default display mode for the <see cref="Axis"/> minor inside 
-			/// "cross" tic marks (<see cref="MinorTic.IsCrossInside"/> property).
-			/// </summary>
-			/// <remarks>
-			/// The "cross" tics are a special, additional set of tic marks that
-			/// always appear on the actual axis, even if it has been shifted due
-			/// to the <see cref="Axis.Cross" /> setting.  The other tic marks are always
-			/// fixed to the edges of the <see cref="Chart.Rect"/>.  The cross tics
-			/// are normally not displayed, since, if <see cref="Axis.CrossAuto" /> is true,
-			/// they will exactly overlay the "normal" and "inside" tics.  If
-			/// <see cref="Axis.CrossAuto"/> is false, then you will most likely want to
-			/// enable the cross tics.
-			/// The major tic spacing is controlled by <see cref="Scale.MinorStep"/>.
-			/// </remarks>
-			/// <value>true to show the major cross tic marks, false otherwise</value>
-			public static bool IsCrossInside = false;
-
-			/// <summary>
-			/// The default color for minor tics (<see cref="MinorTic.Color"/> property).
-			/// </summary>
-			public static Color Color = Color.Black;
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Draw a tic mark at the specified single position.  This includes the inner, outer,
-		/// cross and opposite tic marks as required.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pen">Graphic <see cref="Pen"/> with which to draw the tic mark.</param>
-		/// <param name="pixVal">The pixel location of the tic mark on this
-		/// <see cref="Axis"/></param>
-		/// <param name="topPix">The pixel value of the top of the axis border</param>
-		/// <param name="shift">The number of pixels to shift this axis, based on the
-		/// value of <see cref="Axis.Cross"/>.  A positive value is into the ChartRect relative to
-		/// the default axis position.</param>
-		/// <param name="scaledTic">The scaled size of a minor tic, in pixel units</param>
-		internal void Draw( Graphics g, GraphPane pane, Pen pen, float pixVal, float topPix,
-					float shift, float scaledTic )
-		{
-			// draw the outside tic
-			if ( this.IsOutside )
-				g.DrawLine( pen, pixVal, shift, pixVal, shift + scaledTic );
-
-			// draw the cross tic
-			if ( _isCrossOutside )
-				g.DrawLine( pen, pixVal, 0.0f, pixVal, scaledTic );
-
-			// draw the inside tic
-			if ( this.IsInside )
-				g.DrawLine( pen, pixVal, shift, pixVal, shift - scaledTic );
-
-			// draw the inside cross tic
-			if ( _isCrossInside )
-				g.DrawLine( pen, pixVal, 0.0f, pixVal, -scaledTic );
-
-			// draw the opposite tic
-			if ( this.IsOpposite )
-				g.DrawLine( pen, pixVal, topPix, pixVal, topPix + scaledTic );
-		}
-
-		internal Pen GetPen( GraphPane pane, float scaleFactor )
-		{
-			return new Pen( _color, pane.ScaledPenWidth( _penWidth, scaleFactor ) );
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/NoDupePointList.cs b/BDInfo/ZedGraph/NoDupePointList.cs
deleted file mode 100644
index 5cd75c58f4..0000000000
--- a/BDInfo/ZedGraph/NoDupePointList.cs
+++ /dev/null
@@ -1,358 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Drawing;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A simple storage struct to maintain an individual sampling of data.  This only
-	/// contains two data values in order to reduce to memory load for large datasets.
-	/// (e.g., no Tag or Z property)
-	/// </summary>
-	public struct DataPoint
-	{
-		/// <summary>
-		/// The X value for the point, stored as a double type.
-		/// </summary>
-		public double X;
-		/// <summary>
-		/// The Y value for the point, stored as a double type.
-		/// </summary>
-		public double Y;
-	}
-
-	/// <summary>
-	/// A collection class to maintain a set of samples.
-	/// </summary>
-	/// <remarks>This type, intended for very
-	/// large datasets, will reduce the number of points displayed by eliminating
-	/// individual points that overlay (at the same pixel location) on the graph.
-	/// Note that this type probably does not make sense for line plots, but is intended
-	/// primarily for scatter plots.
-	/// </remarks>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/06/02 06:56:03 $ </version>
-	[Serializable]
-	public class NoDupePointList : List<DataPoint>, IPointList, IPointListEdit
-	{
-		/// <summary>
-		/// Protected field that stores a value indicating whether or not the data have been filtered.
-		/// If the data have not been filtered, then <see cref="Count" /> will be equal to
-		/// <see cref="TotalCount" />.  Use the public property <see cref="IsFiltered" /> to
-		/// access this value.
-		/// </summary>
-		protected bool _isFiltered;
-		/// <summary>
-		/// Protected field that stores the number of data points after filtering (e.g.,
-		/// <see cref="FilterData" /> has been called).  The <see cref="Count" /> property
-		/// returns the total count for an unfiltered dataset, or <see cref="_filteredCount" />
-		/// for a dataset that has been filtered.
-		/// </summary>
-		protected int _filteredCount;
-		/// <summary>
-		/// Protected array of indices for all the points that are currently visible.  This only
-		/// applies if <see cref="IsFiltered" /> is true.
-		/// </summary>
-		protected int[] _visibleIndicies;
-
-
-		/// <summary>
-		/// Protected field that stores a value that determines how close a point must be to a prior
-		/// neighbor in order to be filtered out.  Use the public property <see cref="FilterMode" />
-		/// to access this value.
-		/// </summary>
-		protected int _filterMode;
-
-
-		/// <summary>
-		/// Gets or sets a value that determines how close a point must be to a prior
-		/// neighbor in order to be filtered out.
-		/// </summary>
-		/// <remarks>
-		/// A value of 0 indicates that subsequent
-		/// points must coincide exactly at the same pixel location.  A value of 1 or more
-		/// indicates that number of pixels distance from a prior point that will cause
-		/// a new point to be filtered out.  For example, a value of 2 means that, once
-		/// a particular pixel location is taken, any subsequent point that lies within 2
-		/// pixels of that location will be filtered out.
-		/// </remarks>
-		public int FilterMode
-		{
-			get { return _filterMode; }
-			set { _filterMode = value; }
-		}
-
-		/// <summary>
-		/// Gets a value indicating whether or not the data have been filtered.  If the data
-		/// have not been filtered, then <see cref="Count" /> will be equal to
-		/// <see cref="TotalCount" />.
-		/// </summary>
-		public bool IsFiltered
-		{
-			get { return _isFiltered; }
-		}
-
-		/// <summary>
-		/// Indexer: get the DataPoint instance at the specified ordinal position in the list
-		/// </summary>
-		/// <remarks>
-		/// This method will throw an exception if the index is out of range.  This can happen
-		/// if the index is less than the number of filtered values, or if data points are
-		/// removed from a filtered dataset with updating the filter (by calling
-		/// <see cref="FilterData" />).
-		/// </remarks>
-		/// <param name="index">The ordinal position in the list of points</param>
-		/// <returns>Returns a <see cref="PointPair" /> instance.  The <see cref="PointPair.Z" />
-		/// and <see cref="PointPair.Tag" /> properties will be defaulted to
-		/// <see cref="PointPairBase.Missing" /> and null, respectively.
-		/// </returns>
-		public new PointPair this[int index]
-		{
-			get
-			{
-				int j = index;
-				if ( _isFiltered )
-					j = _visibleIndicies[index];
-
-				DataPoint dp = base[j];
-				PointPair pt = new PointPair( dp.X, dp.Y );
-				return pt;
-			}
-			set
-			{
-				int j = index;
-				if ( _isFiltered )
-					j = _visibleIndicies[index];
-
-				DataPoint dp;
-				dp.X = value.X;
-				dp.Y = value.Y;
-				base[j] = dp;
-			}
-		}
-
-		/// <summary>
-		/// Gets the number of active samples in the collection.  This is the number of
-		/// samples that are non-duplicates.  See the <see cref="TotalCount" /> property
-		/// to get the total number of samples in the list.
-		/// </summary>
-		public new int Count
-		{
-			get
-			{
-				if ( !_isFiltered )
-					return base.Count;
-				else
-					return _filteredCount;
-			}
-		}
-
-		/// <summary>
-		/// Gets the total number of samples in the collection.  See the <see cref="Count" />
-		/// property to get the number of active (non-duplicate) samples in the list.
-		/// </summary>
-		public int TotalCount
-		{
-			get { return base.Count; }
-		}
-
-		/// <summary>
-		/// Append a data point to the collection
-		/// </summary>
-		/// <param name="pt">The <see cref="PointPair" /> value to append</param>
-		public void Add( PointPair pt )
-		{
-			DataPoint dp = new DataPoint();
-			dp.X = pt.X;
-			dp.Y = pt.Y;
-			Add( dp );
-		}
-
-
-		/// <summary>
-		/// Append a point to the collection
-		/// </summary>
-		/// <param name="x">The x value of the point to append</param>
-		/// <param name="y">The y value of the point to append</param>
-		public void Add( double x, double y )
-		{
-			DataPoint dp = new DataPoint();
-			dp.X = x;
-			dp.Y = y;
-			Add( dp );
-		}
-
-
-		// generic Clone: just call the typesafe version
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// typesafe clone method
-		/// </summary>
-		/// <returns>A new cloned NoDupePointList.  This returns a copy of the structure,
-		/// but it does not duplicate the data (it just keeps a reference to the original)
-		/// </returns>
-		public NoDupePointList Clone()
-		{
-			return new NoDupePointList( this );
-		}
-
-		/// <summary>
-		/// default constructor
-		/// </summary>
-		public NoDupePointList()
-		{
-			_isFiltered = false;
-			_filteredCount = 0;
-			_visibleIndicies = null;
-			_filterMode = 0;
-		}
-
-		/// <summary>
-		/// copy constructor -- this returns a copy of the structure,
-		/// but it does not duplicate the data (it just keeps a reference to the original)
-		/// </summary>
-		/// <param name="rhs">The NoDupePointList to be copied</param>
-		public NoDupePointList( NoDupePointList rhs )
-		{
-			int count = rhs.TotalCount;
-			for ( int i = 0; i < count; i++ )
-				Add( rhs.GetDataPointAt( i ) );
-
-			_filteredCount = rhs._filteredCount;
-			_isFiltered = rhs._isFiltered;
-			_filterMode = rhs._filterMode;
-
-			if ( rhs._visibleIndicies != null )
-				_visibleIndicies = (int[]) rhs._visibleIndicies.Clone();
-			else
-				_visibleIndicies = null;
-		}
-
-		/// <summary>
-		/// Protected method to access the internal DataPoint collection, without any
-		/// translation to a PointPair.
-		/// </summary>
-		/// <param name="index">The ordinal position of the DataPoint of interest</param>
-		protected DataPoint GetDataPointAt( int index )
-		{
-			return base[index];
-		}
-
-		/// <summary>
-		/// Clears any filtering previously done by a call to <see cref="FilterData" />.
-		/// After calling this method, all data points will be visible, and
-		/// <see cref="Count" /> will be equal to <see cref="TotalCount" />.
-		/// </summary>
-		public void ClearFilter()
-		{
-			_isFiltered = false;
-			_filteredCount = 0;
-		}
-
-		/// <summary>
-		/// Go through the collection, and hide (filter out) any points that fall on the
-		/// same pixel location as a previously included point.
-		/// </summary>
-		/// <remarks>
-		/// This method does not delete any points, it just temporarily hides them until
-		/// the next call to <see cref="FilterData" /> or <see cref="ClearFilter" />.
-		/// You should call <see cref="FilterData" /> once your collection of points has
-		/// been constructed.  You may need to call <see cref="FilterData" /> again if
-		/// you add points, or if the chart rect changes size (by resizing, printing,
-		/// image save, etc.), or if the scale range changes.
-		/// You must call <see cref="GraphPane.AxisChange()" /> before calling
-		/// this method so that the <see cref="Chart.Rect">GraphPane.Chart.Rect</see>
-		/// and the scale ranges are valid.  This method is not valid for
-		/// ordinal axes (but ordinal axes don't make sense for very large datasets
-		/// anyway).
-		/// </remarks>
-		/// <param name="pane">The <see cref="GraphPane" /> into which the data
-		/// will be plotted. </param>
-		/// <param name="yAxis">The <see cref="Axis" /> class to be used in the Y direction
-		/// for plotting these data.  This can be a <see cref="YAxis" /> or a 
-		/// <see cref="Y2Axis" />, and can be a primary or secondary axis (if multiple Y or Y2
-		/// axes are being used).
-		/// </param>
-		/// <param name="xAxis">The <see cref="Axis" /> class to be used in the X direction
-		/// for plotting these data.  This can be an <see cref="XAxis" /> or a 
-		/// <see cref="X2Axis" />.
-		/// </param>
-		public void FilterData( GraphPane pane, Axis xAxis, Axis yAxis )
-		{
-			if ( _visibleIndicies == null || _visibleIndicies.Length < base.Count )
-				_visibleIndicies = new int[base.Count];
-
-			_filteredCount = 0;
-			_isFiltered = true;
-
-			int width = (int)pane.Chart.Rect.Width;
-			int height = (int)pane.Chart.Rect.Height;
-			if ( width <= 0 || height <= 0 )
-				throw new IndexOutOfRangeException( "Error in FilterData: Chart rect not valid" );
-
-			bool[,] usedArray = new bool[width, height];
-			for ( int i = 0; i < width; i++ )
-				for ( int j = 0; j < height; j++ )
-					usedArray[i, j] = false;
-
-			xAxis.Scale.SetupScaleData( pane, xAxis );
-			yAxis.Scale.SetupScaleData( pane, yAxis );
-
-			int n = _filterMode < 0 ? 0 : _filterMode;
-			int left = (int)pane.Chart.Rect.Left;
-			int top = (int)pane.Chart.Rect.Top;
-
-			for ( int i=0; i<base.Count; i++ )
-			{
-				DataPoint dp = base[i];
-				int x = (int)( xAxis.Scale.Transform( dp.X ) + 0.5 ) - left;
-				int y = (int)( yAxis.Scale.Transform( dp.Y ) + 0.5 ) - top;
-
-				if ( x >= 0 && x < width && y >= 0 && y < height )
-				{
-					bool used = false;
-					if ( n <= 0 )
-						used = usedArray[x, y];
-					else
-					{
-						for ( int ix = x - n; ix <= x + n; ix++ )
-							for ( int iy = y - n; iy <= y + n; iy++ )
-								used |= ( ix >= 0 && ix < width && iy >= 0 && iy < height && usedArray[ix, iy] );
-					}
-
-					if ( !used )
-					{
-						usedArray[x, y] = true;
-						_visibleIndicies[_filteredCount] = i;
-						_filteredCount++;
-					}
-				}
-			}
-		}
-	}
-}
diff --git a/BDInfo/ZedGraph/OHLCBar.cs b/BDInfo/ZedGraph/OHLCBar.cs
deleted file mode 100644
index ba176ee8a1..0000000000
--- a/BDInfo/ZedGraph/OHLCBar.cs
+++ /dev/null
@@ -1,436 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class handles the drawing of the curve <see cref="OHLCBar"/> objects.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class OHLCBar : LineBase, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores the visibility of the <see cref="OHLCBar"/> open and
-		/// close line segments ("wings").  Use the public
-		/// property <see cref="IsOpenCloseVisible"/> to access this value.  If this value is
-		/// false, the wings will not be shown.
-		/// </summary>
-		protected bool _isOpenCloseVisible;
-
-		/// <summary>
-		/// Private field that stores the total width for the Opening/Closing line
-		/// segments.  Use the public property <see cref="Size"/> to access this value.
-		/// </summary>
-		protected float _size;
-
-		/// <summary>
-		/// Private field that determines if the <see cref="Size" /> property will be
-		/// calculated automatically based on the minimum axis scale step size between
-		/// bars.  Use the public property <see cref="IsAutoSize" /> to access this value.
-		/// </summary>
-		protected Boolean _isAutoSize;
-
-		/// <summary>
-		/// The result of the autosize calculation, which is the size of the bars in
-		/// user scale units.  This is converted to pixels at draw time.
-		/// </summary>
-		internal double _userScaleSize = 1.0;
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ZedGraph.OHLCBar"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			// Default Symbol properties
-			/// <summary>
-			/// The default width for the candlesticks (see <see cref="OHLCBar.Size" />),
-			/// in units of points.
-			/// </summary>
-			public static float Size = 12;
-			/// <summary>
-			/// The default display mode for symbols (<see cref="OHLCBar.IsOpenCloseVisible"/> property).
-			/// true to display symbols, false to hide them.
-			/// </summary>
-			public static bool IsOpenCloseVisible = true;
-
-			/// <summary>
-			/// The default value for the <see cref="ZedGraph.OHLCBar.IsAutoSize" /> property.
-			/// </summary>
-			public static Boolean IsAutoSize = true;
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets a property that shows or hides the <see cref="OHLCBar"/> open/close "wings".
-		/// </summary>
-		/// <value>true to show the CandleStick wings, false to hide them</value>
-		/// <seealso cref="Default.IsOpenCloseVisible"/>
-		public bool IsOpenCloseVisible
-		{
-			get { return _isOpenCloseVisible; }
-			set { _isOpenCloseVisible = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the total width to be used for drawing the opening/closing line
-		/// segments ("wings") of the <see cref="OHLCBar" /> items. Units are points.
-		/// </summary>
-		/// <remarks>The size of the candlesticks can be set by this value, which
-		/// is then scaled according to the scaleFactor (see
-		/// <see cref="PaneBase.CalcScaleFactor"/>).  Alternatively,
-		/// if <see cref="IsAutoSize"/> is true, the bar width will
-		/// be set according to the maximum available cluster width less
-		/// the cluster gap (see <see cref="BarSettings.GetClusterWidth"/>
-		/// and <see cref="BarSettings.MinClusterGap"/>).  That is, if
-		/// <see cref="IsAutoSize"/> is true, then the value of
-		/// <see cref="Size"/> will be ignored.  If you modify the value of Size,
-		/// then <see cref="IsAutoSize" /> will be automatically set to false.
-		/// </remarks>
-		/// <value>Size in points (1/72 inch)</value>
-		/// <seealso cref="Default.Size"/>
-		public float Size
-		{
-			get { return _size; }
-			set { _size = value; _isAutoSize = false; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the <see cref="Size" /> property will be
-		/// calculated automatically based on the minimum axis scale step size between
-		/// bars.
-		/// </summary>
-		public Boolean IsAutoSize
-		{
-			get { return _isAutoSize; }
-			set { _isAutoSize = value; }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="OHLCBar"/> properties to
-		/// default values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public OHLCBar() : this( LineBase.Default.Color )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the
-		/// <see cref="Color"/> as specified, and the remaining
-		/// <see cref="OHLCBar"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the color of the symbol
-		/// </param>
-		public OHLCBar( Color color ) : base( color )
-		{
-			_size = Default.Size;
-			_isAutoSize = Default.IsAutoSize;
-			_isOpenCloseVisible = Default.IsOpenCloseVisible;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="OHLCBar"/> object from which to copy</param>
-		public OHLCBar( OHLCBar rhs ) : base( rhs )
-		{
-			_isOpenCloseVisible = rhs._isOpenCloseVisible;
-			_size = rhs._size;
-			_isAutoSize = rhs._isAutoSize;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public OHLCBar Clone()
-		{
-			return new OHLCBar( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected OHLCBar( SerializationInfo info, StreamingContext context ) :
-			base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_isOpenCloseVisible = info.GetBoolean( "isOpenCloseVisible" );
-			_size = info.GetSingle( "size" );
-			_isAutoSize = info.GetBoolean( "isAutoSize" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema", schema );
-			info.AddValue( "isOpenCloseVisible", _isOpenCloseVisible );
-			info.AddValue( "size", _size );
-			info.AddValue( "isAutoSize", _isAutoSize );
-		}
-
-	#endregion
-
-	#region Rendering Methods
-
-
-		/// <summary>
-		/// Draw the <see cref="OHLCBar"/> to the specified <see cref="Graphics"/>
-		/// device at the specified location.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="isXBase">boolean value that indicates if the "base" axis for this
-		/// <see cref="OHLCBar"/> is the X axis.  True for an <see cref="XAxis"/> base,
-		/// false for a <see cref="YAxis"/> or <see cref="Y2Axis"/> base.</param>
-		/// <param name="pixBase">The independent axis position of the center of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixHigh">The dependent axis position of the top of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixLow">The dependent axis position of the bottom of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixOpen">The dependent axis position of the opening value of the candlestick in
-		/// pixel units</param>
-		/// <param name="pixClose">The dependent axis position of the closing value of the candlestick in
-		/// pixel units</param>
-		/// <param name="halfSize">
-		/// The scaled width of the candlesticks, pixels</param>
-		/// <param name="pen">A pen with attributes of <see cref="Color"/> and
-		/// <see cref="LineBase.Width"/> for this <see cref="OHLCBar"/></param>
-		public void Draw( Graphics g, GraphPane pane, bool isXBase,
-								float pixBase, float pixHigh, float pixLow,
-								float pixOpen, float pixClose,
-								float halfSize, Pen pen  )
-		{
-			if ( pixBase != PointPair.Missing )
-			{
-				if ( isXBase )
-				{
-					if ( Math.Abs( pixLow ) < 1000000 && Math.Abs( pixHigh ) < 1000000 )
-						g.DrawLine( pen, pixBase, pixHigh, pixBase, pixLow );
-					if ( _isOpenCloseVisible && Math.Abs( pixOpen ) < 1000000 )
-						g.DrawLine( pen, pixBase - halfSize, pixOpen, pixBase, pixOpen );
-					if ( _isOpenCloseVisible && Math.Abs( pixClose ) < 1000000 )
-						g.DrawLine( pen, pixBase, pixClose, pixBase + halfSize, pixClose );
-				}
-				else
-				{
-					if ( Math.Abs( pixLow ) < 1000000 && Math.Abs( pixHigh ) < 1000000 )
-						g.DrawLine( pen, pixHigh, pixBase, pixLow, pixBase );
-					if ( _isOpenCloseVisible && Math.Abs( pixOpen ) < 1000000 )
-						g.DrawLine( pen, pixOpen, pixBase - halfSize, pixOpen, pixBase );
-					if ( _isOpenCloseVisible && Math.Abs( pixClose ) < 1000000 )
-						g.DrawLine( pen, pixClose, pixBase, pixClose, pixBase + halfSize );
-				}
-			}
-		}
-
-
-		/// <summary>
-		/// Draw all the <see cref="OHLCBar"/>'s to the specified <see cref="Graphics"/>
-		/// device as a candlestick at each defined point.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="OHLCBarItem"/> object representing the
-		/// <see cref="OHLCBar"/>'s to be drawn.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent)
-		/// axis for the <see cref="OHLCBar"/></param>
-		/// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent)
-		/// axis for the <see cref="OHLCBar"/></param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, OHLCBarItem curve,
-							Axis baseAxis, Axis valueAxis, float scaleFactor )
-		{
-			//ValueHandler valueHandler = new ValueHandler( pane, false );
-
-			float pixBase, pixHigh, pixLow, pixOpen, pixClose;
-
-			if ( curve.Points != null )
-			{
-				//float halfSize = _size * scaleFactor;
-				float halfSize = GetBarWidth( pane, baseAxis, scaleFactor );
-
-				using ( Pen pen = !curve.IsSelected ? new Pen( _color, _width ) :
-						new Pen( Selection.Border.Color, Selection.Border.Width ) )
-//				using ( Pen pen = new Pen( _color, _penWidth ) )
-				{
-					// Loop over each defined point							
-					for ( int i = 0; i < curve.Points.Count; i++ )
-					{
-						PointPair pt = curve.Points[i];
-						double date = pt.X;
-						double high = pt.Y;
-						double low = pt.Z;
-						double open = PointPair.Missing;
-						double close = PointPair.Missing;
-						if ( pt is StockPt )
-						{
-							open = ( pt as StockPt ).Open;
-							close = ( pt as StockPt ).Close;
-						}
-
-						// Any value set to double max is invalid and should be skipped
-						// This is used for calculated values that are out of range, divide
-						//   by zero, etc.
-						// Also, any value <= zero on a log scale is invalid
-
-						if ( !curve.Points[i].IsInvalid3D &&
-								( date > 0 || !baseAxis._scale.IsLog ) &&
-								( ( high > 0 && low > 0 ) || !valueAxis._scale.IsLog ) )
-						{
-							pixBase = (int)( baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, date ) + 0.5 );
-							//pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, date );
-							pixHigh = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, high );
-							pixLow = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, low );
-							if ( PointPair.IsValueInvalid( open ) )
-								pixOpen = Single.MaxValue;
-							else
-								pixOpen = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, open );
-
-							if ( PointPair.IsValueInvalid( close ) )
-								pixClose = Single.MaxValue;
-							else
-								pixClose = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, i, close );
-
-							if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
-							{
-								using ( Pen tPen = GetPen( pane, scaleFactor, pt ) )
-									Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis,
-											pixBase, pixHigh, pixLow, pixOpen,
-											pixClose, halfSize, tPen );
-							}
-							else
-								Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis,
-										pixBase, pixHigh, pixLow, pixOpen,
-										pixClose, halfSize, pen );
-						}
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Returns the width of the candleStick, in pixels, based on the settings for
-		/// <see cref="Size"/> and <see cref="IsAutoSize"/>.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
-		/// <param name="baseAxis">The <see cref="Axis"/> object that
-		/// represents the bar base (independent axis).</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>The width of each bar, in pixel units</returns>
-		public float GetBarWidth( GraphPane pane, Axis baseAxis, float scaleFactor )
-		{
-			float width;
-			if ( _isAutoSize )
-				width = baseAxis._scale.GetClusterWidth( _userScaleSize ) /
-								( 1.0F + pane._barSettings.MinClusterGap ) / 2.0f;
-			else
-				width = (float)( _size * scaleFactor ) / 2.0f;
-
-			// use integral size
-			return (int)(width + 0.5f);
-		}
-		
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/OHLCBarItem.cs b/BDInfo/ZedGraph/OHLCBarItem.cs
deleted file mode 100644
index 866cf4fc8c..0000000000
--- a/BDInfo/ZedGraph/OHLCBarItem.cs
+++ /dev/null
@@ -1,343 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates a CandleStick curve type that displays a vertical (or horizontal)
-	/// line displaying the range of data values at each sample point, plus an starting
-	/// mark and an ending mark signifying the opening and closing value for the sample.
-	/// </summary>
-	/// <remarks>For this type to work properly, your <see cref="IPointList" /> must contain
-	/// <see cref="StockPt" /> objects, rather than ordinary <see cref="PointPair" /> types.
-	/// This is because the <see cref="OHLCBarItem"/> type actually displays 5 data values
-	/// but the <see cref="PointPair" /> only stores 3 data values.  The <see cref="StockPt" />
-	/// stores <see cref="StockPt.Date" />, <see cref="StockPt.Close" />,
-	/// <see cref="StockPt.Open" />, <see cref="StockPt.High" />, and
-	/// <see cref="StockPt.Low" /> members.
-	/// For a vertical CandleStick chart, the opening value is drawn as a horizontal line
-	/// segment to the left of the vertical range bar, and the closing value is a horizontal
-	/// line segment to the right.  The total length of these two line segments is controlled
-	/// by the <see cref="ZedGraph.OHLCBar.Size" /> property, which is specified in
-	/// points (1/72nd inch), and scaled according to <see cref="PaneBase.CalcScaleFactor" />.
-	/// The candlesticks are drawn horizontally or vertically depending on the
-	/// value of <see cref="BarSettings.Base"/>, which is a
-	/// <see cref="ZedGraph.BarBase"/> enum type.</remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.3 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class OHLCBarItem : CurveItem, ICloneable, ISerializable
-	{
-	#region Fields
-
-		/// <summary>
-		/// Private field that stores a reference to the <see cref="ZedGraph.OHLCBar"/>
-		/// class defined for this <see cref="OHLCBarItem"/>.  Use the public
-		/// property <see cref="OHLCBar"/> to access this value.
-		/// </summary>
-		/// 
-		protected OHLCBar _bar;
-
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets a reference to the <see cref="OHLCBar"/> class defined
-		/// for this <see cref="OHLCBarItem"/>.
-		/// </summary>
-		public OHLCBar Bar
-		{
-			get { return _bar; }
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return pane._barSettings.Base == BarBase.X;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <remarks>
-		/// IsZIncluded is true for <see cref="OHLCBarItem" /> objects, since the Y and Z
-		/// values are defined as the High and Low values for the day.</remarks>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return true;
-		}
-
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="OHLCBarItem"/>, specifying only the legend label.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		public OHLCBarItem( string label )
-			: base( label )
-		{
-			_bar = new OHLCBar();
-		}
-
-		/// <summary>
-		/// Create a new <see cref="OHLCBarItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The _label that will appear in the legend.</param>
-		/// <param name="points">An <see cref="IPointList"/> of double precision values that define
-		/// the Date, Close, Open, High, and Low values for the curve.  Note that this
-		/// <see cref="IPointList" /> should contain <see cref="StockPt" /> items rather
-		/// than <see cref="PointPair" /> items.
-		/// </param>
-		/// <param name="color">
-		/// The <see cref="System.Drawing.Color" /> to use for drawing the candlesticks.</param>
-		public OHLCBarItem( string label, IPointList points, Color color )
-			: base( label, points )
-		{
-			_bar = new OHLCBar( color );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="OHLCBarItem"/> object from which to copy</param>
-		public OHLCBarItem( OHLCBarItem rhs )
-			: base( rhs )
-		{
-			_bar = rhs._bar.Clone();
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public OHLCBarItem Clone()
-		{
-			return new OHLCBarItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected OHLCBarItem( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_bar = (OHLCBar)info.GetValue( "stick", typeof( OHLCBar ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "stick", _bar );
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="OHLCBarItem"/> to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">The ordinal position of the current <see cref="OHLCBarItem"/>
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor )
-		{
-			if ( _isVisible )
-			{
-				_bar.Draw( g, pane, this, this.BaseAxis( pane ),
-									this.ValueAxis( pane ), scaleFactor );
-			}
-		}
-
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="OHLCBarItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-		/// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect,
-									float scaleFactor )
-		{
-			float pixBase, pixHigh, pixLow, pixOpen, pixClose;
-
-			if ( pane._barSettings.Base == BarBase.X )
-			{
-				pixBase = rect.Left + rect.Width / 2.0F;
-				pixHigh = rect.Top;
-				pixLow = rect.Bottom;
-				pixOpen = pixHigh + rect.Height / 3;
-				pixClose = pixLow - rect.Height / 3;
-			}
-			else
-			{
-				pixBase = rect.Top + rect.Height / 2.0F;
-				pixHigh = rect.Right;
-				pixLow = rect.Left;
-				pixOpen = pixHigh - rect.Width / 3;
-				pixClose = pixLow + rect.Width / 3;
-			}
-
-			using ( Pen pen = new Pen( _bar.Color, _bar._width ) )
-			{
-				_bar.Draw( g, pane, pane._barSettings.Base == BarBase.X, pixBase, pixHigh,
-								pixLow, pixOpen, pixClose, scaleFactor, pen );
-			}
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			if ( i < 0 || i >= _points.Count )
-				return false;
-
-			Axis valueAxis = ValueAxis( pane );
-			Axis baseAxis = BaseAxis( pane );
-
-			float halfSize = _bar.Size * pane.CalcScaleFactor();
-
-			PointPair pt = _points[i];
-			double date = pt.X;
-			double high = pt.Y;
-			double low = pt.Z;
-
-			if ( !pt.IsInvalid3D &&
-					( date > 0 || !baseAxis._scale.IsLog ) &&
-					( ( high > 0 && low > 0 ) || !valueAxis._scale.IsLog ) )
-			{
-				float pixBase, pixHigh, pixLow;
-				pixBase = baseAxis.Scale.Transform( _isOverrideOrdinal, i, date );
-				pixHigh = valueAxis.Scale.Transform( _isOverrideOrdinal, i, high );
-				pixLow = valueAxis.Scale.Transform( _isOverrideOrdinal, i, low );
-
-				// Calculate the pixel location for the side of the bar (on the base axis)
-				float pixSide = pixBase - halfSize;
-
-				// Draw the bar
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixSide, pixLow,
-								pixSide + halfSize * 2, pixHigh );
-				else
-					coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}",
-								pixLow, pixSide,
-								pixHigh, pixSide + halfSize * 2 );
-
-				return true;
-			}
-
-			return false;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/OrdinalScale.cs b/BDInfo/ZedGraph/OrdinalScale.cs
deleted file mode 100644
index 798b63131a..0000000000
--- a/BDInfo/ZedGraph/OrdinalScale.cs
+++ /dev/null
@@ -1,233 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The OrdinalScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Ordinal" />.
-	/// </summary>
-	/// <remarks>
-	/// OrdinalScale is an ordinal axis with tic labels generated at integral values.  An ordinal axis means that
-	/// all data points are evenly spaced at integral values, and the actual coordinate values
-	/// for points corresponding to that axis are ignored.  That is, if the X axis is an
-	/// ordinal type, then all X values associated with the curves are ignored.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.8 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	class OrdinalScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		/// <summary>
-		/// Default constructor that defines the owner <see cref="Axis" />
-		/// (containing object) for this new object.
-		/// </summary>
-		/// <param name="owner">The owner, or containing object, of this instance</param>
-		public OrdinalScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="OrdinalScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="OrdinalScale" /></param>
-		public OrdinalScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new OrdinalScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Return the <see cref="AxisType" /> for this <see cref="Scale" />, which is
-		/// <see cref="AxisType.Ordinal" />.
-		/// </summary>
-		public override AxisType Type
-		{
-			get { return AxisType.Ordinal; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Select a reasonable ordinal axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Ordinal"/> type axes, and it
-		/// is called by the general <see cref="Scale.PickScale"/> method.  The scale range is chosen
-		/// based on increments of 1, 2, or 5 (because they are even divisors of 10).
-		/// Being an ordinal axis type, the <see cref="Scale.MajorStep" /> value will always be integral.  This
-		/// method honors the <see cref="Scale.MinAuto" />, <see cref="Scale.MaxAuto" />,
-		/// and <see cref="Scale.MajorStepAuto" /> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min" />, <see cref="Scale.Max" />, or <see cref="Scale.MajorStep" />
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  The basic defaults for
-		/// scale selection are defined using <see cref="Scale.Default.ZeroLever" />,
-		/// <see cref="Scale.Default.TargetXSteps" />, and <see cref="Scale.Default.TargetYSteps" />
-		/// from the <see cref="Scale.Default" /> default class.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="AxisType.Ordinal"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			PickScale( pane, g, scaleFactor, this );
-		}
-
-		internal static void PickScale( GraphPane pane, Graphics g, float scaleFactor, Scale scale )
-		{
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( scale._max - scale._min < 1.0 )
-			{
-				if ( scale._maxAuto )
-					scale._max = scale._min + 0.5;
-				else
-					scale._min = scale._max - 0.5;
-			}
-			else
-			{
-				// Calculate the new step size
-				if ( scale._majorStepAuto )
-				{
-					// Calculate the step size based on targetSteps
-					scale._majorStep = Scale.CalcStepSize( scale._max - scale._min,
-						( scale._ownerAxis is XAxis || scale._ownerAxis is X2Axis ) ?
-								Default.TargetXSteps : Default.TargetYSteps );
-
-					if ( scale.IsPreventLabelOverlap )
-					{
-						// Calculate the maximum number of labels
-						double maxLabels = (double) scale.CalcMaxLabels( g, pane, scaleFactor );
-
-						// Calculate a step size based on the width of the labels
-						double tmpStep = Math.Ceiling( ( scale._max - scale._min ) / maxLabels );
-
-						// Use the greater of the two step sizes
-						if ( tmpStep > scale._majorStep )
-							scale._majorStep = tmpStep;
-					}
-
-				}
-
-				scale._majorStep = (int)scale._majorStep;
-				if ( scale._majorStep < 1.0 )
-					scale._majorStep = 1.0;
-
-				// Calculate the new minor step size
-				if ( scale._minorStepAuto )
-					scale._minorStep = Scale.CalcStepSize( scale._majorStep,
-						( scale._ownerAxis is XAxis || scale._ownerAxis is X2Axis ) ?
-								Default.TargetMinorXSteps : Default.TargetMinorYSteps );
-
-				if ( scale._minAuto )
-					scale._min -= 0.5;
-				if ( scale._maxAuto )
-					scale._max += 0.5;
-			}
-		}
-
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected OrdinalScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PaneBase.cs b/BDInfo/ZedGraph/PaneBase.cs
deleted file mode 100644
index b957331278..0000000000
--- a/BDInfo/ZedGraph/PaneBase.cs
+++ /dev/null
@@ -1,1220 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Text;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Text;
-using System.Drawing.Imaging;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using System.IO;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An abstract base class that defines basic functionality for handling a pane.  This class is the
-	/// parent class for <see cref="MasterPane"/> and <see cref="GraphPane"/>.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.32 $ $Date: 2007/11/05 18:28:56 $ </version>
-	abstract public class PaneBase : ICloneable
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// The rectangle that defines the full area into which the pane is rendered.  Units are pixels.
-		/// Use the public property <see cref="Rect"/> to access this value.
-		/// </summary>
-		protected RectangleF	_rect;
-		
-		/// <summary>Private field that holds the main title of the pane.  Use the
-		/// public property <see cref="Title"/> to access this value.
-		/// </summary>
-		protected GapLabel _title;
-		
-		/// <summary>Private field instance of the <see cref="ZedGraph.Legend"/> class.  Use the
-		/// public property <see cref="PaneBase.Legend"/> to access this class.</summary>
-		protected Legend _legend;
-
-		/// <summary>
-		/// Private field that stores the user-defined tag for this <see cref="PaneBase"/>.  This tag
-		/// can be any user-defined value.  If it is a <see cref="String"/> type, it can be used as
-		/// a parameter to the <see cref="PaneList.IndexOfTag"/> method.  Use the public property
-		/// <see cref="Tag"/> to access this value.
-		/// </summary>
-		protected object _tag;
-
-		/// <summary>
-		/// private field to store the margin values for this <see cref="PaneBase" />. Use the
-		/// public property <see cref="Margin" /> to access this property.
-		/// </summary>
-		internal Margin _margin;
-
-		/// <summary>Private field that determines whether or not the fonts, tics, gaps, etc.
-		/// will be scaled according to the actual graph size.  true for font and feature scaling
-		/// with graph size, false for fixed font sizes (scaleFactor = 1.0 constant).
-		/// Use the public property <see cref="IsFontsScaled"/> to access this value. </summary>
-		/// <seealso cref="CalcScaleFactor"/>
-		/// <seealso cref="IsPenWidthScaled"/>
-		protected bool _isFontsScaled;
-		/// <summary>
-		/// Private field that controls whether or not pen widths are scaled according to the
-		/// size of the graph.  This value is only applicable if <see cref="IsFontsScaled"/>
-		/// is true.  If <see cref="IsFontsScaled"/> is false, then no scaling will be done,
-		/// regardless of the value of <see cref="IsPenWidthScaled"/>.
-		/// </summary>
-		/// <value>true to scale the pen widths according to the size of the graph,
-		/// false otherwise.</value>
-		/// <seealso cref="IsFontsScaled"/>
-		/// <seealso cref="CalcScaleFactor"/>
-		protected bool _isPenWidthScaled;
-
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for the
-		/// <see cref="Rect"/> background.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		protected Fill	_fill;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Border"/> data for the
-		/// <see cref="Rect"/> border.  Use the public property <see cref="Border"/> to
-		/// access this value.
-		/// </summary>
-		protected Border _border;
-
-		/// <summary>Private field instance of the <see cref="ZedGraph.GraphObjList"/> class.  Use the
-		/// public property <see cref="GraphObjList"/> to access this class.</summary>
-		protected GraphObjList _graphObjList;
-
-		/// <summary>Private field that determines the base size of the pane, in inches.
-		/// Fonts, tics, gaps, etc. are scaled according to this base size.
-		/// Use the public property <see cref="BaseDimension"/> to access this value. </summary>
-		/// <seealso cref="_isFontsScaled"/>
-		/// <seealso cref="CalcScaleFactor"/>
-		protected float _baseDimension;
-
-		/// <summary>
-		/// private field that stores the gap between the bottom of the pane title and the
-		/// client area of the pane.  This is expressed as a fraction of the title character height.
-		/// </summary>
-		protected float _titleGap;
-
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the default property values for the <see cref="PaneBase"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default GraphPane properties
-			/// <summary>
-			/// The default display mode for the title at the top of the pane
-			/// (<see cref="PaneBase.Title"/> <see cref="Label.IsVisible" /> property).  true to
-			/// display a title, false otherwise.
-			/// </summary>
-			public static bool IsShowTitle = true;
-			
-			/// <summary>
-			/// The default font family for the title
-			/// (<see cref="PaneBase.Title"/> property).
-			/// </summary>
-			public static string FontFamily = "Arial";
-			/// <summary>
-			/// The default font size (points) for the
-			/// <see cref="PaneBase.Title"/> (<see cref="ZedGraph.FontSpec.Size"/> property).
-			/// </summary>
-			public static float FontSize = 16;
-			/// <summary>
-			/// The default font color for the
-			/// <see cref="PaneBase.Title"/>
-			/// (<see cref="ZedGraph.FontSpec.FontColor"/> property).
-			/// </summary>
-			public static Color FontColor = Color.Black;
-			/// <summary>
-			/// The default font bold mode for the
-			/// <see cref="PaneBase.Title"/>
-			/// (<see cref="ZedGraph.FontSpec.IsBold"/> property). true
-			/// for a bold typeface, false otherwise.
-			/// </summary>
-			public static bool FontBold = true;
-			/// <summary>
-			/// The default font italic mode for the
-			/// <see cref="PaneBase.Title"/>
-			/// (<see cref="ZedGraph.FontSpec.IsItalic"/> property). true
-			/// for an italic typeface, false otherwise.
-			/// </summary>
-			public static bool FontItalic = false;
-			/// <summary>
-			/// The default font underline mode for the
-			/// <see cref="PaneBase.Title"/>
-			/// (<see cref="ZedGraph.FontSpec.IsUnderline"/> property). true
-			/// for an underlined typeface, false otherwise.
-			/// </summary>
-			public static bool FontUnderline = false;
-			
-			/// <summary>
-			/// The default border mode for the <see cref="PaneBase"/>.
-			/// (<see cref="PaneBase.Border"/> property). true
-			/// to draw a border around the <see cref="PaneBase.Rect"/>,
-			/// false otherwise.
-			/// </summary>
-			public static bool IsBorderVisible = true;
-			/// <summary>
-			/// The default color for the <see cref="PaneBase"/> border.
-			/// (<see cref="PaneBase.Border"/> property). 
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color for the <see cref="PaneBase.Rect"/> background.
-			/// (<see cref="PaneBase.Fill"/> property). 
-			/// </summary>
-			public static Color FillColor = Color.White;
-
-			/// <summary>
-			/// The default pen width for the <see cref="PaneBase"/> border.
-			/// (<see cref="PaneBase.Border"/> property).  Units are in points (1/72 inch).
-			/// </summary>
-			public static float BorderPenWidth = 1;
-
-			/// <summary>
-			/// The default dimension of the <see cref="PaneBase.Rect"/>, which
-			/// defines a normal sized plot.  This dimension is used to scale the
-			/// fonts, symbols, etc. according to the actual size of the
-			/// <see cref="PaneBase.Rect"/>.
-			/// </summary>
-			/// <seealso cref="PaneBase.CalcScaleFactor"/>
-			public static float BaseDimension = 8.0F;
-			
-			/// <summary>
-			/// The default setting for the <see cref="PaneBase.IsPenWidthScaled"/> option.
-			/// true to have all pen widths scaled according to <see cref="PaneBase.BaseDimension"/>,
-			/// false otherwise.
-			/// </summary>
-			/// <seealso cref="PaneBase.CalcScaleFactor"/>
-			public static bool IsPenWidthScaled = false;
-			/// <summary>
-			/// The default setting for the <see cref="PaneBase.IsFontsScaled"/> option.
-			/// true to have all fonts scaled according to <see cref="PaneBase.BaseDimension"/>,
-			/// false otherwise.
-			/// </summary>
-			/// <seealso cref="PaneBase.CalcScaleFactor"/>
-			public static bool IsFontsScaled = true;
-
-			/// <summary>
-			/// The default value for the <see cref="PaneBase.TitleGap" /> property, expressed as
-			/// a fraction of the scaled <see cref="Title" /> character height.
-			/// </summary>
-			public static float TitleGap = 0.5f;
-		}
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// The rectangle that defines the full area into which all graphics
-		/// will be rendered.
-		/// </summary>
-		/// <remarks>Note that this rectangle has x, y, width, and height.  Most of the
-		/// GDI+ graphic primitive actually draw one pixel beyond those dimensions.  For
-		/// example, for a rectangle of ( X=0, Y=0, Width=100, Height=100 ), GDI+ would
-		/// draw into pixels 0 through 100, which is actually 101 pixels.  For the
-		/// ZedGraph Rect, a Width of 100 pixels means that pixels 0 through 99 are used</remarks>
-		/// <value>Units are pixels.</value>
-		/// <seealso cref="ReSize"/>
-		public RectangleF Rect
-		{
-			get { return _rect; }
-			set { _rect = value; }
-		}
-
-		/// <summary>
-		/// Accesses the <see cref="Legend"/> for this <see cref="PaneBase"/>
-		/// </summary>
-		/// <value>A reference to a <see cref="Legend"/> object</value>
-		public Legend Legend
-		{
-			get { return _legend; }
-		}
-
-		/// <summary>
-		/// Gets the <see cref="Label" /> instance that contains the text and attributes of the title.
-		/// This text can be multiple lines separated by newline characters ('\n').
-		/// </summary>
-		/// <seealso cref="FontSpec"/>
-		/// <seealso cref="Default.FontColor"/>
-		/// <seealso cref="Default.FontBold"/>
-		/// <seealso cref="Default.FontItalic"/>
-		/// <seealso cref="Default.FontUnderline"/>
-		/// <seealso cref="Default.FontFamily"/>
-		/// <seealso cref="Default.FontSize"/>
-		public Label Title
-		{
-			get { return _title; }
-		}
-
-		/// <summary>
-		/// Gets or sets the user-defined tag for this <see cref="PaneBase"/>.  This tag
-		/// can be any user-defined value.  If it is a <see cref="String"/> type, it can be used as
-		/// a parameter to the <see cref="PaneList.IndexOfTag"/> method.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag
-		{
-			get { return _tag; }
-			set { _tag = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Border"/> class for drawing the border
-		/// border around the <see cref="Rect"/>
-		/// </summary>
-		/// <seealso cref="Default.BorderColor"/>
-		/// <seealso cref="Default.BorderPenWidth"/>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for the
-		/// filling the background of the <see cref="Rect"/>.
-		/// </summary>
-		public Fill	Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the list of <see cref="GraphObj"/> items for this <see cref="GraphPane"/>
-		/// </summary>
-		/// <value>A reference to a <see cref="GraphObjList"/> collection object</value>
-		public GraphObjList GraphObjList
-		{
-			get { return _graphObjList; }
-			set { _graphObjList = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Margin" /> instance that controls the space between
-		/// the edge of the <see cref="PaneBase.Rect" /> and the rendered content of the graph.
-		/// </summary>
-		public Margin Margin
-		{
-			get { return _margin; }
-			set { _margin = value; }
-		}
-
-		/// <summary>
-		/// BaseDimension is a double precision value that sets "normal" pane size on
-		/// which all the settings are based.  The BaseDimension is in inches.  For
-		/// example, if the BaseDimension is 8.0 inches and the
-		/// <see cref="Title"/> size is 14 points.  Then the pane title font
-		/// will be 14 points high when the <see cref="Rect"/> is approximately 8.0
-		/// inches wide.  If the Rect is 4.0 inches wide, the pane title font will be
-		/// 7 points high.  Most features of the graph are scaled in this manner.
-		/// </summary>
-		/// <value>The base dimension reference for the <see cref="Rect"/>, in inches</value>
-		/// <seealso cref="Default.BaseDimension"/>
-		/// <seealso cref="IsFontsScaled"/>
-		/// <seealso cref="CalcScaleFactor"/>
-		public float BaseDimension
-		{
-			get { return _baseDimension; }
-			set { _baseDimension = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the gap between the bottom of the pane title and the
-		/// client area of the pane.  This is expressed as a fraction of the scaled
-		/// <see cref="Title" /> character height.
-		/// </summary>
-		public float TitleGap
-		{
-			get { return _titleGap; }
-			set { _titleGap = value; }
-		}
-
-		/// <summary>
-		/// Determines if the font sizes, tic sizes, gap sizes, etc. will be scaled according to
-		/// the size of the <see cref="Rect"/> and the <see cref="BaseDimension"/>.  If this
-		/// value is set to false, then the font sizes and tic sizes will always be exactly as
-		/// specified, without any scaling.
-		/// </summary>
-		/// <value>True to have the fonts and tics scaled, false to have them constant</value>
-		/// <seealso cref="PaneBase.CalcScaleFactor"/>
-		public bool IsFontsScaled
-		{
-			get { return _isFontsScaled; }
-			set { _isFontsScaled = value; }
-		}
-		/// <summary>
-		/// Gets or sets the property that controls whether or not pen widths are scaled for this
-		/// <see cref="PaneBase"/>.
-		/// </summary>
-		/// <remarks>This value is only applicable if <see cref="IsFontsScaled"/>
-		/// is true.  If <see cref="IsFontsScaled"/> is false, then no scaling will be done,
-		/// regardless of the value of <see cref="IsPenWidthScaled"/>.  Note that scaling the pen
-		/// widths can cause "artifacts" to appear at typical screen resolutions.  This occurs
-		/// because of roundoff differences; in some cases the pen width may round to 1 pixel wide
-		/// and in another it may round to 2 pixels wide.  The result is typically undesirable.
-		/// Therefore, this option defaults to false.  This option is primarily useful for high
-		/// resolution output, such as printer output or high resolution bitmaps (from
-		/// <see cref="GetImage(int,int,float)"/>) where it is desirable to have the pen width
-		/// be consistent with the screen image.
-		/// </remarks>
-		/// <value>true to scale the pen widths according to the size of the graph,
-		/// false otherwise.</value>
-		/// <seealso cref="IsFontsScaled"/>
-		/// <seealso cref="CalcScaleFactor"/>
-		public bool IsPenWidthScaled
-		{
-			get { return _isPenWidthScaled; }
-			set { _isPenWidthScaled = value; }
-		}
-
-	#endregion
-	
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the <see cref="PaneBase"/> class.  Leaves the <see cref="Rect"/> empty.
-		/// </summary>
-		public PaneBase() : this( "", new RectangleF( 0, 0, 0, 0 ) )
-		{
-		}
-		
-		/// <summary>
-		/// Default constructor for the <see cref="PaneBase"/> class.  Specifies the <see cref="Title"/> of
-		/// the <see cref="PaneBase"/>, and the size of the <see cref="Rect"/>.
-		/// </summary>
-		public PaneBase( string title, RectangleF paneRect )
-		{
-			_rect = paneRect;
-
-			_legend = new Legend();
-				
-			_baseDimension = Default.BaseDimension;
-			_margin = new Margin();
-			_titleGap = Default.TitleGap;
-
-			_isFontsScaled = Default.IsFontsScaled;
-			_isPenWidthScaled = Default.IsPenWidthScaled;
-			_fill = new Fill( Default.FillColor );
-			_border = new Border( Default.IsBorderVisible, Default.BorderColor,
-				Default.BorderPenWidth );
-
-			_title = new GapLabel( title, Default.FontFamily,
-				Default.FontSize, Default.FontColor, Default.FontBold,
-				Default.FontItalic, Default.FontUnderline );
-			_title._fontSpec.Fill.IsVisible = false;
-			_title._fontSpec.Border.IsVisible = false;
-
-			_graphObjList = new GraphObjList();
-			
-			_tag = null;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="PaneBase"/> object from which to copy</param>
-		public PaneBase( PaneBase rhs )
-		{
-			// copy over all the value types
-			_isFontsScaled = rhs._isFontsScaled;
-			_isPenWidthScaled = rhs._isPenWidthScaled;
-
-			_titleGap = rhs._titleGap;
-			_baseDimension = rhs._baseDimension;
-			_margin = rhs._margin.Clone();
-			_rect = rhs._rect;
-
-			// Copy the reference types by cloning
-			_fill = rhs._fill.Clone();
-			_border = rhs._border.Clone();
-			_title = rhs._title.Clone();
-
-			_legend = rhs.Legend.Clone();
-			_title = rhs._title.Clone();
-			_graphObjList = rhs._graphObjList.Clone();
-			
-			if ( rhs._tag is ICloneable )
-				_tag = ((ICloneable) rhs._tag).Clone();
-			else
-				_tag = rhs._tag;
-		}
-
-
-		//abstract public object ShallowClone();
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-
-		/// <summary>
-		/// Create a shallow, memberwise copy of this class.
-		/// </summary>
-		/// <remarks>
-		/// Note that this method uses MemberWiseClone, which will copy all
-		/// members (shallow) including those of classes derived from this class.</remarks>
-		/// <returns>a new copy of the class</returns>
-		public PaneBase ShallowClone()
-		{
-			// return a shallow copy
-			return this.MemberwiseClone() as PaneBase;
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		// schema changed to 2 when Label Class added
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PaneBase( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_rect = (RectangleF) info.GetValue( "rect", typeof(RectangleF) );
-			_legend = (Legend) info.GetValue( "legend", typeof(Legend) );
-			_title = (GapLabel) info.GetValue( "title", typeof(GapLabel) );
-			//this.isShowTitle = info.GetBoolean( "isShowTitle" );
-			_isFontsScaled = info.GetBoolean( "isFontsScaled" );
-			_isPenWidthScaled = info.GetBoolean( "isPenWidthScaled" );
-			//this.fontSpec = (FontSpec) info.GetValue( "fontSpec" , typeof(FontSpec) );
-			_titleGap = info.GetSingle( "titleGap" );
-			_fill = (Fill) info.GetValue( "fill", typeof(Fill) );
-			_border = (Border) info.GetValue( "border", typeof(Border) );
-			_baseDimension = info.GetSingle( "baseDimension" );
-			_margin = (Margin)info.GetValue( "margin", typeof( Margin ) );
-			_graphObjList = (GraphObjList) info.GetValue( "graphObjList", typeof(GraphObjList) );
-
-			_tag = info.GetValue( "tag", typeof(object) );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "rect", _rect );
-			info.AddValue( "legend", _legend );
-			info.AddValue( "title", _title );
-			//info.AddValue( "isShowTitle", isShowTitle );
-			info.AddValue( "isFontsScaled", _isFontsScaled );
-			info.AddValue( "isPenWidthScaled", _isPenWidthScaled );
-			info.AddValue( "titleGap", _titleGap );
-
-			//info.AddValue( "fontSpec", fontSpec );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "baseDimension", _baseDimension );
-			info.AddValue( "margin", _margin );
-			info.AddValue( "graphObjList", _graphObjList );
-
-			info.AddValue( "tag", _tag );
-		}
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Do all rendering associated with this <see cref="PaneBase"/> to the specified
-		/// <see cref="Graphics"/> device.  This abstract method is implemented by the child
-		/// classes.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		public virtual void Draw( Graphics g  )
-		{
-			if ( _rect.Width <= 1 || _rect.Height <= 1 )
-				return;
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = this.CalcScaleFactor();
-
-			// Fill the pane background and draw a border around it			
-			DrawPaneFrame( g, scaleFactor );
-
-			// Clip everything to the rect
-			g.SetClip( _rect );
-
-			// Draw the GraphItems that are behind everything
-			_graphObjList.Draw( g, this, scaleFactor, ZOrder.H_BehindAll );
-
-			// Draw the Pane Title
-			DrawTitle( g, scaleFactor );
-
-			// Draw the Legend
-			//this.Legend.Draw( g, this, scaleFactor );
-
-			// Reset the clipping
-			g.ResetClip();
-		}
-
-		/// <summary>
-		/// Calculate the client area rectangle based on the <see cref="PaneBase.Rect"/>.
-		/// </summary>
-		/// <remarks>The client rectangle is the actual area available for <see cref="GraphPane"/>
-		/// or <see cref="MasterPane"/> items after taking out space for the margins and the title.
-		/// This method does not take out the area required for the <see cref="PaneBase.Legend"/>.
-		/// To do so, you must separately call <see cref="ZedGraph.Legend.CalcRect"/>.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.Default.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <returns>The calculated chart rect, in pixel coordinates.</returns>
-		public RectangleF CalcClientRect( Graphics g, float scaleFactor )
-		{
-			// get scaled values for the paneGap and character height
-			//float scaledOuterGap = (float) ( Default.OuterPaneGap * scaleFactor );
-			float charHeight = _title._fontSpec.GetHeight( scaleFactor );
-
-			// chart rect starts out at the full pane rect.  It gets reduced to make room for the legend,
-			// scales, titles, etc.
-			RectangleF innerRect = new RectangleF(
-							_rect.Left + _margin.Left * scaleFactor,
-							_rect.Top + _margin.Top * scaleFactor,
-							_rect.Width - scaleFactor * ( _margin.Left + _margin.Right ),
-							_rect.Height - scaleFactor * ( _margin.Top + _margin.Bottom ) );
-
-			// Leave room for the title
-			if ( _title._isVisible && _title._text != string.Empty )
-			{
-				SizeF titleSize = _title._fontSpec.BoundingBox( g, _title._text, scaleFactor );
-				// Leave room for the title height, plus a line spacing of charHeight * _titleGap
-				innerRect.Y += titleSize.Height + charHeight * _titleGap;
-				innerRect.Height -= titleSize.Height + charHeight * _titleGap;
-			}
-
-			// Calculate the legend rect, and back it out of the current ChartRect
-			//this.legend.CalcRect( g, this, scaleFactor, ref innerRect );
-
-			return innerRect;
-		}
-
-		/// <summary>
-		/// Draw the border _border around the <see cref="Rect"/> area.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>		
-		public void DrawPaneFrame( Graphics g, float scaleFactor )
-		{
-			// Erase the pane background, filling it with the specified brush
-			_fill.Draw( g, _rect );
-
-			// Reduce the rect width and height by 1 pixel so that for a rect of
-			// new RectangleF( 0, 0, 100, 100 ), which should be 100 pixels wide, we cover
-			// from 0 through 99.  The draw routines normally cover from 0 through 100, which is
-			// actually 101 pixels wide.
-			RectangleF rect = new RectangleF( _rect.X, _rect.Y, _rect.Width - 1, _rect.Height - 1 );
-
-			_border.Draw( g, this, scaleFactor, rect );
-		}
-
-		/// <summary>
-		/// Draw the <see cref="Title"/> on the graph, centered at the top of the pane.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>		
-		public void DrawTitle( Graphics g, float scaleFactor )
-		{	
-			// only draw the title if it's required
-			if ( _title._isVisible )
-			{
-				SizeF size = _title._fontSpec.BoundingBox( g, _title._text, scaleFactor );
-				
-				// use the internal fontSpec class to draw the text using user-specified and/or
-				// default attributes.
-				_title._fontSpec.Draw( g, this, _title._text,
-					( _rect.Left + _rect.Right ) / 2,
-					_rect.Top + _margin.Top * (float) scaleFactor + size.Height / 2.0F,
-					AlignH.Center, AlignV.Center, scaleFactor );
-			}
-		}
-
-		/// <summary>
-		/// Change the size of the <see cref="Rect"/>.  Override this method to handle resizing the contents
-		/// as required.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">The new size for the <see cref="Rect"/>.</param>
-		public virtual void ReSize( Graphics g, RectangleF rect )
-		{
-			_rect = rect;
-		}
-
-		/// <summary>
-		/// Calculate the scaling factor based on the ratio of the current <see cref="Rect"/> dimensions and
-		/// the <see cref="Default.BaseDimension"/>.
-		/// </summary>
-		/// <remarks>This scaling factor is used to proportionally scale the
-		/// features of the <see cref="MasterPane"/> so that small graphs don't have huge fonts, and vice versa.
-		/// The scale factor represents a linear multiple to be applied to font sizes, symbol sizes, tic sizes,
-		/// gap sizes, pen widths, etc.  The units of the scale factor are "World Pixels" per "Standard Point".
-		/// If any object size, in points, is multiplied by this scale factor, the result is the size, in pixels,
-		/// that the object should be drawn using the standard GDI+ drawing instructions.  A "Standard Point"
-		/// is a dimension based on points (1/72nd inch) assuming that the <see cref="Rect"/> size
-		/// matches the <see cref="Default.BaseDimension"/>.
-		/// Note that "World Pixels" will still be transformed by the GDI+ transform matrices to result
-		/// in "Output Device Pixels", but "World Pixels" are the reference basis for the drawing commands.
-		/// </remarks>
-		/// <returns>
-		/// A <see cref="Single"/> value representing the scaling factor to use for the rendering calculations.
-		/// </returns>
-		/// <seealso cref="PaneBase.BaseDimension"/>
-		public float CalcScaleFactor()
-		{
-			float scaleFactor; //, xInch, yInch;
-			const float ASPECTLIMIT = 1.5F;
-			
-			// if font scaling is turned off, then always return a 1.0 scale factor
-			if ( !_isFontsScaled )
-				return 1.0f;
-
-			// Assume the standard width (BaseDimension) is 8.0 inches
-			// Therefore, if the rect is 8.0 inches wide, then the fonts will be scaled at 1.0
-			// if the rect is 4.0 inches wide, the fonts will be half-sized.
-			// if the rect is 16.0 inches wide, the fonts will be double-sized.
-		
-			// Scale the size depending on the client area width in linear fashion
-			if ( _rect.Height <= 0 )
-				return 1.0F;
-			float length = _rect.Width;
-			float aspect = _rect.Width / _rect.Height;
-			if ( aspect > ASPECTLIMIT )
-				length = _rect.Height * ASPECTLIMIT;
-			if ( aspect < 1.0F / ASPECTLIMIT )
-				length = _rect.Width * ASPECTLIMIT;
-
-			scaleFactor = length / ( _baseDimension * 72F );
-
-			// Don't let the scaleFactor get ridiculous
-			if ( scaleFactor < 0.1F )
-				scaleFactor = 0.1F;
-						
-			return scaleFactor;
-		}
-
-		/// <summary>
-		/// Calculate the scaled pen width, taking into account the scaleFactor and the
-		/// setting of the <see cref="IsPenWidthScaled"/> property of the pane.
-		/// </summary>
-		/// <param name="penWidth">The pen width, in points (1/72 inch)</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <returns>The scaled pen width, in world pixels</returns>
-		public float ScaledPenWidth( float penWidth, float scaleFactor )
-		{
-			if ( _isPenWidthScaled )
-				return (float)( penWidth * scaleFactor );
-			else
-				return penWidth;
-		}
-
-		/// <summary>
-		/// Build a <see cref="Bitmap"/> object containing the graphical rendering of
-		/// all the <see cref="GraphPane"/> objects in this list.
-		/// </summary>
-		/// <value>A <see cref="Bitmap"/> object rendered with the current graph.</value>
-		/// <seealso cref="GetImage(int,int,float)"/>
-		/// <seealso cref="GetMetafile()"/>
-		/// <seealso cref="GetMetafile(int,int)"/>
-		public Bitmap GetImage()
-		{
-			return GetImage( false );
-		}
-
-		/// <summary>
-		/// Build a <see cref="Bitmap"/> object containing the graphical rendering of
-		/// all the <see cref="GraphPane"/> objects in this list.
-		/// </summary>
-		/// <value>A <see cref="Bitmap"/> object rendered with the current graph.</value>
-		/// <seealso cref="GetImage(int,int,float)"/>
-		/// <seealso cref="GetMetafile()"/>
-		/// <seealso cref="GetMetafile(int,int)"/>
-		public Bitmap GetImage( bool isAntiAlias )
-		{
-			Bitmap bitmap = new Bitmap( (int) _rect.Width, (int) _rect.Height );
-			using ( Graphics bitmapGraphics = Graphics.FromImage( bitmap ) )
-			{
-				bitmapGraphics.TranslateTransform( -_rect.Left, -_rect.Top );
-				this.Draw( bitmapGraphics );
-			}
-
-			return bitmap;
-		}
-
-		/// <summary>
-		/// Gets an image for the current GraphPane, scaled to the specified size and resolution.
-		/// </summary>
-		/// <param name="width">The scaled width of the bitmap in pixels</param>
-		/// <param name="height">The scaled height of the bitmap in pixels</param>
-		/// <param name="dpi">The resolution of the bitmap, in dots per inch</param>
-		/// <param name="isAntiAlias">true for anti-aliased rendering, false otherwise</param>
-		/// <seealso cref="GetImage()"/>
-		/// <seealso cref="GetMetafile()"/>
-		/// <seealso cref="GetMetafile(int,int)"/>
-		/// <seealso cref="Bitmap"/>
-		public Bitmap GetImage( int width, int height, float dpi, bool isAntiAlias )
-		{
-			Bitmap bitmap = new Bitmap( width, height );
-			bitmap.SetResolution( dpi, dpi );
-			using ( Graphics bitmapGraphics = Graphics.FromImage( bitmap ) )
-			{
-				MakeImage( bitmapGraphics, width, height, isAntiAlias );
-			}
-
-			return bitmap;
-		}
-
-		/// <summary>
-		/// Gets an image for the current GraphPane, scaled to the specified size and resolution.
-		/// </summary>
-		/// <param name="width">The scaled width of the bitmap in pixels</param>
-		/// <param name="height">The scaled height of the bitmap in pixels</param>
-		/// <param name="dpi">The resolution of the bitmap, in dots per inch</param>
-		/// <seealso cref="GetImage()"/>
-		/// <seealso cref="GetMetafile()"/>
-		/// <seealso cref="GetMetafile(int,int)"/>
-		/// <seealso cref="Bitmap"/>
-		public Bitmap GetImage( int width, int height, float dpi )
-		{
-			return GetImage( width, height, dpi, false );
-		}
-
-		/// <summary>
-		/// Setup a <see cref="Graphics" /> instance with appropriate antialias settings.
-		/// </summary>
-		/// <remarks>
-		/// No settings are modified if <paramref name="isAntiAlias"/> is set to false.  This method
-		/// does not restore original settings, it presumes that the Graphics instance will be
-		/// disposed.</remarks>
-		/// <param name="g">An existing <see cref="Graphics" /> instance</param>
-		/// <param name="isAntiAlias">true to render in anti-alias mode, false otherwise</param>
-		internal void SetAntiAliasMode( Graphics g, bool isAntiAlias )
-		{
-			if ( isAntiAlias )
-			{
-				g.SmoothingMode = SmoothingMode.HighQuality;
-				//g.SmoothingMode = SmoothingMode.AntiAlias;
-				g.TextRenderingHint = TextRenderingHint.AntiAlias;
-				g.CompositingQuality = CompositingQuality.HighQuality;
-				g.InterpolationMode = InterpolationMode.HighQualityBicubic;
-			}
-		}
-
-		private void MakeImage( Graphics g, int width, int height, bool antiAlias )
-		{
-			//g.SmoothingMode = SmoothingMode.AntiAlias;
-			SetAntiAliasMode( g, antiAlias );
-
-			// This is actually a shallow clone, so we don't duplicate all the data, curveLists, etc.
-			PaneBase tempPane = this.ShallowClone();
-
-			// Clone the Chart object for GraphPanes so we don't mess up the minPix and maxPix values or
-			// the rect/ChartRect calculations of the original
-			//RectangleF saveRect = new RectangleF();
-			//if ( this is GraphPane )
-			//	saveRect = ( this as GraphPane ).Chart.Rect;
-
-			tempPane.ReSize( g, new RectangleF( 0, 0, width, height ) );
-
-			tempPane.Draw( g );
-
-			//if ( this is GraphPane )
-			//{
-			//	GraphPane gPane = this as GraphPane;
-			//	gPane.Chart.Rect = saveRect;
-			//	gPane.XAxis.Scale.SetupScaleData( gPane, gPane.XAxis );
-			//	foreach ( Axis axis in gPane.YAxisList )
-			//		axis.Scale.SetupScaleData( gPane, axis );
-			//	foreach ( Axis axis in gPane.Y2AxisList )
-			//		axis.Scale.SetupScaleData( gPane, axis );
-			//}
-
-			// To restore all the various state variables, you must redraw the graph in it's
-			// original form.  For this we create a 1x1 bitmap (it doesn't matter what size you use,
-			// since we're only mimicing the draw.  If you use the 'bitmapGraphics' already created,
-			// then you will be drawing back into the bitmap that will be returned.
-
-			Bitmap bm = new Bitmap( 1, 1 );
-			using ( Graphics bmg = Graphics.FromImage( bm ) )
-			{
-				this.ReSize( bmg, this.Rect );
-				SetAntiAliasMode( bmg, antiAlias );
-				this.Draw( bmg );
-			}
-		}
-
-		/// <summary>
-		/// Gets an enhanced metafile image for the current GraphPane, scaled to the specified size.
-		/// </summary>
-		/// <remarks>
-		/// By definition, a Metafile is a vector drawing, and therefore scaling should not matter.
-		/// However, this method is provided because certain options in Zedgraph, such as
-		/// <see cref="IsFontsScaled" /> are affected by the size of the expected image.
-		/// </remarks>
-		/// <param name="width">The "effective" scaled width of the bitmap in pixels</param>
-		/// <param name="height">The "effective" scaled height of the bitmap in pixels</param>
-		/// <param name="isAntiAlias">true to use anti-aliased drawing mode, false otherwise</param>
-		/// <seealso cref="GetImage()"/>
-		/// <seealso cref="GetImage(int,int,float)"/>
-		/// <seealso cref="GetMetafile()"/>
-		public Metafile GetMetafile( int width, int height, bool isAntiAlias )
-		{
-			Bitmap bm = new Bitmap( 1, 1 );
-			using ( Graphics g = Graphics.FromImage( bm ) )
-			{
-				IntPtr hdc = g.GetHdc();
-				Stream stream = new MemoryStream();
-				Metafile metafile = new Metafile( stream, hdc, _rect,
-							MetafileFrameUnit.Pixel, EmfType.EmfPlusDual );
-				g.ReleaseHdc( hdc );
-
-				using ( Graphics metafileGraphics = Graphics.FromImage( metafile ) )
-				{
-					//metafileGraphics.TranslateTransform( -_rect.Left, -_rect.Top );
-					metafileGraphics.PageUnit = System.Drawing.GraphicsUnit.Pixel;
-					PointF P = new PointF( width, height );
-					PointF[] PA = new PointF[] { P };
-					metafileGraphics.TransformPoints( CoordinateSpace.Page, CoordinateSpace.Device, PA );
-					//metafileGraphics.PageScale = 1f;
-
-					// output
-					MakeImage( metafileGraphics, width, height, isAntiAlias );
-					//this.Draw( metafileGraphics );
-
-					return metafile;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Gets an enhanced metafile image for the current GraphPane, scaled to the specified size.
-		/// </summary>
-		/// <remarks>
-		/// By definition, a Metafile is a vector drawing, and therefore scaling should not matter.
-		/// However, this method is provided because certain options in Zedgraph, such as
-		/// <see cref="IsFontsScaled" /> are affected by the size of the expected image.
-		/// </remarks>
-		/// <param name="width">The "effective" scaled width of the bitmap in pixels</param>
-		/// <param name="height">The "effective" scaled height of the bitmap in pixels</param>
-		/// <seealso cref="GetImage()"/>
-		/// <seealso cref="GetImage(int,int,float)"/>
-		/// <seealso cref="GetMetafile()"/>
-		public Metafile GetMetafile( int width, int height )
-		{
-			return GetMetafile( width, height, false );
-		}
-
-		/// <summary>
-		/// Gets an enhanced metafile image for the current GraphPane.
-		/// </summary>
-		/// <seealso cref="GetImage()"/>
-		/// <seealso cref="GetImage(int,int,float)"/>
-		/// <seealso cref="GetMetafile(int,int)"/>
-		public Metafile GetMetafile()
-		{
-			Bitmap bm = new Bitmap( 1, 1 );
-			using ( Graphics g = Graphics.FromImage( bm ) )
-			{
-				IntPtr hdc = g.GetHdc();
-				Stream stream = new MemoryStream();
-				Metafile metafile = new Metafile( stream, hdc, _rect,
-							MetafileFrameUnit.Pixel, EmfType.EmfOnly );
-
-				using ( Graphics metafileGraphics = Graphics.FromImage( metafile ) )
-				{
-					metafileGraphics.TranslateTransform( -_rect.Left, -_rect.Top );
-					metafileGraphics.PageUnit = System.Drawing.GraphicsUnit.Pixel;
-					PointF P = new PointF( _rect.Width, _rect.Height );
-					PointF[] PA = new PointF[] { P };
-					metafileGraphics.TransformPoints( CoordinateSpace.Page, CoordinateSpace.Device, PA );
-					//metafileGraphics.PageScale = 1f;
-
-					// output
-					this.Draw( metafileGraphics );
-
-					g.ReleaseHdc( hdc );
-					return metafile;
-				}
-			}
-		}
-
-		/*
-		         System.Drawing.Imaging.Metafile metafile = null; 
-   
-               // create a Metafile object that is compatible with the surface of this 
-               // form
-               using ( Graphics graphics = this.CreateGraphics() )
-               { 
-                  System.IntPtr hdc = graphics.GetHdc(); 
-                  metafile = new Metafile(filename, hdc, new Rectangle( 0, 0, 
-                     (((int) this.ClientRectangle.Width)), 
-							(((int) this.ClientRectangle.Height ))), 
-							MetafileFrameUnit.Point ); 
-                  graphics.ReleaseHdc( hdc );
-               }
-
-               // draw to the metafile
-               using ( Graphics metafileGraphics = Graphics.FromImage( metafile ) )
-               {
-                  metafileGraphics.PageUnit=System.Drawing.GraphicsUnit.Point;
-                  PointF P=new Point(this.ClientRectangle.Width,this.ClientRectangle.Height);
-                  PointF[] PA=new PointF[]{P};
-                  metafileGraphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Device, PA); 
-                  metafileGraphics.PageScale=1f;
-                  metafileGraphics.SmoothingMode = SmoothingMode.AntiAlias; // smooth the 
-                  // output
-                  this.masterPane.Draw( metafileGraphics );
-                  metafileGraphics.DrawRectangle(new System.Drawing.Pen( Color.Gray),this.ClientRectangle);
-                  metafile.Dispose();
-                  
-               }
-
-               return true;
-            }
-            else
-            {
-               return false;
-            }
-         }
-         else
-         {
-            //no directory given
-            return false;
-         }
-		 */
-
-		
-/*
-				/// <summary>
-				/// Function to export the Diagram as WMF file
-				/// see http://www.codeproject.com/showcase/pdfrasterizer.asp?print=true
-				/// </summary>
-				/// <param name="filename">
-				/// filename is the name to export to
-				/// </param>
-				public bool ExporttoWmf( string filename )
-				{
-					string p;
-
-					//FileInfo TheFile = new FileInfo(filename);
-					p = Path.GetDirectoryName( filename );
-					if ( p != "" )
-					{
-						DirectoryInfo TheDir = new DirectoryInfo( p );
-						if ( TheDir.Exists )
-						{
-							System.Drawing.Imaging.Metafile metafile = null;
-
-							// create a Metafile object that is compatible with the surface of this 
-							// form
-							using ( Graphics graphics = this.CreateGraphics() )
-							{
-								System.IntPtr hdc = graphics.GetHdc();
-								metafile = new Metafile( filename, hdc, new Rectangle( 0, 0,
-									( ( (int)this.ClientRectangle.Width ) ),
-									( ( (int)this.ClientRectangle.Height ) ) ),
-									MetafileFrameUnit.Point );
-								graphics.ReleaseHdc( hdc );
-							}
-
-							// draw to the metafile
-							using ( Graphics metafileGraphics = Graphics.FromImage( metafile ) )
-							{
-								metafileGraphics.PageUnit = System.Drawing.GraphicsUnit.Point;
-								PointF P = new Point( this.ClientRectangle.Width, this.ClientRectangle.Height );
-								PointF[] PA = new PointF[] { P };
-								metafileGraphics.TransformPoints( CoordinateSpace.Page, CoordinateSpace.Device, PA );
-								metafileGraphics.PageScale = 1f;
-								metafileGraphics.SmoothingMode = SmoothingMode.AntiAlias; // smooth the 
-								// output
-								this.masterPane.Draw( metafileGraphics );
-								metafileGraphics.DrawRectangle( new System.Drawing.Pen( Color.Gray ), this.ClientRectangle );
-								metafile.Dispose();
-
-							}
-
-							return true;
-						}
-						else
-						{
-							return false;
-						}
-					}
-					else
-					{
-						//no directory given
-						return false;
-					}
-				}
-		*/
-		internal PointF TransformCoord( double x, double y, CoordType coord )
-		{
-			// If the Transformation is an illegal type, just stick it in the middle
-			if ( !( this is GraphPane ) && !( coord == CoordType.PaneFraction ) )
-			{
-				coord = CoordType.PaneFraction;
-				x = 0.5;
-				y = 0.5;
-			}
-
-			// Just to save some casts
-			GraphPane gPane = null;
-			RectangleF chartRect = new RectangleF( 0, 0, 1, 1 );
-			if ( this is GraphPane )
-			{
-				gPane = this as GraphPane;
-				chartRect = gPane.Chart._rect;
-			}
-
-			PointF ptPix = new PointF();
-
-			if ( coord == CoordType.ChartFraction )
-			{
-				ptPix.X = (float)( chartRect.Left + x * chartRect.Width );
-				ptPix.Y = (float)( chartRect.Top + y * chartRect.Height );
-			}
-			else if ( coord == CoordType.AxisXYScale )
-			{
-				ptPix.X = gPane.XAxis.Scale.Transform( x );
-				ptPix.Y = gPane.YAxis.Scale.Transform( y );
-			}
-			else if ( coord == CoordType.AxisXY2Scale )
-			{
-				ptPix.X = gPane.XAxis.Scale.Transform( x );
-				ptPix.Y = gPane.Y2Axis.Scale.Transform( y );
-			}
-			else if ( coord == CoordType.XScaleYChartFraction )
-			{
-				ptPix.X = gPane.XAxis.Scale.Transform( x );
-				ptPix.Y = (float)( chartRect.Top + y * chartRect.Height );
-			}
-			else if ( coord == CoordType.XChartFractionYScale )
-			{
-				ptPix.X = (float)( chartRect.Left + x * chartRect.Width );
-				ptPix.Y = gPane.YAxis.Scale.Transform( y );
-			}
-			else if ( coord == CoordType.XChartFractionY2Scale )
-			{
-				ptPix.X = (float)( chartRect.Left + x * chartRect.Width );
-				ptPix.Y = gPane.Y2Axis.Scale.Transform( y );
-			}
-			else if ( coord == CoordType.XChartFractionYPaneFraction )
-			{
-				ptPix.X = (float)( chartRect.Left + x * chartRect.Width );
-				ptPix.Y = (float)( this.Rect.Top + y * _rect.Height );
-			}
-			else if ( coord == CoordType.XPaneFractionYChartFraction )
-			{
-				ptPix.X = (float)( this.Rect.Left + x * _rect.Width );
-				ptPix.Y = (float)( chartRect.Top + y * chartRect.Height );
-			}
-			else	// PaneFraction
-			{
-				ptPix.X = (float)( _rect.Left + x * _rect.Width );
-				ptPix.Y = (float)( _rect.Top + y * _rect.Height );
-			}
-
-			return ptPix;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PaneLayoutMgr.cs b/BDInfo/ZedGraph/PaneLayoutMgr.cs
deleted file mode 100644
index b481ef7886..0000000000
--- a/BDInfo/ZedGraph/PaneLayoutMgr.cs
+++ /dev/null
@@ -1,561 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright (C) 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// internal class to store pane layout details for the <see cref="MasterPane" />
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public class PaneLayoutMgr : ICloneable, ISerializable
-	{
-		// =========== PANE LAYOUT STUFF ================
-
-	#region Fields
-
-		/// <summary>
-		/// private field that saves the paneLayout format specified when
-		/// <see cref="SetLayout(PaneLayout)"/> was called. This value will
-		/// default to <see cref="MasterPane.Default.PaneLayout"/> if
-		/// <see cref="SetLayout(PaneLayout)"/> (or an overload) was never called.
-		/// </summary>
-		internal PaneLayout _paneLayout;
-
-		/// <summary>
-		/// Private field that stores the boolean value that determines whether
-		/// <see cref="_countList"/> is specifying rows or columns.
-		/// </summary>
-		internal bool _isColumnSpecified;
-		/// <summary>
-		/// private field that stores the row/column item count that was specified to the
-		/// <see cref="SetLayout(bool,int[],float[])"/> method.  This values will be
-		/// null if <see cref="SetLayout(bool,int[],float[])"/> was never called.
-		/// </summary>
-		internal int[] _countList;
-
-		/// <summary>
-		/// private field that stores the row/column size proportional values as specified
-		/// to the <see cref="SetLayout(bool,int[],float[])"/> method.  This
-		/// value will be null if <see cref="SetLayout(bool,int[],float[])"/>
-		/// was never called.  
-		/// </summary>
-		internal float[] _prop;
-
-	#endregion
-
-	#region Constructors
-
-		internal void Init()
-		{
-			_paneLayout = MasterPane.Default.PaneLayout;
-			_countList = null;
-			_isColumnSpecified = false;
-			_prop = null;
-		}
-
-		internal PaneLayoutMgr()
-		{
-			Init();
-		}
-
-		internal PaneLayoutMgr( PaneLayoutMgr rhs )
-		{
-			_paneLayout = rhs._paneLayout;
-			_countList = rhs._countList;
-			_isColumnSpecified = rhs._isColumnSpecified;
-			_prop = rhs._prop;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public PaneLayoutMgr Clone()
-		{
-			return new PaneLayoutMgr( this );
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		internal const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		public PaneLayoutMgr( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_paneLayout = (PaneLayout)info.GetValue( "paneLayout", typeof( PaneLayout ) );
-			_countList = (int[])info.GetValue( "countList", typeof(int[]) );
-
-			_isColumnSpecified = info.GetBoolean( "isColumnSpecified" );
-			_prop = (float[]) info.GetValue( "prop", typeof( float[] ) );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-
-			info.AddValue( "paneLayout", _paneLayout );
-			info.AddValue( "countList", _countList );
-			info.AddValue( "isColumnSpecified", _isColumnSpecified );
-			info.AddValue( "prop", _prop );
-		}
-	#endregion
-
-	#region Methods
-
-		/// <overloads>The SetLayout() methods setup the desired layout of the
-		/// <see cref="GraphPane" /> objects within a <see cref="MasterPane" />.  These functions
-		/// do not make any changes, they merely set the parameters so that future calls
-		/// to <see cref="PaneBase.ReSize" /> or <see cref="DoLayout(Graphics,MasterPane)" />
-		/// will use the desired layout.<br /><br />
-		/// The layout options include a set of "canned" layouts provided by the
-		/// <see cref="ZedGraph.PaneLayout" /> enumeration, options to just set a specific
-		/// number of rows and columns of panes (and all pane sizes are the same), and more
-		/// customized options of specifying the number or rows in each column or the number of
-		/// columns in each row, along with proportional values that determine the size of each
-		/// individual column or row.
-		/// </overloads>
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a pre-defined layout configuration from a <see cref="PaneLayout" />
-		/// enumeration.
-		/// </summary>
-		/// <remarks>This method uses a <see cref="PaneLayout"/> enumeration to describe the type of layout
-		/// to be used.  Overloads are available that provide other layout options</remarks>
-		/// <param name="paneLayout">A <see cref="PaneLayout"/> enumeration that describes how
-		/// the panes should be laid out within the <see cref="PaneBase.Rect"/>.</param>
-		/// <seealso cref="SetLayout(int,int)" />
-		/// <seealso cref="SetLayout(bool,int[])" />
-		/// <seealso cref="SetLayout(bool,int[],float[])" />
-		public void SetLayout( PaneLayout paneLayout )
-		{
-			Init();
-
-			_paneLayout = paneLayout;
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a reasonable configuration.
-		/// </summary>
-		/// <remarks>This method explicitly specifies the number of rows and columns to use
-		/// in the layout, and all <see cref="GraphPane" /> objects will have the same size.
-		/// Overloads are available that provide other layout options</remarks>
-		/// <param name="rows">The number of rows of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <param name="columns">The number of columns of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <seealso cref="SetLayout(PaneLayout)" />
-		/// <seealso cref="SetLayout(bool,int[])" />
-		/// <seealso cref="SetLayout(bool,int[],float[])" />
-		public void SetLayout( int rows, int columns )
-		{
-			Init();
-
-			if ( rows < 1 )
-				rows = 1;
-			if ( columns < 1 )
-				columns = 1;
-
-			int[] countList = new int[rows];
-
-			for (int i=0; i<rows; i++ )
-				countList[i] = columns;
-
-			SetLayout( true, countList, null );
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to the specified configuration.
-		/// </summary>
-		/// <remarks>This method specifies the number of rows in each column, or the number of
-		/// columns in each row, allowing for irregular layouts.  Overloads are available that
-		/// provide other layout options.
-		/// </remarks>
-		/// <param name="isColumnSpecified">Specifies whether the number of columns in each row, or
-		/// the number of rows in each column will be specified.  A value of true indicates the
-		/// number of columns in each row are specified in <see paramref="countList"/>.</param>
-		/// <param name="countList">An integer array specifying either the number of columns in
-		/// each row or the number of rows in each column, depending on the value of
-		/// <see paramref="isColumnSpecified"/>.</param>
-		/// <seealso cref="SetLayout(PaneLayout)" />
-		/// <seealso cref="SetLayout(int,int)" />
-		/// <seealso cref="SetLayout(bool,int[],float[])" />
-		public void SetLayout( bool isColumnSpecified, int[] countList )
-		{
-			SetLayout( isColumnSpecified, countList, null );
-		}
-
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to the specified configuration.
-		/// </summary>
-		/// <remarks>This method specifies the number of panes in each row or column, allowing for
-		/// irregular layouts.</remarks>
-		/// <remarks>This method specifies the number of rows in each column, or the number of
-		/// columns in each row, allowing for irregular layouts.  Additionally, a
-		/// <see paramref="proportion" /> parameter is provided that allows varying column or
-		/// row sizes.  Overloads for SetLayout() are available that provide other layout options.
-		/// </remarks>
-		/// <param name="isColumnSpecified">Specifies whether the number of columns in each row, or
-		/// the number of rows in each column will be specified.  A value of true indicates the
-		/// number of columns in each row are specified in <see paramref="_countList"/>.</param>
-		/// <param name="countList">An integer array specifying either the number of columns in
-		/// each row or the number of rows in each column, depending on the value of
-		/// <see paramref="isColumnSpecified"/>.</param>
-		/// <param name="proportion">An array of float values specifying proportional sizes for each
-		/// row or column.  Note that these proportions apply to the non-specified dimension -- that is,
-		/// if <see paramref="isColumnSpecified"/> is true, then these proportions apply to the row
-		/// heights, and if <see paramref="isColumnSpecified"/> is false, then these proportions apply
-		/// to the column widths.  The values in this array are arbitrary floats -- the dimension of
-		/// any given row or column is that particular proportional value divided by the sum of all
-		/// the values.  For example, let <see paramref="isColumnSpecified"/> be true, and
-		/// <see paramref="proportion"/> is an array with values of { 1.0, 2.0, 3.0 }.  The sum of
-		/// those values is 6.0.  Therefore, the first row is 1/6th of the available height, the
-		/// second row is 2/6th's of the available height, and the third row is 3/6th's of the
-		/// available height.
-		/// </param>
-		/// <seealso cref="SetLayout(PaneLayout)" />
-		/// <seealso cref="SetLayout(int,int)" />
-		/// <seealso cref="SetLayout(bool,int[])" />
-		public void SetLayout( bool isColumnSpecified, int[] countList, float[] proportion )
-		{
-			Init();
-
-			// use defaults if the parameters are invalid
-			if ( countList != null && countList.Length > 0 )
-			{
-				this._prop = new float[countList.Length];
-
-				// Sum up the total proportional factors
-				float sumProp = 0.0f;
-				for ( int i = 0; i < countList.Length; i++ )
-				{
-					this._prop[i] = ( proportion == null || proportion.Length <= i || proportion[i] < 1e-10 ) ?
-												1.0f : proportion[i];
-					sumProp += this._prop[i];
-				}
-
-				// Make prop sum to 1.0
-				for ( int i=0; i<countList.Length; i++ )
-					this._prop[i] /= sumProp;
-
-				_isColumnSpecified = isColumnSpecified;
-				_countList = countList;
-			}
-		}
-
-		/// <summary>
-		/// Modify the <see cref="GraphPane" /> <see cref="PaneBase.Rect" /> sizes of each
-		/// <see cref="GraphPane" /> such that they fit within the <see cref="MasterPane" />
-		/// in a pre-configured layout.
-		/// </summary>
-		/// <remarks>The <see cref="SetLayout(PaneLayout)" /> method (and overloads) is
-		/// used for setting the layout configuration.</remarks>
-		/// <param name="g">A <see cref="Graphics" /> instance to be used for font sizing,
-		/// etc. in determining the layout configuration.</param>
-		/// <param name="master">The <see cref="MasterPane" /> instance which is to
-		/// be resized.</param>
-		/// <seealso cref="SetLayout(PaneLayout)" />
-		/// <seealso cref="SetLayout(int,int)" />
-		/// <seealso cref="SetLayout(bool,int[])" />
-		/// <seealso cref="SetLayout(bool,int[],float[])" />
-		public void DoLayout( Graphics g, MasterPane master )
-		{
-			if ( this._countList != null )
-				DoLayout( g, master, this._isColumnSpecified, this._countList, this._prop );
-			else
-			{
-				int count = master.PaneList.Count;
-				if ( count == 0 )
-					return;
-
-				int rows,
-						cols,
-						root = (int)( Math.Sqrt( (double)count ) + 0.9999999 );
-
-				//float[] widthList = new float[5];
-
-				switch ( _paneLayout )
-				{
-					case PaneLayout.ForceSquare:
-						rows = root;
-						cols = root;
-						DoLayout( g, master, rows, cols );
-						break;
-					case PaneLayout.SingleColumn:
-						rows = count;
-						cols = 1;
-						DoLayout( g, master, rows, cols );
-						break;
-					case PaneLayout.SingleRow:
-						rows = 1;
-						cols = count;
-						DoLayout( g, master, rows, cols );
-						break;
-					default:
-					case PaneLayout.SquareColPreferred:
-						rows = root;
-						cols = root;
-						if ( count <= root * ( root - 1 ) )
-							rows--;
-						DoLayout( g, master, rows, cols );
-						break;
-					case PaneLayout.SquareRowPreferred:
-						rows = root;
-						cols = root;
-						if ( count <= root * ( root - 1 ) )
-							cols--;
-						DoLayout( g, master, rows, cols );
-						break;
-					case PaneLayout.ExplicitCol12:
-						DoLayout( g, master, true, new int[2] { 1, 2 }, null );
-						break;
-					case PaneLayout.ExplicitCol21:
-						DoLayout( g, master, true, new int[2] { 2, 1 }, null );
-						break;
-					case PaneLayout.ExplicitCol23:
-						DoLayout( g, master, true, new int[2] { 2, 3 }, null );
-						break;
-					case PaneLayout.ExplicitCol32:
-						DoLayout( g, master, true, new int[2] { 3, 2 }, null );
-						break;
-					case PaneLayout.ExplicitRow12:
-						DoLayout( g, master, false, new int[2] { 1, 2 }, null );
-						break;
-					case PaneLayout.ExplicitRow21:
-						DoLayout( g, master, false, new int[2] { 2, 1 }, null );
-						break;
-					case PaneLayout.ExplicitRow23:
-						DoLayout( g, master, false, new int[2] { 2, 3 }, null );
-						break;
-					case PaneLayout.ExplicitRow32:
-						DoLayout( g, master, false, new int[2] { 3, 2 }, null );
-						break;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Internal method that applies a previously set layout with a specific
-		/// row and column count.  This method is only called by
-		/// <see cref="DoLayout(Graphics,MasterPane)" />.
-		/// </summary>
-		internal void DoLayout( Graphics g, MasterPane master, int rows, int columns )
-		{
-			if ( rows < 1 )
-				rows = 1;
-			if ( columns < 1 )
-				columns = 1;
-
-			int[] countList = new int[rows];
-
-			for (int i=0; i<rows; i++ )
-				countList[i] = columns;
-
-			DoLayout( g, master, true, countList, null );
-		}
-
-		/// <summary>
-		/// Internal method that applies a previously set layout with a rows per column or
-		/// columns per row configuration.  This method is only called by
-		/// <see cref="DoLayout(Graphics,MasterPane)" />.
-		/// </summary>
-		internal void DoLayout( Graphics g, MasterPane master, bool isColumnSpecified, int[] countList,
-					float[] proportion )
-		{
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = master.CalcScaleFactor();
-
-			// innerRect is the area for the GraphPane's
-			RectangleF innerRect = master.CalcClientRect( g, scaleFactor );
-			master.Legend.CalcRect( g, master, scaleFactor, ref innerRect );
-
-			// scaled InnerGap is the area between the GraphPane.Rect's
-			float scaledInnerGap = (float)( master._innerPaneGap * scaleFactor );
-
-			int iPane = 0;
-
-			if ( isColumnSpecified )
-			{
-				int rows = countList.Length;
-
-				float y = 0.0f;
-
-				for ( int rowNum = 0; rowNum < rows; rowNum++ )
-				{
-					float propFactor = _prop == null ? 1.0f / rows : _prop[rowNum];
-
-					float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) *
-									propFactor;
-
-					int columns = countList[rowNum];
-					if ( columns <= 0 )
-						columns = 1;
-					float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) /
-									(float)columns;
-
-					if ( iPane >= master._paneList.Count )
-						return;
-
-					for ( int colNum = 0; colNum < columns; colNum++ )
-					{
-						master[iPane].Rect = new RectangleF(
-											innerRect.X + colNum * ( width + scaledInnerGap ),
-											innerRect.Y + y,
-											width,
-											height );
-						iPane++;
-					}
-
-					y += height + scaledInnerGap;
-				}
-			}
-			else
-			{
-				int columns = countList.Length;
-
-				float x = 0.0f;
-
-				for ( int colNum = 0; colNum < columns; colNum++ )
-				{
-					float propFactor = _prop == null ? 1.0f / columns : _prop[colNum];
-
-					float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) *
-									propFactor;
-
-					int rows = countList[colNum];
-					if ( rows <= 0 )
-						rows = 1;
-					float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) / (float)rows;
-
-					for ( int rowNum = 0; rowNum < rows; rowNum++ )
-					{
-						if ( iPane >= master._paneList.Count )
-							return;
-
-						master[iPane].Rect = new RectangleF(
-											innerRect.X + x,
-											innerRect.Y + rowNum * ( height + scaledInnerGap ),
-											width,
-											height );
-						iPane++;
-					}
-
-					x += width + scaledInnerGap;
-				}
-			}
-		}
-
-		/*
-		/// <summary>
-		/// Automatically set all of the <see cref="GraphPane"/> <see cref="PaneBase.Rect"/>'s in
-		/// the list to a reasonable configuration.
-		/// </summary>
-		/// <remarks>This method explicitly specifies the number of rows and columns to use in the layout.
-		/// A more automatic overload, using a <see cref="PaneLayout"/> enumeration, is available.</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rows">The number of rows of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		/// <param name="columns">The number of columns of <see cref="GraphPane"/> objects
-		/// to include in the layout</param>
-		public void DoPaneLayout( Graphics g, int rows, int columns )
-		{
-			// save the layout settings for future reference
-			this._countList = null;
-			this._rows = rows;
-			this._columns = columns;
-
-			// calculate scaleFactor on "normal" pane size (BaseDimension)
-			float scaleFactor = this.CalcScaleFactor();
-
-			// innerRect is the area for the GraphPane's
-			RectangleF innerRect = CalcClientRect( g, scaleFactor );
-			this._legend.CalcRect( g, this, scaleFactor, ref innerRect );
-
-			// scaled InnerGap is the area between the GraphPane.Rect's
-			float scaledInnerGap = (float)( this._innerPaneGap * scaleFactor );
-
-			float width = ( innerRect.Width - (float)( columns - 1 ) * scaledInnerGap ) / (float)columns;
-			float height = ( innerRect.Height - (float)( rows - 1 ) * scaledInnerGap ) / (float)rows;
-
-			int i = 0;
-			foreach ( GraphPane pane in this._paneList )
-			{
-				float rowNum = (float)( i / columns );
-				float colNum = (float)( i % columns );
-
-				pane.Rect = new RectangleF(
-									innerRect.X + colNum * ( width + scaledInnerGap ),
-									innerRect.Y + rowNum * ( height + scaledInnerGap ),
-									width,
-									height );
-
-				i++;
-			}
-		}
-		*/
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PaneList.cs b/BDInfo/ZedGraph/PaneList.cs
deleted file mode 100644
index bd9656b939..0000000000
--- a/BDInfo/ZedGraph/PaneList.cs
+++ /dev/null
@@ -1,237 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="GraphPane"/> objects.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.6 $ $Date: 2006/06/24 20:26:43 $ </version>
-	[Serializable]
-	public class PaneList : List<GraphPane>, ICloneable
-	{
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the collection class.
-		/// </summary>
-		public PaneList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="PaneList"/> object from which to copy</param>
-		public PaneList( PaneList rhs )
-		{
-			foreach ( GraphPane item in rhs )
-			{
-				this.Add( item.Clone() );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public PaneList Clone()
-		{
-			return new PaneList( this );
-		}
-
-		
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PaneList( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-		}
-	#endregion
-
-	#region List Methods
-/*		/// <summary>
-		/// Indexer to access the specified <see cref="GraphPane"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="GraphPane"/> object to be accessed.</param>
-		/// <value>A <see cref="GraphPane"/> object reference.</value>
-		public GraphPane this[ int index ]  
-		{
-			get { return( (GraphPane) List[index] ); }
-			set { List[index] = value; }
-		}
-*/
-		/// <summary>
-		/// Indexer to access the specified <see cref="GraphPane"/> object by
-		/// its <see cref="PaneBase.Title"/> string.
-		/// </summary>
-		/// <param name="title">The string title of the
-		/// <see cref="GraphPane"/> object to be accessed.</param>
-		/// <value>A <see cref="GraphPane"/> object reference.</value>
-		public GraphPane this[ string title ]  
-		{
-			get
-			{
-				int index = IndexOf( title );
-				if ( index >= 0 )
-					return( (GraphPane) this[index]  );
-				else
-					return null;
-			}
-		}
-/*
-		/// <summary>
-		/// Add a <see cref="GraphPane"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object to
-		/// be added</param>
-		/// <seealso cref="IList.Add"/>
-		public void Add( GraphPane pane )
-		{
-			List.Add( pane );
-		}
-
-		/// <summary>
-		/// Remove a <see cref="GraphPane"/> object from the collection based on an object reference.
-		/// </summary>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is to be
-		/// removed.</param>
-		/// <seealso cref="IList.Remove"/>
-		public void Remove( GraphPane pane )
-		{
-			List.Remove( pane );
-		}
-
-		/// <summary>
-		/// Insert a <see cref="GraphPane"/> object into the collection at the specified
-		/// zero-based index location.
-		/// </summary>
-		/// <param name="index">The zero-based index location for insertion.</param>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object that is to be
-		/// inserted.</param>
-		/// <seealso cref="IList.Insert"/>
-		public void Insert( int index, GraphPane pane )
-		{
-			List.Insert( index, pane );
-		}
-*/
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="GraphPane"/> with the specified <see cref="PaneBase.Title"/>.
-		/// </summary>
-		/// <remarks>The comparison of titles is not case sensitive, but it must include
-		/// all characters including punctuation, spaces, etc.</remarks>
-		/// <param name="title">The <see cref="String"/> label that is in the
-		/// <see cref="PaneBase.Title"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="GraphPane"/>,
-		/// or -1 if the <see cref="PaneBase.Title"/> was not found in the list</returns>
-		/// <seealso cref="IndexOfTag"/>
-		public int IndexOf( string title )
-		{
-			int index = 0;
-			foreach ( GraphPane pane in this )
-			{
-				if ( String.Compare( pane.Title.Text, title, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="GraphPane"/> with the specified <see cref="PaneBase.Tag"/>.
-		/// </summary>
-		/// <remarks>In order for this method to work, the <see cref="PaneBase.Tag"/>
-		/// property must be of type <see cref="String"/>.</remarks>
-		/// <param name="tagStr">The <see cref="String"/> tag that is in the
-		/// <see cref="PaneBase.Tag"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="GraphPane"/>,
-		/// or -1 if the <see cref="PaneBase.Tag"/> string is not in the list</returns>
-		public int IndexOfTag( string tagStr )
-		{
-			int index = 0;
-			foreach ( GraphPane pane in this )
-			{
-				if ( pane.Tag is string &&
-						String.Compare( (string) pane.Tag, tagStr, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PieItem.cs b/BDInfo/ZedGraph/PieItem.cs
deleted file mode 100644
index f36189d5db..0000000000
--- a/BDInfo/ZedGraph/PieItem.cs
+++ /dev/null
@@ -1,1091 +0,0 @@
-//============================================================================
-//PieItem Class
-//Copyright © 2005  Bob Kaye
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections;
-using System.Drawing.Drawing2D;
-using System.Globalization;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class representing a pie chart object comprised of one or more
-	/// <see cref="PieItem"/>s.
-	/// </summary>
-	/// <author> Bob Kaye </author>
-	/// <version> $Revision: 1.32 $ $Date: 2007/07/30 05:26:23 $ </version>
-	[Serializable]
-	public class PieItem : CurveItem, ICloneable, ISerializable
-	{
-
-		#region Fields
-		/*
-		/// <summary>
-		/// Private field instance of the <see cref="PieItem"/> class indicating whether
-		/// the instance is displayed in 2D or 3D.(see <see cref="PieItem.PieType"/>)
-		/// </summary>
-		private PieType pieType;
-*/
-		/// <summary>
-		/// Percentage (expressed as #.##) of <see cref="PieItem"/>	radius  to
-		/// which this <see cref="PieItem"/> is to be displaced from the center.
-		///   Displacement is done outward  along the radius
-		/// bisecting the chord of this <see cref="PieItem"/>.  Maximum allowable value
-		/// is 0.5.
-		/// </summary>
-		private double _displacement;
-
-		/// <summary>
-		/// A <see cref="ZedGraph.TextObj"/> which will customize the label display of this
-		/// <see cref="PieItem"/>
-		/// </summary>
-		private TextObj _labelDetail;
-
-		/// <summary>
-		/// Private	field	that stores the	<see cref="ZedGraph.Fill"/> data for this
-		/// <see	cref="PieItem"/>.	 Use the public property <see	cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill _fill;
-
-		/// <summary>
-		/// Private	field	that stores the	<see cref="Border"/> class that defines	the
-		/// properties of the	border around	this <see cref="PieItem"/>. Use the public
-		/// property	<see cref="Border"/> to access this value.
-		/// </summary>
-		private Border _border;
-
-		/// <summary>
-		/// Private field that stores the absolute value of this <see cref="PieItem"/> instance.
-		/// Value will be set to zero if submitted value is less than zero. 
-		/// </summary>
-		private double _pieValue;
-
-		/// <summary>
-		/// An enum that specifies how each <see cref="CurveItem.Label"/> for this <see cref="PieItem"/> object 
-		/// will be displayed.  Use the public property <see cref="LabelType"/> to access this data.  
-		/// Use enum <see cref="ZedGraph.PieLabelType"/>.
-		/// </summary>
-		private PieLabelType _labelType;
-		/// <summary>
-		/// The point on the arc of this <see cref="PieItem"/> representing the intersection of
-		/// the arc and the explosion radius.
-		/// </summary>
-		private PointF _intersectionPoint;
-
-		/// <summary>
-		/// The bounding rectangle for this <see cref="PieItem"/>.
-		/// </summary>
-		private RectangleF _boundingRectangle;
-
-		/// <summary>
-		/// The formatted string for this <see cref="PieItem"/>'s label.  Formatting is
-		/// done based on  the <see cref="PieLabelType"/>.
-		/// </summary>
-		private string _labelStr;
-		/// <summary>
-		/// The point at which the line between this <see cref="PieItem"/> and its
-		/// label bends to the horizontal.
-		/// </summary>
-		private PointF _pivotPoint;
-		/// <summary>
-		/// The point at the end of the line between	this <see cref="PieItem"/> and 
-		/// it's label (i.e. the beginning of the label display)
-		/// </summary>
-		private PointF _endPoint;
-
-		/// <summary>
-		/// Private field to hold the GraphicsPath of this <see cref="PieItem"/> to be
-		/// used for 'hit testing'.
-		/// </summary>
-		private GraphicsPath _slicePath;
-
-		/// <summary>
-		/// Private field which holds the angle (in degrees) at which the display of this <see cref="PieItem"/>
-		/// object will begin.
-		/// </summary>
-		private float _startAngle;
-
-		/// <summary>
-		///Private field which holds the length (in degrees) of the arc representing this <see cref="PieItem"/> 
-		///object.
-		/// </summary>
-		private float _sweepAngle;
-
-		/// <summary>
-		///Private field which represents the angle (in degrees) of the radius along which this <see cref="PieItem"/>
-		///object will be displaced, if desired.
-		/// </summary>
-		private float _midAngle;
-
-		/// <summary>
-		///Private field which determines the number of decimal digits displayed to 
-		///in a <see cref="PieItem"/> label containing a value. 
-		/// </summary>
-		private int _valueDecimalDigits;
-
-		/// <summary>
-		///Private field which determines the number of decimal digits displayed 
-		///in a <see cref="PieItem"/> label containing a percent. 
-		/// </summary>
-		private int _percentDecimalDigits;
-
-		private static ColorSymbolRotator _rotator = new ColorSymbolRotator();
-
-		#endregion
-
-		#region Defaults
-		/// <summary>
-		/// Specify the default property values for the <see cref="PieItem"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			///Default <see cref="PieItem "/> displacement.
-			/// </summary>
-			public static double Displacement = 0;
-
-			/// <summary>
-			/// The default pen width	to be used for drawing the	border around	the PieItem
-			/// (<see cref="ZedGraph.LineBase.Width"/> property). Units are points.
-			/// </summary>
-			public static float BorderWidth = 1.0F;
-			/// <summary>
-			/// The default fill mode for this PieItem (<see	cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.Brush;
-			/// <summary>
-			/// The default border mode for PieItem (<see cref="ZedGraph.LineBase.IsVisible"/> property).
-			/// true to	display frame around PieItem, false otherwise
-			/// </summary>
-			public static bool IsBorderVisible = true;
-			/// <summary>
-			/// The default color for drawing	frames around	PieItem
-			/// (<see cref="ZedGraph.LineBase.Color"/> property).
-			/// </summary>
-			public static Color BorderColor = Color.Black;
-			/// <summary>
-			/// The default color for filling in	the PieItem
-			/// (<see cref="ZedGraph.Fill.Color"/>	property).
-			/// </summary>
-			public static Color FillColor = Color.Red;
-			/// <summary>
-			/// The default custom brush for filling in the PieItem.
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-
-			/// <summary>
-			///Default value for controlling <see cref="PieItem"/> display.
-			/// </summary>
-			public static bool isVisible = true;
-
-			/// <summary>
-			/// Default value for <see cref="PieItem.LabelType"/>.
-			/// </summary>
-			public static PieLabelType LabelType = PieLabelType.Name;
-
-			/// <summary>
-			/// The default font size for  <see cref="PieItem.LabelDetail"/> entries
-			/// (<see cref="ZedGraph.FontSpec.Size"/> property).  Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float FontSize = 10;
-
-			/// <summary>
-			/// Default value for the number of decimal digits  
-			/// to be displayed when <see cref="LabelType"/>  contains a value.
-			/// </summary>
-			public static int ValueDecimalDigits = 0;
-
-			/// <summary>
-			/// Default value for the number of decimal digits  
-			/// to be displayed where <see cref="LabelType"/> contains a percent.
-			/// </summary>
-			public static int PercentDecimalDigits = 2;
-		}
-		#endregion Defaults
-
-		#region PieItem Properties
-		/// <summary>
-		/// Gets or sets the a value which determines the amount, if any, of this <see cref="PieItem"/>  
-		/// displacement.
-		/// </summary>
-		public double Displacement
-		{
-			get { return ( _displacement ); }
-			set { _displacement = value > .5 ? .5 : value; }
-		}
-
-		/// <summary>
-		/// Gets a path representing this <see cref="PieItem"/>
-		/// </summary>
-		public GraphicsPath SlicePath
-		{
-			get { return _slicePath; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="TextObj"/> to be used
-		/// for displaying this <see cref="PieItem"/>'s label.
-		/// </summary>
-		public TextObj LabelDetail
-		{
-			get { return _labelDetail; }
-			set { _labelDetail = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="Border"/> object so as to be able to modify
-		/// its properties.
-		/// </summary>
-		public Border Border
-		{
-			get { return ( _border ); }
-			set { _border = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="Fill" /> object which is used to fill the
-		/// pie slice with color.
-		/// </summary>
-		public Fill Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the arc length (in degrees) of this <see cref="PieItem"/>.
-		/// </summary>
-		private float SweepAngle
-		{
-			get { return _sweepAngle; }
-			set { _sweepAngle = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the starting angle (in degrees) of this <see cref="PieItem"/>.
-		/// </summary>
-		private float StartAngle
-		{
-			get { return ( _startAngle ); }
-			set { _startAngle = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the angle (in degrees) of the radius along which 
-		/// this <see cref="PieItem"/> will be displaced.
-		/// </summary>
-		private float MidAngle
-		{
-			get { return ( _midAngle ); }
-			set { _midAngle = value; }
-		}
-
-		/// <summary>
-		///  Gets or sets the value of this <see cref="PieItem"/>.  
-		///  Minimum value is 0. 
-		/// </summary>
-		public double Value
-		{
-			get { return ( _pieValue ); }
-			set { _pieValue = value > 0 ? value : 0; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="PieLabelType"/> to be used in displaying 
-		/// <see cref="PieItem"/> labels.
-		/// </summary>
-		public PieLabelType LabelType
-		{
-			get { return ( _labelType ); }
-			set
-			{
-				_labelType = value;
-				if ( value == PieLabelType.None )
-					this.LabelDetail.IsVisible = false;
-				else
-					this.LabelDetail.IsVisible = true;
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets the number of decimal digits to be displayed in a <see cref="PieItem"/> 
-		/// value label.
-		/// </summary>
-		public int ValueDecimalDigits
-		{
-			get { return ( _valueDecimalDigits ); }
-			set { _valueDecimalDigits = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the number of decimal digits to be displayed in a <see cref="PieItem"/> 
-		/// percent label.
-		/// </summary>
-		public int PercentDecimalDigits
-		{
-			get { return ( _percentDecimalDigits ); }
-			set { _percentDecimalDigits = value; }
-		}
-
-		/*
-		/// <summary>
-		/// Getsor sets enum <see cref="PieType"/> to be used	for drawing this <see cref="PieItem"/>.
-		/// </summary>
-		public PieType PieType
-		{
-			get { return (this.pieType); }
-			set { this.pieType = value; }
-		}
- */
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return false;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return true;
-		}
-
-		#endregion
-
-		#region Constructors
-		/// <summary>
-		/// Create a new <see cref="PieItem"/>, providing a gradient fill for the pie color.
-		/// </summary>
-		/// <param name="pieValue">The value associated with this <see cref="PieItem"/> instance.</param>
-		/// <param name="color1">The starting display color for the gradient <see cref="Fill"/> for this
-		/// <see cref="PieItem"/> instance.</param>
-		/// <param name="color2">The ending display color for the gradient <see cref="Fill"/> for this
-		/// <see cref="PieItem"/> instance.</param>
-		/// <param name="fillAngle">The angle for the gradient <see cref="Fill"/>.</param>
-		/// <param name="displacement">The amount this <see cref="PieItem"/>  instance will be 
-		/// displaced from the center point.</param>
-		/// <param name="label">Text label for this <see cref="PieItem"/> instance.</param>
-		public PieItem( double pieValue, Color color1, Color color2, float fillAngle,
-						double displacement, string label )
-			:
-						this( pieValue, color1, displacement, label )
-		{
-			if ( !color1.IsEmpty && !color2.IsEmpty )
-				_fill = new Fill( color1, color2, fillAngle );
-		}
-
-		/// <summary>
-		/// Create a new <see cref="PieItem"/>.
-		/// </summary>
-		/// <param name="pieValue">The value associated with this <see cref="PieItem"/> instance.</param>
-		/// <param name="color">The display color for this <see cref="PieItem"/> instance.</param>
-		/// <param name="displacement">The amount this <see cref="PieItem"/>  instance will be 
-		/// displaced from the center point.</param>
-		/// <param name="label">Text label for this <see cref="PieItem"/> instance.</param>
-		public PieItem( double pieValue, Color color, double displacement, string label )
-			: base( label )
-		{
-			_pieValue = pieValue;
-			_fill = new Fill( color.IsEmpty ? _rotator.NextColor : color );
-			_displacement = displacement;
-			_border = new Border( Default.BorderColor, Default.BorderWidth );
-			_labelDetail = new TextObj();
-			_labelDetail.FontSpec.Size = Default.FontSize;
-			_labelType = Default.LabelType;
-			_valueDecimalDigits = Default.ValueDecimalDigits;
-			_percentDecimalDigits = Default.PercentDecimalDigits;
-			_slicePath = null;
-		}
-
-		/// <summary>
-		/// Create a  new <see cref="PieItem"/>.
-		/// </summary>
-		/// <param name="pieValue">The value associated with this <see cref="PieItem"/> instance.</param>
-		/// <param name="label">Text label for this <see cref="PieItem"/> instance</param>
-		public PieItem( double pieValue, string label )
-			:
-			this( pieValue, _rotator.NextColor, Default.Displacement, label )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="PieItem"/> object from which to copy</param>
-		public PieItem( PieItem rhs )
-			: base( rhs )
-		{
-			_pieValue = rhs._pieValue;
-			_fill = rhs._fill.Clone();
-			this.Border = rhs._border.Clone();
-			_displacement = rhs._displacement;
-			_labelDetail = rhs._labelDetail.Clone();
-			_labelType = rhs._labelType;
-			_valueDecimalDigits = rhs._valueDecimalDigits;
-			_percentDecimalDigits = rhs._percentDecimalDigits;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public PieItem Clone()
-		{
-			return new PieItem( this );
-		}
-
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PieItem( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_displacement = info.GetDouble( "displacement" );
-			_labelDetail = (TextObj)info.GetValue( "labelDetail", typeof( TextObj ) );
-			_fill = (Fill)info.GetValue( "fill", typeof( Fill ) );
-			_border = (Border)info.GetValue( "border", typeof( Border ) );
-			_pieValue = info.GetDouble( "pieValue" );
-			_labelType = (PieLabelType)info.GetValue( "labelType", typeof( PieLabelType ) );
-			_intersectionPoint = (PointF)info.GetValue( "intersectionPoint", typeof( PointF ) );
-			_boundingRectangle = (RectangleF)info.GetValue( "boundingRectangle", typeof( RectangleF ) );
-			_pivotPoint = (PointF)info.GetValue( "pivotPoint", typeof( PointF ) );
-			_endPoint = (PointF)info.GetValue( "endPoint", typeof( PointF ) );
-			// _slicePath = (GraphicsPath)info.GetValue( "slicePath", typeof( GraphicsPath ) );
-			_startAngle = (float)info.GetDouble( "startAngle" );
-			_sweepAngle = (float)info.GetDouble( "sweepAngle" );
-			_midAngle = (float)info.GetDouble( "midAngle" );
-			_labelStr = info.GetString( "labelStr" );
-			_valueDecimalDigits = info.GetInt32( "valueDecimalDigits" );
-			_percentDecimalDigits = info.GetInt32( "percentDecimalDigits" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "displacement", _displacement );
-			info.AddValue( "labelDetail", _labelDetail );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "pieValue", _pieValue );
-			info.AddValue( "labelType", _labelType );
-			info.AddValue( "intersectionPoint", _intersectionPoint );
-			info.AddValue( "boundingRectangle", _boundingRectangle );
-			info.AddValue( "pivotPoint", _pivotPoint );
-			info.AddValue( "endPoint", _endPoint );
-			// info.AddValue( "slicePath", _slicePath );
-			info.AddValue( "startAngle", _startAngle );
-			info.AddValue( "sweepAngle", _sweepAngle );
-			info.AddValue( "midAngle", _midAngle );
-			info.AddValue( "labelStr", _labelStr );
-			info.AddValue( "valueDecimalDigits", _valueDecimalDigits );
-			info.AddValue( "percentDecimalDigits", _percentDecimalDigits );
-		}
-
-		#endregion
-
-		#region Methods
-		/// <summary>
-		/// Do all rendering associated with this <see cref="PieItem"/> item to the specified
-		/// <see cref="Graphics"/> device.  This method is normally only
-		/// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
-		/// collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="pos">Not used for rendering Pies</param>param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>				
-		override public void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor )
-		{
-			if ( pane.Chart._rect.Width <= 0 && pane.Chart._rect.Height <= 0 )
-			{
-				//pane.PieRect = RectangleF.Empty;
-				_slicePath = null;
-			}
-			else
-			{
-				//pane.PieRect = CalcPieRect( g, pane, scaleFactor, pane.ChartRect );
-				CalcPieRect( g, pane, scaleFactor, pane.Chart._rect );
-
-				_slicePath = new GraphicsPath();
-
-				if ( !_isVisible )
-					return;
-
-				RectangleF tRect = _boundingRectangle;
-
-				if ( tRect.Width >= 1 && tRect.Height >= 1 )
-				{
-					SmoothingMode sMode = g.SmoothingMode;
-					g.SmoothingMode = SmoothingMode.AntiAlias;
-
-					Fill tFill = _fill;
-					Border tBorder = _border;
-					if ( this.IsSelected )
-					{
-						tFill = Selection.Fill;
-						tBorder = Selection.Border;
-					}
-
-					using ( Brush brush = tFill.MakeBrush( _boundingRectangle ) )
-					{
-						g.FillPie( brush, tRect.X, tRect.Y, tRect.Width, tRect.Height, this.StartAngle, this.SweepAngle );
-
-						//add GraphicsPath for hit testing
-						_slicePath.AddPie( tRect.X, tRect.Y, tRect.Width, tRect.Height,
-							this.StartAngle, this.SweepAngle );
-
-						if ( this.Border.IsVisible )
-						{
-							using ( Pen borderPen = tBorder.GetPen( pane, scaleFactor ) )
-							{
-								g.DrawPie( borderPen, tRect.X, tRect.Y, tRect.Width, tRect.Height,
-									this.StartAngle, this.SweepAngle );
-							}
-						}
-
-						if ( _labelType != PieLabelType.None )
-							DrawLabel( g, pane, tRect, scaleFactor );
-
-						//brush.Dispose();
-					}
-
-					g.SmoothingMode = sMode;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Calculate the <see cref="RectangleF"/> that will be used to define the bounding rectangle of
-		/// the Pie.
-		/// </summary>
-		/// <remarks>This rectangle always lies inside of the <see cref="Chart.Rect"/>, and it is
-		/// normally a square so that the pie itself is not oval-shaped.</remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>				
-		/// <param name="chartRect">The <see cref="RectangleF"/> (normally the <see cref="Chart.Rect"/>)
-		/// that bounds this pie.</param>
-		/// <returns></returns>
-		public static RectangleF CalcPieRect( Graphics g, GraphPane pane, float scaleFactor, RectangleF chartRect )
-		{
-			//want to draw the largest pie possible within ChartRect
-			//but want to leave  5% slack around the pie so labels will not overrun clip area
-			//largest pie is limited by the smaller of ChartRect.height or ChartRect.width...
-			//this rect (nonExplRect)has to be re-positioned so that it's in the center of ChartRect.
-			//Where ChartRect is almost a square - low Aspect Ratio -, need to contract pieRect so that there's some
-			//room for labels, if they're visible.
-			double maxDisplacement = 0;
-			RectangleF tempRect;   //= new RectangleF(0,0,0,0);
-
-			RectangleF nonExplRect = chartRect;
-
-			if ( pane.CurveList.IsPieOnly )
-			{
-				if ( nonExplRect.Width < nonExplRect.Height )
-				{
-					//create slack rect
-					nonExplRect.Inflate( -(float)0.05F * nonExplRect.Height, -(float)0.05F * nonExplRect.Width );
-					//get the difference between dimensions
-					float delta = ( nonExplRect.Height - nonExplRect.Width ) / 2;
-					//make a square	so we end up with circular pie
-					nonExplRect.Height = nonExplRect.Width;
-					//keep the center point  the same
-					nonExplRect.Y += delta;
-				}
-				else
-				{
-					nonExplRect.Inflate( -(float)0.05F * nonExplRect.Height, -(float)0.05F * nonExplRect.Width );
-					float delta = ( nonExplRect.Width - nonExplRect.Height ) / 2;
-					nonExplRect.Width = nonExplRect.Height;
-					nonExplRect.X += delta;
-				}
-				//check aspect ratio
-				double aspectRatio = chartRect.Width / chartRect.Height;
-				//make an adjustment in rect size,as aspect ratio varies
-				if ( aspectRatio < 1.5 )
-					nonExplRect.Inflate( -(float)( .1 * ( 1.5 / aspectRatio ) * nonExplRect.Width ),
-											-(float)( .1 * ( 1.5 / aspectRatio ) * nonExplRect.Width ) );
-
-				//modify the rect to determine if any of the labels need to be wrapped....
-				//first see if there's any exploded slices and if so, what's the max displacement...
-				//also, might as well get all the display params we can
-				PieItem.CalculatePieChartParams( pane, ref maxDisplacement );
-
-				if ( maxDisplacement != 0 )			 //need new rectangle if any slice exploded	
-					CalcNewBaseRect( maxDisplacement, ref nonExplRect );
-
-				foreach ( PieItem slice in pane.CurveList )
-				{
-					slice._boundingRectangle = nonExplRect;
-					//if exploded, need to re-calculate rectangle for slice
-					if ( slice.Displacement != 0 )
-					{
-						tempRect = nonExplRect;
-						slice.CalcExplodedRect( ref tempRect );
-						slice._boundingRectangle = tempRect;
-					}
-					//now get all the other slice specific drawing details, including need for wrapping label
-					slice.DesignLabel( g, pane, slice._boundingRectangle, scaleFactor );
-				}
-			}
-			return nonExplRect;
-		}
-
-		/// <summary>
-		/// Recalculate the bounding rectangle when a piee slice is displaced.
-		/// </summary>
-		/// <param name="explRect">rectangle to be used for drawing exploded pie</param>
-		private void CalcExplodedRect( ref RectangleF explRect )
-		{
-			//pie exploded out along the slice bisector - modify upper left of bounding rect to account for displacement
-			//keep height and width same
-			explRect.X += (float)( this.Displacement * explRect.Width / 2 * Math.Cos( _midAngle * Math.PI / 180 ) );
-			explRect.Y += (float)( this.Displacement * explRect.Height / 2 * Math.Sin( _midAngle * Math.PI / 180 ) );
-		}
-
-		/// <summary>
-		/// Calculate the values needed to properly display this <see cref="PieItem"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="maxDisplacement">maximum slice displacement</param>
-		private static void CalculatePieChartParams( GraphPane pane, ref double maxDisplacement )
-		{
-			string lblStr = " ";
-
-			//loop thru slices and get total value and maxDisplacement
-			double pieTotalValue = 0;
-			foreach ( PieItem curve in pane.CurveList )
-				if ( curve.IsPie )
-				{
-					pieTotalValue += curve._pieValue;
-					if ( curve.Displacement > maxDisplacement )
-						maxDisplacement = curve.Displacement;
-				}
-
-			double nextStartAngle = 0;
-			//now loop thru and calculate the various angle values
-			foreach ( PieItem curve in pane.CurveList )
-			{
-				lblStr = curve._labelStr;
-				curve.StartAngle = (float)nextStartAngle;
-				curve.SweepAngle = (float)( 360 * curve.Value / pieTotalValue );
-				curve.MidAngle = curve.StartAngle + curve.SweepAngle / 2;
-				nextStartAngle = curve._startAngle + curve._sweepAngle;
-				PieItem.BuildLabelString( curve );
-			}
-		}
-
-		/// <summary>
-		/// Render the label for this <see cref="PieItem"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">Bounding rectangle for this <see cref="PieItem"/>.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>				
-		public void DrawLabel( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			if ( !_labelDetail.IsVisible )
-				return;
-
-			using ( Pen labelPen = this.Border.GetPen( pane, scaleFactor ) )
-			{
-				//draw line from intersection point to pivot point -
-				g.DrawLine( labelPen, _intersectionPoint, _pivotPoint );
-
-				//draw horizontal line to move label away from pie...
-				g.DrawLine( labelPen, _pivotPoint, _endPoint );
-			}
-
-			//draw the label (TextObj)
-			_labelDetail.Draw( g, pane, scaleFactor );
-		}
-
-		/// <summary>
-		/// This method collects all the data relative to rendering this <see cref="PieItem"/>'s label.
-		/// </summary>
-		/// <param name="g">
-		///  A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="rect">The rectangle used for rendering this <see cref="PieItem"/>
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public void DesignLabel( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			if ( !_labelDetail.IsVisible )
-				return;
-
-			_labelDetail.LayoutArea = new SizeF();
-			//this.labelDetail.IsWrapped = false;
-
-			//label line will come off the explosion radius and then pivot to the horizontal right or left,
-			//dependent on position.. 
-			//text will be at the end of horizontal segment...
-			CalculateLinePoints( rect, _midAngle );
-
-			//now get size of bounding rect for label
-			SizeF size = _labelDetail.FontSpec.BoundingBox( g, _labelStr, scaleFactor );
-
-			//how much room left for the label - most likely midangles for wrapping
-			//Right - 315 -> 45 degrees
-			//Bottom - 45 -> 135
-			//Left - 135 -> 225
-			//Top - 225 -> 315
-			RectangleF chartRect = pane.Chart._rect;
-			float fill = 0;
-			if ( _midAngle > 315 || _midAngle <= 45 )
-			{
-				//correct by wrapping text
-				fill = chartRect.X + chartRect.Width - _endPoint.X - 5;
-				if ( size.Width > fill )
-				{
-					//need to wrap, so create label rectangle for overloaded DrawString - two rows, max
-					_labelDetail.LayoutArea = new SizeF( fill, size.Height * 3.0F );
-				}
-			}
-
-			if ( _midAngle > 45 && _midAngle <= 135 )
-			{
-				//correct by moving radial line toward one or the other end of the range
-				fill = chartRect.Y + chartRect.Height - _endPoint.Y - 5;
-				//is there enuf room for the label
-				if ( size.Height / 2 > fill )
-				{
-					//no, so got to move explosion radius
-					if ( _midAngle > 90 )	//move _label clockwise one-third of way to the end of the arc
-						CalculateLinePoints( rect, _midAngle + ( _sweepAngle + _startAngle - _midAngle ) / 3 );
-					else						//move _label counter-clockwise one-third of way to the start of the arc
-						CalculateLinePoints( rect, _midAngle - ( _midAngle - ( _midAngle - _startAngle ) / 3 ) );
-				}
-			}
-
-			if ( _midAngle > 135 && _midAngle <= 225 )
-			{
-				//wrap text 
-				fill = _endPoint.X - chartRect.X - 5;
-				//need to wrap, so create label rectangle for overloaded DrawString - two rows, max
-				if ( size.Width > fill )
-				{
-					_labelDetail.LayoutArea = new SizeF( fill, size.Height * 3.0F );
-				}
-			}
-
-			if ( _midAngle > 225 && _midAngle <= 315 )
-			{
-				//correct by moving radial line toward one or the other end of the range
-				fill = _endPoint.Y - 5 - chartRect.Y;
-				//is there enuf room for the label
-				if ( size.Height / 2 > fill )
-				{
-					//no, so got to move explosion radius
-					if ( _midAngle < 270 )	//move _label counter-clockwise one-third of way to the start of the arc
-						CalculateLinePoints( rect, _midAngle - ( _sweepAngle + _startAngle - _midAngle ) / 3 );
-					else						//move _label clockwise one-third of way to the end of the arc
-						CalculateLinePoints( rect, _midAngle + ( _midAngle - _startAngle ) / 3 );
-				}
-			}
-
-			//complete the location Detail info
-			_labelDetail.Location.AlignV = AlignV.Center;
-			_labelDetail.Location.CoordinateFrame = CoordType.PaneFraction;
-			_labelDetail.Location.X = ( _endPoint.X - pane.Rect.X ) / pane.Rect.Width;
-			_labelDetail.Location.Y = ( _endPoint.Y - pane.Rect.Y ) / pane.Rect.Height;
-			_labelDetail.Text = _labelStr;
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="rect"></param>
-		/// <param name="midAngle"></param>
-		private void CalculateLinePoints( RectangleF rect, double midAngle )
-		{
-			//get the point where the explosion radius intersects the this arc
-			PointF rectCenter = new PointF( ( rect.X + rect.Width / 2 ), ( rect.Y + rect.Height / 2 ) );
-
-			_intersectionPoint = new PointF( (float)( rectCenter.X + ( rect.Width / 2 * Math.Cos( ( midAngle ) * Math.PI / 180 ) ) ),
-				(float)( rectCenter.Y + ( rect.Height / 2 * Math.Sin( ( midAngle ) * Math.PI / 180 ) ) ) );
-
-			//draw line from intersection point to pivot point - length to be .05 * pieRect.Width pixels long
-			_pivotPoint = new PointF( (float)( _intersectionPoint.X + .05 * rect.Width * Math.Cos( ( midAngle ) * Math.PI / 180 ) ),
-				(float)( _intersectionPoint.Y + .05 * rect.Width * Math.Sin( ( midAngle ) * Math.PI / 180 ) ) );
-
-			//add horizontal line to move label away from pie...length to be 5% of rect.Width
-			//does line go to left or right....label alignment is to the opposite
-			if ( _pivotPoint.X >= rectCenter.X )		//goes to right
-			{
-				_endPoint = new PointF( (float)( _pivotPoint.X + .05 * rect.Width ), _pivotPoint.Y );
-				_labelDetail.Location.AlignH = AlignH.Left;
-			}
-			else
-			{
-				_endPoint = new PointF( (float)( _pivotPoint.X - .05 * rect.Width ), _pivotPoint.Y );
-				_labelDetail.Location.AlignH = AlignH.Right;
-			}
-			_midAngle = (float)midAngle;
-		}
-
-		/// <summary>
-		/// Build the string that will be displayed as the slice label as determined by 
-		/// <see cref="LabelType"/>.
-		/// </summary>
-		/// <param name="curve">reference to the <see cref="PieItem"/></param>
-		private static void BuildLabelString( PieItem curve )
-		{
-			//set up label string formatting
-			NumberFormatInfo labelFormat = (NumberFormatInfo)NumberFormatInfo.CurrentInfo.Clone();
-
-			labelFormat.NumberDecimalDigits = curve._valueDecimalDigits;
-			labelFormat.PercentPositivePattern = 1;					//no space between number and % sign
-			labelFormat.PercentDecimalDigits = curve._percentDecimalDigits;
-
-			switch ( curve._labelType )
-			{
-				case PieLabelType.Value:
-					curve._labelStr = curve._pieValue.ToString( "F", labelFormat );
-					break;
-				case PieLabelType.Percent:
-					curve._labelStr = ( curve._sweepAngle / 360 ).ToString( "P", labelFormat );
-					break;
-				case PieLabelType.Name_Value:
-					curve._labelStr = curve._label._text + ": " + curve._pieValue.ToString( "F", labelFormat );
-					break;
-				case PieLabelType.Name_Percent:
-					curve._labelStr = curve._label._text + ": " + ( curve._sweepAngle / 360 ).ToString( "P", labelFormat );
-					break;
-				case PieLabelType.Name_Value_Percent:
-					curve._labelStr = curve._label._text + ": " + curve._pieValue.ToString( "F", labelFormat ) +
-						" (" + ( curve._sweepAngle / 360 ).ToString( "P", labelFormat ) + ")";
-					break;
-				case PieLabelType.Name:
-					curve._labelStr = curve._label._text;
-					break;
-				case PieLabelType.None:
-				default:
-					break;
-			}
-		}
-
-		/// <summary>
-		/// A method which calculates a new size for the bounding rectangle for the non-displaced 
-		/// <see cref="PieItem"/>'s in the pie chart.  This method is called after it is found
-		/// that at least one slice is displaced.
-		/// </summary>
-		/// <param name="maxDisplacement">The biggest displacement among the <see cref="PieItem"/>s
-		/// making up the pie chart.</param>
-		/// <param name="baseRect">The current bounding rectangle</param>
-		private static void CalcNewBaseRect( double maxDisplacement, ref RectangleF baseRect )
-		{
-			//displacement expressed in terms of % of pie radius	...do not want exploded slice to 
-			//go beyond nonExplRect, but want to maintain the same center point...therefore, got to 
-			//reduce the diameter of the nonexploded pie by the alue of the displacement
-
-			float xDispl = (float)( ( maxDisplacement * baseRect.Width ) );
-			float yDispl = (float)( ( maxDisplacement * baseRect.Height ) );
-
-			baseRect.Inflate( -(float)( ( xDispl / 10 ) ), -(float)( ( xDispl / 10 ) ) );
-		}
-
-		/// <summary>
-		/// Draw a legend key entry for this <see cref="PieItem"/> at the specified location
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
-		/// location for the legend key</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
-		{
-			if ( !_isVisible )
-				return;
-
-			// Fill the slice
-			if ( _fill.IsVisible )
-			{
-				// just avoid height/width being less than 0.1 so GDI+ doesn't cry
-				using ( Brush brush = _fill.MakeBrush( rect ) )
-				{
-					g.FillRectangle( brush, rect );
-					//brush.Dispose();
-				}
-			}
-
-			// Border the bar
-			if ( !_border.Color.IsEmpty )
-				_border.Draw( g, pane, scaleFactor, rect );
-		}
-
-		/// <summary>
-		/// Determine the coords for the rectangle associated with a specified point for 
-		/// this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
-		/// <param name="i">The index of the point of interest</param>
-		/// <param name="coords">A list of coordinates that represents the "rect" for
-		/// this point (used in an html AREA tag)</param>
-		/// <returns>true if it's a valid point, false otherwise</returns>
-		override public bool GetCoords( GraphPane pane, int i, out string coords )
-		{
-			coords = string.Empty;
-
-			PointF pt = _boundingRectangle.Location;
-			pt.X += _boundingRectangle.Width / 2.0f;
-			pt.Y += _boundingRectangle.Height / 2.0f;
-
-			float radius = _boundingRectangle.Width / 2.0f;
-			Matrix matrix = new Matrix();
-
-			// Move the coordinate system to local coordinates
-			// of this text object (that is, at the specified
-			// x,y location)
-			matrix.Translate( pt.X, pt.Y );
-
-			matrix.Rotate( this.StartAngle );
-			//One mark every 5'ish degrees
-			int count = (int)Math.Floor ( SweepAngle / 5 ) + 1;
-			PointF[] pts = new PointF[2 + count];
-			pts[0] = new PointF( 0, 0 );
-			pts[1] = new PointF( radius, 0 );
-			double angle = 0.0;
-			for ( int j = 2; j < count + 2; j++ )
-			{
-				angle += SweepAngle / count;
-
-				pts[j] = new PointF(radius * (float)Math.Cos(angle * Math.PI / 180.0),
-											radius * (float)Math.Sin( angle * Math.PI / 180.0 ) );
-			}
-
-			matrix.TransformPoints( pts );
-
-			coords = String.Format("{0:f0},{1:f0},{2:f0},{3:f0},",
-						pts[0].X, pts[0].Y, pts[1].X, pts[1].Y );
-			for (int j = 2; j < count + 2; j++)
-				coords += String.Format(j > count ? "{0:f0},{1:f0}" : "{0:f0},{1:f0},", pts[j].X, pts[j].Y);
-
-			return true;
-		}
-
-		#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PointD.cs b/BDInfo/ZedGraph/PointD.cs
deleted file mode 100644
index 7cb381a535..0000000000
--- a/BDInfo/ZedGraph/PointD.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Simple struct that stores X and Y coordinates as doubles.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	[Serializable]
-	public struct PointD
-	{
-		/// <summary>
-		/// The X coordinate
-		/// </summary>
-		public double X;
-		/// <summary>
-		/// The Y coordinate
-		/// </summary>
-		public double Y;
-
-		/// <summary>
-		/// Construct a <see cref="PointD" /> object from two double values.
-		/// </summary>
-		/// <param name="x">The X coordinate</param>
-		/// <param name="y">The Y coordinate</param>
-		public PointD( double x, double y )
-		{
-			X = x;
-			Y = y;
-		}
-	}
-}
-
diff --git a/BDInfo/ZedGraph/PointPair.cs b/BDInfo/ZedGraph/PointPair.cs
deleted file mode 100644
index 3a80d259de..0000000000
--- a/BDInfo/ZedGraph/PointPair.cs
+++ /dev/null
@@ -1,562 +0,0 @@
-//============================================================================
-//PointPair Class
-//Copyright © 2004  Jerry Vos
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using System.Collections;
-using IComparer	= System.Collections.IComparer;
-
-#if ( !DOTNET1 )	// Is this a .Net 2 compilation?
-using System.Collections.Generic;
-#endif
-
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A simple point represented by an (X,Y,Z) group of double values.
-	/// </summary>
-	/// 
-	/// <author> Jerry Vos modified by John Champion </author>
-	/// <version> $Revision: 3.26 $ $Date: 2007/11/28 02:38:22 $ </version>
-	[Serializable]
-	public class PointPair : PointPairBase, ISerializable, ICloneable
-	{
-	#region Member variables
-		
-		/// <summary>
-		/// This PointPair's Z coordinate.  Also used for the lower value (dependent axis)
-		/// for <see cref="HiLowBarItem"/> and <see cref="ErrorBarItem" /> charts.
-		/// </summary>
-		public double Z;
-
-		/// <summary>
-		/// A tag object for use by the user.  This can be used to store additional
-		/// information associated with the <see cref="PointPair"/>.  ZedGraph never
-		/// modifies this value, but if it is a <see cref="String"/> type, it
-		/// may be displayed in a <see cref="System.Windows.Forms.ToolTip"/>
-		/// within the <see cref="ZedGraphControl"/> object.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if you are going to Serialize ZedGraph data, then any type
-		/// that you store in <see cref="Tag"/> must be a serializable type (or
-		/// it will cause an exception).
-		/// </remarks>
-		public object Tag;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public PointPair() : this( 0, 0, 0, null )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X and Y.
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		public PointPair( double x, double y )
-			: this ( x, y, 0, null )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, and
-		/// label (<see cref="Tag"/>).
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="label">This pair's string label (<see cref="Tag"/>)</param>
-		public PointPair( double x, double y, string label )
-			: this( x, y, 0, label as object )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, and base value.
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z or lower dependent coordinate.</param>
-		public PointPair( double x, double y, double z )
-			: this( x, y, z, null )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, base value, and
-		/// string label (<see cref="Tag"/>).
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z or lower dependent coordinate.</param>
-		/// <param name="label">This pair's string label (<see cref="Tag"/>)</param>
-		public PointPair( double x, double y, double z, string label )
-			: this( x, y, z, label as object )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, base value, and
-		/// (<see cref="Tag"/>).
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z or lower dependent coordinate.</param>
-		/// <param name="tag">This pair's <see cref="Tag"/> property</param>
-		public PointPair( double x, double y, double z, object tag )
-			: base( x, y )
-		{
-			this.Z = z;
-			this.Tag = tag;
-		}
-
-		/// <summary>
-		/// Creates a point pair from the specified <see cref="PointF"/> struct.
-		/// </summary>
-		/// <param name="pt">The <see cref="PointF"/> struct from which to get the
-		/// new <see cref="PointPair"/> values.</param>
-		public PointPair( PointF pt ) : this( pt.X, pt.Y, 0, null )
-		{
-		}
-
-		/// <summary>
-		/// The PointPair copy constructor.
-		/// </summary>
-		/// <param name="rhs">The basis for the copy.</param>
-		public PointPair( PointPair rhs ) : base( rhs )
-		{
-			this.Z = rhs.Z;
-
-			if ( rhs.Tag is ICloneable )
-				this.Tag = ((ICloneable) rhs.Tag).Clone();
-			else
-				this.Tag = rhs.Tag;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public PointPair Clone()
-		{
-			return new PointPair( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PointPair( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			Z = info.GetDouble( "Z" );
-			Tag = info.GetValue( "Tag", typeof(object) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "Z", Z );
-			info.AddValue( "Tag", Tag );
-		}
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Readonly value that determines if either the X, Y, or Z
-		/// coordinate in this PointPair is an invalid (not plotable) value.
-		/// It is considered invalid if it is missing (equal to System.Double.Max),
-		/// Infinity, or NaN.
-		/// </summary>
-		/// <returns>true if any value is invalid</returns>
-		public bool IsInvalid3D
-		{
-			get { return	this.X == PointPair.Missing ||
-							this.Y == PointPair.Missing ||
-							this.Z == PointPair.Missing ||
-							Double.IsInfinity( this.X ) ||
-							Double.IsInfinity( this.Y ) ||
-							Double.IsInfinity( this.Z ) ||
-							Double.IsNaN( this.X ) ||
-							Double.IsNaN( this.Y ) ||
-							Double.IsNaN( this.Z );
-				}
-		}
-
-		/// <summary>
-		/// The "low" value for this point (lower dependent-axis value).
-		/// This is really just an alias for <see cref="PointPair.Z"/>.
-		/// </summary>
-		/// <value>The lower dependent value for this <see cref="PointPair"/>.</value>
-		public double LowValue
-		{
-			get { return this.Z; }
-			set { this.Z = value; }
-		}
-
-		/// <summary>
-		/// The ColorValue property is just an alias for the <see cref="PointPair.Z" />
-		/// property.
-		/// </summary>
-		/// <remarks>
-		/// For other types, such as the <see cref="StockPt"/>, the <see cref="StockPt" />
-		/// can be mapped to a unique value.  This is used with the
-		/// <see cref="FillType.GradientByColorValue" /> option.
-		/// </remarks>
-		virtual public double ColorValue
-		{
-			get { return Z; }
-			set { Z = value; }
-		}
-
-	#endregion
-
-	#region Inner classes
-
-	#if ( DOTNET1 )	// Is this a .Net 1.1 compilation?
-
-		/// <summary>
-		/// Compares points based on their y values.  Is setup to be used in an
-		/// ascending order sort.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class PointPairComparerY : IComparer
-		{
-		
-			/// <summary>
-			/// Compares two <see cref="PointPair"/>s.
-			/// </summary>
-			/// <param name="l">Point to the left.</param>
-			/// <param name="r">Point to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.Y's relation to r.Y</returns>
-			public int Compare( object l, object r ) 
-			{
-				PointPair pl = (PointPair) l;
-				PointPair pr = (PointPair) r;
-
-				if (pl == null && pr == null) 
-				{
-					return 0;
-				} 
-				else if (pl == null && pr != null) 
-				{
-					return -1;
-				} 
-				else if (pl != null && pr == null) 
-				{
-					return 1;
-				} 
-
-				double lY = pl.Y;
-				double rY = pr.Y;
-
-				if (System.Math.Abs(lY - rY) < .000000001)
-					return 0;
-				
-				return lY < rY ? -1 : 1;
-			}
-		}
-	
-		/// <summary>
-		/// Compares points based on their x values.  Is setup to be used in an
-		/// ascending order sort.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class PointPairComparer : IComparer
-		{
-			private SortType sortType;
-			
-			/// <summary>
-			/// Constructor for PointPairComparer.
-			/// </summary>
-			/// <param name="type">The axis type on which to sort.</param>
-			public PointPairComparer( SortType type )
-			{
-				this.sortType = type;
-			}
-			
-			/// <summary>
-			/// Compares two <see cref="PointPair"/>s.
-			/// </summary>
-			/// <param name="l">Point to the left.</param>
-			/// <param name="r">Point to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.X's relation to r.X</returns>
-			public int Compare( object l, object r ) 
-			{				 
-				PointPair pl = (PointPair) l;
-				PointPair pr = (PointPair) r;
-
-				if ( pl == null && pr == null ) 
-					return 0;
-				else if ( pl == null && pr != null ) 
-					return -1;
-				else if ( pl != null && pr == null ) 
-					return 1;
-
-				double lVal, rVal;
-			
-				if ( sortType == SortType.XValues )
-				{
-					lVal = pl.X;
-					rVal = pr.X;
-				}
-				else
-				{
-					lVal = pl.Y;
-					rVal = pr.Y;
-				}
-				
-				if ( lVal == PointPair.Missing || Double.IsInfinity( lVal ) || Double.IsNaN( lVal ) )
-					pl = null;
-				if ( rVal == PointPair.Missing || Double.IsInfinity( rVal ) || Double.IsNaN( rVal ) )
-					pr = null;
-
-				if ( ( pl == null && pr == null ) || ( System.Math.Abs( lVal - rVal ) < 1e-10 ) )
-					return 0;
-				else if ( pl == null && pr != null ) 
-					return -1;
-				else if ( pl != null && pr == null ) 
-					return 1;
-				else
-					return lVal < rVal ? -1 : 1;
-			}
-		}
-	
-	#else		// Otherwise, it's .Net 2.0, so use generics
-
-		/// <summary>
-		/// Compares points based on their y values.  Is setup to be used in an
-		/// ascending order sort.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class PointPairComparerY : IComparer<PointPair>
-		{
-
-			/// <summary>
-			/// Compares two <see cref="PointPair"/>s.
-			/// </summary>
-			/// <param name="l">Point to the left.</param>
-			/// <param name="r">Point to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.Y's relation to r.Y</returns>
-			public int Compare( PointPair l, PointPair r )
-			{
-				if ( l == null && r == null )
-				{
-					return 0;
-				}
-				else if ( l == null && r != null )
-				{
-					return -1;
-				}
-				else if ( l != null && r == null )
-				{
-					return 1;
-				}
-
-				double lY = l.Y;
-				double rY = r.Y;
-
-				if ( System.Math.Abs( lY - rY ) < .000000001 )
-					return 0;
-
-				return lY < rY ? -1 : 1;
-			}
-		}
-
-		/// <summary>
-		/// Compares points based on their x values.  Is setup to be used in an
-		/// ascending order sort.
-		/// <seealso cref="System.Collections.ArrayList.Sort()"/>
-		/// </summary>
-		public class PointPairComparer : IComparer<PointPair>
-		{
-			private SortType sortType;
-
-			/// <summary>
-			/// Constructor for PointPairComparer.
-			/// </summary>
-			/// <param name="type">The axis type on which to sort.</param>
-			public PointPairComparer( SortType type )
-			{
-				this.sortType = type;
-			}
-
-			/// <summary>
-			/// Compares two <see cref="PointPair"/>s.
-			/// </summary>
-			/// <param name="l">Point to the left.</param>
-			/// <param name="r">Point to the right.</param>
-			/// <returns>-1, 0, or 1 depending on l.X's relation to r.X</returns>
-			public int Compare( PointPair l, PointPair r )
-			{
-				if ( l == null && r == null )
-					return 0;
-				else if ( l == null && r != null )
-					return -1;
-				else if ( l != null && r == null )
-					return 1;
-
-				double lVal, rVal;
-
-				if ( sortType == SortType.XValues )
-				{
-					lVal = l.X;
-					rVal = r.X;
-				}
-				else
-				{
-					lVal = l.Y;
-					rVal = r.Y;
-				}
-
-				if ( lVal == PointPair.Missing || Double.IsInfinity( lVal ) || Double.IsNaN( lVal ) )
-					l = null;
-				if ( rVal == PointPair.Missing || Double.IsInfinity( rVal ) || Double.IsNaN( rVal ) )
-					r = null;
-
-				if ( ( l == null && r == null ) || ( System.Math.Abs( lVal - rVal ) < 1e-100 ) )
-					return 0;
-				else if ( l == null && r != null )
-					return -1;
-				else if ( l != null && r == null )
-					return 1;
-				else
-					return lVal < rVal ? -1 : 1;
-			}
-		}
-
-	#endif
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Compare two <see cref="PointPair"/> objects for equality.  To be equal, X, Y, and Z
-		/// must be exactly the same between the two objects.
-		/// </summary>
-		/// <param name="obj">The <see cref="PointPair"/> object to be compared with.</param>
-		/// <returns>true if the <see cref="PointPair"/> objects are equal, false otherwise</returns>
-		public override bool Equals( object obj )
-		{
-			PointPair rhs = obj as PointPair;
-			return this.X == rhs.X && this.Y == rhs.Y && this.Z == rhs.Z;
-		}
-
-		/// <summary>
-		/// Return the HashCode from the base class.
-		/// </summary>
-		/// <returns></returns>
-		public override int GetHashCode()
-		{
-			return base.GetHashCode();
-		}
-
-		/// <summary>
-		/// Format this PointPair value using the default format.  Example:  "( 12.345, -16.876 )".
-		/// The two double values are formatted with the "g" format type.
-		/// </summary>
-		/// <param name="isShowZ">true to show the third "Z" or low dependent value coordinate</param>
-		/// <returns>A string representation of the PointPair</returns>
-		virtual public string ToString( bool isShowZ )
-		{
-			return this.ToString( PointPair.DefaultFormat, isShowZ );
-		}
-
-		/// <summary>
-		/// Format this PointPair value using a general format string.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// If <see paramref="isShowZ"/>
-		/// is true, then the third "Z" coordinate is also shown.
-		/// </summary>
-		/// <param name="format">A format string that will be used to format each of
-		/// the two double type values (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		/// <param name="isShowZ">true to show the third "Z" or low dependent value coordinate</param>
-		virtual public string ToString( string format, bool isShowZ )
-		{
-			return "( " + this.X.ToString( format ) +
-					", " + this.Y.ToString( format ) + 
-					( isShowZ ? ( ", " + this.Z.ToString( format ) ) : "" )
-					+ " )";
-		}
-
-		/// <summary>
-		/// Format this PointPair value using different general format strings for the X, Y, and Z values.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// </summary>
-		/// <param name="formatX">A format string that will be used to format the X
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatY">A format string that will be used to format the Y
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatZ">A format string that will be used to format the Z
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		public string ToString( string formatX, string formatY, string formatZ )
-		{
-			return "( " + this.X.ToString( formatX ) +
-					", " + this.Y.ToString( formatY ) + 
-					", " + this.Z.ToString( formatZ ) + 
-					" )";
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PointPair4.cs b/BDInfo/ZedGraph/PointPair4.cs
deleted file mode 100644
index ebe33225d3..0000000000
--- a/BDInfo/ZedGraph/PointPair4.cs
+++ /dev/null
@@ -1,218 +0,0 @@
-//============================================================================
-//PointPair4 Class
-//Copyright © 2006  Jerry Vos & John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using IComparer = System.Collections.IComparer;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The basic <see cref="PointPair" /> class holds three data values (X, Y, Z).  This
-	/// class extends the basic PointPair to contain four data values (X, Y, Z, T).
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.3 $ $Date: 2007/03/17 18:43:44 $ </version>
-	[Serializable]
-	public class PointPair4 : PointPair, ISerializable
-	{
-
-	#region Member variables
-
-		/// <summary>
-		/// This PointPair4's T coordinate.
-		/// </summary>
-		public double T;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public PointPair4() : base()
-		{
-			this.T = 0;
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, Z, and T value.
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z coordinate.</param>
-		/// <param name="t">This pair's t coordinate.</param>
-		public PointPair4( double x, double y, double z, double t ) : base( x, y, z )
-		{
-			this.T = t;
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, base value, and
-		/// label (<see cref="PointPair.Tag"/>).
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z coordinate.</param>
-		/// <param name="t">This pair's t coordinate.</param>
-		/// <param name="label">This pair's string label (<see cref="PointPair.Tag"/>)</param>
-		public PointPair4( double x, double y, double z, double t, string label ) :
-					base( x, y, z, label )
-		{
-			this.T = t;
-		}
-
-		/// <summary>
-		/// The PointPair4 copy constructor.
-		/// </summary>
-		/// <param name="rhs">The basis for the copy.</param>
-		public PointPair4( PointPair4 rhs ) : base( rhs )
-		{
-			this.T = rhs.T;
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PointPair4( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-			T = info.GetDouble( "T" );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema3 );
-			info.AddValue( "T", T );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Readonly value that determines if either the X, Y, Z, or T
-		/// coordinate in this PointPair4 is an invalid (not plotable) value.
-		/// It is considered invalid if it is missing (equal to System.Double.Max),
-		/// Infinity, or NaN.
-		/// </summary>
-		/// <returns>true if any value is invalid</returns>
-		public bool IsInvalid4D
-		{
-			get
-			{
-				return this.X == PointPair.Missing ||
-						this.Y == PointPair.Missing ||
-						this.Z == PointPair.Missing ||
-						this.T == PointPair.Missing ||
-						Double.IsInfinity( this.X ) ||
-						Double.IsInfinity( this.Y ) ||
-						Double.IsInfinity( this.Z ) ||
-						Double.IsInfinity( this.T ) ||
-						Double.IsNaN( this.X ) ||
-						Double.IsNaN( this.Y ) ||
-						Double.IsNaN( this.Z ) ||
-						Double.IsNaN( this.T );
-			}
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Format this PointPair4 value using the default format.  Example:  "( 12.345, -16.876 )".
-		/// The two double values are formatted with the "g" format type.
-		/// </summary>
-		/// <param name="isShowZT">true to show the third "Z" and fourth "T" value coordinates</param>
-		/// <returns>A string representation of the PointPair4</returns>
-		public new string ToString( bool isShowZT )
-		{
-			return this.ToString( PointPair.DefaultFormat, isShowZT );
-		}
-
-		/// <summary>
-		/// Format this PointPair value using a general format string.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// If <see paramref="isShowZ"/>
-		/// is true, then the third "Z" coordinate is also shown.
-		/// </summary>
-		/// <param name="format">A format string that will be used to format each of
-		/// the two double type values (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		/// <param name="isShowZT">true to show the third "Z" or low dependent value coordinate</param>
-		public new string ToString( string format, bool isShowZT )
-		{
-			return "( " + this.X.ToString( format ) +
-					", " + this.Y.ToString( format ) +
-					( isShowZT ? ( ", " + this.Z.ToString( format ) +
-							", " + this.T.ToString( format ) ): "" ) + " )";
-		}
-
-		/// <summary>
-		/// Format this PointPair value using different general format strings for the X, Y, and Z values.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// </summary>
-		/// <param name="formatX">A format string that will be used to format the X
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatY">A format string that will be used to format the Y
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatZ">A format string that will be used to format the Z
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatT">A format string that will be used to format the T
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		public string ToString( string formatX, string formatY, string formatZ, string formatT )
-		{
-			return "( " + this.X.ToString( formatX ) +
-					", " + this.Y.ToString( formatY ) +
-					", " + this.Z.ToString( formatZ ) +
-					", " + this.T.ToString( formatT ) +
-					" )";
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/PointPairBase.cs b/BDInfo/ZedGraph/PointPairBase.cs
deleted file mode 100644
index 5da75e924d..0000000000
--- a/BDInfo/ZedGraph/PointPairBase.cs
+++ /dev/null
@@ -1,281 +0,0 @@
-//============================================================================
-//PointPairBase Class
-//Copyright © 2006  Jerry Vos & John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using IComparer = System.Collections.IComparer;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This is a base class that provides base-level functionality for a data point consisting
-	/// of an (X,Y) pair of double values.
-	/// </summary>
-	/// <remarks>
-	/// This class is typically a base class for actual <see cref="PointPair" /> type implementations.
-	/// </remarks>
-	/// 
-	/// <author> Jerry Vos modified by John Champion </author>
-	/// <version> $Revision: 1.4 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class PointPairBase : ISerializable
-	{
-
-	#region Member variables
-
-		/// <summary>
-		/// Missing values are represented internally using <see cref="System.Double.MaxValue"/>.
-		/// </summary>
-		public const double Missing = Double.MaxValue;
-
-		/// <summary>
-		/// The default format to be used for displaying point values via the
-		/// <see cref="ToString()"/> method.
-		/// </summary>
-		public const string DefaultFormat = "G";
-
-		/// <summary>
-		/// This PointPair's X coordinate
-		/// </summary>
-		public double X;
-
-		/// <summary>
-		/// This PointPair's Y coordinate
-		/// </summary>
-		public double Y;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public PointPairBase()
-			: this( 0, 0 )
-		{
-		}
-
-		/// <summary>
-		/// Creates a point pair with the specified X and Y.
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		public PointPairBase( double x, double y )
-		{
-			this.X = x;
-			this.Y = y;
-		}
-
-		/// <summary>
-		/// Creates a point pair from the specified <see cref="PointF"/> struct.
-		/// </summary>
-		/// <param name="pt">The <see cref="PointF"/> struct from which to get the
-		/// new <see cref="PointPair"/> values.</param>
-		public PointPairBase( PointF pt )
-			: this( pt.X, pt.Y )
-		{
-		}
-
-		/// <summary>
-		/// The PointPairBase copy constructor.
-		/// </summary>
-		/// <param name="rhs">The basis for the copy.</param>
-		public PointPairBase( PointPairBase rhs )
-		{
-			this.X = rhs.X;
-			this.Y = rhs.Y;
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PointPairBase( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			X = info.GetDouble( "X" );
-			Y = info.GetDouble( "Y" );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "X", X );
-			info.AddValue( "Y", Y );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Readonly value that determines if either the X or the Y
-		/// coordinate in this PointPair is a missing value.
-		/// </summary>
-		/// <returns>true if either value is missing</returns>
-		public bool IsMissing
-		{
-			get { return this.X == PointPairBase.Missing || this.Y == PointPairBase.Missing; }
-		}
-
-		/// <summary>
-		/// Readonly value that determines if either the X or the Y
-		/// coordinate in this PointPair is an invalid (not plotable) value.
-		/// It is considered invalid if it is missing (equal to System.Double.Max),
-		/// Infinity, or NaN.
-		/// </summary>
-		/// <returns>true if either value is invalid</returns>
-		public bool IsInvalid
-		{
-			get
-			{
-				return this.X == PointPairBase.Missing ||
-						this.Y == PointPairBase.Missing ||
-						Double.IsInfinity( this.X ) ||
-						Double.IsInfinity( this.Y ) ||
-						Double.IsNaN( this.X ) ||
-						Double.IsNaN( this.Y );
-			}
-		}
-
-		/// <summary>
-		/// static method to determine if the specified point value is invalid.
-		/// </summary>
-		/// <remarks>The value is considered invalid if it is <see cref="PointPairBase.Missing"/>,
-		/// <see cref="Double.PositiveInfinity"/>, <see cref="Double.NegativeInfinity"/>
-		/// or <see cref="Double.NaN"/>.</remarks>
-		/// <param name="value">The value to be checked for validity.</param>
-		/// <returns>true if the value is invalid, false otherwise</returns>
-		public static bool IsValueInvalid( double value )
-		{
-			return ( value == PointPairBase.Missing ||
-					Double.IsInfinity( value ) ||
-					Double.IsNaN( value ) );
-		}
-
-	#endregion
-
-	#region Operator Overloads
-
-		/// <summary>
-		/// Implicit conversion from PointPair to PointF.  Note that this conversion
-		/// can result in data loss, since the data are being cast from a type
-		/// double (64 bit) to a float (32 bit).
-		/// </summary>
-		/// <param name="pair">The PointPair struct on which to operate</param>
-		/// <returns>A PointF struct equivalent to the PointPair</returns>
-		public static implicit operator PointF( PointPairBase pair )
-		{
-			return new PointF( (float)pair.X, (float)pair.Y );
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Compare two <see cref="PointPairBase"/> objects for equality.  To be equal, X and Y
-		/// must be exactly the same between the two objects.
-		/// </summary>
-		/// <param name="obj">The <see cref="PointPairBase"/> object to be compared with.</param>
-		/// <returns>true if the <see cref="PointPairBase"/> objects are equal, false otherwise</returns>
-		public override bool Equals( object obj )
-		{
-			PointPairBase rhs = obj as PointPairBase;
-			return this.X == rhs.X && this.Y == rhs.Y;
-		}
-
-		/// <summary>
-		/// Return the HashCode from the base class.
-		/// </summary>
-		/// <returns></returns>
-		public override int GetHashCode()
-		{
-			return base.GetHashCode();
-		}
-
-		/// <summary>
-		/// Format this PointPair value using the default format.  Example:  "( 12.345, -16.876 )".
-		/// The two double values are formatted with the "g" format type.
-		/// </summary>
-		/// <returns>A string representation of the PointPair</returns>
-		public override string ToString()
-		{
-			return this.ToString( PointPairBase.DefaultFormat );
-		}
-
-		/// <summary>
-		/// Format this PointPair value using a general format string.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// </summary>
-		/// <param name="format">A format string that will be used to format each of
-		/// the two double type values (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		public string ToString( string format )
-		{
-			return "( " + this.X.ToString( format ) +
-					", " + this.Y.ToString( format ) +
-					" )";
-		}
-
-		/// <summary>
-		/// Format this PointPair value using different general format strings for the X and Y values.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// The Z value is not displayed (see <see cref="PointPair.ToString( string, string, string )"/>).
-		/// </summary>
-		/// <param name="formatX">A format string that will be used to format the X
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <param name="formatY">A format string that will be used to format the Y
-		/// double type value (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		public string ToString( string formatX, string formatY )
-		{
-			return "( " + this.X.ToString( formatX ) +
-					", " + this.Y.ToString( formatY ) +
-					" )";
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PointPairCV.cs b/BDInfo/ZedGraph/PointPairCV.cs
deleted file mode 100644
index 6c1d59eb74..0000000000
--- a/BDInfo/ZedGraph/PointPairCV.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-//============================================================================
-//PointPairCV Class
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#if ( !DOTNET1 )	// Is this a .Net 2 compilation?
-using System.Collections.Generic;
-#endif
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A simple instance that stores a data point (X, Y, Z).  This differs from a regular
-	/// <see cref="PointPair" /> in that it maps the <see cref="ColorValue" /> property
-	/// to an independent value.  That is, <see cref="ColorValue" /> and
-	/// <see cref="PointPair.Z" /> are not related (as they are in the
-	/// <see cref="PointPair" />).
-	/// </summary>
-	public class PointPairCV : PointPair
-	{
-
-	#region Properties
-
-		/// <summary>
-		/// This is a user value that can be anything.  It is used to provide special 
-		/// property-based coloration to the graph elements.
-		/// </summary>
-		private double _colorValue;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Creates a point pair with the specified X, Y, and base value.
-		/// </summary>
-		/// <param name="x">This pair's x coordinate.</param>
-		/// <param name="y">This pair's y coordinate.</param>
-		/// <param name="z">This pair's z or lower dependent coordinate.</param>
-		public PointPairCV( double x, double y, double z )
-			: base( x, y, z, null )
-		{
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PointPairCV( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-			ColorValue = info.GetDouble( "ColorValue" );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema2 );
-			info.AddValue( "ColorValue", ColorValue );
-		}
-
-	#endregion
-
-
-	#region Properties
-
-		/// <summary>
-		/// The ColorValue property.  This is used with the
-		/// <see cref="FillType.GradientByColorValue" /> option.
-		/// </summary>
-		override public double ColorValue
-		{
-			get { return _colorValue; }
-			set { _colorValue = value; }
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/PointPairList.cs b/BDInfo/ZedGraph/PointPairList.cs
deleted file mode 100644
index f2e05f45d9..0000000000
--- a/BDInfo/ZedGraph/PointPairList.cs
+++ /dev/null
@@ -1,935 +0,0 @@
-//============================================================================
-//PointPairList Class
-//Copyright © 2004  Jerry Vos
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections.Generic;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="PointPair"/> objects
-	/// that define the set of points to be displayed on the curve.
-	/// </summary>
-	/// <seealso cref="BasicArrayPointList" />
-	/// <seealso cref="IPointList" />
-	/// 
-	/// <author> Jerry Vos based on code by John Champion
-	/// modified by John Champion</author>
-	/// <version> $Revision: 3.37 $ $Date: 2007/06/29 15:39:07 $ </version>
-	[Serializable]
-	public class PointPairList : List<PointPair>, IPointList, IPointListEdit
-	{
-	#region Fields
-		/// <summary>Private field to maintain the sort status of this
-		/// <see cref="PointPairList"/>.  Use the public property
-		/// <see cref="Sorted"/> to access this value.
-		/// </summary>
-		protected bool _sorted = true;
-	#endregion
-
-	#region Properties
-/*		/// <summary>
-		/// Indexer to access the specified <see cref="PointPair"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="PointPair"/> object to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object reference.</value>
-		public PointPair this[ int index ]  
-		{
-			get { return (PointPair) List[index]; }
-			set { List[index] = value; }
-		}
-*/
-		/// <summary>
-		/// true if the list is currently sorted.
-		/// </summary>
-		/// <seealso cref="Sort()"/>
-		public bool Sorted
-		{
-			get { return _sorted; }
-		}
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Default constructor for the collection class
-		/// </summary>
-		public PointPairList()
-		{
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Constructor to initialize the PointPairList from two arrays of
-		/// type double.
-		/// </summary>
-		public PointPairList( double[] x, double[] y )
-		{
-			Add( x, y );
-
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Constructor to initialize the PointPairList from an IPointList
-		/// </summary>
-		public PointPairList( IPointList list )
-		{
-			int count = list.Count;
-			for ( int i = 0; i < count; i++ )
-				Add( list[i] );
-
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Constructor to initialize the PointPairList from three arrays of
-		/// type double.
-		/// </summary>
-		public PointPairList( double[] x, double[] y, double[] baseVal )
-		{
-			Add( x, y, baseVal );
-			
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The PointPairList from which to copy</param>
-		public PointPairList( PointPairList rhs )
-		{
-			Add( rhs );
-
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public PointPairList Clone()
-		{
-			return new PointPairList( this );
-		}
-
-	#endregion
-
-	#region Methods
-		/// <summary>
-		/// Add a <see cref="PointPair"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="point">The <see cref="PointPair"/> object to
-		/// be added</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public new void Add( PointPair point )
-		{
-			_sorted = false;
-			//base.Add( new PointPair( point ) );
-			base.Add( point.Clone() );
-		}
-
-		/// <summary>
-		/// Add a <see cref="PointPairList"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="pointList">A reference to the <see cref="PointPairList"/> object to
-		/// be added</param>
-		/// <returns>The zero-based ordinal index where the last point was added in the list,
-		/// or -1 if no points were added.</returns>
-		public void Add( PointPairList pointList )
-		{
-			foreach ( PointPair point in pointList )
-			Add( point );
-				
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Add a set of points to the PointPairList from two arrays of type double.
-		/// If either array is null, then a set of ordinal values is automatically
-		/// generated in its place (see <see cref="AxisType.Ordinal"/>.
-		/// If the arrays are of different size, then the larger array prevails and the
-		/// smaller array is padded with <see cref="PointPairBase.Missing"/> values.
-		/// </summary>
-		/// <param name="x">A double[] array of X values</param>
-		/// <param name="y">A double[] array of Y values</param>
-		/// <returns>The zero-based ordinal index where the last point was added in the list,
-		/// or -1 if no points were added.</returns>
-		public void Add( double[] x, double[] y )
-		{
-			int 		len = 0;
-			
-			if ( x != null )
-				len = x.Length;
-			if ( y != null && y.Length > len )
-				len = y.Length;
-			
-			for ( int i=0; i<len; i++ )
-			{
-				PointPair	point = new PointPair( 0, 0, 0 );
-				if ( x == null )
-					point.X = (double) i + 1.0;
-				else if ( i < x.Length )
-					point.X = x[i];
-				else
-					point.X = PointPair.Missing;
-					
-				if ( y == null )
-					point.Y = (double) i + 1.0;
-				else if ( i < y.Length )
-					point.Y = y[i];
-				else
-					point.Y = PointPair.Missing;
-					
-				base.Add( point );
-			}
-			
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Add a set of points to the <see cref="PointPairList"/> from three arrays of type double.
-		/// If the X or Y array is null, then a set of ordinal values is automatically
-		/// generated in its place (see <see cref="AxisType.Ordinal"/>.  If the <see paramref="baseVal"/>
-		/// is null, then it is set to zero.
-		/// If the arrays are of different size, then the larger array prevails and the
-		/// smaller array is padded with <see cref="PointPairBase.Missing"/> values.
-		/// </summary>
-		/// <param name="x">A double[] array of X values</param>
-		/// <param name="y">A double[] array of Y values</param>
-		/// <param name="z">A double[] array of Z or lower-dependent axis values</param>
-		/// <returns>The zero-based ordinal index where the last point was added in the list,
-		/// or -1 if no points were added.</returns>
-		public void Add( double[] x, double[] y, double[] z )
-		{
-			int 		len = 0;
-			
-			if ( x != null )
-				len = x.Length;
-			if ( y != null && y.Length > len )
-				len = y.Length;
-			if ( z != null && z.Length > len )
-				len = z.Length;
-						
-			for ( int i=0; i<len; i++ )
-			{
-				PointPair point = new PointPair();
-
-				if ( x == null )
-					point.X = (double) i + 1.0;
-				else if ( i < x.Length )
-					point.X = x[i];
-				else
-					point.X = PointPair.Missing;
-					
-				if ( y == null )
-					point.Y = (double) i + 1.0;
-				else if ( i < y.Length )
-					point.Y = y[i];
-				else
-					point.Y = PointPair.Missing;
-					
-				if ( z == null )
-					point.Z = (double) i + 1.0;
-				else if ( i < z.Length )
-					point.Z = z[i];
-				else
-					point.Z = PointPair.Missing;
-					
-				base.Add( point );
-			}
-			
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="PointPairList"/> from values of type double.
-		/// </summary>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public void Add( double x, double y )
-		{
-			_sorted = false;
-			PointPair	point = new PointPair( x, y );
-			base.Add( point );
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="PointPairList"/> from values of type double.
-		/// </summary>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="tag">The Tag value for the PointPair</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public void Add( double x, double y, string tag )
-		{
-			_sorted = false;
-			PointPair	point = new PointPair( x, y, tag );
-			base.Add( point );
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="PointPairList"/> from values of type double.
-		/// </summary>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="z">The Z or lower dependent axis value</param>
-		/// <returns>The zero-based ordinal index where the point was added
-		/// in the list.</returns>
-		public void Add( double x, double y, double z )
-		{
-			_sorted = false;
-			PointPair point = new PointPair( x, y, z );
-			base.Add( point );
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="PointPairList"/> from values of type double.
-		/// </summary>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="z">The Z or lower dependent axis value</param>
-		/// <param name="tag">The Tag value for the PointPair</param>
-		/// <returns>The zero-based ordinal index where the point was added
-		/// in the list.</returns>
-		public void Add( double x, double y, double z, string tag )
-		{
-			_sorted = false;
-			PointPair point = new PointPair( x, y, z, tag );
-			base.Add( point );
-		}
-
-		/// <summary>
-		/// Add a <see cref="PointPair"/> object to the collection at the specified,
-		/// zero-based, index location.
-		/// </summary>
-		/// <param name="index">
-		/// The zero-based ordinal index where the point is to be added in the list.
-		/// </param>
-		/// <param name="point">
-		/// The <see cref="PointPair"/> object to be added.
-		/// </param>
-		public new void Insert( int index, PointPair point )
-		{
-			_sorted = false;
-			base.Insert( index, point );
-		}
-
-		/// <summary>
-		/// Add a single point (from values of type double ) to the <see cref="PointPairList"/> at the specified,
-		/// zero-based, index location.
-		/// </summary>
-		/// <param name="index">
-		/// The zero-based ordinal index where the point is to be added in the list.
-		/// </param>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		public void Insert( int index, double x, double y )
-		{
-			_sorted = false;
-			base.Insert( index, new PointPair( x, y ) );
-		}
-
-		/// <summary>
-		/// Add a single point (from values of type double ) to the <see cref="PointPairList"/> at the specified,
-		/// zero-based, index location.
-		/// </summary>
-		/// <param name="index">
-		/// The zero-based ordinal index where the point is to be added in the list.
-		/// </param>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="z">The Z or lower dependent axis value</param>
-		public void Insert( int index, double x, double y, double z )
-		{
-			_sorted = false;
-			Insert( index, new PointPair( x, y, z ) );
-		}
-		/*
-				/// <summary>
-				/// Remove the specified <see cref="PointPair"/> object from the collection based
-				/// the point values (must match exactly).
-				/// </summary>
-				/// <param name="pt">
-				/// A <see cref="PointPair"/> that is to be removed by value.
-				/// </param>
-				/// <seealso cref="IList.Remove"/>
-				public void Remove( PointPair pt )
-				{
-					List.Remove( pt );
-				}
-
-				/// <summary>
-				/// Return the zero-based position index of the specified
-				/// <see cref="PointPair"/> in the collection.
-				/// </summary>
-				/// <param name="pt">The <see cref="PointPair"/> object that is to be found.
-				/// </param>
-				/// <returns>The zero-based index of the specified <see cref="PointPair"/>, or -1 if the <see cref="PointPair"/>
-				/// is not in the list</returns>
-				/// <seealso cref="IList.IndexOf"/>
-				public int IndexOf( PointPair pt )
-				{
-					return List.IndexOf( pt );
-				}
-		*/
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="PointPair"/> with the specified label <see cref="PointPair.Tag"/>.
-		/// </summary>
-		/// <remarks>The <see cref="PointPair.Tag"/> object must be of type <see cref="String"/>
-		/// for this method to find it.</remarks>
-		/// <param name="label">The <see cref="String"/> label that is in the
-		/// <see cref="PointPair.Tag"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="PointPair"/>,
-		/// or -1 if the <see cref="PointPair"/> is not in the list</returns>
-		public int IndexOfTag( string label )
-		{
-			int iPt = 0;
-			foreach ( PointPair p in this )
-			{
-				if ( p.Tag is string && String.Compare( (string) p.Tag, label, true ) == 0 )
-					return iPt;
-				iPt++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Compare two <see cref="PointPairList"/> objects to see if they are equal.
-		/// </summary>
-		/// <remarks>Equality is based on equal count of <see cref="PointPair"/> items, and
-		/// each individual <see cref="PointPair"/> must be equal (as per the
-		/// <see cref="PointPair.Equals"/> method.</remarks>
-		/// <param name="obj">The <see cref="PointPairList"/> to be compared with for equality.</param>
-		/// <returns>true if the <see cref="PointPairList"/> objects are equal, false otherwise.</returns>
-		public override bool Equals( object obj )
-		{
-			PointPairList rhs = obj as PointPairList;
-			if( this.Count != rhs.Count )
-				return false;
-
-			for( int i=0; i<this.Count; i++ )
-			{
-				if( !this[i].Equals(rhs[i]) )
-					return false;
-			}
-
-			return true;
-		}
-		
-		/// <summary>
-		/// Return the HashCode from the base class.
-		/// </summary>
-		/// <returns></returns>
-		public override int GetHashCode()
-		{
-			return base.GetHashCode ();
-		}
-
-		/// <summary>
-		/// Sorts the list according to the point x values. Will not sort the 
-		/// list if the list is already sorted.
-		/// </summary>
-		/// <returns>If the list was sorted before sort was called</returns>
-		public new bool Sort()
-		{
-			// if it is already sorted we don't have to sort again
-			if ( _sorted )
-				return true;
-
-			Sort( new PointPair.PointPairComparer( SortType.XValues ) );
-			return false;
-		}
-		
-		/// <summary>
-		/// Sorts the list according to the point values . Will not sort the 
-		/// list if the list is already sorted.
-		/// </summary>
-		/// <param name="type"></param>  The <see cref = "SortType"/>
-		///used to determine whether the X or Y values will be used to sort
-		///the list
-		/// <returns>If the list was sorted before sort was called</returns>
-		public bool Sort( SortType type)
-		{
-			// if it is already sorted we don't have to sort again
-			if ( _sorted )
-				return true;
-				
-			this.Sort( new PointPair.PointPairComparer( type ) );
-			
-			return false;
-		}
-		
-		/// <summary>
-		/// Set the X values for this <see cref="PointPairList"/> from the specified
-		/// array of double values.
-		/// </summary>
-		/// <remarks>
-		/// If <see paramref="x"/> has more values than
-		/// this list, then the extra values will be ignored.  If <see paramref="x"/>
-		/// has less values, then the corresponding <see cref="PointPairList"/> values
-		/// will not be changed.  That is, if the <see cref="PointPairList"/> has 20 values
-		/// and <see paramref="x"/> has 15 values, then the first 15 values of the
-		/// <see cref="PointPairList"/> will be changed, and the last 5 values will not be
-		/// changed.
-		/// </remarks>
-		/// <param name="x">An array of double values that will replace the existing X
-		/// values in the <see cref="PointPairList"/>.</param>
-		public void SetX( double[] x )
-		{
-			for ( int i=0; i<x.Length; i++ )
-			{
-				if ( i < this.Count )
-					this[i].X = x[i];
-			}
-				
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Set the Y values for this <see cref="PointPairList"/> from the specified
-		/// array of double values.
-		/// </summary>
-		/// <remarks>
-		/// If <see paramref="y"/> has more values than
-		/// this list, then the extra values will be ignored.  If <see paramref="y"/>
-		/// has less values, then the corresponding <see cref="PointPairList"/> values
-		/// will not be changed.  That is, if the <see cref="PointPairList"/> has 20 values
-		/// and <see paramref="y"/> has 15 values, then the first 15 values of the
-		/// <see cref="PointPairList"/> will be changed, and the last 5 values will not be
-		/// changed.
-		/// </remarks>
-		/// <param name="y">An array of double values that will replace the existing Y
-		/// values in the <see cref="PointPairList"/>.</param>
-		public void SetY( double[] y )
-		{
-			for ( int i=0; i<y.Length; i++ )
-			{
-				if ( i < this.Count )
-					this[i].Y = y[i];
-			}
-				
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Set the Z values for this <see cref="PointPairList"/> from the specified
-		/// array of double values.
-		/// </summary>
-		/// <remarks>
-		/// If <see paramref="z"/> has more values than
-		/// this list, then the extra values will be ignored.  If <see paramref="z"/>
-		/// has less values, then the corresponding <see cref="PointPairList"/> values
-		/// will not be changed.  That is, if the <see cref="PointPairList"/> has 20 values
-		/// and <see paramref="z"/> has 15 values, then the first 15 values of the
-		/// <see cref="PointPairList"/> will be changed, and the last 5 values will not be
-		/// changed.
-		/// </remarks>
-		/// <param name="z">An array of double values that will replace the existing Z
-		/// values in the <see cref="PointPairList"/>.</param>
-		public void SetZ( double[] z )
-		{
-			for ( int i=0; i<z.Length; i++ )
-			{
-				if ( i < this.Count )
-					this[i].Z = z[i];
-			}
-				
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Add the Y values from the specified <see cref="PointPairList"/> object to this
-		/// <see cref="PointPairList"/>.  If <see paramref="sumList"/> has more values than
-		/// this list, then the extra values will be ignored.  If <see paramref="sumList"/>
-		/// has less values, the missing values are assumed to be zero.
-		/// </summary>
-		/// <param name="sumList">A reference to the <see cref="PointPairList"/> object to
-		/// be summed into the this <see cref="PointPairList"/>.</param>
-		public void SumY( PointPairList sumList )
-		{
-			for ( int i=0; i<this.Count; i++ )
-			{
-				if ( i < sumList.Count )
-					this[i].Y += sumList[i].Y;
-			}
-				
-			//sorted = false;
-		}
-
-		/// <summary>
-		/// Add the X values from the specified <see cref="PointPairList"/> object to this
-		/// <see cref="PointPairList"/>.  If <see paramref="sumList"/> has more values than
-		/// this list, then the extra values will be ignored.  If <see paramref="sumList"/>
-		/// has less values, the missing values are assumed to be zero.
-		/// </summary>
-		/// <param name="sumList">A reference to the <see cref="PointPairList"/> object to
-		/// be summed into the this <see cref="PointPairList"/>.</param>
-		public void SumX( PointPairList sumList )
-		{
-			for ( int i=0; i<this.Count; i++ )
-			{
-				if ( i < sumList.Count )
-					this[i].X += sumList[i].X;
-			}
-				
-			_sorted = false;
-		}
-
-		/// <summary>
-		/// Linearly interpolate the data to find an arbitraty Y value that corresponds to the specified X value.
-		/// </summary>
-		/// <remarks>
-		/// This method uses linear interpolation with a binary search algorithm.  It therefore
-		/// requires that the x data be monotonically increasing.  Missing values are not allowed.  This
-		/// method will extrapolate outside the range of the PointPairList if necessary.
-		/// </remarks>
-		/// <param name="xTarget">The target X value on which to interpolate</param>
-		/// <returns>The Y value that corresponds to the <see paramref="xTarget"/> value.</returns>
-		public double InterpolateX( double xTarget )
-		{
-			int lo, mid, hi;
-			if ( this.Count < 2 )
-				throw new Exception( "Error: Not enough points in curve to interpolate" );
-
-			if ( xTarget <= this[0].X )
-			{
-				lo = 0;
-				hi = 1;
-			}
-			else if ( xTarget >= this[this.Count-1].X )
-			{
-				lo = this.Count - 2;
-				hi = this.Count - 1;
-			}
-			else
-			{
-				// if x is within the bounds of the x table, then do a binary search
-				// in the x table to find table entries that bound the x value
-				lo = 0;
-				hi = this.Count - 1;
-			    
-				// limit to 1000 loops to avoid an infinite loop problem
-				int j;
-				for ( j=0; j<1000 && hi > lo + 1; j++ )
-				{
-					mid = ( hi + lo ) / 2;
-					if ( xTarget > this[mid].X )
-						lo = mid;
-					else
-						hi = mid;
-				}
-
-				if ( j >= 1000 )
-					throw new Exception( "Error: Infinite loop in interpolation" );
-			}
-
-			return ( xTarget - this[lo].X ) / ( this[hi].X - this[lo].X ) *
-					( this[hi].Y - this[lo].Y ) + this[lo].Y;
-
-		}
-
-		/// <summary>
-		/// Use Cardinal Splines to Interpolate the data to find an arbitraty Y value that corresponds to
-		/// the specified X value.
-		/// </summary>
-		/// <remarks>
-		/// This method uses cardinal spline interpolation with a binary search algorithm.  It therefore
-		/// requires that the x data be monotonically increasing.  Missing values are not allowed.  This
-		/// method will not extrapolate outside the range of the PointPairList (it returns
-		/// <see cref="PointPairBase.Missing"/> if extrapolation would be required).  WARNING: Cardinal
-		/// spline interpolation can generate curves with non-unique X values for higher tension
-		/// settings.  That is, there may be multiple X values for the same Y value.  This routine
-		/// follows the path of the spline curve until it reaches the FIRST OCCURRENCE of the
-		/// target X value.  It does not check to see if other solutions are possible.
-		/// </remarks>
-		/// <param name="xTarget">The target X value on which to interpolate</param>
-		/// <param name="tension">The tension setting that controls the curvature of the spline fit.
-		/// Typical values are between 0 and 1, where 0 is a linear fit, and 1 is lots of "roundness".
-		/// Values greater than 1 may give odd results.
-		/// </param>
-		/// <returns>The Y value that corresponds to the <see paramref="xTarget"/> value.</returns>
-		public double SplineInterpolateX( double xTarget, double tension )
-		{
-			// Scale the tension value to be compatible with the GDI+ values
-			tension /= 3.0;
-
-			int lo, mid, hi;
-			if ( this.Count < 2 )
-				throw new Exception( "Error: Not enough points in curve to interpolate" );
-
-			// Extrapolation not allowed
-			if ( xTarget <= this[0].X || xTarget >= this[this.Count-1].X )
-				return PointPair.Missing;
-			else
-			{
-				// if x is within the bounds of the x table, then do a binary search
-				// in the x table to find table entries that bound the x value
-				lo = 0;
-				hi = this.Count - 1;
-			    
-				// limit to 1000 loops to avoid an infinite loop problem
-				int j;
-				for ( j=0; j<1000 && hi > lo + 1; j++ )
-				{
-					mid = ( hi + lo ) / 2;
-					if ( xTarget > this[mid].X )
-						lo = mid;
-					else
-						hi = mid;
-				}
-
-				if ( j >= 1000 )
-					throw new Exception( "Error: Infinite loop in interpolation" );
-			}
-
-			// At this point, we know the two bounding points around our point of interest
-			// We need the four points that surround our point
-
-			double X0, X1, X2, X3;
-			double Y0, Y1, Y2, Y3;
-			double B0, B1, B2, B3;
-
-			X1 = this[lo].X;
-			X2 = this[hi].X;
-			Y1 = this[lo].Y;
-			Y2 = this[hi].Y;
-
-			// if we are at either the beginning of the table or the end, then make up a before
-			// and/or after point to fill in the four points
-			if ( lo == 0 )
-			{
-				X0 = X1 - ( X2 - X1 )/3;
-				Y0 = Y1 - ( Y2 - Y1 )/3;
-			}
-			else
-			{
-				X0 = this[lo-1].X;
-				Y0 = this[lo-1].Y;
-			}
-
-			if ( hi == this.Count - 1 )
-			{
-				X3 = X2 + ( X2 - X1 )/3;
-				Y3 = Y2 + ( Y2 - Y1 )/3;
-			}
-			else
-			{
-				X3 = this[hi+1].X;
-				Y3 = this[hi+1].Y;
-			}
-
-			double	newX, newY,
-						lastX = X1,
-						lastY = Y1;
-
-			// Do 100 steps to find the result
-			for ( double t=0.01; t<=1; t+=0.01 )
-			{
-				B0 = (1 - t) * (1 - t) * (1 - t);
-				B1 = 3.0 * t * (1 - t) * (1 - t);
-				B2 = 3.0 * t * t * (1 - t);
-				B3 = t * t * t;
-
-				newX = X1 * B0 + (X1 + (X2 - X0) * tension) * B1 +
-						(X2 - (X3 - X1) * tension) * B2 + X2 * B3;
-				newY = Y1 * B0 + (Y1 + (Y2 - Y0) * tension) * B1 +
-						(Y2 - (Y3 - Y1) * tension) * B2 + Y2 * B3;
-
-				// We are looking for the first X that exceeds the target
-				if ( newX >= xTarget )
-				{
-					// We now have two bounding X values around our target
-					// use linear interpolation to minimize the discretization
-					// error.
-					return ( xTarget - lastX ) / ( newX - lastX ) *
-							( newY - lastY ) + lastY;
-				}
-
-				lastX = newX;
-				lastY = newY;
-			}
-
-			// This should never happen
-			return Y2;
-		}
-
-		/// <summary>
-		/// Linearly interpolate the data to find an arbitraty X value that corresponds to the specified Y value.
-		/// </summary>
-		/// <remarks>
-		/// This method uses linear interpolation with a binary search algorithm.  It therefore
-		/// requires that the Y data be monotonically increasing.  Missing values are not allowed.  This
-		/// method will extrapolate outside the range of the PointPairList if necessary.
-		/// </remarks>
-		/// <param name="yTarget">The target Y value on which to interpolate</param>
-		/// <returns>The X value that corresponds to the <see paramref="yTarget"/> value.</returns>
-		public double InterpolateY( double yTarget )
-		{
-			int lo, mid, hi;
-			if ( this.Count < 2 )
-				throw new Exception( "Error: Not enough points in curve to interpolate" );
-
-			if ( yTarget <= this[0].Y )
-			{
-				lo = 0;
-				hi = 1;
-			}
-			else if ( yTarget >= this[this.Count-1].Y )
-			{
-				lo = this.Count - 2;
-				hi = this.Count - 1;
-			}
-			else
-			{
-				// if y is within the bounds of the y table, then do a binary search
-				// in the y table to find table entries that bound the y value
-				lo = 0;
-				hi = this.Count - 1;
-			    
-				// limit to 1000 loops to avoid an infinite loop problem
-				int j;
-				for ( j=0; j<1000 && hi > lo + 1; j++ )
-				{
-					mid = ( hi + lo ) / 2;
-					if ( yTarget > this[mid].Y )
-						lo = mid;
-					else
-						hi = mid;
-				}
-
-				if ( j >= 1000 )
-					throw new Exception( "Error: Infinite loop in interpolation" );
-			}
-
-			return ( yTarget - this[lo].Y ) / ( this[hi].Y - this[lo].Y ) *
-					( this[hi].X - this[lo].X ) + this[lo].X;
-
-		}
-
-		/// <summary>
-		/// Use linear regression to form a least squares fit of an existing
-		/// <see cref="IPointList"/> instance.
-		/// </summary>
-		/// <remarks>The output <see cref="PointPairList" /> will cover the
-		/// same X range of data as the original dataset.
-		/// </remarks>
-		/// <param name="points">An <see cref="IPointList" /> instance containing
-		/// the data to be regressed.</param>
-		/// <param name="pointCount">The number of desired points to be included
-		/// in the resultant <see cref="PointPairList" />.
-		/// </param>
-		/// <returns>A new <see cref="PointPairList" /> containing the resultant
-		/// data fit.
-		/// </returns>
-		public PointPairList LinearRegression( IPointList points, int pointCount )
-		{
-			double minX = double.MaxValue;
-			double maxX = double.MinValue;
-
-			for ( int i=0; i<points.Count; i++ )
-			{
-				PointPair pt = points[i];
-
-				if ( !pt.IsInvalid )
-				{
-					minX = pt.X < minX ? pt.X : minX;
-					maxX = pt.X > maxX ? pt.X : maxX;
-				}
-			}
-
-			return LinearRegression( points, pointCount, minX, maxX );
-		}
-
-
-		/// <summary>
-		/// Use linear regression to form a least squares fit of an existing
-		/// <see cref="IPointList"/> instance.
-		/// </summary>
-		/// <param name="points">An <see cref="IPointList" /> instance containing
-		/// the data to be regressed.</param>
-		/// <param name="pointCount">The number of desired points to be included
-		/// in the resultant <see cref="PointPairList" />.
-		/// </param>
-		/// <param name="minX">The minimum X value of the resultant
-		/// <see cref="PointPairList" />.</param>
-		/// <param name="maxX">The maximum X value of the resultant
-		/// <see cref="PointPairList" />.</param>
-		/// <returns>A new <see cref="PointPairList" /> containing the resultant
-		/// data fit.
-		/// </returns>
-		/// <author> Brian Chappell - lazarusds
-		///          modified by John Champion</author>
-		public PointPairList LinearRegression( IPointList points, int pointCount,
-			double minX, double maxX )
-		{
-			double x = 0, y = 0, xx = 0, xy = 0, count = 0;
-			for ( int i = 0; i < points.Count; i++ )
-			{
-				PointPair pt = points[i];
-				if ( !pt.IsInvalid )
-				{
-					x += points[i].X;
-					y += points[i].Y;
-					xx += points[i].X * points[i].X;
-					xy += points[i].X * points[i].Y;
-					count++;
-				}
-			}
-
-			if ( count < 2 || maxX - minX < 1e-20 )
-				return null;
-
-			double slope = ( count * xy - x * y ) / ( count * xx - x * x );
-			double intercept = ( y - slope * x ) / count;
-
-			PointPairList newPoints = new PointPairList();
-			double stepSize = ( maxX - minX ) / pointCount;
-			double value = minX;
-			for ( int i = 0; i < pointCount; i++ )
-			{
-				newPoints.Add( new PointPair( value, value * slope + intercept ) );
-				value += stepSize;
-			}
-
-			return newPoints;
-		} 
-
-
-	#endregion
-	}
-}
-
-
diff --git a/BDInfo/ZedGraph/PolyObj.cs b/BDInfo/ZedGraph/PolyObj.cs
deleted file mode 100644
index ecb760731b..0000000000
--- a/BDInfo/ZedGraph/PolyObj.cs
+++ /dev/null
@@ -1,336 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a bordered and/or filled polygon object on
-	/// the graph.  A list of <see cref="PolyObj"/> objects is maintained by
-	/// the <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/01/25 07:56:09 $ </version>
-	[Serializable]
-	public class PolyObj : BoxObj, ICloneable, ISerializable
-	{
-
-	#region Fields
-
-		private PointD[] _points;
-
-		/// <summary>
-		/// private value that determines if the polygon will be automatically closed.
-		/// true to close the figure, false to leave it "open."  Use the public property
-		/// <see cref="IsClosedFigure" /> to access this value.
-		/// </summary>
-		private bool _isClosedFigure = true;
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="PointD"/> array that defines
-		/// the polygon.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/>.
-		/// </summary>
-		public PointD[] Points
-		{
-			get { return _points; }
-			set { _points = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the polygon will be automatically closed.
-		/// true to close the figure, false to leave it "open."
-		/// </summary>
-		/// <remarks>
-		/// This boolean determines whether or not the CloseFigure() method will be called
-		/// to fully close the path of the polygon.  This value defaults to true, and for any
-		/// closed figure it should fine.  If you want to draw a line that does not close into
-		/// a shape, then you should set this value to false.  For a figure that is naturally
-		/// closed (e.g., the first point of the polygon is the same as the last point),
-		/// leaving this value set to false may result in minor pixel artifacts due to
-		/// rounding.
-		/// </remarks>
-		public bool IsClosedFigure
-		{
-			get { return _isClosedFigure; }
-			set { _isClosedFigure = value; }
-		}
-
-	#endregion
-	
-	#region Constructors
-		/// <overloads>Constructors for the <see cref="PolyObj"/> object</overloads>
-		/// <summary>
-		/// A constructor that allows the position, border color, and solid fill color
-		/// of the <see cref="PolyObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box border</param>
-		/// <param name="fillColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box fill (will be a solid color fill)</param>
-		/// <param name="points">The <see cref="PointD"/> array that defines
-		/// the polygon.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/>.
-		/// </param>
-		public PolyObj( PointD[] points, Color borderColor, Color fillColor ) :
-				base( 0, 0, 1, 1, borderColor, fillColor )
-		{
-			_points = points;
-		}
-
-		/// <summary>
-		/// A constructor that allows the position
-		/// of the <see cref="PolyObj"/> to be pre-specified.  Other properties are defaulted.
-		/// </summary>
-		/// <param name="points">The <see cref="PointD"/> array that defines
-		/// the polygon.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/>.
-		/// </param>
-		public PolyObj( PointD[] points ) : base( 0, 0, 1, 1 )
-		{
-			_points = points;
-		}
-
-		/// <summary>
-		/// A default constructor that creates a <see cref="PolyObj"/> from an empty
-		/// <see cref="PointD"/> array.  Other properties are defaulted.
-		/// </summary>
-		public PolyObj() : this( new PointD[0] )
-		{
-		}
-
-		/// <summary>
-		/// A constructor that allows the position, border color, and two-color
-		/// gradient fill colors
-		/// of the <see cref="PolyObj"/> to be pre-specified.
-		/// </summary>
-		/// <param name="borderColor">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the box border</param>
-		/// <param name="fillColor1">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the start of the box gradient fill</param>
-		/// <param name="fillColor2">An arbitrary <see cref="System.Drawing.Color"/> specification
-		/// for the end of the box gradient fill</param>
-		/// <param name="points">The <see cref="PointD"/> array that defines
-		/// the polygon.  This will be in units determined by
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/>.
-		/// </param>
-		public PolyObj( PointD[] points, Color borderColor,
-							Color fillColor1, Color fillColor2 ) :
-				base( 0, 0, 1, 1, borderColor, fillColor1, fillColor2 )
-		{
-			_points = points;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="PolyObj"/> object from which to copy</param>
-		public PolyObj( PolyObj rhs ) : base( rhs )
-		{
-			rhs._points = (PointD[]) _points.Clone();
-			rhs._isClosedFigure = _isClosedFigure;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new PolyObj Clone()
-		{
-			return new PolyObj( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected PolyObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-			_points = (PointD[]) info.GetValue( "points", typeof(PointD[]) );
-
-			if ( schema3 >= 11 )
-				_isClosedFigure = info.GetBoolean( "isClosedFigure" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema3 );
-
-			info.AddValue( "points", _points );
-			info.AddValue( "isClosedFigure", _isClosedFigure );
-		}
-	#endregion
-	
-	#region Rendering Methods
-		/// <summary>
-		/// Render this object to the specified <see cref="Graphics"/> device.
-		/// </summary>
-		/// <remarks>
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </remarks>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			if ( _points != null && _points.Length > 1 )
-			{
-				using ( GraphicsPath path = MakePath( pane ) )
-				{
-					// Fill or draw the symbol as required
-					if ( _fill.IsVisible )
-					{
-						using ( Brush brush = this.Fill.MakeBrush( path.GetBounds() ) )
-							g.FillPath( brush, path );
-					}
-
-					if ( _border.IsVisible )
-					{
-						using ( Pen pen = _border.GetPen( pane, scaleFactor ) )
-							g.DrawPath( pen, path );
-					}
-				}
-			}
-		}
-		
-		internal GraphicsPath MakePath( PaneBase pane )
-		{
-			GraphicsPath path = new GraphicsPath();
-			bool first = true;
-			PointF lastPt = new PointF();
-
-			foreach( PointD pt in _points )
-			{
-				// Convert the coordinates from the user coordinate system
-				// to the screen coordinate system
-				// Offset the points by the location value
-				PointF pixPt = Location.Transform( pane, pt.X + _location.X, pt.Y + _location.Y,
-						_location.CoordinateFrame );
-
-				if (	Math.Abs( pixPt.X ) < 100000 &&
-						Math.Abs( pixPt.Y ) < 100000 )
-				{
-					if ( first )
-						first = false;
-					else
-						path.AddLine( lastPt, pixPt );
-
-					lastPt = pixPt;
-				}
-			}
-
-			if ( _isClosedFigure )
-				path.CloseFigure();
-
-			return path;
-		}
-
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="PolyObj"/>.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( _points != null && _points.Length > 1 )
-			{
-				if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-					return false;
-
-				using ( GraphicsPath path = MakePath( pane ) )
-					return path.IsVisible( pt );
-			}
-			else
-				return false;
-		}
-		
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/RadarPointList.cs b/BDInfo/ZedGraph/RadarPointList.cs
deleted file mode 100644
index 1bcd32e85c..0000000000
--- a/BDInfo/ZedGraph/RadarPointList.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-//============================================================================
-//RadarPointList Class
-//Copyright © 2006  John Champion, Jerry Vos
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections.Generic;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class containing a set of data values to be plotted as a RadarPlot.
-	/// This class will effectively convert the data into <see cref="PointPair" /> objects
-	/// by converting the polar coordinates to rectangular coordinates
-	/// </summary>
-	/// <seealso cref="BasicArrayPointList" />
-	/// <seealso cref="IPointList" />
-	/// <seealso cref="IPointListEdit" />
-	/// 
-	/// <author>Jerry Vos and John Champion</author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class RadarPointList : List<PointPair>, IPointList, IPointListEdit
-	{
-
-	#region Fields
-		/// <summary>
-		/// Default to clockwise rotation as this is the standard for radar charts
-		/// </summary>
-		private bool _clockwise = true;
-
-		/// <summary>
-		/// Default to 90 degree rotation so main axis is in the 12 o'clock position,
-		/// which is the standard for radar charts.
-		/// </summary>
-		private double _rotation = 90;
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="PointPair"/> object by
-		/// its ordinal position in the list.  This method does the calculations
-		/// to convert the data from polar to rectangular coordinates.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="PointPair"/> object to be accessed.</param>
-		/// <value>A <see cref="PointPair"/> object reference.</value>
-		public new PointPair this[int index]
-		{
-			get
-			{
-				int count = this.Count;
-				// The last point is a repeat of the first point
-				if ( index == count - 1 )
-					index = 0;
-
-				if ( index < 0 || index >= count )
-					return null;
-
-				PointPair pt = (PointPair)base[index];
-//				double theta = (double) index / (double) count * 2.0 * Math.PI;
-				double rotationRadians = _rotation * Math.PI / 180;
-				double theta = rotationRadians + ( _clockwise ? -1.0d : 1.0d ) *
-						( (double) index / (double) (count-1) * 2.0 * Math.PI);
-				double x = pt.Y * Math.Cos( theta );
-				double y = pt.Y * Math.Sin( theta );
-				return new PointPair( x, y, pt.Z, (string) pt.Tag );
-			}
-			set
-			{
-				int count = this.Count;
-				// The last point is a repeat of the first point
-				if ( index == count - 1 )
-					index = 0;
-
-				if ( index < 0 || index >= count )
-					return;
-
-				PointPair pt = (PointPair)base[index];
-				pt.Y = Math.Sqrt( value.X * value.X + value.Y * value.Y );
-			}
-		}
-
-		/// <summary>
-		/// Indicates if points should be added in clockwise or counter-clockwise order
-		/// </summary>
-		public bool Clockwise
-		{
-			get { return _clockwise; }
-			set { _clockwise = value; }
-		}
-
-		/// <summary>
-		/// Sets the angular rotation (starting angle) for the initial axis
-		/// </summary>
-		public double Rotation
-		{
-			get { return _rotation; }
-			set { _rotation = value; }
-		}
-
-		/// <summary>
-		/// Get the raw data
-		/// </summary>
-		/// <param name="index"></param>
-		/// <returns></returns>
-		private PointPair GetAt( int index )
-		{
-			return base[index];
-		}
-
-		/// <summary>
-		/// gets the number of points available in the list
-		/// </summary>
-		public new int Count
-		{
-			get { return base.Count + 1; }
-		}
-
-	#endregion
-
-	#region Constructors
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public RadarPointList() : base()
-		{
-		}
-
-		/// <summary>
-		/// Copy Constructor
-		/// </summary>
-		public RadarPointList( RadarPointList rhs )
-		{
-			for ( int i = 0; i < rhs.Count; i++ )
-				this.Add( rhs.GetAt(i) );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public RadarPointList Clone()
-		{
-			return new RadarPointList( this );
-		}
-
-
-	#endregion
-
-	#region Methods
-/*
- * /// <summary>
-		/// Add the specified PointPair to the collection.
-		/// </summary>
-		/// <param name="pt">The PointPair to be added</param>
-		/// <returns>The ordinal position in the list where the point was added</returns>
-		public int Add( PointPair pt )
-		{
-			return List.Add( pt );
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="RadarPointList"/> from a value of type double.
-		/// </summary>
-		/// <param name="r">The radial coordinate value</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		/// <seealso cref="IList.Add"/>
-		public int Add( double r )
-		{
-			return List.Add( new PointPair( PointPair.Missing, r ) );
-		}
-*/
-		/// <summary>
-		/// Add a single point to the <see cref="RadarPointList"/> from two values of type double.
-		/// </summary>
-		/// <param name="r">The radial coordinate value</param>
-		/// <param name="z">The 'Z' coordinate value, which is not normally used for plotting,
-		/// but can be used for <see cref="FillType.GradientByZ" /> type fills</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public void Add( double r, double z )
-		{
-			Add( new PointPair( PointPair.Missing, r, z ) );
-		}
-
-	#endregion
-	}
-}
-
-
diff --git a/BDInfo/ZedGraph/RollingPointPairList.cs b/BDInfo/ZedGraph/RollingPointPairList.cs
deleted file mode 100644
index d1273d3b92..0000000000
--- a/BDInfo/ZedGraph/RollingPointPairList.cs
+++ /dev/null
@@ -1,655 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2006  John Champion
-//RollingPointPairList class Copyright © 2006 by Colin Green
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-using System;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that provides a rolling list of <see cref="PointPair" /> objects.
-	/// This is essentially a 
-	/// first-in-first-out (FIFO) queue with a fixed capacity which allows 'rolling' 
-	/// (or oscilloscope like) graphs to be be animated without having the overhead of an
-	/// ever-growing ArrayList.
-	/// 
-	/// The queue is constructed with a fixed capacity and new points can be enqueued. When the 
-	/// capacity is reached the oldest (first in) PointPair is overwritten. However, when 
-	/// accessing via <see cref="IPointList" />, the <see cref="PointPair" /> objects are
-	/// seen in the order in which they were enqeued.
-	///
-	/// RollingPointPairList supports data editing through the <see cref="IPointListEdit" />
-	/// interface.
-	/// 
-	/// <author>Colin Green with mods by John Champion</author>
-	/// <version> $Date: 2007/11/05 04:33:26 $ </version>
-	/// </summary>
-	[Serializable]
-	public class RollingPointPairList : IPointList, ISerializable, IPointListEdit
-	{
-
-	#region Fields
-
-		/// <summary>
-		/// An array of PointPair objects that acts as the underlying buffer.
-		/// </summary>
-		protected PointPair[] _mBuffer;
-
-		/// <summary>
-		/// The index of the previously enqueued item. -1 if buffer is empty.
-		/// </summary>
-		protected int _headIdx;
-
-		/// <summary>
-		/// The index of the next item to be dequeued. -1 if buffer is empty.
-		/// </summary>
-		protected int _tailIdx;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Constructs an empty buffer with the specified capacity.
-		/// </summary>
-		/// <param name="capacity">Number of elements in the rolling list.  This number
-		/// cannot be changed once the RollingPointPairList is constructed.</param>
-		public RollingPointPairList( int capacity )
-			: this( capacity, false )
-		{
-			_mBuffer = new PointPair[capacity];
-			_headIdx = _tailIdx = -1;
-		}
-
-		/// <summary>
-		/// Constructs an empty buffer with the specified capacity.  Pre-allocates space
-		/// for all PointPair's in the list if <paramref name="preLoad"/> is true.
-		/// </summary>
-		/// <param name="capacity">Number of elements in the rolling list.  This number
-		/// cannot be changed once the RollingPointPairList is constructed.</param>
-		/// <param name="preLoad">true to pre-allocate all PointPair instances in
-		/// the list, false otherwise.  Note that in order to be memory efficient,
-		/// the <see cref="Add(double,double,double)"/> method should be used to add
-		/// data.  Avoid the <see cref="Add(PointPair)"/> method.
-		/// </param>
-		/// <seealso cref="Add(double,double,double)"/>
-		public RollingPointPairList( int capacity, bool preLoad )
-		{
-			_mBuffer = new PointPair[capacity];
-			_headIdx = _tailIdx = -1;
-
-			if ( preLoad )
-				for ( int i = 0; i < capacity; i++ )
-					_mBuffer[i] = new PointPair();
-		}
-
-		/// <summary>
-		/// Constructs a buffer with a copy of the items within the provided
-		/// <see cref="IPointList" />.
-		/// The <see cref="Capacity" /> is set to the length of the provided list.
-		/// </summary>
-		/// <param name="rhs">The <see cref="IPointList" /> to be copied.</param>
-		public RollingPointPairList( IPointList rhs )
-		{
-			_mBuffer = new PointPair[rhs.Count];
-
-			for ( int i = 0; i < rhs.Count; i++ )
-			{
-				_mBuffer[i] = new PointPair( rhs[i] );
-			}
-
-			_headIdx = rhs.Count - 1;
-			_tailIdx = 0;
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets the capacity of the rolling buffer.
-		/// </summary>
-		public int Capacity
-		{
-			get { return _mBuffer.Length; }
-		}
-
-		/// <summary>
-		/// Gets the count of items within the rolling buffer. Note that this may be less than
-		/// the capacity.
-		/// </summary>
-		public int Count
-		{
-			get
-			{
-				if ( _headIdx == -1 )
-					return 0;
-
-				if ( _headIdx > _tailIdx )
-					return ( _headIdx - _tailIdx ) + 1;
-
-				if ( _tailIdx > _headIdx )
-					return ( _mBuffer.Length - _tailIdx ) + _headIdx + 1;
-
-				return 1;
-			}
-		}
-
-		/// <summary>
-		/// Gets a bolean that indicates if the buffer is empty.
-		/// Alternatively you can test Count==0.
-		/// </summary>
-		public bool IsEmpty
-		{
-			get { return _headIdx == -1; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="PointPair" /> at the specified index in the buffer.
-		/// </summary>
-		/// <remarks>
-		/// Index must be within the current size of the buffer, e.g., the set
-		/// method will not expand the buffer even if <see cref="Capacity" /> is available
-		/// </remarks>
-		public PointPair this[int index]
-		{
-			get
-			{
-				if ( index >= Count || index < 0 )
-					throw new ArgumentOutOfRangeException();
-
-				index += _tailIdx;
-				if ( index >= _mBuffer.Length )
-					index -= _mBuffer.Length;
-
-				return _mBuffer[index];
-			}
-			set
-			{
-				if ( index >= Count || index < 0 )
-					throw new ArgumentOutOfRangeException();
-
-				index += _tailIdx;
-				if ( index >= _mBuffer.Length )
-					index -= _mBuffer.Length;
-
-				_mBuffer[index] = value;
-			}
-
-		}
-
-	#endregion
-
-	#region Public Methods
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public RollingPointPairList Clone()
-		{
-			return new RollingPointPairList( this );
-		}
-
-		/// <summary>
-		/// Clear the buffer of all <see cref="PointPair"/> objects.
-		/// Note that the <see cref="Capacity" /> remains unchanged.
-		/// </summary>
-		public void Clear()
-		{
-			_headIdx = _tailIdx = -1;
-		}
-
-		/// <summary>
-		/// Calculate that the next index in the buffer that should receive a new data point.
-		/// Note that this method actually advances the buffer, so a datapoint should be
-		/// added at _mBuffer[_headIdx].
-		/// </summary>
-		/// <returns>The index position of the new head element</returns>
-		private int GetNextIndex()
-		{
-			if ( _headIdx == -1 )
-			{	// buffer is currently empty.
-				_headIdx = _tailIdx = 0;
-			}
-			else
-			{
-				// Determine the index to write to.
-				if ( ++_headIdx == _mBuffer.Length )
-				{	// Wrap around.
-					_headIdx = 0;
-				}
-
-				if ( _headIdx == _tailIdx )
-				{	// Buffer overflow. Increment tailIdx.
-					if ( ++_tailIdx == _mBuffer.Length )
-					{	// Wrap around.
-						_tailIdx = 0;
-					}
-				}
-			}
-
-			return _headIdx;
-		}
-
-		/// <summary>
-		/// Add a <see cref="PointPair"/> onto the head of the queue,
-		/// overwriting old values if the buffer is full.
-		/// </summary>
-		/// <param name="item">The <see cref="PointPair" /> to be added.</param>
-		public void Add( PointPair item )
-		{
-			_mBuffer[ GetNextIndex() ] = item;
-		}
-
-		/// <summary>
-		/// Add an <see cref="IPointList"/> object to the head of the queue.
-		/// </summary>
-		/// <param name="pointList">A reference to the <see cref="IPointList"/> object to
-		/// be added</param>
-		public void Add( IPointList pointList )
-		{   // A slightly more efficient approach would be to determine where the new points should placed within
-			// the buffer and to then copy them in directly - updating the head and tail indexes appropriately.
-			for ( int i = 0; i < pointList.Count; i++ )
-				Add( pointList[i] );
-		}
-
-		/// <summary>
-		/// Remove an old item from the tail of the queue.
-		/// </summary>
-		/// <returns>The removed item. Throws an <see cref="InvalidOperationException" />
-		/// if the buffer was empty. 
-		/// Check the buffer's length (<see cref="Count" />) or the <see cref="IsEmpty" />
-		/// property to avoid exceptions.</returns>
-		public PointPair Remove()
-		{
-			if ( _tailIdx == -1 )
-			{	// buffer is currently empty.
-				throw new InvalidOperationException( "buffer is empty." );
-			}
-
-			PointPair o = _mBuffer[_tailIdx];
-
-			if ( _tailIdx == _headIdx )
-			{	// The buffer is now empty.
-				_headIdx = _tailIdx = -1;
-				return o;
-			}
-
-			if ( ++_tailIdx == _mBuffer.Length )
-			{	// Wrap around.
-				_tailIdx = 0;
-			}
-
-			return o;
-		}
-
-		/// <summary>
-		/// Remove the <see cref="PointPair" /> at the specified index
-		/// </summary>
-		/// <remarks>
-		/// All items in the queue that lie after <paramref name="index"/> will
-		/// be shifted back by one, and the queue will be one item shorter.
-		/// </remarks>
-		/// <param name="index">The ordinal position of the item to be removed.
-		/// Throws an <see cref="ArgumentOutOfRangeException" /> if index is less than
-		/// zero or greater than or equal to <see cref="Count" />
-		/// </param>
-		public void RemoveAt( int index )
-		{
-			int count = this.Count;
-
-			if ( index >= count || index < 0 )
-				throw new ArgumentOutOfRangeException();
-
-			// shift all the items that lie after index back by 1
-			for ( int i = index + _tailIdx; i < _tailIdx + count - 1; i++ )
-			{
-				i = ( i >= _mBuffer.Length ) ? 0 : i;
-				int j = i + 1;
-				j = ( j >= _mBuffer.Length ) ? 0 : j;
-				_mBuffer[i] = _mBuffer[j];
-			}
-
-			// Remove the item from the head (it's been duplicated already)
-			Pop();
-		}
-
-		/// <summary>
-		/// Remove a range of <see cref="PointPair" /> objects starting at the specified index
-		/// </summary>
-		/// <remarks>
-		/// All items in the queue that lie after <paramref name="index"/> will
-		/// be shifted back, and the queue will be <paramref name="count" /> items shorter.
-		/// </remarks>
-		/// <param name="index">The ordinal position of the item to be removed.
-		/// Throws an <see cref="ArgumentOutOfRangeException" /> if index is less than
-		/// zero or greater than or equal to <see cref="Count" />
-		/// </param>
-		/// <param name="count">The number of items to be removed.  Throws an
-		/// <see cref="ArgumentOutOfRangeException" /> if <paramref name="count" /> is less than zero
-		/// or greater than the total available items in the queue</param>
-		public void RemoveRange( int index, int count )
-		{
-			int totalCount = this.Count;
-
-			if ( index >= totalCount || index < 0 || count < 0 || count > totalCount )
-				throw new ArgumentOutOfRangeException();
-
-			for ( int i = 0; i < count; i++ )
-				this.RemoveAt( index );
-		}
-
-		/// <summary>
-		/// Pop an item off the head of the queue.
-		/// </summary>
-		/// <returns>The popped item. Throws an exception if the buffer was empty.</returns>
-		public PointPair Pop()
-		{
-			if ( _tailIdx == -1 )
-			{	// buffer is currently empty.
-				throw new InvalidOperationException( "buffer is empty." );
-			}
-
-			PointPair o = _mBuffer[_headIdx];
-
-			if ( _tailIdx == _headIdx )
-			{	// The buffer is now empty.
-				_headIdx = _tailIdx = -1;
-				return o;
-			}
-
-			if ( --_headIdx == -1 )
-			{	// Wrap around.
-				_headIdx = _mBuffer.Length - 1;
-			}
-
-			return o;
-		}
-
-		/// <summary>
-		/// Peek at the <see cref="PointPair" /> item at the head of the queue.
-		/// </summary>
-		/// <returns>The <see cref="PointPair" /> item at the head of the queue.
-		/// Throws an <see cref="InvalidOperationException" /> if the buffer was empty.
-		/// </returns>
-		public PointPair Peek()
-		{
-			if ( _headIdx == -1 )
-			{	// buffer is currently empty.
-				throw new InvalidOperationException( "buffer is empty." );
-			}
-
-			return _mBuffer[_headIdx];
-		}
-
-	#endregion
-
-	#region Auxilliary Methods
-
-		/// <summary>
-		/// Add a set of values onto the head of the queue,
-		/// overwriting old values if the buffer is full.
-		/// </summary>
-		/// <remarks>
-		/// This method is much more efficient that the <see cref="Add(PointPair)">Add(PointPair)</see>
-		/// method, since it does not require that a new PointPair instance be provided.
-		/// If the buffer already contains a <see cref="PointPair"/> at the head position,
-		/// then the x, y, z, and tag values will be copied into the existing PointPair.
-		/// Otherwise, a new PointPair instance must be created.
-		/// In this way, each PointPair position in the rolling list will only be allocated one time.
-		/// To truly be memory efficient, the <see cref="Remove" />, <see cref="RemoveAt" />,
-		/// and <see cref="Pop" /> methods should be avoided.  Also, the <paramref name="tag"/> property
-		/// for this method should be null, since it is a reference type.
-		/// </remarks>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="z">The Z value</param>
-		/// <param name="tag">The Tag value for the PointPair</param>
-		public void Add( double x, double y, double z, object tag )
-		{
-			// advance the rolling list
-			GetNextIndex();
-
-			if ( _mBuffer[_headIdx] == null )
-				_mBuffer[_headIdx] = new PointPair( x, y, z, tag );
-			else
-			{
-				_mBuffer[_headIdx].X = x;
-				_mBuffer[_headIdx].Y = y;
-				_mBuffer[_headIdx].Z = z;
-				_mBuffer[_headIdx].Tag = tag;
-			}
-		}
-
-		/// <summary>
-		/// Add a set of values onto the head of the queue,
-		/// overwriting old values if the buffer is full.
-		/// </summary>
-		/// <remarks>
-		/// This method is much more efficient that the <see cref="Add(PointPair)">Add(PointPair)</see>
-		/// method, since it does not require that a new PointPair instance be provided.
-		/// If the buffer already contains a <see cref="PointPair"/> at the head position,
-		/// then the x, y, z, and tag values will be copied into the existing PointPair.
-		/// Otherwise, a new PointPair instance must be created.
-		/// In this way, each PointPair position in the rolling list will only be allocated one time.
-		/// To truly be memory efficient, the <see cref="Remove" />, <see cref="RemoveAt" />,
-		/// and <see cref="Pop" /> methods should be avoided.
-		/// </remarks>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		public void Add( double x, double y )
-		{
-			Add( x, y, PointPair.Missing, null );
-		}
-
-		/// <summary>
-		/// Add a set of values onto the head of the queue,
-		/// overwriting old values if the buffer is full.
-		/// </summary>
-		/// <remarks>
-		/// This method is much more efficient that the <see cref="Add(PointPair)">Add(PointPair)</see>
-		/// method, since it does not require that a new PointPair instance be provided.
-		/// If the buffer already contains a <see cref="PointPair"/> at the head position,
-		/// then the x, y, z, and tag values will be copied into the existing PointPair.
-		/// Otherwise, a new PointPair instance must be created.
-		/// In this way, each PointPair position in the rolling list will only be allocated one time.
-		/// To truly be memory efficient, the <see cref="Remove" />, <see cref="RemoveAt" />,
-		/// and <see cref="Pop" /> methods should be avoided.  Also, the <paramref name="tag"/> property
-		/// for this method should be null, since it is a reference type.
-		/// </remarks>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="tag">The Tag value for the PointPair</param>
-		public void Add( double x, double y, object tag )
-		{
-			Add( x, y, PointPair.Missing, tag );
-		}
-
-		/// <summary>
-		/// Add a set of values onto the head of the queue,
-		/// overwriting old values if the buffer is full.
-		/// </summary>
-		/// <remarks>
-		/// This method is much more efficient that the <see cref="Add(PointPair)">Add(PointPair)</see>
-		/// method, since it does not require that a new PointPair instance be provided.
-		/// If the buffer already contains a <see cref="PointPair"/> at the head position,
-		/// then the x, y, z, and tag values will be copied into the existing PointPair.
-		/// Otherwise, a new PointPair instance must be created.
-		/// In this way, each PointPair position in the rolling list will only be allocated one time.
-		/// To truly be memory efficient, the <see cref="Remove" />, <see cref="RemoveAt" />,
-		/// and <see cref="Pop" /> methods should be avoided.
-		/// </remarks>
-		/// <param name="x">The X value</param>
-		/// <param name="y">The Y value</param>
-		/// <param name="z">The Z value</param>
-		public void Add( double x, double y, double z )
-		{
-			Add( x, y, z, null );
-		}
-
-		/// <summary>
-		/// Add a set of points to the <see cref="RollingPointPairList"/>
-		/// from two arrays of type double.
-		/// If either array is null, then a set of ordinal values is automatically
-		/// generated in its place (see <see cref="AxisType.Ordinal"/>).
-		/// If the arrays are of different size, then the larger array prevails and the
-		/// smaller array is padded with <see cref="PointPairBase.Missing"/> values.
-		/// </summary>
-		/// <param name="x">A double[] array of X values</param>
-		/// <param name="y">A double[] array of Y values</param>
-		public void Add( double[] x, double[] y )
-		{
-			int len = 0;
-
-			if ( x != null )
-				len = x.Length;
-			if ( y != null && y.Length > len )
-				len = y.Length;
-
-			for ( int i = 0; i < len; i++ )
-			{
-				PointPair point = new PointPair( 0, 0, 0 );
-				if ( x == null )
-					point.X = (double)i + 1.0;
-				else if ( i < x.Length )
-					point.X = x[i];
-				else
-					point.X = PointPair.Missing;
-
-				if ( y == null )
-					point.Y = (double)i + 1.0;
-				else if ( i < y.Length )
-					point.Y = y[i];
-				else
-					point.Y = PointPair.Missing;
-
-				Add( point );
-			}
-		}
-
-		/// <summary>
-		/// Add a set of points to the <see cref="RollingPointPairList"/> from
-		/// three arrays of type double.
-		/// If the X or Y array is null, then a set of ordinal values is automatically
-		/// generated in its place (see <see cref="AxisType.Ordinal"/>.
-		/// If the <see paramref="z"/> value
-		/// is null, then it is set to zero.
-		/// If the arrays are of different size, then the larger array prevails and the
-		/// smaller array is padded with <see cref="PointPairBase.Missing"/> values.
-		/// </summary>
-		/// <param name="x">A double[] array of X values</param>
-		/// <param name="y">A double[] array of Y values</param>
-		/// <param name="z">A double[] array of Z values</param>
-		public void Add( double[] x, double[] y, double[] z )
-		{
-			int len = 0;
-
-			if ( x != null )
-				len = x.Length;
-			if ( y != null && y.Length > len )
-				len = y.Length;
-			if ( z != null && z.Length > len )
-				len = z.Length;
-
-			for ( int i = 0; i < len; i++ )
-			{
-				PointPair point = new PointPair();
-
-				if ( x == null )
-					point.X = (double)i + 1.0;
-				else if ( i < x.Length )
-					point.X = x[i];
-				else
-					point.X = PointPair.Missing;
-
-				if ( y == null )
-					point.Y = (double)i + 1.0;
-				else if ( i < y.Length )
-					point.Y = y[i];
-				else
-					point.Y = PointPair.Missing;
-
-				if ( z == null )
-					point.Z = (double)i + 1.0;
-				else if ( i < z.Length )
-					point.Z = z[i];
-				else
-					point.Z = PointPair.Missing;
-
-				Add( point );
-			}
-		}
-
-	#endregion
-		
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected RollingPointPairList( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_headIdx = info.GetInt32( "headIdx" );
-			_tailIdx = info.GetInt32( "tailIdx" );
-			_mBuffer = (PointPair[])info.GetValue( "mBuffer", typeof( PointPair[] ) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "headIdx", _headIdx );
-			info.AddValue( "tailIdx", _tailIdx );
-			info.AddValue( "mBuffer", _mBuffer );
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/SampleMultiPointList.cs b/BDInfo/ZedGraph/SampleMultiPointList.cs
deleted file mode 100644
index f21da41131..0000000000
--- a/BDInfo/ZedGraph/SampleMultiPointList.cs
+++ /dev/null
@@ -1,284 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Charting Library for .Net
-//Copyright © 2005 John Champion and Jerry Vos
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An enum used to specify the X or Y data type of interest -- see
-	/// <see cref="SampleMultiPointList.XData" /> and <see cref="SampleMultiPointList.YData" />.
-	/// </summary>
-	public enum PerfDataType
-	{
-		/// <summary>
-		/// The time (seconds) at which these data are measured
-		/// </summary>
-		Time,
-		/// <summary>
-		/// The distance traveled, meters
-		/// </summary>
-		Distance,
-		/// <summary>
-		/// The instantaneous velocity, meters per second
-		/// </summary>
-		Velocity,
-		/// <summary>
-		/// The instantaneous acceleration, meters per second squared
-		/// </summary>
-		Acceleration
-	};
-
-	/// <summary>
-	/// Sample data structure containing a variety of data values, in this case the values
-	/// are related in that they correspond to the same time value.
-	/// </summary>
-	public class PerformanceData
-	{
-		/// <summary>
-		/// The time (seconds) at which these data are measured
-		/// </summary>
-		public double	time;
-		/// <summary>
-		/// The distance traveled, meters
-		/// </summary>
-		public double	distance;
-		/// <summary>
-		/// The instantaneous velocity, meters per second
-		/// </summary>
-		public double	velocity;
-		/// <summary>
-		/// The instantaneous acceleration, meters per second squared
-		/// </summary>
-		public double	acceleration;
-
-		/// <summary>
-		/// Constructor that specifies each data value in the PerformanceData struct
-		/// </summary>
-		/// <param name="time">The time (seconds) at which these data are measured</param>
-		/// <param name="distance">The distance traveled, meters</param>
-		/// <param name="velocity">The instantaneous velocity, meters per second</param>
-		/// <param name="acceleration">The instantaneous acceleration, meters per second squared</param>
-		public PerformanceData( double time, double distance, double velocity, double acceleration )
-		{
-			this.time = time;
-			this.distance = distance;
-			this.velocity = velocity;
-			this.acceleration = acceleration;
-		}
-
-		/// <summary>
-		/// Gets or sets the data value as specified by the <see cref="PerfDataType" /> enum
-		/// </summary>
-		/// <param name="type">The required data value type</param>
-		public double this[ PerfDataType type ]
-		{
-			get
-			{
-				switch( type )
-				{
-					default:
-					case PerfDataType.Time:
-						return time;
-					case PerfDataType.Distance:
-						return distance;
-					case PerfDataType.Velocity:
-						return velocity;
-					case PerfDataType.Acceleration:
-						return acceleration;
-				}
-			}
-			set
-			{
-				switch( type )
-				{
-					case PerfDataType.Time:
-						time = value;
-						break;
-					case PerfDataType.Distance:
-						distance = value;
-						break;
-					case PerfDataType.Velocity:
-						velocity = value;
-						break;
-					case PerfDataType.Acceleration:
-						acceleration = value;
-						break;
-				}
-			}
-		}
-	}
-
-	/// <summary>
-	/// A sample class that holds an internal collection, and implements the
-	/// <see cref="IPointList" /> interface so that it can be used by ZedGraph as curve data.
-	/// </summary>
-	/// <remarks>
-	/// This particular class efficiently implements the data storage so that the class
-	/// can be cloned without duplicating the data points.  For example, you can create
-	/// a <see cref="SampleMultiPointList" />, populate it with values, and set
-	/// <see cref="XData" /> = <see cref="PerfDataType.Time" /> and
-	/// <see cref="YData" /> = <see cref="PerfDataType.Distance" />.
-	/// You can then clone this <see cref="SampleMultiPointList" /> to a new one, and set
-	/// <see cref="YData" /> = <see cref="PerfDataType.Velocity" />.
-	/// Each of these <see cref="SampleMultiPointList" />'s can then be used as an
-	/// <see cref="ZedGraph.GraphPane.AddCurve(string,IPointList,Color)" /> argument,
-	/// thereby plotting a distance vs time curve and a velocity vs time curve.  There
-	/// will still be only one copy of the data in memory.
-	/// </remarks>
-	[Serializable]
-	public class SampleMultiPointList : IPointList
-	{
-		/// <summary>
-		/// This is where the data are stored.  Duplicating the <see cref="SampleMultiPointList" />
-		/// copies the reference to this <see cref="ArrayList" />, but does not actually duplicate
-		/// the data.
-		/// </summary>
-		private ArrayList	DataCollection;
-
-		/// <summary>
-		/// Determines what X data will be returned by the indexer of this list.
-		/// </summary>
-		public PerfDataType XData;
-		/// <summary>
-		/// Determines what Y data will be returned by the indexer of this list.
-		/// </summary>
-		public PerfDataType YData;
-
-		/// <summary>
-		/// Default constructor
-		/// </summary>
-		public SampleMultiPointList()
-		{
-			XData = PerfDataType.Time;
-			YData = PerfDataType.Distance;
-			DataCollection = new ArrayList();
-		}
-
-		/// <summary>
-		/// The Copy Constructor.  This method does NOT duplicate the data, it merely makes
-		/// another "Window" into the same collection.  You can make multiple copies and
-		/// set the <see cref="XData" /> and/or <see cref="YData" /> properties to different
-		/// values to plot different data, while maintaining only one copy of the original values.
-		/// </summary>
-		/// <param name="rhs">The <see cref="SampleMultiPointList" /> from which to copy</param>
-		public SampleMultiPointList( SampleMultiPointList rhs )
-		{
-			DataCollection = rhs.DataCollection;
-			XData = rhs.XData;
-			YData = rhs.YData;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public SampleMultiPointList Clone()
-		{
-			return new SampleMultiPointList( this );
-		}
-
-		/// <summary>
-		/// Indexer to access the data.  This gets the appropriate data and converts to
-		/// the <see cref="PointPair" /> struct that is compatible with ZedGraph.  The
-		/// actual data returned depends on the values of <see cref="XData" /> and
-		/// <see cref="YData" />.
-		/// </summary>
-		/// <param name="index">The ordinal position of the desired point in the list</param>
-		/// <returns>A <see cref="PointPair" /> corresponding to the specified ordinal data position</returns>
-		public PointPair this[ int index ]
-		{
-			get
-			{
-				double xVal, yVal;
-				if ( index >= 0 && index < this.Count )
-				{
-					// grab the specified PerformanceData struct
-					PerformanceData perfData = (PerformanceData) DataCollection[index];
-					// extract the values from the struct according to the user-set
-					// enum values of XData and YData
-					xVal = perfData[XData];
-					yVal = perfData[YData];
-				}
-				else
-				{
-					xVal = PointPair.Missing;
-					yVal = PointPair.Missing;
-				}
-
-				// insert the values into a pointpair and return
-				return new PointPair( xVal, yVal, PointPair.Missing, null );
-			}
-		}
-
-		/// <summary>
-		/// Gets the number of data points in the collection
-		/// </summary>
-		public int Count
-		{
-			get { return DataCollection.Count; }
-		}
-
-		/// <summary>
-		/// Adds the specified <see cref="PerformanceData" /> struct to the end of the collection.
-		/// </summary>
-		/// <param name="perfData">A <see cref="PerformanceData" /> struct to be added</param>
-		/// <returns>The ordinal position in the collection where the values were added</returns>
-		public int Add( PerformanceData perfData )
-		{
-			return DataCollection.Add( perfData );
-		}
-
-		/// <summary>
-		/// Remove the <see cref="PerformanceData" /> struct from the list at the specified
-		/// ordinal location.
-		/// </summary>
-		/// <param name="index">The ordinal location of the <see cref="PerformanceData" />
-		/// struct to be removed</param>
-		public void RemoveAt( int index )
-		{
-			DataCollection.RemoveAt( index );
-		}
-
-		/// <summary>
-		/// Insert the specified <see cref="PerformanceData" /> struct into the list at
-		/// the specified ordinal location.
-		/// </summary>
-		/// <param name="index">The ordinal location at which to insert</param>
-		/// <param name="perfData">The <see cref="PerformanceData" /> struct to be inserted</param>
-		public void Insert( int index, PerformanceData perfData )
-		{
-			DataCollection.Insert( index, perfData );
-		}
-
-	}
-}
diff --git a/BDInfo/ZedGraph/SamplePointList.cs b/BDInfo/ZedGraph/SamplePointList.cs
deleted file mode 100644
index aa2871f527..0000000000
--- a/BDInfo/ZedGraph/SamplePointList.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-using System;
-using System.Collections;
-using System.Text;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// enumeration used to indicate which type of data will be plotted.
-	/// </summary>
-	public enum SampleType
-	{
-		/// <summary>
-		/// Designates the "Time" property will be used
-		/// </summary>
-		Time,
-		/// <summary>
-		/// Designates the "Position" property will be used
-		/// </summary>
-		Position,
-		/// <summary>
-		/// Designates the Instantaneous Velocity property will be used
-		/// </summary>
-		VelocityInst,
-		/// <summary>
-		/// Designates the "Time since start" property will be used
-		/// </summary>
-		TimeDiff,
-		/// <summary>
-		/// Designates the Average Velocity property will be used
-		/// </summary>
-		VelocityAvg
-	};
-
-	/// <summary>
-	/// A simple storage class to maintain an individual sampling of data
-	/// </summary>
-	public class Sample : System.Object
-	{
-		private DateTime	_time;
-		private double		_position;
-		private double		_velocity;
-
-		/// <summary>
-		/// The time of the sample
-		/// </summary>
-		public DateTime Time
-		{
-			get { return _time; }
-			set { _time = value; }
-		}
-		/// <summary>
-		/// The position at sample time
-		/// </summary>
-		public double Position
-		{
-			get { return _position; }
-			set { _position = value; }
-		}
-		/// <summary>
-		/// The instantaneous velocity at sample time
-		/// </summary>
-		public double Velocity
-		{
-			get { return _velocity; }
-			set { _velocity = value; }
-		}
-	}
-
-	/// <summary>
-	/// A collection class to maintain a set of samples
-	/// </summary>
-	[Serializable]
-	public class SamplePointList : IPointList
-	{
-		/// <summary>
-		/// Determines what data type gets plotted for the X values
-		/// </summary>
-		public SampleType XType;
-		/// <summary>
-		/// Determines what data type gets plotted for the Y values
-		/// </summary>
-		public SampleType YType;
-
-		// Stores the collection of samples
-		private ArrayList list;
-
-		/// <summary>
-		/// Indexer: get the Sample instance at the specified ordinal position in the list
-		/// </summary>
-		/// <param name="index">The ordinal position in the list of samples</param>
-		/// <returns>Returns a <see cref="PointPair" /> instance containing the
-		/// data specified by <see cref="XType" /> and <see cref="YType" />
-		/// </returns>
-		public PointPair this[int index]
-		{
-			get
-			{
-				PointPair pt = new PointPair();
-				Sample sample = (Sample) list[index];
-				pt.X = GetValue( sample, XType );
-				pt.Y = GetValue( sample, YType );
-				return pt;
-			}
-		}
-
-		/// <summary>
-		/// Gets the number of samples in the collection
-		/// </summary>
-		public int Count
-		{
-			get { return list.Count; }
-		}
-
-		/// <summary>
-		/// Get the specified data type from the specified sample
-		/// </summary>
-		/// <param name="sample">The sample instance of interest</param>
-		/// <param name="type">The data type to be extracted from the sample</param>
-		/// <returns>A double value representing the requested data</returns>
-		public double GetValue( Sample sample, SampleType type )
-		{
-			switch ( type )
-			{
-				case SampleType.Position:
-					return sample.Position;
-				case SampleType.Time:
-					return sample.Time.ToOADate();
-				case SampleType.TimeDiff:
-					return sample.Time.ToOADate() - ( (Sample)list[0] ).Time.ToOADate();
-				case SampleType.VelocityAvg:
-					double timeDiff = sample.Time.ToOADate() - ( (Sample)list[0] ).Time.ToOADate();
-					if ( timeDiff <= 0 )
-						return PointPair.Missing;
-					else
-						return ( sample.Position - ( (Sample)list[0] ).Position ) / timeDiff;
-				case SampleType.VelocityInst:
-					return sample.Velocity;
-				default:
-					return PointPair.Missing;
-			}
-		}
-
-		/// <summary>
-		/// Append a sample to the collection
-		/// </summary>
-		/// <param name="sample">The sample to append</param>
-		/// <returns>The ordinal position at which the sample was added</returns>
-		public int Add( Sample sample )
-		{
-			return list.Add( sample );
-		}
-
-		// generic Clone: just call the typesafe version
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// typesafe clone method
-		/// </summary>
-		/// <returns>A new cloned SamplePointList.  This returns a copy of the structure,
-		/// but it does not duplicate the data (it just keeps a reference to the original)
-		/// </returns>
-		public SamplePointList Clone()
-		{
-			return new SamplePointList( this );
-		}
-
-		/// <summary>
-		/// default constructor
-		/// </summary>
-		public SamplePointList()
-		{
-			XType = SampleType.Time;
-			YType = SampleType.Position;
-			list = new ArrayList();
-		}
-
-		/// <summary>
-		/// copy constructor -- this returns a copy of the structure,
-		/// but it does not duplicate the data (it just keeps a reference to the original)
-		/// </summary>
-		/// <param name="rhs">The SamplePointList to be copied</param>
-		public SamplePointList( SamplePointList rhs )
-		{
-			XType = rhs.XType;
-			YType = rhs.YType;
-
-			// Don't duplicate the data values, just copy the reference to the ArrayList
-			this.list = rhs.list;
-
-			//foreach ( Sample sample in rhs )
-			//	list.Add( sample );
-		}
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Scale.cs b/BDInfo/ZedGraph/Scale.cs
deleted file mode 100644
index c312418156..0000000000
--- a/BDInfo/ZedGraph/Scale.cs
+++ /dev/null
@@ -1,2930 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The Scale class is an abstract base class that encompasses the properties
-	/// and methods associated with a scale of data.
-	/// </summary>
-	/// <remarks>This class is inherited by the
-	/// <see cref="LinearScale"/>, <see cref="LogScale"/>, <see cref="OrdinalScale"/>,
-	/// <see cref="TextScale"/>, <see cref="DateScale"/>, <see cref="ExponentScale"/>,
-	/// <see cref="DateAsOrdinalScale"/>, and <see cref="LinearAsOrdinalScale"/>
-	/// classes to define specific characteristics for those types.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.33 $ $Date: 2007/09/19 06:41:56 $ </version>
-	[Serializable]
-	abstract public class Scale : ISerializable
-	{
-	#region Fields
-
-		/// <summary> Private fields for the <see cref="Axis"/> scale definitions.
-		/// Use the public properties <see cref="Min"/>, <see cref="Max"/>,
-		/// <see cref="MajorStep"/>, <see cref="MinorStep"/>, and <see cref="Exponent" />
-		/// for access to these values.
-		/// </summary>
-		internal double	_min,
-								_max,
-								_majorStep,
-								_minorStep,
-								_exponent,
-								_baseTic;
-
-		/// <summary> Private fields for the <see cref="Axis"/> automatic scaling modes.
-		/// Use the public properties <see cref="MinAuto"/>, <see cref="MaxAuto"/>,
-		/// <see cref="MajorStepAuto"/>, <see cref="MinorStepAuto"/>, 
-		/// <see cref="MagAuto"/> and <see cref="FormatAuto"/>
-		/// for access to these values.
-		/// </summary>
-		internal bool		_minAuto,
-								_maxAuto,
-								_majorStepAuto,
-								_minorStepAuto,
-								_magAuto,
-								_formatAuto;
-
-		/// <summary> Private fields for the <see cref="Axis"/> "grace" settings.
-		/// These values determine how much extra space is left before the first data value
-		/// and after the last data value.
-		/// Use the public properties <see cref="MinGrace"/> and <see cref="MaxGrace"/>
-		/// for access to these values.
-		/// </summary>
-		internal double	_minGrace,
-								_maxGrace;
-
-
-		/// <summary> Private field for the <see cref="Axis"/> scale value display.
-		/// Use the public property <see cref="Mag"/> for access to this value.
-		/// </summary>
-		internal int		_mag;
-
-		/// <summary> Private fields for the <see cref="Scale"/> attributes.
-		/// Use the public properties <see cref="Scale.IsReverse"/> and <see cref="Scale.IsUseTenPower"/>
-		/// for access to these values.
-		/// </summary>
-		internal bool		_isReverse,
-								_isPreventLabelOverlap,
-								_isUseTenPower,
-								_isLabelsInside,
-								_isSkipFirstLabel,
-								_isSkipLastLabel,
-								_isSkipCrossLabel,
-								_isVisible;
-
-		/// <summary> Private <see cref="System.Collections.ArrayList"/> field for the <see cref="Axis"/> array of text labels.
-		/// This property is only used if <see cref="Type"/> is set to
-		/// <see cref="AxisType.Text"/> </summary>
-		internal string[] _textLabels = null;
-
-		/// <summary> Private field for the format of the <see cref="Axis"/> tic labels.
-		/// Use the public property <see cref="Format"/> for access to this value. </summary>
-		/// <seealso cref="FormatAuto"/>
-		internal string	_format;
-
-		/// <summary>
-		/// Private fields for Unit types to be used for the major and minor tics.
-		/// See <see cref="MajorUnit"/> and <see cref="MinorUnit"/> for the corresponding
-		/// public properties.
-		/// These types only apply for date-time scales (<see cref="IsDate"/>).
-		/// </summary>
-		/// <value>The value of these types is of enumeration type <see cref="DateUnit"/>
-		/// </value>
-		internal DateUnit		_majorUnit,
-									_minorUnit;
-
-		/// <summary> Private field for the alignment of the <see cref="Axis"/> tic labels.
-		/// This fields controls whether the inside, center, or outside edges of the text labels are aligned.
-		/// Use the public property <see cref="Scale.Align"/>
-		/// for access to this value. </summary>
-		/// <seealso cref="FormatAuto"/>
-		internal AlignP _align;
-
-		/// <summary> Private field for the alignment of the <see cref="Axis"/> tic labels.
-		/// This fields controls whether the left, center, or right edges of the text labels are aligned.
-		/// Use the public property <see cref="Scale.AlignH"/>
-		/// for access to this value. </summary>
-		/// <seealso cref="FormatAuto"/>
-		internal AlignH _alignH;
-
-
-		/// <summary> Private fields for the <see cref="Axis"/> font specificatios.
-		/// Use the public properties <see cref="FontSpec"/> and
-		/// <see cref="Scale.FontSpec"/> for access to these values. </summary>
-		internal FontSpec _fontSpec;
-
-		/// <summary>
-		/// Internal field that stores the amount of space between the scale labels and the
-		/// major tics.  Use the public property <see cref="LabelGap" /> to access this
-		/// value.
-		/// </summary>
-		internal float _labelGap;
-
-		/// <summary>
-		/// Data range temporary values, used by GetRange().
-		/// </summary>
-		internal double	_rangeMin,
-								_rangeMax,
-								_lBound,
-								_uBound;
-
-		/// <summary>
-		/// Pixel positions at the minimum and maximum value for this scale.
-		/// These are temporary values used/valid only during the Draw process.
-		/// </summary>
-		internal float _minPix,
-							_maxPix;
-	
-		/// <summary>
-		/// Scale values for calculating transforms.  These are temporary values
-		/// used ONLY during the Draw process.
-		/// </summary>
-		/// <remarks>
-		/// These values are just <see cref="Scale.Min" /> and <see cref="Scale.Max" />
-		/// for normal linear scales, but for log or exponent scales they will be a
-		/// linear representation.  For <see cref="LogScale" />, it is the
-		/// <see cref="Math.Log(double)" /> of the value, and for <see cref="ExponentScale" />,
-		/// it is the <see cref="Math.Exp(double)" />
-		/// of the value.
-		/// </remarks>
-		internal double	_minLinTemp,
-								_maxLinTemp;
-
-		/// <summary>
-		/// Gets or sets the linearized version of the <see cref="Min" /> scale range.
-		/// </summary>
-		/// <remarks>
-		/// This value is valid at any time, whereas <see cref="_minLinTemp" /> is an optimization
-		/// pre-set that is only valid during draw operations.
-		/// </remarks>
-		internal double _minLinearized
-		{
-			get { return Linearize( _min ); }
-			set { _min = DeLinearize( value ); }
-		}
-
-		/// <summary>
-		/// Gets or sets the linearized version of the <see cref="Max" /> scale range.
-		/// </summary>
-		/// <remarks>
-		/// This value is valid at any time, whereas <see cref="_maxLinTemp" /> is an optimization
-		/// pre-set that is only valid during draw operations.
-		/// </remarks>
-		internal double _maxLinearized
-		{
-			get { return Linearize( _max ); }
-			set { _max = DeLinearize( value ); }
-		}
-
-		/// <summary>
-		/// private field that stores the owner Axis that contains this Scale instance.
-		/// </summary>
-		internal Axis _ownerAxis;
-
-	#endregion
-
-	#region Defaults
-
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="Scale"/> class.
-		/// </summary>
-		public struct Default
-		{
-			/// <summary>
-			/// The default "zero lever" for automatically selecting the axis
-			/// scale range (see <see cref="PickScale"/>). This number is
-			/// used to determine when an axis scale range should be extended to
-			/// include the zero value.  This value is maintained only in the
-			/// <see cref="Default"/> class, and cannot be changed after compilation.
-			/// </summary>
-			public static double ZeroLever = 0.25;
-			/// <summary> The default "grace" value applied to the minimum data range.
-			/// This value is
-			/// expressed as a fraction of the total data range.  For example, assume the data
-			/// range is from 4.0 to 16.0, leaving a range of 12.0.  If MinGrace is set to
-			/// 0.1, then 10% of the range, or 1.2 will be subtracted from the minimum data value.
-			/// The scale will then be ranged to cover at least 2.8 to 16.0.
-			/// </summary>
-			/// <seealso cref="MinGrace"/>
-			public static double MinGrace = 0.1;
-			/// <summary> The default "grace" value applied to the maximum data range.
-			/// This value is
-			/// expressed as a fraction of the total data range.  For example, assume the data
-			/// range is from 4.0 to 16.0, leaving a range of 12.0.  If MaxGrace is set to
-			/// 0.1, then 10% of the range, or 1.2 will be added to the maximum data value.
-			/// The scale will then be ranged to cover at least 4.0 to 17.2.
-			/// </summary>
-			/// <seealso cref="MinGrace"/>
-			/// <seealso cref="MaxGrace"/>
-			public static double MaxGrace = 0.1;
-			/// <summary>
-			/// The maximum number of text labels (major tics) that will be allowed on the plot by
-			/// the automatic scaling logic.  This value applies only to <see cref="AxisType.Text"/>
-			/// axes.  If there are more than MaxTextLabels on the plot, then
-			/// <see cref="MajorStep"/> will be increased to reduce the number of labels.  That is,
-			/// the step size might be increased to 2.0 to show only every other label.
-			/// </summary>
-			public static double MaxTextLabels = 12.0;
-			/// <summary>
-			/// The default target number of steps for automatically selecting the X axis
-			/// scale step size (see <see cref="PickScale"/>).
-			/// This number is an initial target value for the number of major steps
-			/// on an axis.  This value is maintained only in the
-			/// <see cref="Default"/> class, and cannot be changed after compilation.
-			/// </summary>
-			public static double TargetXSteps = 7.0;
-			/// <summary>
-			/// The default target number of steps for automatically selecting the Y or Y2 axis
-			/// scale step size (see <see cref="PickScale"/>).
-			/// This number is an initial target value for the number of major steps
-			/// on an axis.  This value is maintained only in the
-			/// <see cref="Default"/> class, and cannot be changed after compilation.
-			/// </summary>
-			public static double TargetYSteps = 7.0;
-			/// <summary>
-			/// The default target number of minor steps for automatically selecting the X axis
-			/// scale minor step size (see <see cref="PickScale"/>).
-			/// This number is an initial target value for the number of minor steps
-			/// on an axis.  This value is maintained only in the
-			/// <see cref="Default"/> class, and cannot be changed after compilation.
-			/// </summary>
-			public static double TargetMinorXSteps = 5.0;
-			/// <summary>
-			/// The default target number of minor steps for automatically selecting the Y or Y2 axis
-			/// scale minor step size (see <see cref="PickScale"/>).
-			/// This number is an initial target value for the number of minor steps
-			/// on an axis.  This value is maintained only in the
-			/// <see cref="Default"/> class, and cannot be changed after compilation.
-			/// </summary>
-			public static double TargetMinorYSteps = 5.0;
-			/// <summary>
-			/// The default reverse mode for the <see cref="Axis"/> scale
-			/// (<see cref="IsReverse"/> property). true for a reversed scale
-			/// (X decreasing to the left, Y/Y2 decreasing upwards), false otherwise.
-			/// </summary>
-			public static bool IsReverse = false;
-			/// <summary>
-			/// The default setting for the <see cref="Axis"/> scale format string
-			/// (<see cref="Format"/> property).  For numeric values, this value is
-			/// setting according to the <see cref="String.Format(string,object)"/> format strings.  For date
-			/// type values, this value is set as per the <see cref="XDate.ToString()"/> function.
-			/// </summary>
-			//public static string ScaleFormat = "&dd-&mmm-&yy &hh:&nn";
-			public static string Format = "g";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Year"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Year"/>.
-			/// This value normally defaults to 1825 days (5 years).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeYearYear = 1825;  // 5 years
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Year"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Month"/>.
-			/// This value normally defaults to 730 days (2 years).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeYearMonth = 730;  // 2 years
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Month"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Month"/>.
-			/// This value normally defaults to 300 days (10 months).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeMonthMonth = 300;  // 10 months
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Day"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Day"/>.
-			/// This value normally defaults to 10 days.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeDayDay = 10;  // 10 days
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Day"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Hour"/>.
-			/// This value normally defaults to 3 days.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeDayHour = 3;  // 3 days
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Hour"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Hour"/>.
-			/// This value normally defaults to 0.4167 days (10 hours).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeHourHour = 0.4167;  // 10 hours
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Hour"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Minute"/>.
-			/// This value normally defaults to 0.125 days (3 hours).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeHourMinute = 0.125;  // 3 hours
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Minute"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Minute"/>.
-			/// This value normally defaults to 6.94e-3 days (10 minutes).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeMinuteMinute = 6.94e-3;  // 10 Minutes
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Minute"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Second"/>.
-			/// This value normally defaults to 2.083e-3 days (3 minutes).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeMinuteSecond = 2.083e-3;  // 3 Minutes
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// If the total span of data exceeds this number (in days), then the auto-range
-			/// code will select <see cref="MajorUnit"/> = <see cref="DateUnit.Second"/>
-			/// and <see cref="MinorUnit"/> = <see cref="DateUnit.Second"/>.
-			/// This value normally defaults to 3.472e-5 days (3 seconds).
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			public static double RangeSecondSecond = 3.472e-5;  // 3 Seconds
-
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Year"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Year"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatYearYear = "yyyy";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Year"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Month"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatYearMonth = "MMM-yyyy";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Month"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Month"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatMonthMonth = "MMM-yyyy";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Day"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Day"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatDayDay = "d-MMM";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Day"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Hour"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatDayHour = "d-MMM HH:mm";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Hour"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Hour"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatHourHour = "HH:mm";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Hour"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Minute"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatHourMinute = "HH:mm";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Minute"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Minute"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatMinuteMinute = "HH:mm";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Minute"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Second"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatMinuteSecond = "mm:ss";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Second"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Second"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatSecondSecond = "mm:ss";
-			/// <summary>
-			/// A default setting for the <see cref="AxisType.Date"/> auto-ranging code.
-			/// This values applies only to Date-Time type axes.
-			/// This is the format used for the scale values when auto-ranging code
-			/// selects a <see cref="Format"/> of <see cref="DateUnit.Millisecond"/>
-			/// for <see cref="MajorUnit"/> and <see cref="DateUnit.Millisecond"/> for 
-			/// for <see cref="MinorUnit"/>.
-			/// This value is used by the <see cref="DateScale.CalcDateStepSize"/> method.
-			/// </summary>
-			/// <seealso cref="System.Globalization.DateTimeFormatInfo"/>
-			public static string FormatMillisecond = "ss.fff";
-
-			/*  Prior format assignments using original XDate.ToString()
-					this.scaleFormat = "&yyyy";
-					this.scaleFormat = "&mmm-&yy";
-					this.scaleFormat = "&mmm-&yy";
-					scaleFormat = "&d-&mmm";
-					this.scaleFormat = "&d-&mmm &hh:&nn";
-					scaleFormat = "&hh:&nn";
-					scaleFormat = "&hh:&nn";
-					scaleFormat = "&hh:&nn";
-					scaleFormat = "&nn:&ss";
-					scaleFormat = "&nn:&ss";
-			*/
-			/// <summary> The default alignment of the <see cref="Axis"/> tic labels.
-			/// This value controls whether the inside, center, or outside edges of the text labels are aligned.
-			/// </summary>
-			/// <seealso cref="AlignP"/>
-			public static AlignP Align = AlignP.Center;
-			/// <summary> The default alignment of the <see cref="Axis"/> tic labels.
-			/// This value controls whether the left, center, or right edges of the text labels are aligned.
-			/// </summary>
-			/// <seealso cref="AlignH"/>
-			public static AlignH AlignH = AlignH.Center;
-			/// <summary>
-			/// The default font family for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.Family"/> property).
-			/// </summary>
-			public static string FontFamily = "Arial";
-			/// <summary>
-			/// The default font size for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.Size"/> property).  Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float FontSize = 14;
-			/// <summary>
-			/// The default font color for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.FontColor"/> property).
-			/// </summary>
-			public static Color FontColor = Color.Black;
-			/// <summary>
-			/// The default font bold mode for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.IsBold"/> property). true
-			/// for a bold typeface, false otherwise.
-			/// </summary>
-			public static bool FontBold = false;
-			/// <summary>
-			/// The default font italic mode for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.IsItalic"/> property). true
-			/// for an italic typeface, false otherwise.
-			/// </summary>
-			public static bool FontItalic = false;
-			/// <summary>
-			/// The default font underline mode for the <see cref="Axis"/> scale values
-			/// font specification <see cref="FontSpec"/>
-			/// (<see cref="ZedGraph.FontSpec.IsUnderline"/> property). true
-			/// for an underlined typeface, false otherwise.
-			/// </summary>
-			public static bool FontUnderline = false;
-			/// <summary>
-			/// The default color for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.White;
-			/// <summary>
-			/// The default custom brush for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default fill mode for filling in the scale text background
-			/// (see <see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.None;
-			/// <summary>
-			/// The default value for <see cref="IsVisible"/>, which determines
-			/// whether or not the scale values are displayed.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// The default value for <see cref="IsLabelsInside"/>, which determines
-			/// whether or not the scale labels and title for the <see cref="Axis"/> will appear
-			/// on the opposite side of the <see cref="Axis"/> that it normally appears.
-			/// </summary>
-			public static bool IsLabelsInside = false;
-			/// <summary>
-			/// Determines the size of the band at the beginning and end of the axis that will have labels
-			/// omitted if the axis is shifted due to a non-default location using the <see cref="Axis.Cross"/>
-			/// property.
-			/// </summary>
-			/// <remarks>
-			/// This parameter applies only when <see cref="Axis.CrossAuto"/> is false.  It is scaled according
-			/// to the size of the graph based on <see cref="PaneBase.BaseDimension"/>.  When a non-default
-			/// axis location is selected, the first and last labels on that axis will overlap the opposing
-			/// axis frame.  This parameter allows those labels to be omitted to avoid the overlap.  Set this
-			/// parameter to zero to turn off the effect.
-			/// </remarks>
-			public static float EdgeTolerance = 6;
-
-			/// <summary>
-			/// The default setting for the gap between the outside tics (or the axis edge
-			/// if there are no outside tics) and the scale labels, expressed as a fraction of
-			/// the major tic size.
-			/// </summary>
-			public static float LabelGap = 0.3f;
-		}
-
-	#endregion
-
-	#region constructors
-
-		/// <summary>
-		/// Basic constructor -- requires that the <see cref="Scale" /> object be intialized with
-		/// a pre-existing owner <see cref="Axis" />.
-		/// </summary>
-		/// <param name="ownerAxis">The <see cref="Axis" /> object that is the owner of this
-		/// <see cref="Scale" /> instance.</param>
-		public Scale( Axis ownerAxis )
-		{
-			_ownerAxis = ownerAxis;
-
-			_min = 0.0;
-			_max = 1.0;
-			_majorStep = 0.1;
-			_minorStep = 0.1;
-			_exponent = 1.0;
-			_mag = 0;
-			_baseTic = PointPair.Missing;
-
-			_minGrace = Default.MinGrace;
-			_maxGrace = Default.MaxGrace;
-
-			_minAuto = true;
-			_maxAuto = true;
-			_majorStepAuto = true;
-			_minorStepAuto = true;
-			_magAuto = true;
-			_formatAuto = true;
-
-			_isReverse = Default.IsReverse;
-			_isUseTenPower = true;
-			_isPreventLabelOverlap = true;
-			_isVisible = true;
-			_isSkipFirstLabel = false;
-			_isSkipLastLabel = false;
-			_isSkipCrossLabel = false;
-
-			_majorUnit = DateUnit.Day;
-			_minorUnit = DateUnit.Day;
-
-			_format = null;
-			_textLabels = null;
-
-			_isLabelsInside = Default.IsLabelsInside;
-			_align = Default.Align;
-			_alignH = Default.AlignH;
-
-			_fontSpec = new FontSpec(
-				Default.FontFamily, Default.FontSize,
-				Default.FontColor, Default.FontBold,
-				Default.FontUnderline, Default.FontItalic,
-				Default.FillColor, Default.FillBrush,
-				Default.FillType );
-
-			_fontSpec.Border.IsVisible = false;
-			_labelGap = Default.LabelGap;
-		}
-
-		/// <summary>
-		/// Copy Constructor.  Create a new <see cref="Scale" /> object based on the specified
-		/// existing one.
-		/// </summary>
-		/// <param name="rhs">The <see cref="Scale" /> object to be copied.</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="Scale" /></param>
-		public Scale( Scale rhs, Axis owner )
-		{
-			_ownerAxis = owner;
-
-			_min = rhs._min;
-			_max = rhs._max;
-			_majorStep = rhs._majorStep;
-			_minorStep = rhs._minorStep;
-			_exponent = rhs._exponent;
-			_baseTic = rhs._baseTic;
-
-			_minAuto = rhs._minAuto;
-			_maxAuto = rhs._maxAuto;
-			_majorStepAuto = rhs._majorStepAuto;
-			_minorStepAuto = rhs._minorStepAuto;
-			_magAuto = rhs._magAuto;
-			_formatAuto = rhs._formatAuto;
-
-			_minGrace = rhs._minGrace;
-			_maxGrace = rhs._maxGrace;
-
-			_mag = rhs._mag;
-
-			_isUseTenPower = rhs._isUseTenPower;
-			_isReverse = rhs._isReverse;
-			_isPreventLabelOverlap = rhs._isPreventLabelOverlap;
-			_isVisible = rhs._isVisible;
-			_isSkipFirstLabel = rhs._isSkipFirstLabel;
-			_isSkipLastLabel = rhs._isSkipLastLabel;
-			_isSkipCrossLabel = rhs._isSkipCrossLabel;
-
-			_majorUnit = rhs._majorUnit;
-			_minorUnit = rhs._minorUnit;
-
-			_format = rhs._format;
-
-			_isLabelsInside = rhs._isLabelsInside;
-			_align = rhs._align;
-			_alignH = rhs._alignH;
-
-			_fontSpec = (FontSpec) rhs._fontSpec.Clone();
-
-			_labelGap = rhs._labelGap;
-
-			if ( rhs._textLabels != null )
-				_textLabels = (string[])rhs._textLabels.Clone();
-			else
-				_textLabels = null;
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		abstract public Scale Clone( Axis owner );
-/*
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of Clone />
-		/// </summary>
-		/// <remarks>
-		/// Note that this method must be called with an explicit cast to ICloneable, and
-		/// that it is inherently virtual.  For example:
-		/// <code>
-		/// ParentClass foo = new ChildClass();
-		/// ChildClass bar = (ChildClass) ((ICloneable)foo).Clone();
-		/// </code>
-		/// Assume that ChildClass is inherited from ParentClass.  Even though foo is declared with
-		/// ParentClass, it is actually an instance of ChildClass.  Calling the ICloneable implementation
-		/// of Clone() on foo actually calls ChildClass.Clone() as if it were a virtual function.
-		/// </remarks>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			throw new NotImplementedException( "Can't clone an abstract base type -- child types must implement ICloneable" );
-			//return new PaneBase( this );
-		}
-*/
-
-		/// <summary>
-		/// A construction method that creates a new <see cref="Scale"/> object using the
-		/// properties of an existing <see cref="Scale"/> object, but specifying a new
-		/// <see cref="AxisType"/>.
-		/// </summary>
-		/// <remarks>
-		/// This constructor is used to change the type of an existing <see cref="Axis" />.
-		/// By specifying the old <see cref="Scale"/> object, you are giving a set of properties
-		/// (which encompasses all fields associated with the scale, since the derived types
-		/// have no fields) to be used in creating a new <see cref="Scale"/> object, only this
-		/// time having the newly specified object type.</remarks>
-		/// <param name="oldScale">The existing <see cref="Scale" /> object from which to
-		/// copy the field data.</param>
-		/// <param name="type">An <see cref="AxisType"/> representing the type of derived type
-		/// of new <see cref="Scale" /> object to create.</param>
-		/// <returns>The new <see cref="Scale"/> object.</returns>
-		public Scale MakeNewScale( Scale oldScale, AxisType type )
-		{
-			switch ( type )
-			{
-				case AxisType.Linear:
-					return new LinearScale( oldScale, _ownerAxis );
-				case AxisType.Date:
-					return new DateScale( oldScale, _ownerAxis );
-				case AxisType.Log:
-					return new LogScale( oldScale, _ownerAxis );
-				case AxisType.Exponent:
-					return new ExponentScale( oldScale, _ownerAxis );
-				case AxisType.Ordinal:
-					return new OrdinalScale( oldScale, _ownerAxis );
-				case AxisType.Text:
-					return new TextScale( oldScale, _ownerAxis );
-				case AxisType.DateAsOrdinal:
-					return new DateAsOrdinalScale( oldScale, _ownerAxis );
-				case AxisType.LinearAsOrdinal:
-					return new LinearAsOrdinalScale( oldScale, _ownerAxis );
-				default:
-					throw new Exception( "Implementation Error: Invalid AxisType" );
-			}
-		}
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		// schema changed to 2 with isScaleVisible
-		public const int schema = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Scale( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_min = info.GetDouble( "min" );
-			_max = info.GetDouble( "max" );
-			_majorStep = info.GetDouble( "majorStep" );
-			_minorStep = info.GetDouble( "minorStep" );
-			_exponent = info.GetDouble( "exponent" );
-			_baseTic = info.GetDouble( "baseTic" );
-
-
-			_minAuto = info.GetBoolean( "minAuto" );
-			_maxAuto = info.GetBoolean( "maxAuto" );
-			_majorStepAuto = info.GetBoolean( "majorStepAuto" );
-			_minorStepAuto = info.GetBoolean( "minorStepAuto" );
-			_magAuto = info.GetBoolean( "magAuto" );
-			_formatAuto = info.GetBoolean( "formatAuto" );
-			
-			_minGrace = info.GetDouble( "minGrace" );
-			_maxGrace = info.GetDouble( "maxGrace" );
-
-			_mag = info.GetInt32( "mag" );
-
-			_isReverse = info.GetBoolean( "isReverse" );
-			_isPreventLabelOverlap = info.GetBoolean( "isPreventLabelOverlap" );
-			_isUseTenPower = info.GetBoolean( "isUseTenPower" );
-
-			_isVisible = true;
-			_isVisible = info.GetBoolean( "isVisible" );
-
-			_isSkipFirstLabel = info.GetBoolean( "isSkipFirstLabel" );
-			_isSkipLastLabel = info.GetBoolean( "isSkipLastLabel" );
-			_isSkipCrossLabel = info.GetBoolean( "isSkipCrossLabel" );
-
-			_textLabels = (string[]) info.GetValue( "textLabels", typeof(string[]) );
-			_format = info.GetString( "format" );
-
-			_majorUnit = (DateUnit) info.GetValue( "majorUnit", typeof(DateUnit) );
-			_minorUnit = (DateUnit) info.GetValue( "minorUnit", typeof(DateUnit) );
-
-			_isLabelsInside = info.GetBoolean( "isLabelsInside" );
-			_align = (AlignP)info.GetValue( "align", typeof( AlignP ) );
-			if ( schema >= 11 )
-				_alignH = (AlignH)info.GetValue( "alignH", typeof( AlignH ) );
-
-			_fontSpec = (FontSpec)info.GetValue( "fontSpec", typeof( FontSpec ) );
-			_labelGap = info.GetSingle( "labelGap" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to
-		/// serialize the target object
-		/// </summary>
-		/// <remarks>
-		/// You MUST set the _ownerAxis property after deserializing a BarSettings object.
-		/// </remarks>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "min", _min );
-			info.AddValue( "max", _max );
-			info.AddValue( "majorStep", _majorStep );
-			info.AddValue( "minorStep", _minorStep );
-			info.AddValue( "exponent", _exponent );
-			info.AddValue( "baseTic", _baseTic );
-
-			info.AddValue( "minAuto", _minAuto );
-			info.AddValue( "maxAuto", _maxAuto );
-			info.AddValue( "majorStepAuto", _majorStepAuto );
-			info.AddValue( "minorStepAuto", _minorStepAuto );
-			info.AddValue( "magAuto", _magAuto );
-			info.AddValue( "formatAuto", _formatAuto );
-
-			info.AddValue( "minGrace", _minGrace );
-			info.AddValue( "maxGrace", _maxGrace );
-
-			info.AddValue( "mag", _mag );
-			info.AddValue( "isReverse", _isReverse );
-			info.AddValue( "isPreventLabelOverlap", _isPreventLabelOverlap );
-			info.AddValue( "isUseTenPower", _isUseTenPower );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "isSkipFirstLabel", _isSkipFirstLabel );
-			info.AddValue( "isSkipLastLabel", _isSkipLastLabel );
-			info.AddValue( "isSkipCrossLabel", _isSkipCrossLabel );
-
-
-			info.AddValue( "textLabels", _textLabels );
-			info.AddValue( "format", _format );
-
-			info.AddValue( "majorUnit", _majorUnit );
-			info.AddValue( "minorUnit", _minorUnit );
-
-			info.AddValue( "isLabelsInside", _isLabelsInside );
-			info.AddValue( "align", _align );
-			info.AddValue( "alignH", _alignH );
-			info.AddValue( "fontSpec", _fontSpec );
-			info.AddValue( "labelGap", _labelGap );
-		}
-	#endregion
-
-	#region properties
-
-		/// <summary>
-		/// Get an <see cref="AxisType" /> enumeration that indicates the type of this scale.
-		/// </summary>
-		abstract public AxisType Type { get; }
-
-		/// <summary>
-		/// True if this scale is <see cref="AxisType.Log" />, false otherwise.
-		/// </summary>
-		public bool IsLog { get { return this is LogScale; } }
-		/// <summary>
-		/// True if this scale is <see cref="AxisType.Exponent" />, false otherwise.
-		/// </summary>
-		public bool IsExponent { get { return this is ExponentScale; } }
-		/// <summary>
-		/// True if this scale is <see cref="AxisType.Date" />, false otherwise.
-		/// </summary>
-		public bool IsDate { get { return this is DateScale; } }
-		/// <summary>
-		/// True if this scale is <see cref="AxisType.Text" />, false otherwise.
-		/// </summary>
-		public bool IsText { get { return this is TextScale; } }
-		/// <summary>
-		/// True if this scale is <see cref="AxisType.Ordinal" />, false otherwise.
-		/// </summary>
-		/// <remarks>
-		/// Note that this is only true for an actual <see cref="OrdinalScale" /> class.
-		/// This property will be false for other ordinal types such as
-		/// <see cref="AxisType.Text" />, <see cref="AxisType.LinearAsOrdinal" />,
-		/// or <see cref="AxisType.DateAsOrdinal" />.  Use the <see cref="IsAnyOrdinal" />
-		/// as a "catchall" for all ordinal type axes.
-		/// </remarks>
-		public bool IsOrdinal { get { return this is OrdinalScale; } }
-
-		/// <summary>
-		/// Gets a value that indicates if this <see cref="Scale" /> is of any of the
-		/// ordinal types in the <see cref="AxisType" /> enumeration.
-		/// </summary>
-		/// <seealso cref="Type" />
-		public bool IsAnyOrdinal
-		{
-			get
-			{
-				AxisType type = this.Type;
-
-				return	type == AxisType.Ordinal ||
-							type == AxisType.Text ||
-							type == AxisType.LinearAsOrdinal ||
-							type == AxisType.DateAsOrdinal;
-			}
-		}
-/*
-		/// <summary>
-		/// The pixel position at the minimum value for this axis.  This read-only
-		/// value is used/valid only during the Draw process.
-		/// </summary>
-		public float MinPix
-		{
-			get { return _minPix; }
-		}
-		/// <summary>
-		/// The pixel position at the maximum value for this axis.  This read-only
-		/// value is used/valid only during the Draw process.
-		/// </summary>
-		public float MaxPix
-		{
-			get { return _maxPix; }
-		}
-*/
-		/// <summary>
-		/// Gets or sets the minimum scale value for this <see cref="Scale" />.
-		/// </summary>
-		/// <remarks>This value can be set
-		/// automatically based on the state of <see cref="MinAuto"/>.  If
-		/// this value is set manually, then <see cref="MinAuto"/> will
-		/// also be set to false.
-		/// </remarks>
-		/// <value> The value is defined in user scale units for <see cref="AxisType.Log"/>
-		/// and <see cref="AxisType.Linear"/> axes. For <see cref="AxisType.Text"/>
-		/// and <see cref="AxisType.Ordinal"/> axes,
-		/// this value is an ordinal starting with 1.0.  For <see cref="AxisType.Date"/>
-		/// axes, this value is in XL Date format (see <see cref="XDate"/>, which is the
-		/// number of days since the reference date of January 1, 1900.</value>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MinAuto"/>
-		public virtual double Min
-		{
-			get { return _min; }
-			set { _min = value; _minAuto = false; }
-		}
-		/// <summary>
-		/// Gets or sets the maximum scale value for this <see cref="Scale" />.
-		/// </summary>
-		/// <remarks>
-		/// This value can be set
-		/// automatically based on the state of <see cref="MaxAuto"/>.  If
-		/// this value is set manually, then <see cref="MaxAuto"/> will
-		/// also be set to false.
-		/// </remarks>
-		/// <value> The value is defined in user scale units for <see cref="AxisType.Log"/>
-		/// and <see cref="AxisType.Linear"/> axes. For <see cref="AxisType.Text"/>
-		/// and <see cref="AxisType.Ordinal"/> axes,
-		/// this value is an ordinal starting with 1.0.  For <see cref="AxisType.Date"/>
-		/// axes, this value is in XL Date format (see <see cref="XDate"/>, which is the
-		/// number of days since the reference date of January 1, 1900.</value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MaxAuto"/>
-		public virtual double Max
-		{
-			get { return _max; }
-			set { _max = value; _maxAuto = false; }
-		}
-		/// <summary>
-		/// Gets or sets the scale step size for this <see cref="Scale" /> (the increment between
-		/// labeled axis values).
-		/// </summary>
-		/// <remarks>
-		/// This value can be set
-		/// automatically based on the state of <see cref="MajorStepAuto"/>.  If
-		/// this value is set manually, then <see cref="MajorStepAuto"/> will
-		/// also be set to false.  This value is ignored for <see cref="AxisType.Log"/>
-		/// axes.  For <see cref="AxisType.Date"/> axes, this
-		/// value is defined in units of <see cref="MajorUnit"/>.
-		/// </remarks>
-		/// <value> The value is defined in user scale units </value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MajorStepAuto"/>
-		/// <seealso cref="ZedGraph.Scale.Default.TargetXSteps"/>
-		/// <seealso cref="ZedGraph.Scale.Default.TargetYSteps"/>
-		/// <seealso cref="ZedGraph.Scale.Default.ZeroLever"/>
-		/// <seealso cref="ZedGraph.Scale.Default.MaxTextLabels"/>
-		public double MajorStep
-		{
-			get { return _majorStep; }
-			set
-			{
-				if ( value < 1e-300 )
-				{
-					_majorStepAuto = true;
-				}
-				else
-				{
-					_majorStep = value;
-					_majorStepAuto = false;
-				}
-			}
-		}
-		/// <summary>
-		/// Gets or sets the scale minor step size for this <see cref="Scale" /> (the spacing between
-		/// minor tics).
-		/// </summary>
-		/// <remarks>This value can be set
-		/// automatically based on the state of <see cref="MinorStepAuto"/>.  If
-		/// this value is set manually, then <see cref="MinorStepAuto"/> will
-		/// also be set to false.  This value is ignored for <see cref="AxisType.Log"/> and
-		/// <see cref="AxisType.Text"/> axes.  For <see cref="AxisType.Date"/> axes, this
-		/// value is defined in units of <see cref="MinorUnit"/>.
-		/// </remarks>
-		/// <value> The value is defined in user scale units </value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStepAuto"/>
-		public double MinorStep
-		{
-			get { return _minorStep; }
-			set
-			{
-				if ( value < 1e-300 )
-				{
-					_minorStepAuto = true;
-				}
-				else
-				{
-					_minorStep = value;
-					_minorStepAuto = false;
-				}
-			}
-		}
-		/// <summary>
-		/// Gets or sets the scale exponent value.  This only applies to <see cref="AxisType.Exponent" />. 
-		/// </summary>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MajorStepAuto"/>
-		/// <seealso cref="ZedGraph.Scale.Default.TargetXSteps"/>
-		/// <seealso cref="ZedGraph.Scale.Default.TargetYSteps"/>
-		/// <seealso cref="ZedGraph.Scale.Default.ZeroLever"/>
-		/// <seealso cref="ZedGraph.Scale.Default.MaxTextLabels"/>
-		public double Exponent
-		{
-			get { return _exponent; }
-			set { _exponent = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the scale value at which the first major tic label will appear.
-		/// </summary>
-		/// <remarks>This property allows the scale labels to start at an irregular value.
-		/// For example, on a scale range with <see cref="Min"/> = 0, <see cref="Max"/> = 1000,
-		/// and <see cref="MajorStep"/> = 200, a <see cref="BaseTic"/> value of 50 would cause
-		/// the scale labels to appear at values 50, 250, 450, 650, and 850.  Note that the
-		/// default value for this property is <see cref="PointPairBase.Missing"/>, which means the
-		/// value is not used.  Setting this property to any value other than
-		/// <see cref="PointPairBase.Missing"/> will activate the effect.  The value specified must
-		/// coincide with the first major tic.  That is, if <see cref="BaseTic"/> were set to
-		/// 650 in the example above, then the major tics would only occur at 650 and 850.  This
-		/// setting may affect the minor tics, since the minor tics are always referenced to the
-		/// <see cref="BaseTic"/>.  That is, in the example above, if the <see cref="MinorStep"/>
-		/// were set to 30 (making it a non-multiple of the major step), then the minor tics would
-		/// occur at 20, 50 (so it lines up with the BaseTic), 80, 110, 140, etc.
-		/// </remarks>
-		/// <value> The value is defined in user scale units </value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="Axis.Cross"/>
-		public double BaseTic
-		{
-			get { return _baseTic; }
-			set { _baseTic = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the type of units used for the major step size (<see cref="MajorStep"/>).
-		/// </summary>
-		/// <remarks>
-		/// This unit type only applies to Date-Time axes (<see cref="AxisType.Date"/> = true).
-		/// The axis is set to date type with the <see cref="Type"/> property.
-		/// The unit types are defined as <see cref="DateUnit"/>.
-		/// </remarks>
-		/// <value> The value is a <see cref="DateUnit"/> enum type </value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MajorStepAuto"/>
-		public DateUnit MajorUnit
-		{
-			get { return _majorUnit; }
-			set { _majorUnit = value; }
-		}
-		/// <summary>
-		/// Gets or sets the type of units used for the minor step size (<see cref="MinorStep"/>).
-		/// </summary>
-		/// <remarks>
-		/// This unit type only applies to Date-Time axes (<see cref="AxisType.Date"/> = true).
-		/// The axis is set to date type with the <see cref="Type"/> property.
-		/// The unit types are defined as <see cref="DateUnit"/>.
-		/// </remarks>
-		/// <value> The value is a <see cref="DateUnit"/> enum type </value>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="MajorStep"/>
-		/// <seealso cref="MinorStep"/>
-		/// <seealso cref="MinorStepAuto"/>
-		public DateUnit MinorUnit
-		{
-			get { return _minorUnit; }
-			set { _minorUnit = value; }
-		}
-
-		/// <summary>
-		/// Gets the major unit multiplier for this scale type, if any.
-		/// </summary>
-		/// <remarks>The major unit multiplier will correct the units of
-		/// <see cref="MajorStep" /> to match the units of <see cref="Min" />
-		/// and <see cref="Max" />.  This reflects the setting of
-		/// <see cref="MajorUnit" />.
-		/// </remarks>
-		virtual internal double MajorUnitMultiplier
-		{
-			get { return 1.0; }
-		}
-
-		/// <summary>
-		/// Gets the minor unit multiplier for this scale type, if any.
-		/// </summary>
-		/// <remarks>The minor unit multiplier will correct the units of
-		/// <see cref="MinorStep" /> to match the units of <see cref="Min" />
-		/// and <see cref="Max" />.  This reflects the setting of
-		/// <see cref="MinorUnit" />.
-		/// </remarks>
-		virtual internal double MinorUnitMultiplier
-		{
-			get { return 1.0; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the minimum scale value <see cref="Min"/>
-		/// is set automatically.
-		/// </summary>
-		/// <remarks>
-		/// This value will be set to false if
-		/// <see cref="Min"/> is manually changed.
-		/// </remarks>
-		/// <value>true for automatic mode, false for manual mode</value>
-		/// <seealso cref="Min"/>
-		public bool MinAuto
-		{
-			get { return _minAuto; }
-			set { _minAuto = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the maximum scale value <see cref="Max"/>
-		/// is set automatically.
-		/// </summary>
-		/// <remarks>
-		/// This value will be set to false if
-		/// <see cref="Max"/> is manually changed.
-		/// </remarks>
-		/// <value>true for automatic mode, false for manual mode</value>
-		/// <seealso cref="Max"/>
-		public bool MaxAuto
-		{
-			get { return _maxAuto; }
-			set { _maxAuto = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the scale step size <see cref="MajorStep"/>
-		/// is set automatically.
-		/// </summary>
-		/// <remarks>
-		/// This value will be set to false if
-		/// <see cref="MajorStep"/> is manually changed.
-		/// </remarks>
-		/// <value>true for automatic mode, false for manual mode</value>
-		/// <seealso cref="MajorStep"/>
-		public bool MajorStepAuto
-		{
-			get { return _majorStepAuto; }
-			set { _majorStepAuto = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the minor scale step size <see cref="MinorStep"/>
-		/// is set automatically.
-		/// </summary>
-		/// <remarks>
-		/// This value will be set to false if
-		/// <see cref="MinorStep"/> is manually changed.
-		/// </remarks>
-		/// <value>true for automatic mode, false for manual mode</value>
-		/// <seealso cref="MinorStep"/>
-		public bool MinorStepAuto
-		{
-			get { return _minorStepAuto; }
-			set { _minorStepAuto = value; }
-		}
-
-		/// <summary>
-		/// Determines whether or not the scale label format <see cref="Format"/>
-		/// is determined automatically based on the range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This value will be set to false if
-		/// <see cref="Format"/> is manually changed.
-		/// </remarks>
-		/// <value>true if <see cref="Format"/> will be set automatically, false
-		/// if it is to be set manually by the user</value>
-		/// <seealso cref="Mag"/>
-		/// <seealso cref="Format"/>
-		/// <seealso cref="FontSpec"/>
-		public bool FormatAuto
-		{
-			get { return _formatAuto; }
-			set { _formatAuto = value; }
-		}
-
-		/// <summary>
-		/// The format of the <see cref="Axis"/> tic labels.
-		/// </summary>
-		/// <remarks>
-		/// This property may be a date format or a numeric format, depending on the setting of
-		/// <see cref="Type">Scale.Type</see>.
-		/// This property may be set automatically by ZedGraph, depending on the state of
-		/// <see cref="FormatAuto"/>.
-		/// </remarks>
-		/// <value>The format string conforms to the
-		/// <see cref="System.Globalization.DateTimeFormatInfo" /> for date formats, and
-		/// <see cref="System.Globalization.NumberFormatInfo" /> for numeric formats.
-		/// </value>
-		/// <seealso cref="Mag"/>
-		/// <seealso cref="FormatAuto"/>
-		/// <seealso cref="FontSpec"/>
-		// /// <seealso cref="NumDec"/>
-		public string Format
-		{
-			get { return _format; }
-			set { _format = value; _formatAuto = false; }
-		}
-
-		/// <summary>
-		/// The magnitude multiplier for scale values.
-		/// </summary>
-		/// <remarks>
-		/// This is used to limit
-		/// the size of the displayed value labels.  For example, if the value
-		/// is really 2000000, then the graph will display 2000 with a 10^3
-		/// magnitude multiplier.  This value can be determined automatically
-		/// depending on the state of <see cref="MagAuto"/>.
-		/// If this value is set manually by the user,
-		/// then <see cref="MagAuto"/> will also be set to false.
-		/// </remarks>
-		/// <value>The magnitude multiplier (power of 10) for the scale
-		/// value labels</value>
-		/// <seealso cref="AxisLabel.IsOmitMag"/>
-		/// <seealso cref="Axis.Title"/>
-		/// <seealso cref="Format"/>
-		/// <seealso cref="FontSpec"/>
-		// /// <seealso cref="NumDec"/>
-		public int Mag
-		{
-			get { return _mag; }
-			set { _mag = value; _magAuto = false; }
-		}
-		/// <summary>
-		/// Determines whether the <see cref="Mag"/> value will be set
-		/// automatically based on the data, or manually by the user.
-		/// </summary>
-		/// <remarks>
-		/// If the user manually sets the <see cref="Mag"/> value, then this
-		/// flag will be set to false.
-		/// </remarks>
-		/// <value>true to have <see cref="Mag"/> set automatically,
-		/// false otherwise</value>
-		/// <seealso cref="AxisLabel.IsOmitMag"/>
-		/// <seealso cref="Axis.Title"/>
-		/// <seealso cref="Mag"/>
-		public bool MagAuto
-		{
-			get { return _magAuto; }
-			set { _magAuto = value; }
-		}
-
-		/// <summary> Gets or sets the "grace" value applied to the minimum data range.
-		/// </summary>
-		/// <remarks>
-		/// This value is
-		/// expressed as a fraction of the total data range.  For example, assume the data
-		/// range is from 4.0 to 16.0, leaving a range of 12.0.  If MinGrace is set to
-		/// 0.1, then 10% of the range, or 1.2 will be subtracted from the minimum data value.
-		/// The scale will then be ranged to cover at least 2.8 to 16.0.
-		/// </remarks>
-		/// <seealso cref="Min"/>
-		/// <seealso cref="ZedGraph.Scale.Default.MinGrace"/>
-		/// <seealso cref="MaxGrace"/>
-		public double MinGrace
-		{
-			get { return _minGrace; }
-			set { _minGrace = value; }
-		}
-		/// <summary> Gets or sets the "grace" value applied to the maximum data range.
-		/// </summary>
-		/// <remarks>
-		/// This values determines how much extra space is left after the last data value.
-		/// This value is
-		/// expressed as a fraction of the total data range.  For example, assume the data
-		/// range is from 4.0 to 16.0, leaving a range of 12.0.  If MaxGrace is set to
-		/// 0.1, then 10% of the range, or 1.2 will be added to the maximum data value.
-		/// The scale will then be ranged to cover at least 4.0 to 17.2.
-		/// </remarks>
-		/// <seealso cref="Max"/>
-		/// <seealso cref="ZedGraph.Scale.Default.MaxGrace"/>
-		/// <seealso cref="MinGrace"/>
-		public double MaxGrace
-		{
-			get { return _maxGrace; }
-			set { _maxGrace = value; }
-		}
-
-		/// <summary> Controls the alignment of the <see cref="Axis"/> tic labels.
-		/// </summary>
-		/// <remarks>
-		/// This property controls whether the inside, center, or outside edges of the
-		/// text labels are aligned.
-		/// </remarks>
-		public AlignP Align
-		{
-			get { return _align; }
-			set { _align = value; }
-		}
-
-		/// <summary> Controls the alignment of the <see cref="Axis"/> tic labels.
-		/// </summary>
-		/// <remarks>
-		/// This property controls whether the left, center, or right edges of the
-		/// text labels are aligned.
-		/// </remarks>
-		public AlignH AlignH
-		{
-			get { return _alignH; }
-			set { _alignH = value; }
-		}
-
-		/// <summary>
-		/// Gets a reference to the <see cref="ZedGraph.FontSpec"/> class used to render
-		/// the scale values
-		/// </summary>
-		/// <seealso cref="Default.FontFamily"/>
-		/// <seealso cref="Default.FontSize"/>
-		/// <seealso cref="Default.FontColor"/>
-		/// <seealso cref="Default.FontBold"/>
-		/// <seealso cref="Default.FontUnderline"/>
-		/// <seealso cref="Default.FontItalic"/>
-		public FontSpec FontSpec
-		{
-			get { return _fontSpec; }
-			set
-			{
-				if ( value == null )
-					throw new ArgumentNullException( "Uninitialized FontSpec in Scale" );
-				_fontSpec = value;
-			}
-		}
-
-		/// <summary>
-		/// The gap between the scale labels and the tics.
-		/// </summary>
-		public float LabelGap
-		{
-			get { return _labelGap; }
-			set { _labelGap = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that causes the axis scale labels and title to appear on the
-		/// opposite side of the axis.
-		/// </summary>
-		/// <remarks>
-		/// For example, setting this flag to true for the <see cref="YAxis"/> will shift the
-		/// axis labels and title to the right side of the <see cref="YAxis"/> instead of the
-		/// normal left-side location.  Set this property to true for the <see cref="XAxis" />,
-		/// and set the <see cref="Axis.Cross"/> property for the <see cref="XAxis"/> to an arbitrarily
-		/// large value (assuming <see cref="IsReverse"/> is false for the <see cref="YAxis" />) in
-		/// order to have the <see cref="XAxis"/> appear at the top of the <see cref="Chart.Rect" />.
-		/// </remarks>
-		/// <seealso cref="IsReverse"/>
-		/// <seealso cref="Axis.Cross"/>
-		public bool IsLabelsInside
-		{
-			get { return _isLabelsInside; }
-			set { _isLabelsInside = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that causes the first scale label for this <see cref="Axis"/> to be
-		/// hidden.
-		/// </summary>
-		/// <remarks>
-		/// Often, for axis that have an active <see cref="Axis.Cross"/> setting (e.g., <see cref="Axis.CrossAuto"/>
-		/// is false), the first and/or last scale label are overlapped by opposing axes.  Use this
-		/// property to hide the first scale label to avoid the overlap.  Note that setting this value
-		/// to true will hide any scale label that appears within <see cref="Scale.Default.EdgeTolerance"/> of the
-		/// beginning of the <see cref="Axis"/>.
-		/// </remarks>
-		public bool IsSkipFirstLabel
-		{
-			get { return _isSkipFirstLabel; }
-			set { _isSkipFirstLabel = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that causes the last scale label for this <see cref="Axis"/> to be
-		/// hidden.
-		/// </summary>
-		/// <remarks>
-		/// Often, for axis that have an active <see cref="Axis.Cross"/> setting (e.g., <see cref="Axis.CrossAuto"/>
-		/// is false), the first and/or last scale label are overlapped by opposing axes.  Use this
-		/// property to hide the last scale label to avoid the overlap.  Note that setting this value
-		/// to true will hide any scale label that appears within <see cref="Scale.Default.EdgeTolerance"/> of the
-		/// end of the <see cref="Axis"/>.
-		/// </remarks>
-		public bool IsSkipLastLabel
-		{
-			get { return _isSkipLastLabel; }
-			set { _isSkipLastLabel = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that causes the scale label that is located at the <see cref="Axis.Cross" />
-		/// value for this <see cref="Axis"/> to be hidden.
-		/// </summary>
-		/// <remarks>
-		/// For axes that have an active <see cref="Axis.Cross"/> setting (e.g., <see cref="Axis.CrossAuto"/>
-		/// is false), the scale label at the <see cref="Axis.Cross" /> value is overlapped by opposing axes.
-		/// Use this property to hide the scale label to avoid the overlap.
-		/// </remarks>
-		public bool IsSkipCrossLabel
-		{
-			get { return _isSkipCrossLabel; }
-			set { _isSkipCrossLabel = value; }
-		}
-
-		/// <summary>
-		/// Determines if the scale values are reversed for this <see cref="Axis"/>
-		/// </summary>
-		/// <value>true for the X values to decrease to the right or the Y values to
-		/// decrease upwards, false otherwise</value>
-		/// <seealso cref="ZedGraph.Scale.Default.IsReverse"/>.
-		public bool IsReverse
-		{
-			get { return _isReverse; }
-			set { _isReverse = value; }
-		}
-		/// <summary>
-		/// Determines if powers-of-ten notation will be used for the numeric value labels.
-		/// </summary>
-		/// <remarks>
-		/// The powers-of-ten notation is just the text "10" followed by a superscripted value
-		/// indicating the magnitude.  This mode is only valid for log scales (see
-		/// <see cref="IsLog"/> and <see cref="Type"/>).
-		/// </remarks>
-		/// <value> boolean value; true to show the title as a power of ten, false to
-		/// show a regular numeric value (e.g., "0.01", "10", "1000")</value>
-		public bool IsUseTenPower
-		{
-			get { return _isUseTenPower; }
-			set { _isUseTenPower = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a <see cref="bool"/> value that determines if ZedGraph will check to
-		/// see if the <see cref="Axis"/> scale labels are close enough to overlap.  If so,
-		/// ZedGraph will adjust the step size to prevent overlap.
-		/// </summary>
-		/// <remarks>
-		/// The process of checking for overlap is done during the <see cref="GraphPane.AxisChange()"/>
-		/// method call, and affects the selection of the major step size (<see cref="MajorStep"/>).
-		/// </remarks>
-		/// <value> boolean value; true to check for overlap, false otherwise</value>
-		public bool IsPreventLabelOverlap
-		{
-			get { return _isPreventLabelOverlap; }
-			set { _isPreventLabelOverlap = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a property that determines whether or not the scale values will be shown.
-		/// </summary>
-		/// <value>true to show the scale values, false otherwise</value>
-		/// <seealso cref="Axis.IsVisible"/>.
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-
-		/// <summary>
-		/// The text labels for this <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// This property is only
-		/// applicable if <see cref="Type"/> is set to <see cref="AxisType.Text"/>.
-		/// </remarks>
-		public string[] TextLabels
-		{
-			get { return _textLabels; }
-			set { _textLabels = value; }
-		}
-
-	#endregion
-/*
-	#region events
-
-		/// <summary>
-		/// A delegate that allows full custom formatting of the Axis labels
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane" /> for which the label is to be
-		/// formatted</param>
-		/// <param name="axis">The <see cref="Axis" /> for which the label is to be formatted</param>
-		/// <param name="val">The value to be formatted</param>
-		/// <param name="index">The zero-based index of the label to be formatted</param>
-		/// <returns>
-		/// A string value representing the label, or null if the ZedGraph should go ahead
-		/// and generate the label according to the current settings</returns>
-		/// <seealso cref="ScaleFormatEvent" />
-		public delegate string ScaleFormatHandler( GraphPane pane, Axis axis, double val, int index );
-
-		/// <summary>
-		/// Subscribe to this event to handle custom formatting of the scale labels.
-		/// </summary>
-		public event ScaleFormatHandler ScaleFormatEvent;
-
-	#endregion
-*/
-	#region Methods
-
-		/// <summary>
-		/// Setup some temporary transform values in preparation for rendering the
-		/// <see cref="Axis"/>.
-		/// </summary>
-		/// <remarks>
-		/// This method is typically called by the parent <see cref="GraphPane"/>
-		/// object as part of the <see cref="GraphPane.Draw"/> method.  It is also
-		/// called by <see cref="GraphPane.GeneralTransform(double,double,CoordType)"/> and
-		/// <see cref="GraphPane.ReverseTransform( PointF, out double, out double )"/>
-		/// methods to setup for coordinate transformations.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="axis">
-		/// The parent <see cref="Axis" /> for this <see cref="Scale" />
-		/// </param>
-		virtual public void SetupScaleData( GraphPane pane, Axis axis )
-		{
-			// save the ChartRect data for transforming scale values to pixels
-			if ( axis is XAxis || axis is X2Axis )
-			{
-				_minPix = pane.Chart._rect.Left;
-				_maxPix = pane.Chart._rect.Right;
-			}
-			else
-			{
-				_minPix = pane.Chart._rect.Top;
-				_maxPix = pane.Chart._rect.Bottom;
-			}
-
-			_minLinTemp = Linearize( _min );
-			_maxLinTemp = Linearize( _max );
-
-		}
-
-/*		internal void ResetScaleData()
-		{
-			_minPix = float.NaN;
-			_maxPix = float.NaN;
-			_minLinTemp = double.NaN;
-			_maxLinTemp = double.NaN;
-		}
-*/
-		/// <summary>
-		/// Convert a value to its linear equivalent for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the log or power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		virtual public double Linearize( double val )
-		{
-			return val;
-		}
-
-		/// <summary>
-		/// Convert a value from its linear equivalent to its actual scale value
-		/// for this type of scale.
-		/// </summary>
-		/// <remarks>
-		/// The default behavior is to just return the value unchanged.  However,
-		/// for <see cref="AxisType.Log" /> and <see cref="AxisType.Exponent" />,
-		/// it returns the anti-log or inverse-power equivalent.
-		/// </remarks>
-		/// <param name="val">The value to be converted</param>
-		virtual public double DeLinearize( double val )
-		{
-			return val;
-		}
-/*
-		/// <summary>
-		/// Make a value label for the axis at the specified ordinal position.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="IsLog"/>, <see cref="IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="IsLog"/>)
-		/// and text (<see cref="IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		virtual internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( this.ScaleFormatEvent != null )
-			{
-				string label;
-
-				label = this.ScaleFormatEvent( pane, _ownerAxis, dVal, index );
-				if ( label != null )
-					return label;
-			}
-
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			// linear or ordinal is the default behavior
-			// this method is overridden for other Scale types
-
-			double scaleMult = Math.Pow( (double) 10.0, _mag );
-
-			return ( dVal / scaleMult ).ToString( _format );
-		}
-*/
-
-		/// <summary>
-		/// Make a value label for the axis at the specified ordinal position.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="IsLog"/>, <see cref="IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="IsLog"/>)
-		/// and text (<see cref="IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		virtual internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			// linear or ordinal is the default behavior
-			// this method is overridden for other Scale types
-
-			double scaleMult = Math.Pow( (double)10.0, _mag );
-
-			return ( dVal / scaleMult ).ToString( _format );
-		}
-
-		/// <summary>
-		/// Get the maximum width of the scale value text that is required to label this
-		/// <see cref="Axis"/>.
-		/// The results of this method are used to determine how much space is required for
-		/// the axis labels.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="applyAngle">
-		/// true to get the bounding box of the text using the <see cref="ZedGraph.FontSpec.Angle" />,
-		/// false to just get the bounding box without rotation
-		/// </param>
-		/// <returns>the maximum width of the text in pixel units</returns>
-		internal SizeF GetScaleMaxSpace( Graphics g, GraphPane pane, float scaleFactor,
-							bool applyAngle )
-		{
-			if ( _isVisible )
-			{
-				double dVal,
-					scaleMult = Math.Pow( (double)10.0, _mag );
-				int i;
-
-				float saveAngle = _fontSpec.Angle;
-				if ( !applyAngle )
-					_fontSpec.Angle = 0;
-
-				int nTics = CalcNumTics();
-
-				double startVal = CalcBaseTic();
-
-				SizeF maxSpace = new SizeF( 0, 0 );
-
-				// Repeat for each tic
-				for ( i = 0; i < nTics; i++ )
-				{
-					dVal = CalcMajorTicValue( startVal, i );
-
-					// draw the label
-					//string tmpStr = MakeLabel( pane, i, dVal );
-					string tmpStr = _ownerAxis.MakeLabelEventWorks( pane, i, dVal );
-
-					SizeF sizeF;
-					if ( this.IsLog && _isUseTenPower )
-						sizeF = _fontSpec.BoundingBoxTenPower( g, tmpStr,
-							scaleFactor );
-					else
-						sizeF = _fontSpec.BoundingBox( g, tmpStr,
-							scaleFactor );
-
-					if ( sizeF.Height > maxSpace.Height )
-						maxSpace.Height = sizeF.Height;
-					if ( sizeF.Width > maxSpace.Width )
-						maxSpace.Width = sizeF.Width;
-				}
-
-				_fontSpec.Angle = saveAngle;
-
-				return maxSpace;
-			}
-			else
-				return new SizeF(0,0);
-		}
-
-		/// <summary>
-		/// Determine the value for any major tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="IsLog"/>, <see cref="IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double)
-		/// </param>
-		/// <param name="tic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified major tic value (floating point double).
-		/// </returns>
-		virtual internal double CalcMajorTicValue( double baseVal, double tic )
-		{
-			// Default behavior is a normal linear scale (also works for ordinal types)
-			return baseVal + (double) _majorStep * tic;
-		}
-
-		/// <summary>
-		/// Determine the value for any minor tic.
-		/// </summary>
-		/// <remarks>
-		/// This method properly accounts for <see cref="IsLog"/>, <see cref="IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <param name="baseVal">
-		/// The value of the first major tic (floating point double).  This tic value is the base
-		/// reference for all tics (including minor ones).
-		/// </param>
-		/// <param name="iTic">
-		/// The major tic number (0 = first major tic).  For log scales, this is the actual power of 10.
-		/// </param>
-		/// <returns>
-		/// The specified minor tic value (floating point double).
-		/// </returns>
-		virtual internal double CalcMinorTicValue( double baseVal, int iTic )
-		{
-			// default behavior is a linear axis (works for ordinal types too
-			return baseVal + (double) _minorStep * (double) iTic;
-		}
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first minor tic mark
-		/// </summary>
-		/// <param name="baseVal">
-		/// The value of the first major tic for the axis.
-		/// </param>
-		/// <returns>
-		/// The ordinal position of the first minor tic, relative to the first major tic.
-		/// This value can be negative (e.g., -3 means the first minor tic is 3 minor step
-		/// increments before the first major tic.
-		/// </returns>
-		virtual internal int CalcMinorStart( double baseVal )
-		{
-			// Default behavior is for a linear scale (works for ordinal as well
-			return (int) ( ( _min - baseVal ) / _minorStep );
-		}
-
-		/// <summary>
-		/// Determine the value for the first major tic.
-		/// </summary>
-		/// <remarks>
-		/// This is done by finding the first possible value that is an integral multiple of
-		/// the step size, taking into account the date/time units if appropriate.
-		/// This method properly accounts for <see cref="IsLog"/>, <see cref="IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <returns>
-		/// First major tic value (floating point double).
-		/// </returns>
-		virtual internal double CalcBaseTic()
-		{
-			if ( _baseTic != PointPair.Missing )
-				return _baseTic;
-			else if ( IsAnyOrdinal )
-			{
-				// basetic is always 1 for ordinal types
-				return 1;
-			}
-			else
-			{
-				// default behavior is linear or ordinal type
-				// go to the nearest even multiple of the step size
-				return Math.Ceiling( (double)_min / (double)_majorStep - 0.00000001 )
-														* (double)_majorStep;
-			}
-		}
-
-		/// <summary>
-		/// Draw the value labels, tic marks, and grid lines as
-		/// required for this <see cref="Axis"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="baseVal">
-		/// The first major tic value for the axis
-		/// </param>
-		/// <param name="nTics">
-		/// The total number of major tics for the axis
-		/// </param>
-		/// <param name="topPix">
-		/// The pixel location of the far side of the ChartRect from this axis.
-		/// This value is the ChartRect.Height for the XAxis, or the ChartRect.Width
-		/// for the YAxis and Y2Axis.
-		/// </param>
-		/// <param name="shift">The number of pixels to shift this axis, based on the
-		/// value of <see cref="Axis.Cross"/>.  A positive value is into the ChartRect relative to
-		/// the default axis position.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		internal void DrawLabels( Graphics g, GraphPane pane, double baseVal, int nTics,
-						float topPix, float shift, float scaleFactor )
-		{
-			MajorTic tic = _ownerAxis._majorTic;
-//			MajorGrid grid = _ownerAxis._majorGrid;
-
-			double dVal, dVal2;
-			float pixVal, pixVal2;
-			float scaledTic = tic.ScaledTic( scaleFactor );
-
-			double scaleMult = Math.Pow( (double)10.0, _mag );
-
-			using ( Pen ticPen = tic.GetPen( pane, scaleFactor ) )
-//			using ( Pen gridPen = grid.GetPen( pane, scaleFactor ) )
-			{
-				// get the Y position of the center of the axis labels
-				// (the axis itself is referenced at zero)
-				SizeF maxLabelSize = GetScaleMaxSpace( g, pane, scaleFactor, true );
-				float charHeight = _fontSpec.GetHeight( scaleFactor );
-				float maxSpace = maxLabelSize.Height;
-
-				float edgeTolerance = Default.EdgeTolerance * scaleFactor;
-				double rangeTol = ( _maxLinTemp - _minLinTemp ) * 0.001;
-
-				int firstTic = (int)( ( _minLinTemp - baseVal ) / _majorStep + 0.99 );
-				if ( firstTic < 0 )
-					firstTic = 0;
-
-				// save the position of the previous tic
-				float lastPixVal = -10000;
-
-				// loop for each major tic
-				for ( int i = firstTic; i < nTics + firstTic; i++ )
-				{
-					dVal = CalcMajorTicValue( baseVal, i );
-
-					// If we're before the start of the scale, just go to the next tic
-					if ( dVal < _minLinTemp )
-						continue;
-					// if we've already past the end of the scale, then we're done
-					if ( dVal > _maxLinTemp + rangeTol )
-						break;
-
-					// convert the value to a pixel position
-					pixVal = LocalTransform( dVal );
-
-					// see if the tic marks will be drawn between the labels instead of at the labels
-					// (this applies only to AxisType.Text
-					if ( tic._isBetweenLabels && IsText )
-					{
-						// We need one extra tic in order to draw the tics between labels
-						// so provide an exception here
-						if ( i == 0 )
-						{
-							dVal2 = CalcMajorTicValue( baseVal, -0.5 );
-							if ( dVal2 >= _minLinTemp )
-							{
-								pixVal2 = LocalTransform( dVal2 );
-								tic.Draw( g, pane, ticPen, pixVal2, topPix, shift, scaledTic );
-
-//								grid.Draw( g, gridPen, pixVal2, topPix );
-							}
-						}
-
-						dVal2 = CalcMajorTicValue( baseVal, (double)i + 0.5 );
-						if ( dVal2 > _maxLinTemp )
-							break;
-						pixVal2 = LocalTransform( dVal2 );
-					}
-					else
-						pixVal2 = pixVal;
-
-					tic.Draw( g, pane, ticPen, pixVal2, topPix, shift, scaledTic );
-
-					// draw the grid
-//					grid.Draw( g, gridPen, pixVal2, topPix );
-
-					bool isMaxValueAtMaxPix = ( ( _ownerAxis is XAxis || _ownerAxis is Y2Axis ) &&
-															!IsReverse ) ||
-												( _ownerAxis is Y2Axis && IsReverse );
-
-					bool isSkipZone = ( ( ( _isSkipFirstLabel && isMaxValueAtMaxPix ) ||
-											( _isSkipLastLabel && !isMaxValueAtMaxPix ) ) &&
-												pixVal < edgeTolerance ) ||
-										( ( ( _isSkipLastLabel && isMaxValueAtMaxPix ) ||
-											( _isSkipFirstLabel && !isMaxValueAtMaxPix ) ) &&
-												pixVal > _maxPix - _minPix - edgeTolerance );
-
-					bool isSkipCross = _isSkipCrossLabel && !_ownerAxis._crossAuto &&
-									Math.Abs( _ownerAxis._cross - dVal ) < rangeTol * 10.0;
-
-					isSkipZone = isSkipZone || isSkipCross;
-
-					if ( _isVisible && !isSkipZone )
-					{
-						// For exponential scales, just skip any label that would overlap with the previous one
-						// This is because exponential scales have varying label spacing
-						if ( IsPreventLabelOverlap &&
-								Math.Abs( pixVal - lastPixVal ) < maxLabelSize.Width )
-							continue;
-
-						DrawLabel( g, pane, i, dVal, pixVal, shift, maxSpace, scaledTic, charHeight, scaleFactor );
-
-						lastPixVal = pixVal;
-					}
-				}
-			}
-		}
-
-		internal void DrawGrid( Graphics g, GraphPane pane, double baseVal, float topPix, float scaleFactor )
-		{
-			MajorTic tic = _ownerAxis._majorTic;
-			MajorGrid grid = _ownerAxis._majorGrid;
-
-			int nTics = CalcNumTics();
-
-			double dVal, dVal2;
-			float pixVal, pixVal2;
-
-			using ( Pen gridPen = grid.GetPen( pane, scaleFactor ) )
-			{
-				// get the Y position of the center of the axis labels
-				// (the axis itself is referenced at zero)
-//				SizeF maxLabelSize = GetScaleMaxSpace( g, pane, scaleFactor, true );
-//				float charHeight = _fontSpec.GetHeight( scaleFactor );
-//				float maxSpace = maxLabelSize.Height;
-
-//				float edgeTolerance = Default.EdgeTolerance * scaleFactor;
-				double rangeTol = ( _maxLinTemp - _minLinTemp ) * 0.001;
-
-				int firstTic = (int)( ( _minLinTemp - baseVal ) / _majorStep + 0.99 );
-				if ( firstTic < 0 )
-					firstTic = 0;
-
-				// save the position of the previous tic
-//				float lastPixVal = -10000;
-
-				// loop for each major tic
-				for ( int i = firstTic; i < nTics + firstTic; i++ )
-				{
-					dVal = CalcMajorTicValue( baseVal, i );
-
-					// If we're before the start of the scale, just go to the next tic
-					if ( dVal < _minLinTemp )
-						continue;
-					// if we've already past the end of the scale, then we're done
-					if ( dVal > _maxLinTemp + rangeTol )
-						break;
-
-					// convert the value to a pixel position
-					pixVal = LocalTransform( dVal );
-
-					// see if the tic marks will be drawn between the labels instead of at the labels
-					// (this applies only to AxisType.Text
-					if ( tic._isBetweenLabels && IsText )
-					{
-						// We need one extra tic in order to draw the tics between labels
-						// so provide an exception here
-						if ( i == 0 )
-						{
-							dVal2 = CalcMajorTicValue( baseVal, -0.5 );
-							if ( dVal2 >= _minLinTemp )
-							{
-								pixVal2 = LocalTransform( dVal2 );
-								grid.Draw( g, gridPen, pixVal2, topPix );
-							}
-						}
-
-						dVal2 = CalcMajorTicValue( baseVal, (double)i + 0.5 );
-						if ( dVal2 > _maxLinTemp )
-							break;
-						pixVal2 = LocalTransform( dVal2 );
-					}
-					else
-						pixVal2 = pixVal;
-
-					// draw the grid
-					grid.Draw( g, gridPen, pixVal2, topPix );
-				}
-			}
-		}
-
-		internal void DrawLabel( Graphics g, GraphPane pane, int i, double dVal, float pixVal,
-						float shift, float maxSpace, float scaledTic, float charHeight, float scaleFactor )
-		{
-			float textTop, textCenter;
-			if ( _ownerAxis.MajorTic.IsOutside )
-				textTop = scaledTic + charHeight * _labelGap;
-			else
-				textTop = charHeight * _labelGap;
-
-			// draw the label
-			//string tmpStr = MakeLabel( pane, i, dVal );
-			string tmpStr = _ownerAxis.MakeLabelEventWorks( pane, i, dVal );
-
-			float height;
-			if ( this.IsLog && _isUseTenPower )
-				height = _fontSpec.BoundingBoxTenPower( g, tmpStr, scaleFactor ).Height;
-			else
-				height = _fontSpec.BoundingBox( g, tmpStr, scaleFactor ).Height;
-
-			if ( _align == AlignP.Center )
-				textCenter = textTop + maxSpace / 2.0F;
-			else if ( _align == AlignP.Outside )
-				textCenter = textTop + maxSpace - height / 2.0F;
-			else	// inside
-				textCenter = textTop + height / 2.0F;
-
-			if ( _isLabelsInside )
-				textCenter = shift - textCenter;
-			else
-				textCenter = shift + textCenter;
-
-			AlignV av = AlignV.Center;
-			AlignH ah = AlignH.Center;
-
-			if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-				ah = _alignH;
-			else
-				av = _alignH == AlignH.Left ? AlignV.Top : ( _alignH == AlignH.Right ? AlignV.Bottom : AlignV.Center );
-
-			if ( this.IsLog && _isUseTenPower )
-				_fontSpec.DrawTenPower( g, pane, tmpStr,
-					pixVal, textCenter,
-					ah, av,
-					scaleFactor );
-			else
-				_fontSpec.Draw( g, pane, tmpStr,
-					pixVal, textCenter,
-					ah, av,
-					scaleFactor );
-		}
-
-		/// <summary>
-		/// Draw the scale, including the tic marks, value labels, and grid lines as
-		/// required for this <see cref="Axis"/>.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="shiftPos">
-		/// The number of pixels to shift to account for non-primary axis position (e.g.,
-		/// the second, third, fourth, etc. <see cref="YAxis" /> or <see cref="Y2Axis" />.
-		/// </param>
-		internal void Draw( Graphics g, GraphPane pane, float scaleFactor, float shiftPos )
-		{
-			MajorGrid majorGrid = _ownerAxis._majorGrid;
-			MajorTic majorTic = _ownerAxis._majorTic;
-			MinorTic minorTic = _ownerAxis._minorTic;
-
-			float rightPix,
-					topPix;
-
-			GetTopRightPix( pane, out topPix, out rightPix );
-
-			// calculate the total number of major tics required
-			int nTics = CalcNumTics();
-
-			// get the first major tic value
-			double baseVal = CalcBaseTic();
-
-			using ( Pen pen = new Pen( _ownerAxis.Color,
-						pane.ScaledPenWidth( majorTic._penWidth, scaleFactor ) ) )
-			{
-
-				// redraw the axis border
-				if ( _ownerAxis.IsAxisSegmentVisible )
-					g.DrawLine( pen, 0.0F, shiftPos, rightPix, shiftPos );
-
-				// Draw a zero-value line if needed
-				if ( majorGrid._isZeroLine && _min < 0.0 && _max > 0.0 )
-				{
-					float zeroPix = LocalTransform( 0.0 );
-					g.DrawLine( pen, zeroPix, 0.0F, zeroPix, topPix );
-				}
-			}
-
-			// draw the major tics and labels
-			DrawLabels( g, pane, baseVal, nTics, topPix, shiftPos, scaleFactor );
-
-//			_ownerAxis.DrawMinorTics( g, pane, baseVal, shiftPos, scaleFactor, topPix );
-
-			_ownerAxis.DrawTitle( g, pane, shiftPos, scaleFactor );
-		}
-
-		internal void GetTopRightPix( GraphPane pane, out float topPix, out float rightPix )
-		{
-			if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-			{
-				rightPix = pane.Chart._rect.Width;
-				topPix = -pane.Chart._rect.Height;
-			}
-			else
-			{
-				rightPix = pane.Chart._rect.Height;
-				topPix = -pane.Chart._rect.Width;
-			}
-
-			// sanity check
-			if ( _min >= _max )
-				return;
-
-			// if the step size is outrageous, then quit
-			// (step size not used for log scales)
-			if ( !IsLog )
-			{
-				if ( _majorStep <= 0 || _minorStep <= 0 )
-					return;
-
-				double tMajor = ( _max - _min ) / ( _majorStep * MajorUnitMultiplier );
-				double tMinor = ( _max - _min ) / ( _minorStep * MinorUnitMultiplier );
-
-				MinorTic minorTic = _ownerAxis._minorTic;
-
-				if ( tMajor > 1000 ||
-					( ( minorTic.IsOutside || minorTic.IsInside || minorTic.IsOpposite )
-					&& tMinor > 5000 ) )
-					return;
-			}
-		}
-
-		/// <summary>
-		/// Determine the width, in pixel units, of each bar cluster including
-		/// the cluster gaps and bar gaps.
-		/// </summary>
-		/// <remarks>
-		/// This method uses the <see cref="BarSettings.ClusterScaleWidth" /> for
-		/// non-ordinal axes, or a cluster width of 1.0 for ordinal axes.
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <returns>The width of each bar cluster, in pixel units</returns>
-		public float GetClusterWidth( GraphPane pane )
-		{
-			double basisVal = _min;
-			return Math.Abs( Transform( basisVal +
-					( IsAnyOrdinal ? 1.0 : pane._barSettings._clusterScaleWidth ) ) -
-					Transform( basisVal ) );
-		}
-
-		/// <summary>
-		/// Calculates the cluster width, in pixels, by transforming the specified
-		/// clusterScaleWidth.
-		/// </summary>
-		/// <param name="clusterScaleWidth">The width in user scale units of each
-		/// bar cluster</param>
-		/// <returns>The equivalent pixel size of the bar cluster</returns>
-		public float GetClusterWidth( double clusterScaleWidth )
-		{
-			double basisVal = _min;
-			return Math.Abs( Transform( basisVal + clusterScaleWidth ) -
-					Transform( basisVal ) );
-		}
-
-	#endregion
-
-	#region Scale Picker Methods
-
-		/// <summary>
-		/// Select a reasonable scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// The scale range is chosen
-		/// based on increments of 1, 2, or 5 (because they are even divisors of 10).  This
-		/// routine honors the <see cref="MinAuto"/>, <see cref="MaxAuto"/>,
-		/// and <see cref="MajorStepAuto"/> autorange settings as well as the <see cref="IsLog"/>
-		/// setting.  In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Min"/>, <see cref="Max"/>, or <see cref="MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.  The basic defaults for
-		/// scale selection are defined using <see cref="Default.ZeroLever"/>,
-		/// <see cref="Default.TargetXSteps"/>, and <see cref="Default.TargetYSteps"/>
-		/// from the <see cref="Default"/> default class.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Min"/> is set to scale minimum (if <see cref="MinAuto"/> = true)</para>
-		/// <para><see cref="Max"/> is set to scale maximum (if <see cref="MaxAuto"/> = true)</para>
-		/// <para><see cref="MajorStep"/> is set to scale step size (if <see cref="MajorStepAuto"/> = true)</para>
-		/// <para><see cref="MinorStep"/> is set to scale minor step size (if <see cref="MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		virtual public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			double minVal = _rangeMin;
-			double maxVal = _rangeMax;
-
-			// Make sure that minVal and maxVal are legitimate values
-			if ( Double.IsInfinity( minVal ) || Double.IsNaN( minVal ) || minVal == Double.MaxValue )
-				minVal = 0.0;
-			if ( Double.IsInfinity( maxVal ) || Double.IsNaN( maxVal ) || maxVal == Double.MaxValue )
-				maxVal = 0.0;
-
-			// if the scales are autoranged, use the actual data values for the range
-			double range = maxVal - minVal;
-
-			// "Grace" is applied to the numeric axis types only
-			bool numType = !this.IsAnyOrdinal;
-
-			// For autoranged values, assign the value.  If appropriate, adjust the value by the
-			// "Grace" value.
-			if ( _minAuto )
-			{
-				_min = minVal;
-				// Do not let the grace value extend the axis below zero when all the values were positive
-				if ( numType && ( _min < 0 || minVal - _minGrace * range >= 0.0 ) )
-					_min = minVal - _minGrace * range;
-			}
-			if ( _maxAuto )
-			{
-				_max = maxVal;
-				// Do not let the grace value extend the axis above zero when all the values were negative
-				if ( numType && ( _max > 0 || maxVal + _maxGrace * range <= 0.0 ) )
-					_max = maxVal + _maxGrace * range;
-			}
-
-			if ( _max == _min && _maxAuto && _minAuto )
-			{
-				if ( Math.Abs( _max ) > 1e-100 )
-				{
-					_max *= ( _min < 0 ? 0.95 : 1.05 );
-					_min *= ( _min < 0 ? 1.05 : 0.95 );
-				}
-				else
-				{
-					_max = 1.0;
-					_min = -1.0;
-				}
-			}
-
-			if ( _max <= _min )
-			{
-				if ( _maxAuto )
-					_max = _min + 1.0;
-				else if ( _minAuto )
-					_min = _max - 1.0;
-			}
-
-		}
-
-		/// <summary>
-		/// Calculate the maximum number of labels that will fit on this axis.
-		/// </summary>
-		/// <remarks>
-		/// This method works for
-		/// both X and Y direction axes, and it works for angled text (assuming that a bounding box
-		/// is an appropriate measure).  Technically, labels at 45 degree angles could fit better than
-		/// the return value of this method since the bounding boxes can overlap without the labels actually
-		/// overlapping.
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		public int CalcMaxLabels( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			SizeF size = this.GetScaleMaxSpace( g, pane, scaleFactor, false );
-
-			// The font angles are already set such that the Width is parallel to the appropriate (X or Y)
-			// axis.  Therefore, we always use size.Width.
-			// use the minimum of 1/4 the max Width or 1 character space
-			//			double allowance = this.Scale.FontSpec.GetWidth( g, scaleFactor );
-			//			if ( allowance > size.Width / 4 )
-			//				allowance = size.Width / 4;
-
-
-			float maxWidth = 1000;
-			float temp = 1000;
-			float costh = (float) Math.Abs( Math.Cos( _fontSpec.Angle * Math.PI / 180.0 ) );
-			float sinth = (float) Math.Abs( Math.Sin( _fontSpec.Angle * Math.PI / 180.0 ) );
-
-			if ( costh > 0.001 )
-				maxWidth = size.Width / costh;
-			if ( sinth > 0.001 )
-				temp = size.Height / sinth;
-			if ( temp < maxWidth )
-				maxWidth = temp;
-
-
-			//maxWidth = size.Width;
-			/*
-						if ( this is XAxis )
-							// Add an extra character width to leave a minimum of 1 character space between labels
-							maxWidth = size.Width + this.Scale.FontSpec.GetWidth( g, scaleFactor );
-						else
-							// For vertical spacing, we only need 1/2 character
-							maxWidth = size.Width + this.Scale.FontSpec.GetWidth( g, scaleFactor ) / 2.0;
-			*/
-			if ( maxWidth <= 0 )
-				maxWidth = 1;
-
-
-			// Calculate the maximum number of labels
-			double width;
-			RectangleF chartRect = pane.Chart._rect;
-			if ( _ownerAxis is XAxis || _ownerAxis is X2Axis )
-				width = ( chartRect.Width == 0 ) ? pane.Rect.Width * 0.75 : chartRect.Width;
-			else
-				width = ( chartRect.Height == 0 ) ? pane.Rect.Height * 0.75 : chartRect.Height;
-
-			int maxLabels = (int) ( width / maxWidth );
-			if ( maxLabels <= 0 )
-				maxLabels = 1;
-
-			return maxLabels;
-		}
-
-		internal void SetScaleMag( double min, double max, double step )
-		{
-			// set the scale magnitude if required
-			if ( _magAuto )
-			{
-				// Find the optimal scale display multiple
-				double mag = -100;
-				double mag2 = -100;
-
-				if ( Math.Abs( _min ) > 1.0e-30 )
-					mag = Math.Floor( Math.Log10( Math.Abs( _min ) ) );
-				if ( Math.Abs( _max ) > 1.0e-30 )
-					mag2 = Math.Floor( Math.Log10( Math.Abs( _max ) ) );
-
-				mag = Math.Max( mag2, mag );
-
-				// Do not use scale multiples for magnitudes below 4
-				if ( mag == -100 || Math.Abs( mag ) <= 3 )
-					mag = 0;
-
-				// Use a power of 10 that is a multiple of 3 (engineering scale)
-				_mag = (int) ( Math.Floor( mag / 3.0 ) * 3.0 );
-			}
-
-			// Calculate the appropriate number of dec places to display if required
-			if ( _formatAuto )
-			{
-				int numDec = 0 - (int) ( Math.Floor( Math.Log10( _majorStep ) ) - _mag );
-				if ( numDec < 0 )
-					numDec = 0;
-				_format = "f" + numDec.ToString();
-			}
-		}
-
-		/// <summary>
-		/// Calculate a step size based on a data range.
-		/// </summary>
-		/// <remarks>
-		/// This utility method
-		/// will try to honor the <see cref="Default.TargetXSteps"/> and
-		/// <see cref="Default.TargetYSteps"/> number of
-		/// steps while using a rational increment (1, 2, or 5 -- which are
-		/// even divisors of 10).  This method is used by <see cref="PickScale"/>.
-		/// </remarks>
-		/// <param name="range">The range of data in user scale units.  This can
-		/// be a full range of the data for the major step size, or just the
-		/// value of the major step size to calculate the minor step size</param>
-		/// <param name="targetSteps">The desired "typical" number of steps
-		/// to divide the range into</param>
-		/// <returns>The calculated step size for the specified data range.</returns>
-		protected static double CalcStepSize( double range, double targetSteps )
-		{
-			// Calculate an initial guess at step size
-			double tempStep = range / targetSteps;
-
-			// Get the magnitude of the step size
-			double mag = Math.Floor( Math.Log10( tempStep ) );
-			double magPow = Math.Pow( (double) 10.0, mag );
-
-			// Calculate most significant digit of the new step size
-			double magMsd = ( (int) ( tempStep / magPow + .5 ) );
-
-			// promote the MSD to either 1, 2, or 5
-			if ( magMsd > 5.0 )
-				magMsd = 10.0;
-			else if ( magMsd > 2.0 )
-				magMsd = 5.0;
-			else if ( magMsd > 1.0 )
-				magMsd = 2.0;
-
-			return magMsd * magPow;
-		}
-
-		/// <summary>
-		/// Calculate a step size based on a data range, limited to a maximum number of steps.
-		/// </summary>
-		/// <remarks>
-		/// This utility method
-		/// will calculate a step size, of no more than maxSteps,
-		/// using a rational increment (1, 2, or 5 -- which are
-		/// even divisors of 10).  This method is used by <see cref="PickScale"/>.
-		/// </remarks>
-		/// <param name="range">The range of data in user scale units.  This can
-		/// be a full range of the data for the major step size, or just the
-		/// value of the major step size to calculate the minor step size</param>
-		/// <param name="maxSteps">The maximum allowable number of steps
-		/// to divide the range into</param>
-		/// <returns>The calculated step size for the specified data range.</returns>
-		protected double CalcBoundedStepSize( double range, double maxSteps )
-		{
-			// Calculate an initial guess at step size
-			double tempStep = range / maxSteps;
-
-			// Get the magnitude of the step size
-			double mag = Math.Floor( Math.Log10( tempStep ) );
-			double magPow = Math.Pow( (double) 10.0, mag );
-
-			// Calculate most significant digit of the new step size
-			double magMsd = Math.Ceiling( tempStep / magPow );
-
-			// promote the MSD to either 1, 2, or 5
-			if ( magMsd > 5.0 )
-				magMsd = 10.0;
-			else if ( magMsd > 2.0 )
-				magMsd = 5.0;
-			else if ( magMsd > 1.0 )
-				magMsd = 2.0;
-
-			return magMsd * magPow;
-		}
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first and last major axis label.
-		/// </summary>
-		/// <returns>
-		/// This is the total number of major tics for this axis.
-		/// </returns>
-		virtual internal int CalcNumTics()
-		{
-			int nTics = 1;
-
-			// default behavior is for a linear or ordinal scale
-			nTics = (int) ( ( _max - _min ) / _majorStep + 0.01 ) + 1;
-
-			if ( nTics < 1 )
-				nTics = 1;
-			else if ( nTics > 1000 )
-				nTics = 1000;
-
-			return nTics;
-		}
-
-		/// <summary>
-		/// Calculate the modulus (remainder) in a safe manner so that divide
-		/// by zero errors are avoided
-		/// </summary>
-		/// <param name="x">The divisor</param>
-		/// <param name="y">The dividend</param>
-		/// <returns>the value of the modulus, or zero for the divide-by-zero
-		/// case</returns>
-		protected double MyMod( double x, double y )
-		{
-			double temp;
-
-			if ( y == 0 )
-				return 0;
-
-			temp = x / y;
-			return y * ( temp - Math.Floor( temp ) );
-		}
-
-		/// <summary>
-		/// Define suitable default ranges for an axis in the event that
-		/// no data were available
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> of interest</param>
-		/// <param name="axis">The <see cref="Axis"/> for which to set the range</param>
-		internal void SetRange( GraphPane pane, Axis axis )
-		{
-			if ( _rangeMin >= Double.MaxValue || _rangeMax <= Double.MinValue )
-			{
-				// If this is a Y axis, and the main Y axis is valid, use it for defaults
-				if ( axis != pane.XAxis && axis != pane.X2Axis &&
-					pane.YAxis.Scale._rangeMin < double.MaxValue && pane.YAxis.Scale._rangeMax > double.MinValue )
-				{
-					_rangeMin = pane.YAxis.Scale._rangeMin;
-					_rangeMax = pane.YAxis.Scale._rangeMax;
-				}
-				// Otherwise, if this is a Y axis, and the main Y2 axis is valid, use it for defaults
-				else if ( axis != pane.XAxis && axis != pane.X2Axis &&
-					pane.Y2Axis.Scale._rangeMin < double.MaxValue && pane.Y2Axis.Scale._rangeMax > double.MinValue )
-				{
-					_rangeMin = pane.Y2Axis.Scale._rangeMin;
-					_rangeMax = pane.Y2Axis.Scale._rangeMax;
-				}
-				// Otherwise, just use 0 and 1
-				else
-				{
-					_rangeMin = 0;
-					_rangeMax = 1;
-				}
-
-			}
-
-			/*
-				if ( yMinVal >= Double.MaxValue || yMaxVal <= Double.MinValue )
-				{
-					if ( y2MinVal < Double.MaxValue && y2MaxVal > Double.MinValue )
-					{
-						yMinVal = y2MinVal;
-						yMaxVal = y2MaxVal;
-					}
-					else
-					{
-						yMinVal = 0;
-						yMaxVal = 0.01;
-					}
-				}
-			
-				if ( y2MinVal >= Double.MaxValue || y2MaxVal <= Double.MinValue )
-				{
-					if ( yMinVal < Double.MaxValue && yMaxVal > Double.MinValue )
-					{
-						y2MinVal = yMinVal;
-						y2MaxVal = yMaxVal;
-					}
-					else
-					{
-						y2MinVal = 0;
-						y2MaxVal = 1;
-					}
-				}
-				*/
-		}
-
-	#endregion
-
-	#region Coordinate Transform Methods
-
-		/// <summary>
-		/// Transform the coordinate value from user coordinates (scale value)
-		/// to graphics device coordinates (pixels).
-		/// </summary>
-		/// <remarks>This method takes into
-		/// account the scale range (<see cref="Min"/> and <see cref="Max"/>),
-		/// logarithmic state (<see cref="IsLog"/>), scale reverse state
-		/// (<see cref="IsReverse"/>) and axis type (<see cref="XAxis"/>,
-		/// <see cref="YAxis"/>, or <see cref="Y2Axis"/>).
-		/// Note that the <see cref="Chart.Rect"/> must be valid, and
-		/// <see cref="SetupScaleData"/> must be called for the
-		/// current configuration before using this method (this is called everytime
-		/// the graph is drawn (i.e., <see cref="GraphPane.Draw"/> is called).
-		/// </remarks>
-		/// <param name="x">The coordinate value, in user scale units, to
-		/// be transformed</param>
-		/// <returns>the coordinate value transformed to screen coordinates
-		/// for use in calling the <see cref="Graphics"/> draw routines</returns>
-		public float Transform( double x )
-		{
-			// Must take into account Log, and Reverse Axes
-			double denom = ( _maxLinTemp - _minLinTemp );
-			double ratio;
-			if ( denom > 1e-100 )
-				ratio = ( Linearize( x ) - _minLinTemp ) / denom;
-			else
-				ratio = 0;
-
-			// _isReverse   axisType    Eqn
-			//     T          XAxis     _maxPix - ...
-			//     F          YAxis     _maxPix - ...
-			//     F          Y2Axis    _maxPix - ...
-
-			//     T          YAxis     _minPix + ...
-			//     T          Y2Axis    _minPix + ...
-			//     F          XAxis     _minPix + ...
-
-			if ( _isReverse == ( _ownerAxis is XAxis || _ownerAxis is X2Axis ) )
-				return (float) ( _maxPix - ( _maxPix - _minPix ) * ratio );
-			else
-				return (float) ( _minPix + ( _maxPix - _minPix ) * ratio );
-		}
-
-		/// <summary>
-		/// Transform the coordinate value from user coordinates (scale value)
-		/// to graphics device coordinates (pixels).
-		/// </summary>
-		/// <remarks>
-		/// This method takes into
-		/// account the scale range (<see cref="Min"/> and <see cref="Max"/>),
-		/// logarithmic state (<see cref="IsLog"/>), scale reverse state
-		/// (<see cref="IsReverse"/>) and axis type (<see cref="XAxis"/>,
-		/// <see cref="YAxis"/>, or <see cref="Y2Axis"/>).
-		/// Note that the <see cref="Chart.Rect"/> must be valid, and
-		/// <see cref="SetupScaleData"/> must be called for the
-		/// current configuration before using this method (this is called everytime
-		/// the graph is drawn (i.e., <see cref="GraphPane.Draw"/> is called).
-		/// </remarks>
-		/// <param name="isOverrideOrdinal">true to force the axis to honor the data
-		/// value, rather than replacing it with the ordinal value</param>
-		/// <param name="i">The ordinal value of this point, just in case
-		/// this is an <see cref="AxisType.Ordinal"/> axis</param>
-		/// <param name="x">The coordinate value, in user scale units, to
-		/// be transformed</param>
-		/// <returns>the coordinate value transformed to screen coordinates
-		/// for use in calling the <see cref="Graphics"/> draw routines</returns>
-		public float Transform( bool isOverrideOrdinal, int i, double x )
-		{
-			// ordinal types ignore the X value, and just use the ordinal position
-			if ( this.IsAnyOrdinal && i >= 0 && !isOverrideOrdinal )
-				x = (double) i + 1.0;
-			return Transform( x );
-
-		}
-
-		/// <summary>
-		/// Reverse transform the user coordinates (scale value)
-		/// given a graphics device coordinate (pixels).
-		/// </summary>
-		/// <remarks>
-		/// This method takes into
-		/// account the scale range (<see cref="Min"/> and <see cref="Max"/>),
-		/// logarithmic state (<see cref="IsLog"/>), scale reverse state
-		/// (<see cref="IsReverse"/>) and axis type (<see cref="XAxis"/>,
-		/// <see cref="YAxis"/>, or <see cref="Y2Axis"/>).
-		/// Note that the <see cref="Chart.Rect"/> must be valid, and
-		/// <see cref="SetupScaleData"/> must be called for the
-		/// current configuration before using this method (this is called everytime
-		/// the graph is drawn (i.e., <see cref="GraphPane.Draw"/> is called).
-		/// </remarks>
-		/// <param name="pixVal">The screen pixel value, in graphics device coordinates to
-		/// be transformed</param>
-		/// <returns>The user scale value that corresponds to the screen pixel location</returns>
-		public double ReverseTransform( float pixVal )
-		{
-			double val;
-
-			// see if the sign of the equation needs to be reversed
-			if ( ( _isReverse ) == ( _ownerAxis is XAxis || _ownerAxis is X2Axis ) )
-				val = (double) ( pixVal - _maxPix )
-						/ (double) ( _minPix - _maxPix )
-						* ( _maxLinTemp - _minLinTemp ) + _minLinTemp;
-			else
-				val = (double) ( pixVal - _minPix )
-						/ (double) ( _maxPix - _minPix )
-						* ( _maxLinTemp - _minLinTemp ) + _minLinTemp;
-
-			return DeLinearize( val );
-		}
-
-
-		/// <summary>
-		/// Transform the coordinate value from user coordinates (scale value)
-		/// to graphics device coordinates (pixels).
-		/// </summary>
-		/// <remarks>Assumes that the origin
-		/// has been set to the "left" of this axis, facing from the label side.
-		/// Note that the left side corresponds to the scale minimum for the X and
-		/// Y2 axes, but it is the scale maximum for the Y axis.
-		/// This method takes into
-		/// account the scale range (<see cref="Min"/> and <see cref="Max"/>),
-		/// logarithmic state (<see cref="IsLog"/>), scale reverse state
-		/// (<see cref="IsReverse"/>) and axis type (<see cref="XAxis"/>,
-		/// <see cref="YAxis"/>, or <see cref="Y2Axis"/>).  Note that
-		/// the <see cref="Chart.Rect"/> must be valid, and
-		/// <see cref="SetupScaleData"/> must be called for the
-		/// current configuration before using this method.
-		/// </remarks>
-		/// <param name="x">The coordinate value, in linearized user scale units, to
-		/// be transformed</param>
-		/// <returns>the coordinate value transformed to screen coordinates
-		/// for use in calling the <see cref="Draw"/> method</returns>
-		public float LocalTransform( double x )
-		{
-			// Must take into account Log, and Reverse Axes
-			double ratio;
-			float rv;
-
-			// Coordinate values for log scales are already in exponent form, so no need
-			// to take the log here
-			ratio = ( x - _minLinTemp ) /
-						( _maxLinTemp - _minLinTemp );
-
-			if ( _isReverse == ( _ownerAxis is YAxis || _ownerAxis is X2Axis ) )
-				rv = (float) ( ( _maxPix - _minPix ) * ratio );
-			else
-				rv = (float)( ( _maxPix - _minPix ) * ( 1.0F - ratio ) );
-
-			return rv;
-		}
-
-		/// <summary>
-		/// Calculate a base 10 logarithm in a safe manner to avoid math exceptions
-		/// </summary>
-		/// <param name="x">The value for which the logarithm is to be calculated</param>
-		/// <returns>The value of the logarithm, or 0 if the <paramref name="x"/>
-		/// argument was negative or zero</returns>
-		public static double SafeLog( double x )
-		{
-			if ( x > 1.0e-20 )
-				return Math.Log10( x );
-			else
-				return 0.0;
-		}
-
-		///<summary>
-		///Calculate an exponential in a safe manner to avoid math exceptions
-		///</summary> 
-		/// <param name="x">The value for which the exponential is to be calculated</param>
-		/// <param name="exponent">The exponent value to use for calculating the exponential.</param>
-		public static double SafeExp( double x, double exponent )
-		{
-			if ( x > 1.0e-20 )
-				return Math.Pow( x, exponent );
-			else
-				return 0.0;
-		}
-
-	#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ScaleState.cs b/BDInfo/ZedGraph/ScaleState.cs
deleted file mode 100644
index 906ac717c4..0000000000
--- a/BDInfo/ZedGraph/ScaleState.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Text;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that captures an <see cref="Axis"/> scale range.
-	/// </summary>
-	/// <remarks>This structure is used by the <see cref="ZoomState"/> class to store
-	/// <see cref="Axis"/> scale range settings in a collection for later retrieval.
-	/// The class stores the <see cref="Scale.Min"/>, <see cref="Scale.Max"/>,
-	/// <see cref="Scale.MinorStep"/>, and <see cref="Scale.MajorStep"/> properties, along with
-	/// the corresponding auto-scale settings: <see cref="Scale.MinAuto"/>,
-	/// <see cref="Scale.MaxAuto"/>, <see cref="Scale.MinorStepAuto"/>,
-	/// and <see cref="Scale.MajorStepAuto"/>.</remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.2 $ $Date: 2007/02/19 08:05:24 $ </version>
-	public class ScaleState : ICloneable
-	{
-		/// <summary>
-		/// The axis range data for <see cref="Scale.Min"/>, <see cref="Scale.Max"/>,
-		/// <see cref="Scale.MinorStep"/>, and <see cref="Scale.MajorStep"/>
-		/// </summary>
-		private double _min, _minorStep, _majorStep, _max;
-		/// <summary>
-		/// The status of <see cref="Scale.MinAuto"/>,
-		/// <see cref="Scale.MaxAuto"/>, <see cref="Scale.MinorStepAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/>
-		/// </summary>
-		private bool _minAuto, _minorStepAuto,
-							_majorStepAuto, _maxAuto,
-							_formatAuto, _magAuto;
-
-		/// <summary>
-		/// The status of <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		private DateUnit _minorUnit, _majorUnit;
-
-		private string _format;
-		private int _mag;
-
-		/// <summary>
-		/// Construct a <see cref="ScaleState"/> from the specified <see cref="Axis"/>
-		/// </summary>
-		/// <param name="axis">The <see cref="Axis"/> from which to collect the scale
-		/// range settings.</param>
-		public ScaleState( Axis axis )
-		{
-			_min = axis._scale._min;
-			_minorStep = axis._scale._minorStep;
-			_majorStep = axis._scale._majorStep;
-			_max = axis._scale._max;
-			_majorUnit = axis._scale._majorUnit;
-			_minorUnit = axis._scale._minorUnit;
-
-			_format = axis._scale._format;
-			_mag = axis._scale._mag;
-			//this.numDec = axis.NumDec;
-
-			_minAuto = axis._scale._minAuto;
-			_majorStepAuto = axis._scale._majorStepAuto;
-			_minorStepAuto = axis._scale._minorStepAuto;
-			_maxAuto = axis._scale._maxAuto;
-
-			_formatAuto = axis._scale._formatAuto;
-			_magAuto = axis._scale._magAuto;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ScaleState"/> object from which to copy</param>
-		public ScaleState( ScaleState rhs )
-		{
-			_min = rhs._min;
-			_majorStep = rhs._majorStep;
-			_minorStep = rhs._minorStep;
-			_max = rhs._max;
-			_majorUnit = rhs._majorUnit;
-			_minorUnit = rhs._minorUnit;
-
-			_format = rhs._format;
-			_mag = rhs._mag;
-
-			_minAuto = rhs._minAuto;
-			_majorStepAuto = rhs._majorStepAuto;
-			_minorStepAuto = rhs._minorStepAuto;
-			_maxAuto = rhs._maxAuto;
-
-			_formatAuto = rhs._formatAuto;
-			_magAuto = rhs._magAuto;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ScaleState Clone()
-		{
-			return new ScaleState( this );
-		}
-
-		/// <summary>
-		/// Copy the properties from this <see cref="ScaleState"/> out to the specified <see cref="Axis"/>.
-		/// </summary>
-		/// <param name="axis">The <see cref="Axis"/> reference to which the properties should be
-		/// copied</param>
-		public void ApplyScale( Axis axis )
-		{
-			axis._scale._min = _min;
-			axis._scale._majorStep = _majorStep;
-			axis._scale._minorStep = _minorStep;
-			axis._scale._max = _max;
-			axis._scale._majorUnit = _majorUnit;
-			axis._scale._minorUnit = _minorUnit;
-
-			axis._scale._format = _format;
-			axis._scale._mag = _mag;
-
-			// The auto settings must be made after the min/step/max settings, since setting those
-			// properties actually affects the auto settings.
-			axis._scale._minAuto = _minAuto;
-			axis._scale._minorStepAuto = _minorStepAuto;
-			axis._scale._majorStepAuto = _majorStepAuto;
-			axis._scale._maxAuto = _maxAuto;
-
-			axis._scale._formatAuto = _formatAuto;
-			axis._scale._magAuto = _magAuto;
-
-		}
-
-		/// <summary>
-		/// Determine if the state contained in this <see cref="ScaleState"/> object is different from
-		/// the state of the specified <see cref="Axis"/>.
-		/// </summary>
-		/// <param name="axis">The <see cref="Axis"/> object with which to compare states.</param>
-		/// <returns>true if the states are different, false otherwise</returns>
-		public bool IsChanged( Axis axis )
-		{
-			return axis._scale._min != _min ||
-					axis._scale._majorStep != _majorStep ||
-					axis._scale._minorStep != _minorStep ||
-					axis._scale._max != _max ||
-					axis._scale._minorUnit != _minorUnit ||
-					axis._scale._majorUnit != _majorUnit ||
-					axis._scale._minAuto != _minAuto ||
-					axis._scale._minorStepAuto != _minorStepAuto ||
-					axis._scale._majorStepAuto != _majorStepAuto ||
-					axis._scale._maxAuto != _maxAuto;
-		}
-
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ScaleStateList.cs b/BDInfo/ZedGraph/ScaleStateList.cs
deleted file mode 100644
index eea1f95d09..0000000000
--- a/BDInfo/ZedGraph/ScaleStateList.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class that maintains a list of <see cref="ScaleState" />
-	/// objects, corresponding to the list of <see cref="Axis" /> objects
-	/// from <see cref="GraphPane.YAxisList" /> or <see cref="GraphPane.Y2AxisList" />.
-	/// </summary>
-	public class ScaleStateList : List<ScaleState>, ICloneable
-	{
-		/// <summary>
-		/// Construct a new <see cref="ScaleStateList" /> automatically from an
-		/// existing <see cref="YAxisList" />.
-		/// </summary>
-		/// <param name="list">The <see cref="YAxisList" /> (a list of Y axes),
-		/// from which to retrieve the state and create the <see cref="ScaleState" />
-		/// objects.</param>
-		public ScaleStateList( YAxisList list )
-		{
-			foreach ( Axis axis in list )
-				this.Add( new ScaleState( axis ) );
-		}
-
-		/// <summary>
-		/// Construct a new <see cref="ScaleStateList" /> automatically from an
-		/// existing <see cref="Y2AxisList" />.
-		/// </summary>
-		/// <param name="list">The <see cref="Y2AxisList" /> (a list of Y axes),
-		/// from which to retrieve the state and create the <see cref="ScaleState" />
-		/// objects.</param>
-		public ScaleStateList( Y2AxisList list )
-		{
-			foreach ( Axis axis in list )
-				this.Add( new ScaleState( axis ) );
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ScaleStateList"/> object from which to copy</param>
-		public ScaleStateList( ScaleStateList rhs )
-		{
-			foreach ( ScaleState item in rhs )
-			{
-				this.Add( item.Clone() );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ScaleStateList Clone()
-		{
-			return new ScaleStateList( this );
-		}
-
-		/// <summary>
-		/// Iterate through the list of <see cref="ScaleState" /> objects, comparing them
-		/// to the state of the specified <see cref="YAxisList" /> <see cref="Axis" />
-		/// objects.
-		/// </summary>
-		/// <param name="list">A <see cref="YAxisList" /> object specifying a list of
-		/// <see cref="Axis" /> objects to be compared with this <see cref="ScaleStateList" />.
-		/// </param>
-		/// <returns>true if a difference is found, false otherwise</returns>
-		public bool IsChanged( YAxisList list )
-		{
-			int count = Math.Min( list.Count, this.Count );
-			for ( int i = 0; i < count; i++ )
-				if ( this[i].IsChanged( list[i] ) )
-					return true;
-
-			return false;
-		}
-
-		/// <summary>
-		/// Iterate through the list of <see cref="ScaleState" /> objects, comparing them
-		/// to the state of the specified <see cref="Y2AxisList" /> <see cref="Axis" />
-		/// objects.
-		/// </summary>
-		/// <param name="list">A <see cref="Y2AxisList" /> object specifying a list of
-		/// <see cref="Axis" /> objects to be compared with this <see cref="ScaleStateList" />.
-		/// </param>
-		/// <returns>true if a difference is found, false otherwise</returns>
-		public bool IsChanged( Y2AxisList list )
-		{
-			int count = Math.Min( list.Count, this.Count );
-			for ( int i = 0; i < count; i++ )
-				if ( this[i].IsChanged( list[i] ) )
-					return true;
-
-			return false;
-		}
-		/*
-				/// <summary>
-				/// Indexer to access the specified <see cref="ScaleState"/> object by
-				/// its ordinal position in the list.
-				/// </summary>
-				/// <param name="index">The ordinal position (zero-based) of the
-				/// <see cref="ScaleState"/> object to be accessed.</param>
-				/// <value>A <see cref="ScaleState"/> object reference.</value>
-				public ScaleState this[ int index ]  
-				{
-					get { return (ScaleState) List[index]; }
-					set { List[index] = value; }
-				}
-				/// <summary>
-				/// Add a <see cref="ScaleState"/> object to the collection at the end of the list.
-				/// </summary>
-				/// <param name="state">A reference to the <see cref="ScaleState"/> object to
-				/// be added</param>
-				/// <seealso cref="IList.Add"/>
-				public void Add( ScaleState state )
-				{
-					List.Add( state );
-				}
-		*/
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="list"></param>
-		public void ApplyScale( YAxisList list )
-		{
-			int count = Math.Min( list.Count, this.Count );
-			for ( int i = 0; i < count; i++ )
-				this[i].ApplyScale( list[i] );
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="list"></param>
-		public void ApplyScale( Y2AxisList list )
-		{
-			int count = Math.Min( list.Count, this.Count );
-			for ( int i = 0; i < count; i++ )
-				this[i].ApplyScale( list[i] );
-		}
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ScrollRange.cs b/BDInfo/ZedGraph/ScrollRange.cs
deleted file mode 100644
index 8bf383423a..0000000000
--- a/BDInfo/ZedGraph/ScrollRange.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A simple struct to store minimum and maximum <see cref="double" /> type
-	/// values for the scroll range
-	/// </summary>
-	public struct ScrollRange
-	{
-		private bool _isScrollable;
-		private double _min;
-		private double _max;
-
-		/// <summary>
-		/// Construct a <see cref="ScrollRange" /> object given the specified data values.
-		/// </summary>
-		/// <param name="min">The minimum axis value limit for the scroll bar</param>
-		/// <param name="max">The maximum axis value limit for the scroll bar</param>
-		/// <param name="isScrollable">true to make this item scrollable, false otherwise</param>
-		public ScrollRange( double min, double max, bool isScrollable )
-		{
-			_min = min;
-			_max = max;
-			_isScrollable = isScrollable;
-		}
-
-		/// <summary>
-		/// Sets the scroll range to default values of zero, and sets the <see cref="IsScrollable" />
-		/// property as specified.
-		/// </summary>
-		/// <param name="isScrollable">true to make this item scrollable, false otherwise</param>
-		public ScrollRange( bool isScrollable )
-		{
-			_min = 0.0;
-			_max = 0.0;
-			_isScrollable = isScrollable;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ScrollRange"/> object from which to copy</param>
-		public ScrollRange( ScrollRange rhs )
-		{
-			_min = rhs._min;
-			_max = rhs._max;
-			_isScrollable = rhs._isScrollable;
-		}
-				
-		/// <summary>
-		/// Gets or sets a property that determines if the <see cref="Axis" /> corresponding to
-		/// this <see cref="ScrollRange" /> object can be scrolled.
-		/// </summary>
-		public bool IsScrollable
-		{
-			get { return _isScrollable; }
-			set { _isScrollable = value; }
-		}
-
-		/// <summary>
-		/// The minimum axis value limit for the scroll bar.
-		/// </summary>
-		public double Min
-		{
-			get { return _min; }
-			set { _min = value; }
-		}
-		/// <summary>
-		/// The maximum axis value limit for the scroll bar.
-		/// </summary>
-		public double Max
-		{
-			get { return _max; }
-			set { _max = value; }
-		}
-	}
-}
diff --git a/BDInfo/ZedGraph/ScrollRangeList.cs b/BDInfo/ZedGraph/ScrollRangeList.cs
deleted file mode 100644
index 5a07cf3608..0000000000
--- a/BDInfo/ZedGraph/ScrollRangeList.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="ScrollRange"/> objects.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.3 $ $Date: 2006/06/24 20:26:43 $ </version>
-	public class ScrollRangeList : List<ScrollRange>, ICloneable
-	{
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the collection class.
-		/// </summary>
-		public ScrollRangeList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ScrollRangeList"/> object from which to copy</param>
-		public ScrollRangeList( ScrollRangeList rhs )
-		{
-			foreach ( ScrollRange item in rhs )
-				this.Add( new ScrollRange( item ) );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ScrollRangeList Clone()
-		{
-			return new ScrollRangeList( this );
-		}
-
-		
-	#endregion
-
-	#region List Methods
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="ScrollRange"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="ScrollRange"/> object to be accessed.</param>
-		/// <value>A <see cref="ScrollRange"/> object instance</value>
-		public new ScrollRange this[ int index ]  
-		{
-			get
-			{
-				if ( index < 0 || index >= this.Count )
-					return new ScrollRange( false );
-				else
-					return (ScrollRange) base[index];
-			}
-			set { base[index] = value; }
-		}
-
-		/*		/// <summary>
-				/// Add a <see cref="ScrollRange"/> object to the collection at the end of the list.
-				/// </summary>
-				/// <param name="item">The <see cref="ScrollRange"/> object to be added</param>
-				/// <seealso cref="IList.Add"/>
-				public int Add( ScrollRange item )
-				{
-					return List.Add( item );
-				}
-				/// <summary>
-				/// Insert a <see cref="ScrollRange"/> object into the collection at the specified
-				/// zero-based index location.
-				/// </summary>
-				/// <param name="index">The zero-based index location for insertion.</param>
-				/// <param name="item">The <see cref="ScrollRange"/> object that is to be
-				/// inserted.</param>
-				/// <seealso cref="IList.Insert"/>
-				public void Insert( int index, ScrollRange item )
-				{
-					List.Insert( index, item );
-				}
-		*/
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Selection.cs b/BDInfo/ZedGraph/Selection.cs
deleted file mode 100644
index a153c73f8d..0000000000
--- a/BDInfo/ZedGraph/Selection.cs
+++ /dev/null
@@ -1,258 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion and JCarpenter
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// </summary>
-	/// <remarks>
-	/// </remarks>
-	/// 
-	/// <author> John Champion and JCarpenter </author>
-	/// <version> $Revision: 3.5 $ $Date: 2007/03/11 02:08:16 $ </version>
-	public class Selection : CurveList
-	{
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Subscribe to this event to receive notice 
-		/// that the list of selected CurveItems has changed
-		/// </summary>
-		public event EventHandler SelectionChangedEvent;
-
-	#region static properties
-
-		/// <summary>
-		/// The <see cref="Border" /> type to be used for drawing "selected"
-		/// <see cref="PieItem" />, <see cref="BarItem" />, <see cref="HiLowBarItem" />,
-		/// <see cref="OHLCBarItem" />, and <see cref="JapaneseCandleStickItem" /> item types.
-		/// </summary>
-		public static Border Border = new Border( Color.Gray, 1.0f );
-		/// <summary>
-		/// The <see cref="Fill" /> type to be used for drawing "selected"
-		/// <see cref="PieItem" />, <see cref="BarItem" />, <see cref="HiLowBarItem" />,
-		/// and <see cref="JapaneseCandleStickItem" /> item types.
-		/// </summary>
-		public static Fill Fill = new Fill( Color.Gray );
-		/// <summary>
-		/// The <see cref="Line" /> type to be used for drawing "selected"
-		/// <see cref="LineItem" /> and <see cref="StickItem" /> types
-		/// </summary>
-		public static Line Line = new Line( Color.Gray );
-		//			public static ErrorBar ErrorBar = new ErrorBar( Color.Gray );
-		/// <summary>
-		/// The <see cref="Symbol" /> type to be used for drawing "selected"
-		/// <see cref="LineItem" /> and <see cref="ErrorBarItem" /> types.
-		/// </summary>
-		public static Symbol Symbol = new Symbol( SymbolType.Circle, Color.Gray );
-
-		//public static Color SelectedSymbolColor = Color.Gray;
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Place a <see cref="CurveItem" /> in the selection list, removing all other
-		/// items.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that is the "owner"
-		/// of the <see cref="CurveItem" />'s.</param>
-		/// <param name="ci">The <see cref="CurveItem" /> to be added to the list.</param>
-		public void Select( MasterPane master, CurveItem ci )
-		{
-			//Clear the selection, but don't send the event,
-			//the event will be sent in "AddToSelection" by calling "UpdateSelection"
-			ClearSelection( master, false );
-
-			AddToSelection( master, ci );
-		}
-
-		/// <summary>
-		/// Place a list of <see cref="CurveItem" />'s in the selection list, removing all other
-		/// items.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that is the "owner"
-		/// of the <see cref="CurveItem" />'s.</param>
-		/// <param name="ciList">The list of <see cref="CurveItem" /> to be added to the list.</param>
-		public void Select( MasterPane master, CurveList ciList )
-		{
-			//Clear the selection, but don't send the event,
-			//the event will be sent in "AddToSelection" by calling "UpdateSelection"
-			ClearSelection( master, false );
-
-			AddToSelection( master, ciList );
-		}
-
-		/// <summary>
-		/// Add a <see cref="CurveItem" /> to the selection list.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that is the "owner"
-		/// of the <see cref="CurveItem" />'s.</param>
-		/// <param name="ci">The <see cref="CurveItem" /> to be added to the list.</param>
-		public void AddToSelection( MasterPane master, CurveItem ci )
-		{
-			if ( this.Contains( ci ) == false )
-				Add( ci );
-
-			UpdateSelection( master );
-		}
-
-		/// <summary>
-		/// Add a list of <see cref="CurveItem" />'s to the selection list.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that is the "owner"
-		/// of the <see cref="CurveItem" />'s.</param>
-		/// <param name="ciList">The list of <see cref="CurveItem" />'s to be added to the list.</param>
-		public void AddToSelection( MasterPane master, CurveList ciList )
-		{
-			foreach ( CurveItem ci in ciList )
-			{
-				if ( this.Contains( ci ) == false )
-					this.Add( ci );
-			}
-
-			UpdateSelection( master );
-		}
-
-#if ( DOTNET1 )
-
-		// Define a "Contains" method so that this class works with .Net 1.1 or 2.0
-		internal bool Contains( CurveItem item )
-		{
-			foreach ( CurveItem ci in this )
-				if ( item == ci )
-					return true;
-
-			return false;
-		}
-#endif
-
-		/// <summary>
-		/// Remove the specified <see cref="CurveItem" /> from the selection list.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that is the "owner"
-		/// of the <see cref="CurveItem" />'s.</param>
-		/// <param name="ci">The <see cref="CurveItem" /> to be removed from the list.</param>
-		public void RemoveFromSelection( MasterPane master, CurveItem ci )
-		{
-			if ( this.Contains( ci ) )
-				this.Remove( ci );
-
-			UpdateSelection( master );
-
-		}
-
-		/// <summary>
-		/// Clear the selection list and trigger a <see cref="SelectionChangedEvent" />.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that "owns" the selection list.</param>
-		public void ClearSelection( MasterPane master )
-		{
-			ClearSelection( master, true );
-		}
-
-		/// <summary>
-		/// Clear the selection list and optionally trigger a <see cref="SelectionChangedEvent" />.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that "owns" the selection list.</param>
-		/// <param name="sendEvent">true to trigger a <see cref="SelectionChangedEvent" />,
-		/// false otherwise.</param>
-		public void ClearSelection( MasterPane master, bool sendEvent )
-		{
-			this.Clear();
-
-			foreach ( GraphPane pane in master.PaneList )
-			{
-				foreach ( CurveItem ci in pane.CurveList )
-				{
-					ci.IsSelected = false;
-				}
-			}
-
-			if ( sendEvent )
-			{
-				if ( SelectionChangedEvent != null )
-					SelectionChangedEvent( this, new EventArgs() );
-			}
-		}
-
-		/// <summary>
-		/// Mark the <see cref="CurveItem" />'s that are included in the selection list
-		/// by setting the <see cref="CurveItem.IsSelected" /> property to true.
-		/// </summary>
-		/// <param name="master">The <see cref="MasterPane" /> that "owns" the selection list.</param>
-		public void UpdateSelection( MasterPane master )
-		{
-			if ( Count <= 0 )
-			{
-				ClearSelection( master );
-				return;
-			}
-
-			foreach ( GraphPane pane in master.PaneList )
-			{
-				foreach ( CurveItem ci in pane.CurveList )
-				{
-					//Make it Inactive
-					ci.IsSelected = false;
-				}
-
-			}
-			foreach ( CurveItem ci in  this )
-			{
-				//Make Active
-				ci.IsSelected = true;
-
-				//If it is a line / scatterplot, the selected Curve may be occluded by an unselected Curve
-				//So, move it to the top of the ZOrder by removing it, and re-adding it.
-
-				//Why only do this for Lines? ...Bar and Pie Curves are less likely to overlap, 
-				//and adding and removing Pie elements changes thier display order
-				if ( ci.IsLine )
-				{
-					//I don't know how to get a Pane, from a CurveItem, so I can only do it 
-					//if there is one and only one Pane, based on the assumption that the 
-					//Curve's Pane is MasterPane[0]
-
-					//If there is only one Pane
-					if ( master.PaneList.Count == 1 )
-					{
-						GraphPane pane = master.PaneList[0];
-						pane.CurveList.Remove( ci );
-						pane.CurveList.Insert( 0, ci );
-					}
-
-				}
-			}
-
-			//Send Selection Changed Event
-			if ( SelectionChangedEvent != null )
-				SelectionChangedEvent( this, new EventArgs() );
-
-		}
-
-		#endregion
-
-
-	}
-}
diff --git a/BDInfo/ZedGraph/StickItem.cs b/BDInfo/ZedGraph/StickItem.cs
deleted file mode 100644
index edf2848aca..0000000000
--- a/BDInfo/ZedGraph/StickItem.cs
+++ /dev/null
@@ -1,219 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// Encapsulates a curve type that is displayed as a series of vertical "sticks",
-	/// one at each defined point.
-	/// </summary>
-	/// <remarks>
-	/// The sticks run from the zero value of the Y axis, to the Y point defined in each
-	/// <see cref="PointPair"/> of the <see cref="IPointList" /> (see <see cref="CurveItem.Points"/>).
-	/// The properties of the sticks are defined in the <see cref="Line"/> property.
-	/// Normally, the <see cref="Symbol"/> is not visible.  However, if you manually enable the
-	/// <see cref="Symbol"/> using the <see cref="ZedGraph.Symbol.IsVisible"/> property, the
-	/// symbols will be drawn at the "Z" value from each <see cref="PointPair" /> (see
-	/// <see cref="PointPair.Z" />).
-	/// </remarks>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 1.7 $ $Date: 2007/01/25 07:56:09 $ </version>
-	[Serializable]
-	public class StickItem : LineItem, ICloneable, ISerializable
-	{
-	#region Fields
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets a flag indicating if the Z data range should be included in the axis scaling calculations.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the Z data are included, false otherwise</value>
-		override internal bool IsZIncluded( GraphPane pane )
-		{
-			return _symbol.IsVisible;
-		}
-
-		/// <summary>
-		/// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
-		/// </param>
-		/// <value>true if the X axis is independent, false otherwise</value>
-		override internal bool IsXIndependent( GraphPane pane )
-		{
-			return true;
-		}
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Create a new <see cref="StickItem"/>, specifying only the legend <see cref="CurveItem.Label" />.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		public StickItem( string label ) : base( label )
-		{
-			_symbol.IsVisible = false;
-		}
-		
-		/// <summary>
-		/// Create a new <see cref="StickItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="lineWidth">The width (in points) to be used for the <see cref="Line"/>.  This
-		/// width is scaled based on <see cref="PaneBase.CalcScaleFactor"/>.  Use a value of zero to
-		/// hide the line (see <see cref="ZedGraph.LineBase.IsVisible"/>).</param>
-		public StickItem( string label, double[] x, double[] y, Color color, float lineWidth )
-			: this( label, new PointPairList( x, y ), color, lineWidth )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="StickItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="x">An array of double precision values that define
-		/// the independent (X axis) values for this curve</param>
-		/// <param name="y">An array of double precision values that define
-		/// the dependent (Y axis) values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		public StickItem( string label, double[] x, double[] y, Color color )
-			: this( label, new PointPairList( x, y ), color )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="StickItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		public StickItem( string label, IPointList points, Color color )
-			: this( label, points, color, ZedGraph.LineBase.Default.Width )
-		{
-		}
-
-		/// <summary>
-		/// Create a new <see cref="StickItem"/> using the specified properties.
-		/// </summary>
-		/// <param name="label">The label that will appear in the legend.</param>
-		/// <param name="points">A <see cref="IPointList"/> of double precision value pairs that define
-		/// the X and Y values for this curve</param>
-		/// <param name="color">A <see cref="Color"/> value that will be applied to
-		/// the <see cref="Line"/> and <see cref="Symbol"/> properties.
-		/// </param>
-		/// <param name="lineWidth">The width (in points) to be used for the <see cref="Line"/>.  This
-		/// width is scaled based on <see cref="PaneBase.CalcScaleFactor"/>.  Use a value of zero to
-		/// hide the line (see <see cref="ZedGraph.LineBase.IsVisible"/>).</param>
-		public StickItem( string label, IPointList points, Color color, float lineWidth )
-			: base( label, points, color, Symbol.Default.Type, lineWidth )
-		{
-			_symbol.IsVisible = false;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="StickItem"/> object from which to copy</param>
-		public StickItem( StickItem rhs ) : base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public new StickItem Clone()
-		{
-			return new StickItem( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected StickItem( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema3 );
-		}
-	#endregion
-
-	#region Methods
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/StockPointList.cs b/BDInfo/ZedGraph/StockPointList.cs
deleted file mode 100644
index b14817df2e..0000000000
--- a/BDInfo/ZedGraph/StockPointList.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-//============================================================================
-//PointPairList Class
-//Copyright © 2006  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections.Generic;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="StockPt"/> objects
-	/// that define the set of points to be displayed on the curve.
-	/// </summary>
-	/// 
-	/// <author> John Champion based on code by Jerry Vos</author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/02/18 05:51:54 $ </version>
-	[Serializable]
-	public class StockPointList : List<StockPt>, IPointList, IPointListEdit
-	{
-
-	#region Properties
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="StockPt"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="StockPt"/> object to be accessed.</param>
-		/// <value>A <see cref="StockPt"/> object reference.</value>
-		public new PointPair this[int index]
-		{
-			get { return base[index]; }
-			set { base[index] = new StockPt( value ); }
-		}
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default constructor for the collection class
-		/// </summary>
-		public StockPointList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The StockPointList from which to copy</param>
-		public StockPointList( StockPointList rhs )
-		{
-			for ( int i = 0; i < rhs.Count; i++ )
-			{
-				StockPt pt = new StockPt( rhs[i] );
-				this.Add( pt );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public StockPointList Clone()
-		{
-			return new StockPointList( this );
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Add a <see cref="StockPt"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="point">The <see cref="StockPt"/> object to
-		/// be added</param>
-		new public void Add( StockPt point )
-		{
-			base.Add( new StockPt( point ) );
-		}
-
-		/// <summary>
-		/// Add a <see cref="PointPair"/> object to the collection at the end of the list.
-		/// </summary>
-		/// <param name="point">The <see cref="PointPair"/> object to be added</param>
-		public void Add( PointPair point )
-		{
-//			throw new ArgumentException( "Error: Only the StockPt type can be added to StockPointList" +
-//				".  An ordinary PointPair is not allowed" );
-			base.Add( new StockPt( point ) );
-		}
-
-		/// <summary>
-		/// Add a <see cref="StockPt"/> object to the collection at the end of the list using
-		/// the specified values.  The unspecified values (low, open, close) are all set to
-		/// <see cref="PointPairBase.Missing" />.
-		/// </summary>
-		/// <param name="date">An <see cref="XDate" /> value</param>
-		/// <param name="high">The high value for the day</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public void Add( double date, double high )
-		{
-			Add( new StockPt( date, high, PointPair.Missing, PointPair.Missing,
-				PointPair.Missing, PointPair.Missing ) );
-		}
-
-		/// <summary>
-		/// Add a single point to the <see cref="PointPairList"/> from values of type double.
-		/// </summary>
-		/// <param name="date">An <see cref="XDate" /> value</param>
-		/// <param name="high">The high value for the day</param>
-		/// <param name="low">The low value for the day</param>
-		/// <param name="open">The opening value for the day</param>
-		/// <param name="close">The closing value for the day</param>
-		/// <param name="vol">The trading volume for the day</param>
-		/// <returns>The zero-based ordinal index where the point was added in the list.</returns>
-		public void Add( double date, double high, double low, double open, double close, double vol )
-		{
-			StockPt point = new StockPt( date, high, low, open, close, vol );
-			Add( point );
-		}
-
-		/// <summary>
-		/// Access the <see cref="StockPt" /> at the specified ordinal index.
-		/// </summary>
-		/// <remarks>
-		/// To be compatible with the <see cref="IPointList" /> interface, the
-		/// <see cref="StockPointList" /> must implement an index that returns a
-		/// <see cref="PointPair" /> rather than a <see cref="StockPt" />.  This method
-		/// will return the actual <see cref="StockPt" /> at the specified position.
-		/// </remarks>
-		/// <param name="index">The ordinal position (zero-based) in the list</param>
-		/// <returns>The specified <see cref="StockPt" />.
-		/// </returns>
-		public StockPt GetAt( int index )
-		{
-			return base[index];
-		}
-
-	#endregion
-	}
-}
-
-
diff --git a/BDInfo/ZedGraph/StockPt.cs b/BDInfo/ZedGraph/StockPt.cs
deleted file mode 100644
index 7828dd45ec..0000000000
--- a/BDInfo/ZedGraph/StockPt.cs
+++ /dev/null
@@ -1,316 +0,0 @@
-//============================================================================
-//PointPair4 Class
-//Copyright © 2006  Jerry Vos & John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-using IComparer = System.Collections.IComparer;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The basic <see cref="PointPair" /> class holds three data values (X, Y, Z).  This
-	/// class extends the basic PointPair to contain five data values (X, Y, Z, Open, Close).
-	/// </summary>
-	/// <remarks>
-	/// The values are remapped to <see cref="Date" />, <see cref="High" />,
-	/// <see cref="Low" />, <see cref="Open" />, and <see cref="Close" />.
-	/// </remarks>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/02/07 07:46:46 $ </version>
-	[Serializable]
-	public class StockPt : PointPair, ISerializable
-	{
-
-	#region Member variables
-
-		// member variable mapping:
-		//   Date = X
-		//   High = Y
-		//   Low = Z
-		//   Open = Open
-		//   Close = Close
-		//   Vol = Vol
-
-		/// <summary>
-		/// This opening value
-		/// </summary>
-		public double Open;
-
-		/// <summary>
-		/// This closing value
-		/// </summary>
-		public double Close;
-
-		/// <summary>
-		/// This daily trading volume
-		/// </summary>
-		public double Vol;
-
-		/// <summary>
-		/// This is a user value that can be anything.  It is used to provide special 
-		/// property-based coloration to the graph elements.
-		/// </summary>
-		private double _colorValue;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public StockPt() : this( 0, 0, 0, 0, 0, 0, null )
-		{
-		}
-
-		/// <summary>
-		/// Construct a new StockPt from the specified data values
-		/// </summary>
-		/// <param name="date">The trading date (<see cref="XDate" />)</param>
-		/// <param name="open">The opening stock price</param>
-		/// <param name="close">The closing stock price</param>
-		/// <param name="high">The daily high stock price</param>
-		/// <param name="low">The daily low stock price</param>
-		/// <param name="vol">The daily trading volume</param>
-		public StockPt( double date, double high, double low, double open, double close, double vol )
-			: this( date, high, low, open, close, vol, null )
-		{
-		}
-
-		/// <summary>
-		/// Construct a new StockPt from the specified data values including a Tag property
-		/// </summary>
-		/// <param name="date">The trading date (<see cref="XDate" />)</param>
-		/// <param name="open">The opening stock price</param>
-		/// <param name="close">The closing stock price</param>
-		/// <param name="high">The daily high stock price</param>
-		/// <param name="low">The daily low stock price</param>
-		/// <param name="vol">The daily trading volume</param>
-		/// <param name="tag">The user-defined <see cref="PointPair.Tag" /> property.</param>
-		public StockPt( double date, double high, double low, double open, double close, double vol,
-					string tag )
-			: base( date, high )
-		{
-			this.Low = low;
-			this.Open = open;
-			this.Close = close;
-			this.Vol = vol;
-			this.ColorValue = PointPair.Missing;
-			this.Tag = tag;
-		}
-
-		/// <summary>
-		/// The StockPt copy constructor.
-		/// </summary>
-		/// <param name="rhs">The basis for the copy.</param>
-		public StockPt( StockPt rhs )
-			: base( rhs )
-		{
-			this.Low = rhs.Low;
-			this.Open = rhs.Open;
-			this.Close = rhs.Close;
-			this.Vol = rhs.Vol;
-			this.ColorValue = rhs.ColorValue;
-
-			if ( rhs.Tag is ICloneable )
-				this.Tag = ( (ICloneable)rhs.Tag ).Clone();
-			else
-				this.Tag = rhs.Tag;
-		}
-
-		/// <summary>
-		/// The StockPt copy constructor.
-		/// </summary>
-		/// <param name="rhs">The basis for the copy.</param>
-		public StockPt( PointPair rhs )
-			: base( rhs )
-		{
-			if ( rhs is StockPt )
-			{
-				StockPt pt = rhs as StockPt;
-				this.Open = pt.Open;
-				this.Close = pt.Close;
-				this.Vol = pt.Vol;
-				this.ColorValue = rhs.ColorValue;
-			}
-			else
-			{
-				this.Open = PointPair.Missing;
-				this.Close = PointPair.Missing;
-				this.Vol = PointPair.Missing;
-				this.ColorValue = PointPair.Missing;
-			}
-		}
-
-	#endregion
-
-	#region Serialization
-
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema3 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected StockPt( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema3" );
-
-			Open = info.GetDouble( "Open" );
-			Close = info.GetDouble( "Close" );
-			Vol = info.GetDouble( "Vol" );
-			ColorValue = info.GetDouble( "ColorValue" );
-		}
-
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema3", schema2 );
-			info.AddValue( "Open", Open );
-			info.AddValue( "Close", Close );
-			info.AddValue( "Vol", Vol );
-			info.AddValue( "ColorValue", ColorValue );
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Map the Date property to the X value
-		/// </summary>
-		public double Date
-		{
-			get { return X; }
-			set { X = value; }
-		}
-
-		/// <summary>
-		/// Map the high property to the Y value
-		/// </summary>
-		public double High
-		{
-			get { return Y; }
-			set { Y = value; }
-		}
-
-		/// <summary>
-		/// Map the low property to the Z value
-		/// </summary>
-		public double Low
-		{
-			get { return Z; }
-			set { Z = value; }
-		}
-
-		/// <summary>
-		/// The ColorValue property.  This is used with the
-		/// <see cref="FillType.GradientByColorValue" /> option.
-		/// </summary>
-		override public double ColorValue
-		{
-			get { return _colorValue; }
-			set { _colorValue = value; }
-		}
-
-		/// <summary>
-		/// Readonly value that determines if either the Date, Close, Open, High, or Low
-		/// coordinate in this StockPt is an invalid (not plotable) value.
-		/// It is considered invalid if it is missing (equal to System.Double.Max),
-		/// Infinity, or NaN.
-		/// </summary>
-		/// <returns>true if any value is invalid</returns>
-		public bool IsInvalid5D
-		{
-			get
-			{
-				return this.Date == PointPair.Missing ||
-						this.Close == PointPair.Missing ||
-						this.Open == PointPair.Missing ||
-						this.High == PointPair.Missing ||
-						this.Low == PointPair.Missing ||
-						Double.IsInfinity( this.Date ) ||
-						Double.IsInfinity( this.Close ) ||
-						Double.IsInfinity( this.Open ) ||
-						Double.IsInfinity( this.High ) ||
-						Double.IsInfinity( this.Low ) ||
-						Double.IsNaN( this.Date ) ||
-						Double.IsNaN( this.Close ) ||
-						Double.IsNaN( this.Open ) ||
-						Double.IsNaN( this.High ) ||
-						Double.IsNaN( this.Low );
-			}
-		}
-
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Format this StockPt value using the default format.  Example:  "( 12.345, -16.876 )".
-		/// The two double values are formatted with the "g" format type.
-		/// </summary>
-		/// <param name="isShowAll">true to show all the value coordinates</param>
-		/// <returns>A string representation of the <see cref="StockPt" />.</returns>
-		override public string ToString( bool isShowAll )
-		{
-			return this.ToString( PointPair.DefaultFormat, isShowAll );
-		}
-
-		/// <summary>
-		/// Format this PointPair value using a general format string.
-		/// Example:  a format string of "e2" would give "( 1.23e+001, -1.69e+001 )".
-		/// If <see paramref="isShowAll"/>
-		/// is true, then the third all coordinates are shown.
-		/// </summary>
-		/// <param name="format">A format string that will be used to format each of
-		/// the two double type values (see <see cref="System.Double.ToString()"/>).</param>
-		/// <returns>A string representation of the PointPair</returns>
-		/// <param name="isShowAll">true to show all the value coordinates</param>
-		override public string ToString( string format, bool isShowAll )
-		{
-			return "( " + XDate.ToString( this.Date,  "g" ) +
-					", " + this.Close.ToString( format ) +
-					( isShowAll ? (
-								", " + this.Low.ToString( format ) +
-								", " + this.Open.ToString( format ) +
-								", " + this.Close.ToString( format ) ) : "" ) + " )";
-		}
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/Symbol.cs b/BDInfo/ZedGraph/Symbol.cs
deleted file mode 100644
index 38159a8e32..0000000000
--- a/BDInfo/ZedGraph/Symbol.cs
+++ /dev/null
@@ -1,680 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// This class handles the drawing of the curve <see cref="Symbol"/> objects.
-	/// The symbols are the small shapes that appear over each defined point
-	/// along the curve.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.37 $ $Date: 2007/09/19 06:41:56 $ </version>
-	[Serializable]
-	public class Symbol : ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary>
-		/// Private field that stores the size of this
-        /// <see cref="Symbol"/> in points (1/72 inch).  Use the public
-        /// property <see cref="Size"/> to access this value.
-		/// </summary>
-		private float		_size;
-		/// <summary>
-		/// Private field that stores the <see cref="SymbolType"/> for this
-		/// <see cref="Symbol"/>.  Use the public
-		/// property <see cref="Type"/> to access this value.
-		/// </summary>
-		private SymbolType	_type;
-		/// <summary>
-		/// private field that determines if the symbols are drawn using
-		/// Anti-Aliasing capabilities from the <see cref="Graphics" /> class.
-		/// Use the public property <see cref="IsAntiAlias" /> to access
-		/// this value.
-		/// </summary>
-		private bool _isAntiAlias;
-		/// <summary>
-		/// Private field that stores the visibility of this
-		/// <see cref="Symbol"/>.  Use the public
-		/// property <see cref="IsVisible"/> to access this value.  If this value is
-		/// false, the symbols will not be shown (but the <see cref="Line"/> may
-		/// still be shown).
-		/// </summary>
-		private bool		_isVisible;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Symbol"/>.  Use the public property <see cref="Fill"/> to
-		/// access this value.
-		/// </summary>
-		private Fill		_fill;
-		/// <summary>
-		/// Private field that stores the <see cref="ZedGraph.Border"/> data for this
-		/// <see cref="Symbol"/>.  Use the public property <see cref="Border"/> to
-		/// access this value.
-		/// </summary>
-		private Border		_border;
-		/// <summary>
-		/// Private field that stores the user defined <see cref="GraphicsPath"/> data for this
-		/// <see cref="Symbol"/>.  Use the public property <see cref="UserSymbol"/> to
-		/// access this value.
-		/// </summary>
-		private GraphicsPath _userSymbol;
-	#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="ZedGraph.Symbol"/> class.
-		/// </summary>
-		public struct Default
-		{
-			// Default Symbol properties
-			/// <summary>
-			/// The default size for curve symbols (<see cref="Symbol.Size"/> property),
-			/// in units of points.
-			/// </summary>
-			public static float Size = 7;
-			/// <summary>
-			/// The default pen width to be used for drawing curve symbols
-			/// (<see cref="ZedGraph.LineBase.Width"/> property).  Units are points.
-			/// </summary>
-			public static float PenWidth = 1.0F;
-			/// <summary>
-			/// The default color for filling in this <see cref="Symbol"/>
-			/// (<see cref="ZedGraph.Fill.Color"/> property).
-			/// </summary>
-			public static Color FillColor = Color.Red;
-			/// <summary>
-			/// The default custom brush for filling in this <see cref="Symbol"/>
-			/// (<see cref="ZedGraph.Fill.Brush"/> property).
-			/// </summary>
-			public static Brush FillBrush = null;
-			/// <summary>
-			/// The default fill mode for the curve (<see cref="ZedGraph.Fill.Type"/> property).
-			/// </summary>
-			public static FillType FillType = FillType.None;
-			/// <summary>
-			/// The default symbol type for curves (<see cref="Symbol.Type"/> property).
-			/// This is defined as a <see cref="ZedGraph.SymbolType"/> enumeration.
-			/// </summary>
-			public static SymbolType Type = SymbolType.Square;
-			/// <summary>
-			/// The default value for the <see cref="Symbol.IsAntiAlias"/>
-			/// property.
-			/// </summary>
-			public static bool IsAntiAlias = false;
-			/// <summary>
-			/// The default display mode for symbols (<see cref="Symbol.IsVisible"/> property).
-			/// true to display symbols, false to hide them.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// The default for drawing frames around symbols (<see cref="ZedGraph.LineBase.IsVisible"/> property).
-			/// true to display symbol frames, false to hide them.
-			/// </summary>
-			public static bool IsBorderVisible = true;
-			/// <summary>
-			/// The default color for drawing symbols (<see cref="ZedGraph.LineBase.Color"/> property).
-			/// </summary>
-			public static Color BorderColor = Color.Red;
-		}
-	#endregion
-
-	#region Properties
-		/// <summary>
-		/// Gets or sets the size of the <see cref="Symbol"/>
-		/// </summary>
-        /// <value>Size in points (1/72 inch)</value>
-        /// <seealso cref="Default.Size"/>
-		public float Size
-		{
-			get { return _size; }
-			set { _size = value; }
-		}
-		/// <summary>
-		/// Gets or sets the type (shape) of the <see cref="Symbol"/>
-		/// </summary>
-		/// <value>A <see cref="SymbolType"/> enum value indicating the shape</value>
-		/// <seealso cref="Default.Type"/>
-		public SymbolType Type
-		{
-			get { return _type; }
-			set { _type = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines if the symbols are drawn using
-		/// Anti-Aliasing capabilities from the <see cref="Graphics" /> class.
-		/// </summary>
-		/// <remarks>
-		/// If this value is set to true, then the <see cref="Graphics.SmoothingMode" />
-		/// property will be set to <see cref="SmoothingMode.HighQuality" /> only while
-		/// this <see cref="Symbol" /> is drawn.  A value of false will leave the value of
-		/// <see cref="Graphics.SmoothingMode" /> unchanged.
-		/// </remarks>
-		public bool IsAntiAlias
-		{
-			get { return _isAntiAlias; }
-			set { _isAntiAlias = value; }
-		}
-		/// <summary>
-		/// Gets or sets a property that shows or hides the <see cref="Symbol"/>.
-		/// </summary>
-		/// <value>true to show the symbol, false to hide it</value>
-		/// <seealso cref="Default.IsVisible"/>
-		public bool IsVisible
-		{
-			get { return _isVisible; }
-			set { _isVisible = value; }
-		}
-		
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Fill"/> data for this
-		/// <see cref="Symbol"/>.
-		/// </summary>
-		public Fill	Fill
-		{
-			get { return _fill; }
-			set { _fill = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.Border"/> data for this
-		/// <see cref="Symbol"/>, which controls the border outline of the symbol.
-		/// </summary>
-		public Border Border
-		{
-			get { return _border; }
-			set { _border = value; }
-		}
-		/// <summary>
-		/// Gets or sets the <see cref="GraphicsPath"/> data for this
-		/// <see cref="Symbol"/>, describing the user-defined symbol type.
-		/// </summary>
-		/// <remarks>
-		/// This value only applies if <see cref="Symbol.Type">Symbol.Type</see>
-		/// is <see cref="SymbolType.UserDefined">SymbolType.UserDefined</see>
-		/// </remarks>
-		public GraphicsPath UserSymbol
-		{
-			get { return _userSymbol; }
-			set { _userSymbol = value; }
-		}
-
-		#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Default constructor that sets all <see cref="Symbol"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		public Symbol() : this( SymbolType.Default, Color.Empty )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets the <see cref="SymbolType"/> and
-		/// <see cref="Color"/> as specified, and the remaining
-		/// <see cref="Symbol"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="type">A <see cref="SymbolType"/> enum value
-		/// indicating the shape of the symbol</param>
-		/// <param name="color">A <see cref="Color"/> value indicating
-		/// the color of the symbol
-		/// </param>
-		public Symbol( SymbolType type, Color color )
-		{
-			_size = Default.Size;
-			_type = type;
-			_isAntiAlias = Default.IsAntiAlias;
-			_isVisible = Default.IsVisible;
-			_border = new Border( Default.IsBorderVisible, color, Default.PenWidth );
-			_fill = new Fill( color, Default.FillBrush, Default.FillType );
-			_userSymbol = null;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Symbol object from which to copy</param>
-		public Symbol( Symbol rhs )
-		{
-			_size = rhs.Size;
-			_type = rhs.Type;
-			_isAntiAlias = rhs._isAntiAlias;
-			_isVisible = rhs.IsVisible;
-			_fill = rhs.Fill.Clone();
-			_border = rhs.Border.Clone();
-
-			if ( rhs.UserSymbol != null )
-				_userSymbol = rhs.UserSymbol.Clone() as GraphicsPath;
-			else
-				_userSymbol = null;
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Symbol Clone()
-		{
-			return new Symbol( this );
-		}
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Symbol( SerializationInfo info, StreamingContext context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema" );
-
-			_size = info.GetSingle( "size" );
-			_type = (SymbolType) info.GetValue( "type", typeof(SymbolType) );
-			_isAntiAlias = info.GetBoolean( "isAntiAlias" );
-			_isVisible = info.GetBoolean( "isVisible" );
-			_fill = (Fill) info.GetValue( "fill", typeof(Fill) );
-			_border = (Border) info.GetValue( "border", typeof(Border) );
-
-			if ( sch >= 11 )
-				_userSymbol = (GraphicsPath)info.GetValue( "userSymbol", typeof( GraphicsPath ) );
-			else
-				_userSymbol = null;
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public virtual void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			info.AddValue( "schema", schema );
-			info.AddValue( "size", _size );
-			info.AddValue( "type", _type );
-			info.AddValue( "isAntiAlias", _isAntiAlias );
-			info.AddValue( "isVisible", _isVisible );
-			info.AddValue( "fill", _fill );
-			info.AddValue( "border", _border );
-			info.AddValue( "userSymbol", _userSymbol );
-		}
-	#endregion
-
-	#region Rendering Methods
-
-		/// <summary>
-		/// Draw the <see cref="Symbol"/> to the specified <see cref="Graphics"/> device
-		/// at the specified location.  This routine draws a single symbol.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="x">The x position of the center of the symbol in
-		/// pixel units</param>
-		/// <param name="y">The y position of the center of the symbol in
-		/// pixel units</param>
-		/// <param name="path">A <see cref="GraphicsPath"/> previously constructed by
-		/// <see cref="MakePath"/> for this symbol</param>
-		/// <param name="pen">A <see cref="Pen"/> class representing the standard pen for this symbol</param>
-		/// <param name="brush">A <see cref="Brush"/> class representing a default solid brush for this symbol
-		/// If this symbol uses a <see cref="LinearGradientBrush"/>, it will be created on the fly for
-		/// each point, since it has to be scaled to the individual point coordinates.</param>
-		private void DrawSymbol( Graphics g, int x, int y, GraphicsPath path,
-							Pen pen, Brush brush )
-		{
-			// Only draw if the symbol is visible
-			if ( _isVisible &&
-					this.Type != SymbolType.None &&
-					x < 100000 && x > -100000 &&
-					y < 100000 && y > -100000 )
-			{
-				Matrix saveMatrix = g.Transform;
-				g.TranslateTransform( x, y );
-
-				// Fill or draw the symbol as required
-				if ( _fill.IsVisible )
-					g.FillPath( brush, path );
-				//FillPoint( g, x, y, scaleFactor, pen, brush );
-
-				if ( _border.IsVisible )
-					g.DrawPath( pen, path );
-				//DrawPoint( g, x, y, scaleFactor, pen );
-
-				g.Transform = saveMatrix;
-			}
-		}
-
-		/// <summary>
-		/// Draw the <see cref="Symbol"/> to the specified <see cref="Graphics"/> device
-		/// at the specified location.  This routine draws a single symbol.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-        /// <param name="pane">
-        /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
-        /// owner of this object.
-        /// </param>
-        /// <param name="x">The x position of the center of the symbol in
-        /// pixel units</param>
-		/// <param name="y">The y position of the center of the symbol in
-		/// pixel units</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.
-		/// </param>
-		/// <param name="dataValue">The data value to be used for a value-based
-		/// color gradient.  This is only applicable for <see cref="FillType.GradientByX"/>,
-		/// <see cref="FillType.GradientByY"/> or <see cref="FillType.GradientByZ"/>.</param>
-		/// <param name="isSelected">Indicates that the <see cref="Symbol" /> should be drawn
-		/// with attributes from the <see cref="Selection" /> class.
-		/// </param>
-		public void DrawSymbol( Graphics g, GraphPane pane, int x, int y,
-							float scaleFactor, bool isSelected, PointPair dataValue )
-		{
-			Symbol source = this;
-			if ( isSelected )
-				source = Selection.Symbol;
-
-			// Only draw if the symbol is visible
-			if (	_isVisible &&
-					this.Type != SymbolType.None &&
-					x < 100000 && x > -100000 &&
-					y < 100000 && y > -100000 )
-			{
-				SmoothingMode sModeSave = g.SmoothingMode;
-				if ( _isAntiAlias )
-					g.SmoothingMode = SmoothingMode.HighQuality;
-
-				using ( Pen pen = _border.GetPen( pane, scaleFactor, dataValue ) )
-				using ( GraphicsPath path = this.MakePath( g, scaleFactor ) )
-				using ( Brush brush = this.Fill.MakeBrush( path.GetBounds(), dataValue ) )
-				{
-					DrawSymbol( g, x, y, path, pen, brush );
-				}
-
-				g.SmoothingMode = sModeSave;
-			}
-		}
-
-		/// <summary>
-		/// Create a <see cref="GraphicsPath"/> struct for the current symbol based on the
-		/// specified scaleFactor and assuming the symbol will be centered at position 0,0.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor for the features of the graph based on the <see cref="PaneBase.BaseDimension"/>.  This
-		/// scaling factor is calculated by the <see cref="PaneBase.CalcScaleFactor"/> method.  The scale factor
-		/// represents a linear multiple to be applied to font sizes, symbol sizes, etc.</param>
-		/// <returns>Returns the <see cref="GraphicsPath"/> for the current symbol</returns>
-		public GraphicsPath MakePath( Graphics g, float scaleFactor )
-		{
-			float	scaledSize = (float) ( _size * scaleFactor );
-			float	hsize = scaledSize / 2,
-					hsize1 = hsize + 1;
-			
-			GraphicsPath path = new GraphicsPath();
-			
-			switch( _type == SymbolType.Default || ( _type == SymbolType.UserDefined && _userSymbol == null ) ? Default.Type : _type )
-			{
-			case SymbolType.Square:
-				path.AddLine( -hsize, -hsize, hsize, -hsize );
-				path.AddLine( hsize, -hsize, hsize, hsize );
-				path.AddLine( hsize, hsize, -hsize, hsize );
-				path.AddLine( -hsize, hsize, -hsize, -hsize );
-				break;
-			case SymbolType.Diamond:
-				path.AddLine( 0, -hsize, hsize, 0 );
-				path.AddLine( hsize, 0, 0, hsize );
-				path.AddLine( 0, hsize, -hsize, 0 );
-				path.AddLine( -hsize, 0, 0, -hsize );
-				break;
-			case SymbolType.Triangle:
-				path.AddLine( 0, -hsize, hsize, hsize );
-				path.AddLine( hsize, hsize, -hsize, hsize );
-				path.AddLine( -hsize, hsize, 0, -hsize );
-				break;
-			case SymbolType.Circle:
-				path.AddEllipse( -hsize, -hsize, scaledSize, scaledSize );
-				break;
-			case SymbolType.XCross:
-				path.AddLine( -hsize, -hsize, hsize1, hsize1 );
-				path.StartFigure();
-				path.AddLine( hsize, -hsize, -hsize1, hsize1 );
-				break;
-			case SymbolType.Plus:
-				path.AddLine( 0, -hsize, 0, hsize1 );
-				path.StartFigure();
-				path.AddLine( -hsize, 0, hsize1, 0 );
-				break;
-			case SymbolType.Star:
-				path.AddLine( 0, -hsize, 0, hsize1 );
-				path.StartFigure();
-				path.AddLine( -hsize, 0, hsize1, 0 );
-				path.StartFigure();
-				path.AddLine( -hsize, -hsize, hsize1, hsize1 );
-				path.StartFigure();
-				path.AddLine( hsize, -hsize, -hsize1, hsize1 );
-				break;
-			case SymbolType.TriangleDown:
-				path.AddLine( 0, hsize, hsize, -hsize );
-				path.AddLine( hsize, -hsize, -hsize, -hsize );
-				path.AddLine( -hsize, -hsize, 0, hsize );
-				break;
-			case SymbolType.HDash:
-				path.AddLine( -hsize, 0, hsize1, 0 );
-				break;
-			case SymbolType.VDash:
-				path.AddLine( 0, -hsize, 0, hsize1 );
-				break;
-			case SymbolType.UserDefined:
-				path = _userSymbol.Clone() as GraphicsPath;
-				Matrix scaleTransform = new Matrix( scaledSize, 0.0f, 0.0f, scaledSize, 0.0f, 0.0f );
-				path.Transform( scaleTransform );
-				break;
-			}
-			
-			return path;
-		}
-
-		/// <summary>
-		/// Draw this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
-		/// device as a symbol at each defined point.  The routine
-		/// only draws the symbols; the lines are draw by the
-		/// <see cref="Line.DrawCurve"/> method.  This method
-		/// is normally only called by the Draw method of the
-		/// <see cref="CurveItem"/> object
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="curve">A <see cref="LineItem"/> representing this
-		/// curve.</param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <param name="isSelected">Indicates that the <see cref="Symbol" /> should be drawn
-		/// with attributes from the <see cref="Selection" /> class.
-		/// </param>
-		public void Draw( Graphics g, GraphPane pane, LineItem curve, float scaleFactor,
-			bool isSelected )
-		{
-			Symbol source = this;
-			if ( isSelected )
-				source = Selection.Symbol;
-
-			int tmpX, tmpY;
-
-			int minX = (int)pane.Chart.Rect.Left;
-			int maxX = (int)pane.Chart.Rect.Right;
-			int minY = (int)pane.Chart.Rect.Top;
-			int maxY = (int)pane.Chart.Rect.Bottom;
-
-			// (Dale-a-b) we'll set an element to true when it has been drawn	
-			bool[,] isPixelDrawn = new bool[maxX + 1, maxY + 1];
-
-			double curX, curY, lowVal;
-			IPointList points = curve.Points;
-
-			if ( points != null && ( _border.IsVisible || _fill.IsVisible ) )
-			{
-				SmoothingMode sModeSave = g.SmoothingMode;
-				if ( _isAntiAlias )
-					g.SmoothingMode = SmoothingMode.HighQuality;
-
-				// For the sake of speed, go ahead and create a solid brush and a pen
-				// If it's a gradient fill, it will be created on the fly for each symbol
-				//SolidBrush	brush = new SolidBrush( this.fill.Color );
-
-				using ( Pen pen = source._border.GetPen( pane, scaleFactor ) )
-				using ( GraphicsPath path = MakePath( g, scaleFactor ) )
-				{
-					RectangleF rect = path.GetBounds();
-
-					using ( Brush brush = source.Fill.MakeBrush( rect ) )
-					{
-						ValueHandler valueHandler = new ValueHandler( pane, false );
-						Scale xScale = curve.GetXAxis( pane ).Scale;
-						Scale yScale = curve.GetYAxis( pane ).Scale;
-
-						bool xIsLog = xScale.IsLog;
-						bool yIsLog = yScale.IsLog;
-						bool xIsOrdinal = xScale.IsAnyOrdinal;
-
-						double xMin = xScale.Min;
-						double xMax = xScale.Max;
-
-						// Loop over each defined point							
-						for ( int i = 0; i < points.Count; i++ )
-						{
-							// Get the user scale values for the current point
-							// use the valueHandler only for stacked types
-							if ( pane.LineType == LineType.Stack )
-							{
-								valueHandler.GetValues( curve, i, out curX, out lowVal, out curY );
-							}
-							// otherwise, just access the values directly.  Avoiding the valueHandler for
-							// non-stacked types is an optimization to minimize overhead in case there are
-							// a large number of points.
-							else
-							{
-								curX = points[i].X;
-								if ( curve is StickItem )
-									curY = points[i].Z;
-								else
-									curY = points[i].Y;
-							}
-
-							// Any value set to double max is invalid and should be skipped
-							// This is used for calculated values that are out of range, divide
-							//   by zero, etc.
-							// Also, any value <= zero on a log scale is invalid
-
-							if ( curX != PointPair.Missing &&
-									curY != PointPair.Missing &&
-									!System.Double.IsNaN( curX ) &&
-									!System.Double.IsNaN( curY ) &&
-									!System.Double.IsInfinity( curX ) &&
-									!System.Double.IsInfinity( curY ) &&
-									( curX > 0 || !xIsLog ) &&
-									( !yIsLog || curY > 0.0 ) &&
-									( xIsOrdinal || ( curX >= xMin && curX <= xMax ) ) )
-							{
-								// Transform the user scale values to pixel locations
-								tmpX = (int) xScale.Transform( curve.IsOverrideOrdinal, i, curX );
-								tmpY = (int) yScale.Transform( curve.IsOverrideOrdinal, i, curY );
-
-								// Maintain an array of "used" pixel locations to avoid duplicate drawing operations
-								if ( tmpX >= minX && tmpX <= maxX && tmpY >= minY && tmpY <= maxY ) // guard against the zoom-in case
-								{
-									if ( isPixelDrawn[tmpX, tmpY] )
-										continue;
-									isPixelDrawn[tmpX, tmpY] = true;
-								}
-
-								// If the fill type for this symbol is a Gradient by value type,
-								// the make a brush corresponding to the appropriate current value
-								if ( _fill.IsGradientValueType || _border._gradientFill.IsGradientValueType )
-								{
-									using ( Brush tBrush = _fill.MakeBrush( rect, points[i] ) )
-									using ( Pen tPen = _border.GetPen( pane, scaleFactor, points[i] ) )
-										this.DrawSymbol( g, tmpX, tmpY, path, tPen, tBrush );
-								}
-								else
-								{
-									// Otherwise, the brush is already defined
-									// Draw the symbol at the specified pixel location
-									this.DrawSymbol( g, tmpX, tmpY, path, pen, brush );
-								}
-							}
-						}
-					}
-				}
-
-				g.SmoothingMode = sModeSave;
-			}
-		}
-		#endregion
-	
-	}
-}
-
diff --git a/BDInfo/ZedGraph/TextObj.cs b/BDInfo/ZedGraph/TextObj.cs
deleted file mode 100644
index 2b2ae78db4..0000000000
--- a/BDInfo/ZedGraph/TextObj.cs
+++ /dev/null
@@ -1,447 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that represents a text object on the graph.  A list of
-	/// <see cref="GraphObj"/> objects is maintained by the
-	/// <see cref="GraphObjList"/> collection class.
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.4 $ $Date: 2007/01/25 07:56:09 $ </version>
-	[Serializable]
-	public class TextObj : GraphObj, ICloneable, ISerializable
-	{
-	#region Fields
-		/// <summary> Private field to store the actual text string for this
-		/// <see cref="TextObj"/>.  Use the public property <see cref="TextObj.Text"/>
-		/// to access this value.
-		/// </summary>
-		private string _text;
-		/// <summary>
-		/// Private field to store the <see cref="FontSpec"/> class used to render
-		/// this <see cref="TextObj"/>.  Use the public property <see cref="FontSpec"/>
-		/// to access this class.
-		/// </summary>
-		private FontSpec	_fontSpec;
-
-		/*
-		/// <summary>
-		/// Private field to indicate whether this <see cref="TextObj"/> is to be
-		/// wrapped when rendered.  Wrapping is to be done within <see cref="TextObj.wrappedRect"/>.
-		/// Use the public property <see cref="TextObj.IsWrapped"/>
-		/// to access this value.
-		/// </summary>
-		private bool isWrapped;
-		*/
-
-		/// <summary>
-		/// Private field holding the SizeF into which this <see cref="TextObj"/>
-		/// should be rendered. Use the public property <see cref="TextObj.LayoutArea"/>
-		/// to access this value.
-		/// </summary>
-		private SizeF _layoutArea;
-
-
-		#endregion
-
-	#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="TextObj"/> class.
-		/// </summary>
-		new public struct Default
-		{
-			/*
-			/// <summary>
-			/// The default wrapped flag for rendering this <see cref="TextObj,Text"/>. 
-			/// </summary>
-			public static bool IsWrapped = false ;
-			/// <summary>
-			/// The default RectangleF for rendering this <see cref="TextObj.Text"/> 
-			/// </summary>
-			public static SizeF WrappedSize = new SizeF( 0,0 );
-			*/
-
-			/// <summary>
-			/// The default font family for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.Family"/> property).
-			/// </summary>
-			public static string FontFamily = "Arial";
-			/// <summary>
-			/// The default font size for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.Size"/> property).  Units are
-			/// in points (1/72 inch).
-			/// </summary>
-			public static float FontSize = 12.0F;
-			/// <summary>
-			/// The default font color for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.FontColor"/> property).
-			/// </summary>
-			public static Color FontColor = Color.Black;
-			/// <summary>
-			/// The default font bold mode for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.IsBold"/> property). true
-			/// for a bold typeface, false otherwise.
-			/// </summary>
-			public static bool FontBold = false;
-			/// <summary>
-			/// The default font underline mode for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.IsUnderline"/> property). true
-			/// for an underlined typeface, false otherwise.
-			/// </summary>
-			public static bool FontUnderline = false;
-			/// <summary>
-			/// The default font italic mode for the <see cref="TextObj"/> text
-			/// (<see cref="ZedGraph.FontSpec.IsItalic"/> property). true
-			/// for an italic typeface, false otherwise.
-			/// </summary>
-			public static bool FontItalic = false;
-		}
-	#endregion
-
-	#region Properties
-		
-		/*
-		/// <summary>
-		/// 
-		/// </summary>
-		internal bool IsWrapped
-		{
-			get { return (this.isWrapped); }
-			set { this.isWrapped = value; } 
-		}
-		*/
-
-		/// <summary>
-		/// 
-		/// </summary>
-		public SizeF LayoutArea
-		{
-			get { return _layoutArea; }
-			set { _layoutArea = value; } 
-		}
-
-
-		/// <summary>
-		/// The <see cref="TextObj"/> to be displayed.  This text can be multi-line by
-		/// including newline ('\n') characters between the lines.
-		/// </summary>
-		public string Text
-		{
-			get { return _text; }
-			set { _text = value; }
-		}
-		/// <summary>
-		/// Gets a reference to the <see cref="FontSpec"/> class used to render
-		/// this <see cref="TextObj"/>
-		/// </summary>
-		/// <seealso cref="Default.FontColor"/>
-		/// <seealso cref="Default.FontBold"/>
-		/// <seealso cref="Default.FontItalic"/>
-		/// <seealso cref="Default.FontUnderline"/>
-		/// <seealso cref="Default.FontFamily"/>
-		/// <seealso cref="Default.FontSize"/>
-		public FontSpec FontSpec
-		{
-			get { return _fontSpec; }
-			set
-			{
-				if ( value == null )
-					throw new ArgumentNullException( "Uninitialized FontSpec in TextObj" );
-				_fontSpec = value;
-			}
-		}
-	#endregion
-	
-	#region Constructors
-		/// <summary>
-		/// Constructor that sets all <see cref="TextObj"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="text">The text to be displayed.</param>
-		/// <param name="x">The x position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		public TextObj( string text, double x, double y )
-			: base( x, y )
-		{
-			Init( text );
-		}
-
-		private void Init( string text )
-		{
-			if ( text != null )
-				_text = text;
-			else
-				text = "Text";
-			
-			_fontSpec = new FontSpec(
-				Default.FontFamily, Default.FontSize,
-				Default.FontColor, Default.FontBold,
-				Default.FontItalic, Default.FontUnderline );
-			
-			//this.isWrapped = Default.IsWrapped ;
-			_layoutArea = new SizeF( 0, 0 );
-		}
-		
-		/// <summary>
-		/// Constructor that sets all <see cref="TextObj"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="text">The text to be displayed.</param>
-		/// <param name="x">The x position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		public TextObj( string text, double x, double y, CoordType coordType )
-			: base( x, y, coordType )
-		{
-			Init( text );
-		}
-
-		/// <summary>
-		/// Constructor that sets all <see cref="TextObj"/> properties to default
-		/// values as defined in the <see cref="Default"/> class.
-		/// </summary>
-		/// <param name="text">The text to be displayed.</param>
-		/// <param name="x">The x position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the <see cref="AlignH"/>
-		/// property.</param>
-		/// <param name="y">The y position of the text.  The units
-		/// of this position are specified by the
-		/// <see cref="ZedGraph.Location.CoordinateFrame"/> property.  The text will be
-		/// aligned to this position based on the
-		/// <see cref="AlignV"/> property.</param>
-		/// <param name="coordType">The <see cref="CoordType"/> enum value that
-		/// indicates what type of coordinate system the x and y parameters are
-		/// referenced to.</param>
-		/// <param name="alignH">The <see cref="ZedGraph.AlignH"/> enum that specifies
-		/// the horizontal alignment of the object with respect to the (x,y) location</param>
-		/// <param name="alignV">The <see cref="ZedGraph.AlignV"/> enum that specifies
-		/// the vertical alignment of the object with respect to the (x,y) location</param>
-		public TextObj( string text, double x, double y, CoordType coordType, AlignH alignH, AlignV alignV )
-			: base( x, y, coordType, alignH, alignV )
-		{
-			Init( text );
-		}
-
-		/// <summary>
-		/// Parameterless constructor that initializes a new <see cref="TextObj"/>.
-		/// </summary>
-		public TextObj() : base( 0, 0 )
-		{
-			Init( "" );
-		}
-		
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="TextObj"/> object from which to copy</param>
-		public TextObj( TextObj rhs ) : base( rhs )
-		{
-			_text = rhs.Text;
-			_fontSpec = new FontSpec( rhs.FontSpec );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public TextObj Clone()
-		{
-			return new TextObj( this );
-		}
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected TextObj( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-			_text = info.GetString( "text" );
-			_fontSpec = (FontSpec) info.GetValue( "fontSpec", typeof(FontSpec) );
-			//isWrapped = info.GetBoolean ("isWrapped") ;
-			_layoutArea = (SizeF) info.GetValue( "layoutArea", typeof(SizeF) );
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-			info.AddValue( "text", _text );
-			info.AddValue( "fontSpec", _fontSpec );
-			//info.AddValue( "isWrapped", isWrapped );
-			info.AddValue( "layoutArea", _layoutArea );
-		}
-	#endregion
-
-	#region Rendering Methods
-		/// <summary>
-		/// Render this <see cref="TextObj"/> object to the specified <see cref="Graphics"/> device
-		/// This method is normally only called by the Draw method
-		/// of the parent <see cref="GraphObjList"/> collection object.
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void Draw( Graphics g, PaneBase pane, float scaleFactor )
-		{
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			PointF pix = _location.Transform( pane );
-			
-			// Draw the text on the screen, including any frame and background
-			// fill elements
-			if ( pix.X > -100000 && pix.X < 100000 && pix.Y > -100000 && pix.Y < 100000 )
-			{
-				//if ( this.layoutSize.IsEmpty )
-				//	this.FontSpec.Draw( g, pane.IsPenWidthScaled, this.text, pix.X, pix.Y,
-				//		this.location.AlignH, this.location.AlignV, scaleFactor );
-				//else
-					this.FontSpec.Draw( g, pane, _text, pix.X, pix.Y,
-						_location.AlignH, _location.AlignV, scaleFactor, _layoutArea );
-
-			}
-		}
-		
-		/// <summary>
-		/// Determine if the specified screen point lies inside the bounding box of this
-		/// <see cref="TextObj"/>.  This method takes into account rotation and alignment
-		/// parameters of the text, as specified in the <see cref="FontSpec"/>.
-		/// </summary>
-		/// <param name="pt">The screen point, in pixels</param>
-		/// <param name="pane">
-		/// A reference to the <see cref="PaneBase"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <returns>true if the point lies in the bounding box, false otherwise</returns>
-		override public bool PointInBox( PointF pt, PaneBase pane, Graphics g, float scaleFactor )
-		{
-			if ( ! base.PointInBox(pt, pane, g, scaleFactor ) )
-				return false;
-
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			PointF pix = _location.Transform( pane );
-			
-			return _fontSpec.PointInBox( pt, g, _text, pix.X, pix.Y,
-								_location.AlignH, _location.AlignV, scaleFactor, this.LayoutArea );
-		}
-
-		/// <summary>
-		/// Determines the shape type and Coords values for this GraphObj
-		/// </summary>
-		override public void GetCoords( PaneBase pane, Graphics g, float scaleFactor,
-				out string shape, out string coords )
-		{
-			// transform the x,y location from the user-defined
-			// coordinate frame to the screen pixel location
-			PointF pix = _location.Transform( pane );
-
-			PointF[] pts = _fontSpec.GetBox( g, _text, pix.X, pix.Y, _location.AlignH,
-				_location.AlignV, scaleFactor, new SizeF() );
-
-			shape = "poly";
-			coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0},{4:f0},{5:f0},{6:f0},{7:f0},",
-						pts[0].X, pts[0].Y, pts[1].X, pts[1].Y,
-						pts[2].X, pts[2].Y, pts[3].X, pts[3].Y );
-		}
-
-		
-	#endregion
-	
-	}
-}
diff --git a/BDInfo/ZedGraph/TextScale.cs b/BDInfo/ZedGraph/TextScale.cs
deleted file mode 100644
index 8994eaf407..0000000000
--- a/BDInfo/ZedGraph/TextScale.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Collections;
-using System.Text;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// The TextScale class inherits from the <see cref="Scale" /> class, and implements
-	/// the features specific to <see cref="AxisType.Text" />.
-	/// </summary>
-	/// <remarks>
-	/// TextScale is an ordinal axis with user-defined text labels.  An ordinal axis means that
-	/// all data points are evenly spaced at integral values, and the actual coordinate values
-	/// for points corresponding to that axis are ignored.  That is, if the X axis is an
-	/// ordinal type, then all X values associated with the curves are ignored.
-	/// </remarks>
-	/// 
-	/// <author> John Champion  </author>
-	/// <version> $Revision: 1.8 $ $Date: 2006/08/25 05:19:09 $ </version>
-	[Serializable]
-	class TextScale : Scale, ISerializable //, ICloneable
-	{
-
-	#region constructors
-
-		public TextScale( Axis owner )
-			: base( owner )
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="TextScale" /> object from which to copy</param>
-		/// <param name="owner">The <see cref="Axis" /> object that will own the
-		/// new instance of <see cref="TextScale" /></param>
-		public TextScale( Scale rhs, Axis owner )
-			: base( rhs, owner )
-		{
-		}
-
-		/// <summary>
-		/// Create a new clone of the current item, with a new owner assignment
-		/// </summary>
-		/// <param name="owner">The new <see cref="Axis" /> instance that will be
-		/// the owner of the new Scale</param>
-		/// <returns>A new <see cref="Scale" /> clone.</returns>
-		public override Scale Clone( Axis owner )
-		{
-			return new TextScale( this, owner );
-		}
-
-	#endregion
-
-	#region properties
-
-		public override AxisType Type
-		{
-			get { return AxisType.Text; }
-		}
-
-	#endregion
-
-	#region methods
-
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first minor tic mark
-		/// </summary>
-		/// <param name="baseVal">
-		/// The value of the first major tic for the axis.
-		/// </param>
-		/// <returns>
-		/// The ordinal position of the first minor tic, relative to the first major tic.
-		/// This value can be negative (e.g., -3 means the first minor tic is 3 minor step
-		/// increments before the first major tic.
-		/// </returns>
-		override internal int CalcMinorStart( double baseVal )
-		{
-			// This should never happen (no minor tics for text labels)
-			return 0;
-		}
-
-		/// <summary>
-		/// Determine the value for the first major tic.
-		/// </summary>
-		/// <remarks>
-		/// This is done by finding the first possible value that is an integral multiple of
-		/// the step size, taking into account the date/time units if appropriate.
-		/// This method properly accounts for <see cref="Scale.IsLog"/>, <see cref="Scale.IsText"/>,
-		/// and other axis format settings.
-		/// </remarks>
-		/// <returns>
-		/// First major tic value (floating point double).
-		/// </returns>
-		override internal double CalcBaseTic()
-		{
-			if ( _baseTic != PointPair.Missing )
-				return _baseTic;
-			else
-				return 1.0;
-
-		}
-		
-		/// <summary>
-		/// Internal routine to determine the ordinals of the first and last major axis label.
-		/// </summary>
-		/// <returns>
-		/// This is the total number of major tics for this axis.
-		/// </returns>
-		override internal int CalcNumTics()
-		{
-			int nTics = 1;
-
-			// If no array of labels is available, just assume 10 labels so we don't blow up.
-			if ( _textLabels == null )
-				nTics = 10;
-			else
-				nTics = _textLabels.Length;
-
-			if ( nTics < 1 )
-				nTics = 1;
-			else if ( nTics > 1000 )
-				nTics = 1000;
-
-			return nTics;
-		}
-
-		/// <summary>
-		/// Select a reasonable text axis scale given a range of data values.
-		/// </summary>
-		/// <remarks>
-		/// This method only applies to <see cref="AxisType.Text"/> type axes, and it
-		/// is called by the general <see cref="PickScale"/> method.  This is an ordinal
-		/// type, such that the labeled values start at 1.0 and increment by 1.0 for
-		/// each successive label.  The maximum number of labels on the graph is
-		/// determined by <see cref="Scale.Default.MaxTextLabels"/>.  If necessary, this method will
-		/// set the <see cref="Scale.MajorStep"/> value to greater than 1.0 in order to keep the total
-		/// labels displayed below <see cref="Scale.Default.MaxTextLabels"/>.  For example, a
-		/// <see cref="Scale.MajorStep"/> size of 2.0 would only display every other label on the
-		/// axis.  The <see cref="Scale.MajorStep"/> value calculated by this routine is always
-		/// an integral value.  This
-		/// method honors the <see cref="Scale.MinAuto"/>, <see cref="Scale.MaxAuto"/>,
-		/// and <see cref="Scale.MajorStepAuto"/> autorange settings.
-		/// In the event that any of the autorange settings are false, the
-		/// corresponding <see cref="Scale.Min"/>, <see cref="Scale.Max"/>, or <see cref="Scale.MajorStep"/>
-		/// setting is explicitly honored, and the remaining autorange settings (if any) will
-		/// be calculated to accomodate the non-autoranged values.
-		/// <para>On Exit:</para>
-		/// <para><see cref="Scale.Min"/> is set to scale minimum (if <see cref="Scale.MinAuto"/> = true)</para>
-		/// <para><see cref="Scale.Max"/> is set to scale maximum (if <see cref="Scale.MaxAuto"/> = true)</para>
-		/// <para><see cref="Scale.MajorStep"/> is set to scale step size (if <see cref="Scale.MajorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.MinorStep"/> is set to scale minor step size (if <see cref="Scale.MinorStepAuto"/> = true)</para>
-		/// <para><see cref="Scale.Mag"/> is set to a magnitude multiplier according to the data</para>
-		/// <para><see cref="Scale.Format"/> is set to the display format for the values (this controls the
-		/// number of decimal places, whether there are thousands separators, currency types, etc.)</para>
-		/// </remarks>
-		/// <param name="pane">A reference to the <see cref="GraphPane"/> object
-		/// associated with this <see cref="Axis"/></param>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		/// <seealso cref="PickScale"/>
-		/// <seealso cref="AxisType.Text"/>
-		override public void PickScale( GraphPane pane, Graphics g, float scaleFactor )
-		{
-			// call the base class first
-			base.PickScale( pane, g, scaleFactor );
-
-			// if text labels are provided, then autorange to the number of labels
-			if ( _textLabels != null )
-			{
-				if ( _minAuto )
-					_min = 0.5;
-				if ( _maxAuto )
-					_max = _textLabels.Length + 0.5;
-			}
-			else
-			{
-				if ( _minAuto )
-					_min -= 0.5;
-				if ( _maxAuto )
-					_max += 0.5;
-			}
-			// Test for trivial condition of range = 0 and pick a suitable default
-			if ( _max - _min < .1 )
-			{
-				if ( _maxAuto )
-					_max = _min + 10.0;
-				else
-					_min = _max - 10.0;
-			}
-
-			if ( _majorStepAuto )
-			{
-				if ( !_isPreventLabelOverlap )
-				{
-					_majorStep = 1;
-				}
-				else if ( _textLabels != null )
-				{
-					// Calculate the maximum number of labels
-					double maxLabels = (double) this.CalcMaxLabels( g, pane, scaleFactor );
-
-					// Calculate a step size based on the width of the labels
-					double tmpStep = Math.Ceiling( ( _max - _min ) / maxLabels );
-
-					// Use the lesser of the two step sizes
-					//if ( tmpStep < this.majorStep )
-					_majorStep = tmpStep;
-				}
-				else
-					_majorStep = (int) ( ( _max - _min - 1.0 ) / Default.MaxTextLabels ) + 1.0;
-
-			}
-			else
-			{
-				_majorStep = (int) _majorStep;
-				if ( _majorStep <= 0 )
-					_majorStep = 1.0;
-			}
-
-			if ( _minorStepAuto )
-			{
-				_minorStep = _majorStep / 10;
-
-				//_minorStep = CalcStepSize( _majorStep, 10 );
-				if ( _minorStep < 1 )
-					_minorStep = 1;
-			}
-
-			_mag = 0;
-		}
-
-		/// <summary>
-		/// Make a value label for an <see cref="AxisType.Text" /> <see cref="Axis" />.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="index">
-		/// The zero-based, ordinal index of the label to be generated.  For example, a value of 2 would
-		/// cause the third value label on the axis to be generated.
-		/// </param>
-		/// <param name="dVal">
-		/// The numeric value associated with the label.  This value is ignored for log (<see cref="Scale.IsLog"/>)
-		/// and text (<see cref="Scale.IsText"/>) type axes.
-		/// </param>
-		/// <returns>The resulting value label as a <see cref="string" /></returns>
-		override internal string MakeLabel( GraphPane pane, int index, double dVal )
-		{
-			if ( _format == null )
-				_format = Scale.Default.Format;
-
-			index *= (int) _majorStep;
-			if ( _textLabels == null || index < 0 || index >= _textLabels.Length )
-				return string.Empty;
-			else
-				return _textLabels[index];
-		}
-
-
-	#endregion
-
-	#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected TextScale( SerializationInfo info, StreamingContext context ) : base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/Types.cs b/BDInfo/ZedGraph/Types.cs
deleted file mode 100644
index 85e2fc0826..0000000000
--- a/BDInfo/ZedGraph/Types.cs
+++ /dev/null
@@ -1,868 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-
-
-namespace ZedGraph
-{	
-	/// <summary>
-	/// Enumeration type for the various axis types that are available
-	/// </summary>
-	/// <seealso cref="ZedGraph.Axis.Type"/>
-	public enum AxisType
-	{
-		/// <summary> An ordinary, cartesian axis </summary>
-		Linear,
-		/// <summary> A base 10 log axis </summary>
-		Log,
-		/// <summary> A cartesian axis with calendar dates or times </summary>
-		Date,
-		/// <summary> An ordinal axis with user-defined text labels.  An ordinal axis means that
-		/// all data points are evenly spaced at integral values, and the actual coordinate values
-		/// for points corresponding to that axis are ignored.  That is, if the X axis is an
-		/// ordinal type, then all X values associated with the curves are ignored.</summary>
-		/// <seealso cref="AxisType.Ordinal"/>
-		/// <seealso cref="Scale.IsText"/>
-		/// <seealso cref="ZedGraph.Scale.Default.MaxTextLabels"/>
-		Text,
-		/// <summary> An ordinal axis with regular numeric labels.  An ordinal axis means that
-		/// all data points are evenly spaced at integral values, and the actual coordinate values
-		/// for points corresponding to that axis are ignored.  That is, if the X axis is an
-		/// ordinal type, then all X values associated with the curves are ignored. </summary>
-		/// <seealso cref="AxisType.Text"/>
-		/// <seealso cref="Scale.IsOrdinal"/>
-		Ordinal,
-		/// <summary> An ordinal axis that will have labels formatted with ordinal values corresponding
-		/// to the number of values in each <see cref="CurveItem" />.
-		/// </summary>
-		/// <remarks>
-		/// The <see cref="CurveItem" /> data points will be evenly-spaced at ordinal locations, and the
-		/// actual data values are ignored. </remarks>
-		/// <seealso cref="AxisType.Text"/>
-		/// <seealso cref="Scale.IsOrdinal"/>
-		DateAsOrdinal,
-		/// <summary> An ordinal axis that will have labels formatted with values from the actual data
-		/// values of the first <see cref="CurveItem" /> in the <see cref="CurveList" />.
-		/// </summary>
-		/// <remarks>
-		/// Although the tics are labeled with real data values, the actual points will be
-		/// evenly-spaced in spite of the data values.  For example, if the X values of the first curve
-		/// are 1, 5, and 100, then the tic labels will show 1, 5, and 100, but they will be equal
-		/// distance from each other. </remarks>
-		/// <seealso cref="AxisType.Text"/>
-		/// <seealso cref="Scale.IsOrdinal"/>
-		LinearAsOrdinal,
-		/// <summary> An exponential axis </summary>
-		Exponent
-	}
-
-	/// <summary>
-	/// Enumeration type for the various types of fills that can be used with <see cref="Bar"/>
-	/// charts.
-	/// </summary>
-	public enum FillType
-	{
-		/// <summary> No fill </summary>
-		None,
-		/// <summary> A solid fill using <see cref="System.Drawing.SolidBrush"/> </summary>
-		Solid,
-		/// <summary> A custom fill using either <see cref="LinearGradientBrush"/> or
-		/// <see cref="TextureBrush"/></summary>
-		Brush,
-		/// <summary>
-		/// Fill with a single solid color based on the X value of the data.</summary>
-		/// <remarks>The X value is
-		/// used to determine the color value based on a gradient brush, and using a data range
-		/// of <see cref="Fill.RangeMin"/> and <see cref="Fill.RangeMax"/>.  You can create a multicolor
-		/// range by initializing the <see cref="Fill"/> class with your own custom
-		/// <see cref="Brush"/> object based on a <see cref="ColorBlend"/>.  In cases where a
-		/// data value makes no sense (<see cref="PaneBase.Fill"/>, <see cref="Legend.Fill"/>,
-		/// etc.), a default value of 50% of the range is assumed.  The default range is 0 to 1.
-		/// </remarks>
-		/// <seealso cref="Fill.RangeMin"/>
-		/// <seealso cref="Fill.RangeMax"/>
-		/// <seealso cref="Fill.RangeDefault"/>
-		GradientByX,
-		/// <summary>
-		/// Fill with a single solid color based on the Z value of the data.</summary>
-		/// <remarks>The Z value is
-		/// used to determine the color value based on a gradient brush, and using a data range
-		/// of <see cref="Fill.RangeMin"/> and <see cref="Fill.RangeMax"/>.  You can create a multicolor
-		/// range by initializing the <see cref="Fill"/> class with your own custom
-		/// <see cref="Brush"/> object based on a <see cref="ColorBlend"/>.  In cases where a
-		/// data value makes no sense (<see cref="PaneBase.Fill"/>, <see cref="Legend.Fill"/>,
-		/// etc.), a default value of 50% of the range is assumed.  The default range is 0 to 1.
-		/// </remarks>
-		/// <seealso cref="Fill.RangeMin"/>
-		/// <seealso cref="Fill.RangeMax"/>
-		/// <seealso cref="Fill.RangeDefault"/>
-		GradientByY,
-		/// <summary>
-		/// Fill with a single solid color based on the Z value of the data.</summary>
-		/// <remarks>The Z value is
-		/// used to determine the color value based on a gradient brush, and using a data range
-		/// of <see cref="Fill.RangeMin"/> and <see cref="Fill.RangeMax"/>.  You can create a multicolor
-		/// range by initializing the <see cref="Fill"/> class with your own custom
-		/// <see cref="Brush"/> object based on a <see cref="ColorBlend"/>.  In cases where a
-		/// data value makes no sense (<see cref="PaneBase.Fill"/>, <see cref="Legend.Fill"/>,
-		/// etc.), a default value of 50% of the range is assumed.  The default range is 0 to 1.
-		/// </remarks>
-		/// <seealso cref="Fill.RangeMin"/>
-		/// <seealso cref="Fill.RangeMax"/>
-		/// <seealso cref="Fill.RangeDefault"/>
-		GradientByZ,
-		/// <summary>
-		/// Fill with a single solid color based on the "ColorValue" property of the data.</summary>
-		/// <remarks>The "ColorValue" property is
-		/// used to determine the color value based on a gradient brush, and using a data range
-		/// of <see cref="Fill.RangeMin"/> and <see cref="Fill.RangeMax"/>.  You can create a multicolor
-		/// range by initializing the <see cref="Fill"/> class with your own custom
-		/// <see cref="Brush"/> object based on a <see cref="ColorBlend"/>.  In cases where a
-		/// data value makes no sense (<see cref="PaneBase.Fill"/>, <see cref="Legend.Fill"/>,
-		/// etc.), a default value of 50% of the range is assumed.  The default range is 0 to 1.
-		/// </remarks>
-		/// <seealso cref="Fill.RangeMin"/>
-		/// <seealso cref="Fill.RangeMax"/>
-		/// <seealso cref="Fill.RangeDefault"/>
-		GradientByColorValue
-
-	}
-
-	/// <summary>
-	/// Enumeration type for the various axis date and time unit types that are available
-	/// </summary>
-	public enum DateUnit
-	{
-		/// <summary> Yearly units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Year,
-		/// <summary> Monthly units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Month,
-		/// <summary> Daily units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Day,
-		/// <summary> Hourly units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Hour,
-		/// <summary> Minute units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Minute,
-		/// <summary> Second units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Second,
-		/// <summary> Millisecond units <see cref="Scale.MajorUnit"/> and <see cref="Scale.MinorUnit"/>
-		/// </summary>
-		Millisecond
-	}
-
-	/// <summary>
-	/// Enumeration type for the various symbol shapes that are available
-	/// </summary>
-	/// <seealso cref="ZedGraph.Symbol.Fill"/>
-	public enum SymbolType 
-	{
-		/// <summary> Square-shaped <see cref="ZedGraph.Symbol"/> </summary>
-		Square,
-		/// <summary> Rhombus-shaped <see cref="ZedGraph.Symbol"/> </summary>
-		Diamond,
-		/// <summary> Equilateral triangle <see cref="ZedGraph.Symbol"/> </summary>
-		Triangle,
-		/// <summary> Uniform circle <see cref="ZedGraph.Symbol"/> </summary>
-		Circle,
-		/// <summary> "X" shaped <see cref="ZedGraph.Symbol"/>.  This symbol cannot
-		/// be filled since it has no outline. </summary>
-		XCross,
-		/// <summary> "+" shaped <see cref="ZedGraph.Symbol"/>.  This symbol cannot
-		/// be filled since it has no outline. </summary>
-		Plus,
-		/// <summary> Asterisk-shaped <see cref="ZedGraph.Symbol"/>.  This symbol
-		/// cannot be filled since it has no outline. </summary>
-		Star,
-		/// <summary> Unilateral triangle <see cref="ZedGraph.Symbol"/>, pointing
-		/// down. </summary>
-		TriangleDown,
-		/// <summary>
-		/// Horizontal dash <see cref="ZedGraph.Symbol"/>.  This symbol cannot be
-		/// filled since it has no outline.
-		/// </summary>
-		HDash,
-		/// <summary>
-		/// Vertical dash <see cref="ZedGraph.Symbol"/>.  This symbol cannot be
-		/// filled since it has no outline.
-		/// </summary>
-		VDash,
-		/// <summary> A symbol defined by the <see cref="Symbol.UserSymbol"/> propery.
-		/// If no symbol is defined, the <see cref="Symbol.Default.Type"/>. symbol will
-		/// be used.
-		/// </summary>
-		UserDefined,
-		/// <summary> A Default symbol type (the symbol type will be obtained
-		/// from <see cref="Symbol.Default.Type"/>. </summary>
-		Default,
-		/// <summary> No symbol is shown (this is equivalent to using
-		/// <see cref="Symbol.IsVisible"/> = false.</summary>
-		None
-	}
-
-	/// <summary>
-	/// Enumeration type that defines the possible legend locations
-	/// </summary>
-	/// <seealso cref="Legend.Position"/>
-	public enum LegendPos
-	{
-		/// <summary>
-		/// Locate the <see cref="Legend"/> above the <see cref="Chart.Rect"/>
-		/// </summary>
-		Top,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> on the left side of the <see cref="Chart.Rect"/>
-		/// </summary>
-		Left,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> on the right side of the <see cref="Chart.Rect"/>
-		/// </summary>
-		Right,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> below the <see cref="Chart.Rect"/>
-		/// </summary>
-		Bottom,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> inside the <see cref="Chart.Rect"/> in the
-		/// top-left corner.  
-		/// </summary>
-		InsideTopLeft,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> inside the <see cref="Chart.Rect"/> in the
-		/// top-right corner. 
-		/// </summary>
-		InsideTopRight,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> inside the <see cref="Chart.Rect"/> in the
-		/// bottom-left corner.
-		/// </summary>
-		InsideBotLeft,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> inside the <see cref="Chart.Rect"/> in the
-		/// bottom-right corner. 
-		/// </summary>
-		InsideBotRight,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> as a floating object above the graph at the
-		/// location specified by <see cref="Legend.Location"/>.
-		/// </summary>
-		Float,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> centered above the <see cref="Chart.Rect"/>
-		/// </summary>
-		TopCenter,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> centered below the <see cref="Chart.Rect"/>
-		/// </summary>
-		BottomCenter,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> above the <see cref="Chart.Rect"/>, but flush
-		/// against the left margin of the <see cref="PaneBase.Rect" />.
-		/// </summary>
-		TopFlushLeft,
-		/// <summary>
-		/// Locate the <see cref="Legend"/> below the <see cref="Chart.Rect"/>, but flush
-		/// against the left margin of the <see cref="PaneBase.Rect" />.
-		/// </summary>
-		BottomFlushLeft
-
-	}
-
-	/// <summary>
-	/// Enumeration type for the different horizontal text alignment options
-	/// </summary>
-	/// <seealso cref="FontSpec"/>
-	public enum AlignH
-	{
-		/// <summary>
-		/// Position the text so that its left edge is aligned with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Left,
-		/// <summary>
-		/// Position the text so that its center is aligned (horizontally) with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Center,
-		/// <summary>
-		/// Position the text so that its right edge is aligned with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Right
-	}
-	
-	/// <summary>
-	/// Enumeration type for the different proximal alignment options
-	/// </summary>
-	/// <seealso cref="FontSpec"/>
-	/// <seealso cref="Scale.Align"/>
-	public enum AlignP
-	{
-		/// <summary>
-		/// Position the text so that its "inside" edge (the edge that is
-		/// nearest to the alignment reference point or object) is aligned.
-		/// Used by the <see cref="Scale.Align"/> method to align text
-		/// to the axis.
-		/// </summary>
-		Inside,
-		/// <summary>
-		/// Position the text so that its center is aligned with the
-		/// reference object or point.
-		/// Used by the <see cref="Scale.Align"/> method to align text
-		/// to the axis.
-		/// </summary>
-		Center,
-		/// <summary>
-		/// Position the text so that its right edge (the edge that is
-		/// farthest from the alignment reference point or object) is aligned.
-		/// Used by the <see cref="Scale.Align"/> method to align text
-		/// to the axis.
-		/// </summary>
-		Outside
-	}
-	
-	/// <summary>
-	/// Enumeration type for the different vertical text alignment options
-	/// </summary>
-	/// specified X,Y location.  Used by the
-	/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-	public enum AlignV
-	{
-		/// <summary>
-		/// Position the text so that its top edge is aligned with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Top,
-		/// <summary>
-		/// Position the text so that its center is aligned (vertically) with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Center,
-		/// <summary>
-		/// Position the text so that its bottom edge is aligned with the
-		/// specified X,Y location.  Used by the
-		/// <see cref="FontSpec.Draw(Graphics,PaneBase,string,float,float,AlignH,AlignV,float)"/> method.
-		/// </summary>
-		Bottom
-	}
-
-	/// <summary>
-	/// Enumeration type for the user-defined coordinate types available.
-	/// These coordinate types are used the <see cref="ArrowObj"/> objects
-	/// and <see cref="TextObj"/> objects only.
-	/// </summary>
-	/// <seealso cref="ZedGraph.Location.CoordinateFrame"/>
-	public enum CoordType
-	{
-		/// <summary>
-		/// Coordinates are specified as a fraction of the
-		/// <see cref="Chart.Rect"/>.  That is, for the X coordinate, 0.0
-		/// is at the left edge of the ChartRect and 1.0
-		/// is at the right edge of the ChartRect. A value less
-		/// than zero is left of the ChartRect and a value
-		/// greater than 1.0 is right of the ChartRect.  For the Y coordinate, 0.0
-		/// is the top and 1.0 is the bottom.
-		/// </summary>
-		ChartFraction,
-		/// <summary>
-		/// Coordinates are specified as a fraction of the
-		/// <see cref="PaneBase.Rect"/>.  That is, for the X coordinate, 0.0
-		/// is at the left edge of the Rect and 1.0
-		/// is at the right edge of the Rect. A value less
-		/// than zero is left of the Rect and a value
-		/// greater than 1.0 is right of the Rect.  For the Y coordinate, 0.0
-		/// is the top and 1.0 is the bottom.  Note that
-		/// any value less than zero or greater than 1.0 will be outside
-		/// the Rect, and therefore clipped.
-		/// </summary>
-		PaneFraction,
-		/// <summary>
-		/// Coordinates are specified according to the user axis scales
-		/// for the <see cref="GraphPane.XAxis"/> and <see cref="GraphPane.YAxis"/>.
-		/// </summary>
-		AxisXYScale,
-		/// <summary>
-		/// Coordinates are specified according to the user axis scales
-		/// for the <see cref="GraphPane.XAxis"/> and <see cref="GraphPane.Y2Axis"/>.
-		/// </summary>
-		AxisXY2Scale,
-		/// <summary>
-		/// The X coordinate is specified as a fraction of the <see cref="Chart.Rect"/>,
-		/// and the Y coordinate is specified as a fraction of the <see cref="PaneBase.Rect" />.
-		/// </summary>
-		/// <remarks>
-		/// For the X coordinate, 0.0
-		/// is at the left edge of the ChartRect and 1.0
-		/// is at the right edge of the ChartRect. A value less
-		/// than zero is left of the ChartRect and a value
-		/// greater than 1.0 is right of the ChartRect.  For the Y coordinate, a value of zero is at
-		/// the left side of the pane, and a value of 1.0 is at the right side of the pane.
-		/// </remarks>
-		XChartFractionYPaneFraction,
-		/// <summary>
-		/// The X coordinate is specified as a fraction of the <see cref="PaneBase.Rect"/>,
-		/// and the Y coordinate is specified as a fraction of the <see cref="Chart.Rect" />.
-		/// </summary>
-		/// <remarks>
-		/// For the X coordinate, a value of zero is at
-		/// the left side of the pane, and a value of 1.0 is at the right side of the pane.
-		/// For the Y coordinate, 0.0
-		/// is at the top edge of the ChartRect and 1.0
-		/// is at the bottom edge of the ChartRect. A value less
-		/// than zero is above the ChartRect and a value
-		/// greater than 1.0 is below the ChartRect.
-		/// </remarks>
-		XPaneFractionYChartFraction,
-		/// <summary>
-		/// The X coordinate is specified as an X Scale value, and the Y coordinate
-		/// is specified as a fraction of the <see cref="Chart.Rect"/>.
-		/// </summary>
-		/// <remarks>
-		/// For the X coordinate, the value just corresponds to the values of the X scale.
-		/// Values outside the scale range will be
-		/// outside the <see cref="Chart.Rect" />.  For the Y coordinate, 0.0
-		/// is at the top edge of the ChartRect and 1.0
-		/// is at the bottom edge of the ChartRect. A value less
-		/// than zero is above the ChartRect and a value
-		/// greater than 1.0 is below the ChartRect.
-		/// </remarks>
-		XScaleYChartFraction,
-		/// <summary>
-		/// The X coordinate is specified as a fraction of the
-		/// <see cref="Chart.Rect"/> and the Y coordinate is specified as
-		/// a Y scale value.
-		/// </summary>
-		/// <remarks>
-		/// For the X coordinate, 0.0
-		/// is at the left edge of the ChartRect and 1.0
-		/// is at the right edge of the ChartRect. A value less
-		/// than zero is left of the ChartRect and a value
-		/// greater than 1.0 is right of the ChartRect.  For the Y coordinate, the value just
-		/// corresponds to the values of the Y scale.  Values outside the scale range will be
-		/// outside the <see cref="Chart.Rect" />.
-		/// </remarks>
-		XChartFractionYScale,
-		/// <summary>
-		/// The X coordinate is specified as a fraction of the
-		/// <see cref="Chart.Rect"/> and the Y coordinate is specified as
-		/// a Y2 scale value.
-		/// </summary>
-		/// <remarks>
-		/// For the X coordinate, 0.0
-		/// is at the left edge of the ChartRect and 1.0
-		/// is at the right edge of the ChartRect. A value less
-		/// than zero is left of the ChartRect and a value
-		/// greater than 1.0 is right of the ChartRect.  For the Y coordinate, the value just
-		/// corresponds to the values of the Y2 scale.  Values outside the scale range will be
-		/// outside the <see cref="Chart.Rect" />.
-		/// </remarks>
-		XChartFractionY2Scale
-
-	}
-	
-	/// <summary>
-	/// Enumeration type that defines how a curve is drawn.  Curves can be drawn
-	/// as ordinary lines by connecting the points directly, or in a stair-step
-	/// fashion as a series of discrete, constant values.  In a stair step plot,
-	/// all lines segments are either horizontal or vertical.  In a non-step (line)
-	/// plot, the lines can be any angle.
-	/// </summary>
-	/// <seealso cref="Line.StepType"/>
-	public enum StepType
-	{
-		/// <summary>
-		/// Draw the <see cref="CurveItem"/> as a stair-step in which each
-		/// point defines the
-		/// beginning (left side) of a new stair.  This implies the points are
-		/// defined at the beginning of an "event."
-		/// </summary>
-		ForwardStep,
-		/// <summary>
-		/// Draw the <see cref="CurveItem"/> as a stair-step in which each
-		/// point defines the end (right side) of a new stair.  This implies
-		/// the points are defined at the end of an "event."
-		/// </summary>
-		RearwardStep,
-		/// <summary>
-		/// Draw the <see cref="CurveItem"/> as an ordinary line, in which the
-		/// points are connected directly by line segments.
-		/// </summary>
-		NonStep,
-		/// <summary>
-		/// Draw the <see cref="CurveItem"/> as a segment in which each point defines the
-		/// beginning (left side) of a new "stair."  This implies the points are defined
-		/// at the beginning of an "event."  Note that ForwardSegment is different
-		/// from ForwardStep in that it does not draw the vertical portion of the step.
-		/// </summary>
-		ForwardSegment,
-		/// <summary>
-		/// Draw the <see cref="CurveItem"/> as a segment in which each point defines the
-		/// end (right side) of a new "stair."  This implies the points are defined
-		/// at the end of an "event."  Note that RearwardSegment is different
-		/// from RearwardStep in that it does not draw the vertical portion of the step.
-		/// </summary>
-		RearwardSegment
-	}
-	
-	/// <summary>
-	/// Enumeration type that defines the base axis from which <see cref="Bar"/> graphs
-	/// are displayed. The bars can be drawn on any of the four axes (<see cref="XAxis"/>,
-	/// <see cref="X2Axis"/>, <see cref="YAxis"/>, and <see cref="Y2Axis"/>).
-	/// </summary>
-	/// <seealso cref="BarSettings.Base"/>
-	public enum BarBase
-	{
-		/// <summary>
-		/// Draw the <see cref="Bar"/> chart based from the <see cref="XAxis"/>.
-		/// </summary>
-		X,
-		/// <summary>
-		/// Draw the <see cref="Bar"/> chart based from the <see cref="X2Axis"/>.
-		/// </summary>
-		X2,
-		/// <summary>
-		/// Draw the <see cref="Bar"/> chart based from the <see cref="YAxis"/>.
-		/// </summary>
-		Y,
-		/// <summary>
-		/// Draw the <see cref="Bar"/> chart based from the <see cref="Y2Axis"/>.
-		/// </summary>
-		Y2
-	}
-	
-	/// <summary>
-	/// Enumeration type that defines the available types of <see cref="LineItem"/> graphs.
-	/// </summary>
-	/// <seealso cref="GraphPane.LineType"/>
-	public enum LineType
-	{
-		/// <summary>
-		/// Draw the lines as normal.  Any fill area goes from each line down to the X Axis.
-		/// </summary>
-		Normal,
-		/// <summary>
-		/// Draw the lines stacked on top of each other, accumulating values to a total value.
-		/// </summary>
-		Stack
-	}
-	
-	/// <summary>
-	/// Enumeration type that defines the available types of <see cref="BarItem"/> graphs.
-	/// </summary>
-	/// <seealso cref="BarSettings.Type"/>
-	public enum BarType
-	{
-		/// <summary>
-		/// Draw each <see cref="BarItem"/> side by side in clusters.
-		/// </summary>
-		Cluster,
-		/// <summary>
-		/// Draw the <see cref="BarItem"/> bars one on top of the other.  The bars will
-		/// be drawn such that the last bar in the <see cref="CurveList"/> will be behind
-		/// all other bars.  Note that the bar values are not summed up for the overlay
-		/// mode.  The data values must be summed before being passed
-		/// to <see cref="GraphPane.AddBar(string,IPointList,Color)"/>.
-		/// For example, if the first bar of
-		/// the first <see cref="BarItem"/> has a value of 100, and the first bar of
-		/// the second <see cref="BarItem"/> has a value of 120, then that bar will
-		/// appear to be 20 units on top of the first bar.
-		/// </summary>
-		Overlay,
-		/// <summary>
-		/// Draw the <see cref="BarItem"/> bars one on top of the other.  The bars will
-		/// be drawn such that the bars are sorted according to the maximum value, with
-		/// the tallest bar at each point at the back and the shortest bar at the front.
-		/// This is similar to the <see cref="Overlay"/> mode, but the bars are sorted at
-		/// each base value.
-		/// The data values must be summed before being passed
-		/// to <see cref="GraphPane.AddBar(string,IPointList,Color)"/>.  For example, if the first bar of
-		/// the first <see cref="BarItem"/> has a value of 100, and the first bar of
-		/// the second <see cref="BarItem"/> has a value of 120, then that bar will
-		/// appear to be 20 units on top of the first bar.
-		/// </summary>
-		SortedOverlay,
-		/// <summary>
-		/// Draw the <see cref="BarItem"/> bars in an additive format so that they stack on
-		/// top of one another.  The value of the last bar drawn will be the sum of the values
-		/// of all prior bars.
-		/// </summary>
-		Stack,
-		/// <summary>
-		/// Draw the <see cref="BarItem"/> bars in a format whereby the height of each
-		/// represents the percentage of the total each one represents.  Negative values
-		///are displayed below the zero line as percentages of the absolute total of all values. 
-		/// </summary>
-		PercentStack 
-	}
-	
-	/// <summary>
-	/// Enumeration type that defines which set of data points - X or Y - is used  
-	/// <seealso cref="System.Collections.ArrayList.Sort()"/> to perform the sort.
-	/// </summary>
-	public enum SortType
-	{
-	   /// <summary>
-	   /// Use the Y values to sort the list.
-	   /// </summary>
-	   YValues,
-	   /// <summary>
-	   /// Use the X values to sort the list.
-	   /// </summary>
-	   XValues
-	};
-
-	/// <summary>
-	/// Enumeration that specifies a Z-Order position for <see cref="GraphObj"/>
-	/// objects.
-	/// </summary>
-	/// <remarks>This enumeration allows you to set the layering of various graph
-	/// features.  Except for the <see cref="GraphObj"/> objects, other feature types
-	/// all have a fixed depth as follows (front to back):
-	/// <list>
-	/// <see cref="Legend"/> objects
-	/// The border around <see cref="Chart.Rect"/>
-	/// <see cref="CurveItem"/> objects
-	/// The <see cref="Axis"/> features
-	/// The background fill of the <see cref="Chart.Rect"/>
-	/// The pane <see cref="PaneBase.Title"/>
-	/// The background fill of the <see cref="PaneBase.Rect"/>
-	/// </list>
-	/// You cannot place anything behind the <see cref="PaneBase.Rect"/>
-	/// background fill, but <see cref="GraphObj.ZOrder"/> allows you to
-	/// explicitly control the depth of <see cref="GraphObj"/> objects
-	/// between all other object types.  For items of equal <see cref="ZOrder"/>,
-	/// such as multiple <see cref="CurveItem"/>'s or <see cref="GraphObj"/>'s
-	/// having the same <see cref="ZOrder"/> value, the relative depth is
-	/// controlled by the ordinal position in the list (either
-	/// <see cref="CurveList"/> or <see cref="GraphObjList"/>).
-	/// <see cref="GraphObj"/> objects
-	/// can be placed in the <see cref="GraphObjList"/> of either a
-	/// <see cref="GraphPane"/> or a <see cref="MasterPane"/>.  For a
-	/// <see cref="GraphPane"/>-based <see cref="GraphObj"/>, all <see cref="ZOrder"/>
-	/// values are applicable.  For a <see cref="MasterPane"/>-based
-	/// <see cref="GraphObj"/>, any <see cref="ZOrder"/> value can be used, but there
-	/// are really only three depths:
-	/// <list><see cref="ZOrder.H_BehindAll"/> will place the item behind the pane title,
-	/// <see cref="ZOrder.A_InFront"/> will place on top of all other graph features,
-	/// any other value places the object above the pane title, but behind the <see cref="GraphPane"/>'s.
-	/// </list>
-	/// </remarks>
-	public enum ZOrder
-	{
-	   /// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be behind all other
-	   /// objects (including the <see cref="PaneBase"/> <see cref="PaneBase.Title"/>).
-	   /// </summary>
-	   H_BehindAll,
-	   /// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be behind the
-	   /// <see cref="Chart.Rect"/> background <see cref="Fill"/>
-	   /// (see <see cref="Chart.Fill"/>).
-	   /// </summary>
-	   G_BehindChartFill,
-		/// <summary>
-		/// Specifies that the <see cref="GraphObj"/> will be behind the grid lines.
-		/// </summary>
-		F_BehindGrid,
-		/// <summary>
-		/// Specifies that the <see cref="GraphObj"/> will be behind the
-		/// <see cref="CurveItem"/> objects.
-		/// </summary>
-		E_BehindCurves,
-		/// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be behind the
-	   /// <see cref="Axis"/> objects.
-	   /// </summary>
-	   D_BehindAxis,
-	   /// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be behind the
-	   /// <see cref="Chart"/> border.
-	   /// </summary>
-	   C_BehindChartBorder,
-	   /// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be behind the
-	   /// <see cref="Legend"/> object.
-	   /// </summary>
-	   B_BehindLegend,
-	   /// <summary>
-	   /// Specifies that the <see cref="GraphObj"/> will be in front of
-	   /// all other objects, except for the other <see cref="GraphObj"/>
-	   /// objects that have the same <see cref="ZOrder"/> and are before
-	   /// this object in the <see cref="GraphObjList"/>.
-	   /// </summary>
-	   A_InFront
-	}
-
-	/// <summary>
-	/// Enumeration that determines the type of label that is displayed for each pie slice
-	/// (see <see cref="PieItem.LabelType"/>).
-	/// </summary>
-	public enum PieLabelType
-	{
-		/// <summary>
-		/// Displays <see cref="CurveItem.Label"/> and <see cref="PieItem.Value"/> for
-		/// a slice in a Pie Chart.
-		/// </summary>
-		Name_Value,
-
-		/// <summary>
-		/// Displays <see cref="CurveItem.Label"/> and <see cref="PieItem.Value"/> (as % of total) for
-		/// a slice in a Pie Chart.
-		/// </summary>
-		Name_Percent,		
-
-		/// <summary>
-		/// Displays a <see cref="CurveItem.Label"/> containing the <see cref="PieItem.Value"/> both  
-		/// as an absolute number and as percentage of the total.
-		/// </summary>
-		Name_Value_Percent,		
-
-		/// <summary>
-		/// Displays <see cref="PieItem.Value"/> for
-		/// a slice in a Pie Chart.
-		/// </summary>
-		Value,
-
-		/// <summary>
-		/// Displays <see cref="PieItem.Value"/> (as % of total) for
-		/// a slice in a Pie Chart.
-		/// </summary>
-		Percent,
-
-		/// <summary>
-		/// Displays <see cref="CurveItem.Label"/> for a slice in a Pie Chart.
-		/// </summary>
-		Name,
-
-		/// <summary>
-		///No label displayed. 
-		/// </summary>
-		None
-	}
-	
-	/// <summary>
-	/// Define the auto layout options for the
-	/// <see cref="MasterPane.SetLayout(Graphics,PaneLayout)"/> method.
-	/// </summary>
-	public enum PaneLayout
-	{
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s so they are in a square grid (always 2x2, 3x3, 4x4),
-		/// leaving blank spaces as required.
-		/// </summary>
-		/// <remarks>For example, a single pane would generate a 1x1 grid, between 2 and 4 panes would generate
-		/// a 2x2 grid, 5 to 9 panes would generate a 3x3 grid.</remarks>
-		ForceSquare,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s so they are in a general square (2x2, 3x3, etc.), but use extra
-		/// columns when necessary (row x column = 1x2, 2x3, 3x4, etc.) depending on the total number
-		/// of panes required.
-		/// </summary>
-		/// <remarks>For example, a 2x2 grid has four panes and a 3x3 grid has 9 panes.  If there are
-		/// 6 panes required, then this option will eliminate a row (column preferred) to make a
-		/// 2 row x 3 column grid.  With 7 panes, it will make a 3x3 grid with 2 empty spaces.</remarks>
-		SquareColPreferred,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s so they are in a general square (2x2, 3x3, etc.), but use extra
-		/// rows when necessary (2x1, 3x2, 4x3, etc.) depending on the total number of panes required.
-		/// </summary>
-		/// <remarks>For example, a 2x2 grid has four panes and a 3x3 grid has 9 panes.  If there are
-		/// 6 panes required, then this option will eliminate a column (row preferred) to make a
-		/// 3 row x 2 column grid.  With 7 panes, it will make a 3x3 grid with 2 empty spaces.</remarks>
-		SquareRowPreferred,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s in a single row
-		/// </summary>
-		SingleRow,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s in a single column
-		/// </summary>
-		SingleColumn,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of columns: The first row has
-		/// 1 column and the second row has 2 columns for a total of 3 panes.
-		/// </summary>
-		ExplicitCol12,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of columns: The first row has
-		/// 2 columns and the second row has 1 column for a total of 3 panes.
-		/// </summary>
-		ExplicitCol21,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of columns: The first row has
-		/// 2 columns and the second row has 3 columns for a total of 5 panes.
-		/// </summary>
-		ExplicitCol23,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of columns: The first row has
-		/// 3 columns and the second row has 2 columns for a total of 5 panes.
-		/// </summary>
-		ExplicitCol32,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of rows: The first column has
-		/// 1 row and the second column has 2 rows for a total of 3 panes.
-		/// </summary>
-		ExplicitRow12,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of rows: The first column has
-		/// 2 rows and the second column has 1 row for a total of 3 panes.
-		/// </summary>
-		ExplicitRow21,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of rows: The first column has
-		/// 2 rows and the second column has 3 rows for a total of 5 panes.
-		/// </summary>
-		ExplicitRow23,
-		/// <summary>
-		/// Layout the <see cref="GraphPane"/>'s with an explicit number of rows: The first column has
-		/// 3 rows and the second column has 2 rows for a total of 5 panes.
-		/// </summary>
-		ExplicitRow32
-	}
-
-	/// <summary>
-	/// Enum for specifying the type of data to be returned by the ZedGraphWeb Render() method.
-	/// </summary>
-	public enum RenderModeType
-	{
-		/// <summary>
-		/// Renders as an IMG tag referencing a local generated image. ContentType stays text.
-		/// </summary>
-		ImageTag,
-		/// <summary>
-		/// Renders the binary image. ContentType is changed accordingly.
-		/// </summary>
-		RawImage
-	}
-
-
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ValueHandler.cs b/BDInfo/ZedGraph/ValueHandler.cs
deleted file mode 100644
index cca617fdb9..0000000000
--- a/BDInfo/ZedGraph/ValueHandler.cs
+++ /dev/null
@@ -1,372 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-using System;
-using System.Text;
-using System.Drawing;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class designed to simplify the process of getting the actual value for
-	/// the various stacked and regular curve types
-	/// </summary>
-	/// 
-	/// <author> John Champion</author>
-	/// <version> $Revision: 3.20 $ $Date: 2007/11/03 04:41:29 $ </version>
-	public class ValueHandler
-	{
-		private GraphPane _pane;
-
-		/// <summary>
-		/// Basic constructor that saves a reference to the parent
-		/// <see cref="GraphPane"/> object.
-		/// </summary>
-		/// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
-		/// <param name="initialize">A <see cref="bool"/> flag to indicate whether or
-		/// not the drawing variables should be initialized.  Initialization is not
-		/// required if this is part of a ZedGraph internal draw operation (i.e., its in
-		/// the middle of a call to <see cref="GraphPane.Draw"/>).  Otherwise, you should
-		/// initialize to make sure the drawing variables are configured.  true to do
-		/// an initialization, false otherwise.</param>
-		public ValueHandler( GraphPane pane, bool initialize )
-		{
-			_pane = pane;
-			if ( initialize )
-			{
-				// just create a dummy image, which results in a full draw operation
-				using ( Image image = pane.GetImage() )
-				{
-				}
-			}
-		}
-
-		/// <summary>
-		/// Get the user scale values associate with a particular point of a
-		/// particular curve.</summary>
-		/// <remarks>The main purpose of this method is to handle
-		/// stacked bars, in which case the stacked values are returned rather
-		/// than the individual data values.
-		/// </remarks>
-		/// <param name="curve">A <see cref="CurveItem"/> object of interest.</param>
-		/// <param name="iPt">The zero-based point index for the point of interest.</param>
-		/// <param name="baseVal">A <see cref="Double"/> value representing the value
-		/// for the independent axis.</param>
-		/// <param name="lowVal">A <see cref="Double"/> value representing the lower
-		/// value for the dependent axis.</param>
-		/// <param name="hiVal">A <see cref="Double"/> value representing the upper
-		/// value for the dependent axis.</param>
-		/// <returns>true if the data point is value, false for
-		/// <see cref="PointPairBase.Missing"/>, invalid, etc. data.</returns>
-		public bool GetValues( CurveItem curve, int iPt, out double baseVal,
-							out double lowVal, out double hiVal )
-		{
-			return GetValues( _pane, curve, iPt, out baseVal,
-									out lowVal, out hiVal );
-		}
-
-		/// <summary>
-		/// Get the user scale values associate with a particular point of a
-		/// particular curve.</summary>
-		/// <remarks>The main purpose of this method is to handle
-		/// stacked bars and lines, in which case the stacked values are returned rather
-		/// than the individual data values.  However, this method works generically for any
-		/// curve type.
-		/// </remarks>
-		/// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
-		/// <param name="curve">A <see cref="CurveItem"/> object of interest.</param>
-		/// <param name="iPt">The zero-based point index for the point of interest.</param>
-		/// <param name="baseVal">A <see cref="Double"/> value representing the value
-		/// for the independent axis.</param>
-		/// <param name="lowVal">A <see cref="Double"/> value representing the lower
-		/// value for the dependent axis.</param>
-		/// <param name="hiVal">A <see cref="Double"/> value representing the upper
-		/// value for the dependent axis.</param>
-		/// <returns>true if the data point is value, false for
-		/// <see cref="PointPairBase.Missing"/>, invalid, etc. data.</returns>
-		public static bool GetValues( GraphPane pane, CurveItem curve, int iPt,
-							out double baseVal, out double lowVal, out double hiVal )
-		{
-			hiVal = PointPair.Missing;
-			lowVal = PointPair.Missing;
-			baseVal = PointPair.Missing;
-
-			if ( curve == null || curve.Points.Count <= iPt || !curve.IsVisible )
-				return false;
-
-			Axis baseAxis = curve.BaseAxis( pane );
-			Axis valueAxis = curve.ValueAxis( pane );
-
-			if ( baseAxis is XAxis || baseAxis is X2Axis )
-				baseVal = curve.Points[iPt].X;
-			else
-				baseVal = curve.Points[iPt].Y;
-
-			// is it a stacked bar type?
-			if ( curve is BarItem && ( pane._barSettings.Type == BarType.Stack ||
-						pane._barSettings.Type == BarType.PercentStack ) )
-			{
-				double positiveStack = 0;
-				double negativeStack = 0;
-				double curVal;
-
-				// loop through all the curves, summing up the values to get a total (only
-				// for the current ordinal position iPt)
-				foreach ( CurveItem tmpCurve in pane.CurveList )
-				{
-					// Sum the value for the current curve only if it is a bar
-					if ( tmpCurve.IsBar && tmpCurve.IsVisible )
-					{
-						curVal = PointPair.Missing;
-						// For non-ordinal curves, find a matching base value (must match exactly)
-						if ( curve.IsOverrideOrdinal || !baseAxis._scale.IsAnyOrdinal )
-						{
-							IPointList points = tmpCurve.Points;
-
-							for ( int i=0; i<points.Count; i++ )
-							{
-								if ( ( baseAxis is XAxis || baseAxis is X2Axis ) && points[i].X == baseVal )
-								{
-									curVal = points[i].Y;
-									break;
-								}
-								else if ( !(baseAxis is XAxis || baseAxis is X2Axis) && points[i].Y == baseVal )
-								{
-									curVal = points[i].X;
-									break;
-								}
-							}
-						}
-						// otherwise, it's an ordinal type so use the value at the same ordinal position
-						else if ( iPt < tmpCurve.Points.Count )
-						{
-							// Get the value for the appropriate value axis
-							if ( baseAxis is XAxis || baseAxis is X2Axis )
-								curVal = tmpCurve.Points[iPt].Y;
-							else
-								curVal = tmpCurve.Points[iPt].X;
-						}
-
-						// If it's a missing value, skip it
-						if ( curVal == PointPair.Missing )
-						{
-							positiveStack = PointPair.Missing;
-							negativeStack = PointPair.Missing;
-						}
-
-						// the current curve is the target curve, save the summed values for later
-						if ( tmpCurve == curve )
-						{
-							// if the value is positive, use the positive stack
-							if ( curVal >= 0 )
-							{
-								lowVal = positiveStack;
-								hiVal = ( curVal == PointPair.Missing || positiveStack == PointPair.Missing ) ?
-										PointPair.Missing : positiveStack + curVal;
-							}
-							// otherwise, use the negative stack
-							else
-							{
-								hiVal = negativeStack;
-								lowVal = ( curVal == PointPair.Missing || negativeStack == PointPair.Missing ) ?
-										PointPair.Missing : negativeStack + curVal;
-							}
-						}
-
-						// Add all positive values to the positive stack, and negative values to the
-						// negative stack
-						if ( curVal >= 0 )
-							positiveStack = ( curVal == PointPair.Missing || positiveStack == PointPair.Missing ) ?
-										PointPair.Missing : positiveStack + curVal;
-						else
-							negativeStack = ( curVal == PointPair.Missing || negativeStack == PointPair.Missing ) ?
-										PointPair.Missing : negativeStack + curVal;
-					}
-				}
-
-				// if the curve is a PercentStack type, then calculate the percent for this bar
-				// based on the total height of the stack
-				if ( pane._barSettings.Type == BarType.PercentStack &&
-							hiVal != PointPair.Missing && lowVal != PointPair.Missing )
-				{
-					// Use the total magnitude of the positive plus negative bar stacks to determine
-					// the percentage value
-					positiveStack += Math.Abs( negativeStack );
-
-					// just to avoid dividing by zero...
-					if ( positiveStack != 0 )
-					{
-						// calculate the percentage values
-						lowVal = lowVal / positiveStack * 100.0;
-						hiVal = hiVal / positiveStack * 100.0;
-					}
-					else
-					{
-						lowVal = 0;
-						hiVal = 0;
-					}
-				}
-
-				if ( baseVal == PointPair.Missing || lowVal == PointPair.Missing ||
-						hiVal == PointPair.Missing )
-					return false;
-				else
-					return true;
-			}
-			// If the curve is a stacked line type, then sum up the values similar to the stacked bar type
-			else if ( curve is LineItem && pane.LineType == LineType.Stack )
-			{
-				double stack = 0;
-				double curVal;
-
-				// loop through all the curves, summing up the values to get a total (only
-				// for the current ordinal position iPt)
-				foreach ( CurveItem tmpCurve in pane.CurveList )
-				{
-					// make sure the curve is a Line type
-					if ( tmpCurve is LineItem && tmpCurve.IsVisible )
-					{
-						curVal = PointPair.Missing;
-						// For non-ordinal curves, find a matching base value (must match exactly)
-						if ( curve.IsOverrideOrdinal || !baseAxis._scale.IsAnyOrdinal )
-						{
-							IPointList points = tmpCurve.Points;
-
-							for ( int i = 0; i < points.Count; i++ )
-							{
-								if ( points[i].X == baseVal )
-								{
-									curVal = points[i].Y;
-									break;
-								}
-							}
-						}
-						// otherwise, it's an ordinal type so use the value at the same ordinal position
-						else if ( iPt < tmpCurve.Points.Count )
-						{
-							// For line types, the Y axis is always the value axis
-							curVal = tmpCurve.Points[iPt].Y;
-						}
-
-						// if the current value is missing, then the rest of the stack is missing
-						if ( curVal == PointPair.Missing )
-							stack = PointPair.Missing;
-
-						// if the current curve is the target curve, save the values
-						if ( tmpCurve == curve )
-						{
-							lowVal = stack;
-//							if ( curVal < 0 && stack == 0 )
-//							{
-//								stack = curVal;
-//								lowVal = curVal;
-//								hiVal = curVal;
-//							}
-//							else
-								hiVal = ( curVal == PointPair.Missing || stack == PointPair.Missing ) ?
-									PointPair.Missing : stack + curVal;
-						}
-
-						// sum all the curves to a single total.  This includes both positive and
-						// negative values (unlike the bar stack type).
-						stack = ( curVal == PointPair.Missing || stack == PointPair.Missing ) ?
-								PointPair.Missing : stack + curVal;
-					}
-				}
-				
-				if ( baseVal == PointPair.Missing || lowVal == PointPair.Missing ||
-					hiVal == PointPair.Missing )
-					return false;
-				else
-					return true;
-			}
-			// otherwise, the curve is not a stacked type (not a stacked bar or stacked line)
-			else
-			{
-				if ( ! (curve is HiLowBarItem) )
-					lowVal = 0;
-				else
-					lowVal = curve.Points[iPt].LowValue;
-
-				if ( baseAxis is XAxis || baseAxis is X2Axis )
-					hiVal = curve.Points[iPt].Y;
-				else
-					hiVal = curve.Points[iPt].X;
-			}
-
-			// Special Exception: Bars on log scales should always plot from the Min value upwards,
-			// since they can never be zero
-			if ( curve is BarItem && valueAxis._scale.IsLog && lowVal == 0 )
-				lowVal = valueAxis._scale._min;
-
-			if ( baseVal == PointPair.Missing || hiVal == PointPair.Missing ||
-					( lowVal == PointPair.Missing && ( curve is ErrorBarItem ||
-						curve is HiLowBarItem ) ) )
-				return false;
-			else
-				return true;
-		}
-
-		/// <summary>
-		/// Calculate the user scale position of the center of the specified bar, using the
-		/// <see cref="Axis"/> as specified by <see cref="BarSettings.Base"/>.  This method is
-		/// used primarily by the
-		/// <see cref="GraphPane.FindNearestPoint(PointF,out CurveItem,out int)"/> method in order to
-		/// determine the bar "location," which is defined as the center of the top of the individual bar.
-		/// </summary>
-		/// <param name="curve">The <see cref="CurveItem"/> representing the
-		/// bar of interest.</param>
-		/// <param name="barWidth">The width of each individual bar. This can be calculated using
-		/// the <see cref="CurveItem.GetBarWidth"/> method.</param>
-		/// <param name="iCluster">The cluster number for the bar of interest.  This is the ordinal
-		/// position of the current point.  That is, if a particular <see cref="CurveItem"/> has
-		/// 10 points, then a value of 3 would indicate the 4th point in the data array.</param>
-		/// <param name="val">The actual independent axis value for the bar of interest.</param>
-		/// <param name="iOrdinal">The ordinal position of the <see cref="CurveItem"/> of interest.
-		/// That is, the first bar series is 0, the second is 1, etc.  Note that this applies only
-		/// to the bars.  If a graph includes both bars and lines, then count only the bars.</param>
-		/// <returns>A user scale value position of the center of the bar of interest.</returns>
-		public double BarCenterValue( CurveItem curve, float barWidth, int iCluster,
-										  double val, int iOrdinal )
-		{
-			Axis baseAxis = curve.BaseAxis( _pane );
-			if ( curve is ErrorBarItem || curve is HiLowBarItem ||
-					curve is OHLCBarItem || curve is JapaneseCandleStickItem )
-			{
-				if ( baseAxis._scale.IsAnyOrdinal && iCluster >= 0 && !curve.IsOverrideOrdinal )
-					return (double) iCluster + 1.0;
-				else
-					return val;
-			}
-			else
-			{
-				float clusterWidth = _pane._barSettings.GetClusterWidth();
-				float clusterGap = _pane._barSettings.MinClusterGap * barWidth;
-				float barGap = barWidth * _pane._barSettings.MinBarGap;
-
-				if ( curve.IsBar && _pane._barSettings.Type != BarType.Cluster )
-					iOrdinal = 0;
-
-				float centerPix = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, iCluster, val )
-					- clusterWidth / 2.0F + clusterGap / 2.0F +
-					iOrdinal * ( barWidth + barGap ) + 0.5F * barWidth;
-				return baseAxis.Scale.ReverseTransform( centerPix );
-			}
-		}
-	}
-}
diff --git a/BDInfo/ZedGraph/X2Axis.cs b/BDInfo/ZedGraph/X2Axis.cs
deleted file mode 100644
index 8df1d92af4..0000000000
--- a/BDInfo/ZedGraph/X2Axis.cs
+++ /dev/null
@@ -1,260 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// <see cref="X2Axis"/> inherits from <see cref="Axis"/>, and defines the
-	/// special characteristics of a horizontal axis, specifically located at
-	/// the top of the <see cref="Chart.Rect"/> of the <see cref="GraphPane"/>
-	/// object
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2007/04/16 00:03:07 $ </version>
-	[Serializable]
-	public class X2Axis : Axis, ICloneable, ISerializable
-	{
-
-		#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="X2Axis"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			// Default X2 Axis properties
-			/// <summary>
-			/// The default display mode for the <see cref="X2Axis"/>
-			/// (<see cref="Axis.IsVisible"/> property). true to display the scale
-			/// values, title, tic marks, false to hide the axis entirely.
-			/// </summary>
-			public static bool IsVisible = false;
-			/// <summary>
-			/// Determines if a line will be drawn at the zero value for the 
-			/// <see cref="X2Axis"/>, that is, a line that
-			/// divides the negative values from positive values.
-			/// <seealso cref="MajorGrid.IsZeroLine"/>.
-			/// </summary>
-			public static bool IsZeroLine = false;
-		}
-		#endregion
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="X2Axis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class
-		/// </summary>
-		public X2Axis()
-			: this( "X2 Axis" )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="X2Axis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class, except
-		/// for the axis title
-		/// </summary>
-		/// <param name="title">The <see cref="Axis.Title"/> for this axis</param>
-		public X2Axis( string title )
-			: base( title )
-		{
-			_isVisible = Default.IsVisible;
-			_majorGrid._isZeroLine = Default.IsZeroLine;
-			_scale._fontSpec.Angle = 180F;
-			_title._fontSpec.Angle = 180F;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The X2Axis object from which to copy</param>
-		public X2Axis( X2Axis rhs )
-			: base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public X2Axis Clone()
-		{
-			return new X2Axis( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 11;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected X2Axis( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-		#endregion
-
-		#region Methods
-		/// <summary>
-		/// Setup the Transform Matrix to handle drawing of this <see cref="X2Axis"/>
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void SetTransformMatrix( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			// Move the origin to the TopLeft of the ChartRect, which is the left
-			// side of the X2 axis (facing from the label side)
-			g.TranslateTransform( pane.Chart._rect.Right, pane.Chart._rect.Top );
-			//g.ScaleTransform( 1.0f, -1.0f );
-			// rotate so this axis is in the right-left direction
-			g.RotateTransform( 180 );
-		}
-
-		/// <summary>
-		/// Determines if this <see cref="Axis" /> object is a "primary" one.
-		/// </summary>
-		/// <remarks>
-		/// The primary axes are the <see cref="XAxis" /> (always),
-		/// the <see cref="X2Axis" /> (always), the first
-		/// <see cref="YAxis" /> in the <see cref="GraphPane.YAxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0),  and the first
-		/// <see cref="Y2Axis" /> in the <see cref="GraphPane.Y2AxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0).  Note that
-		/// <see cref="GraphPane.YAxis" /> and <see cref="GraphPane.Y2Axis" />
-		/// always reference the primary axes.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>true for a primary <see cref="Axis" /> (for the <see cref="X2Axis" />,
-		/// this is always true), false otherwise</returns>
-		override internal bool IsPrimary( GraphPane pane )
-		{
-			return this == pane.X2Axis;
-		}
-
-		/// <summary>
-		/// Calculate the "shift" size, in pixels, in order to shift the axis from its default
-		/// location to the value specified by <see cref="Axis.Cross"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>The shift amount measured in pixels</returns>
-		internal override float CalcCrossShift( GraphPane pane )
-		{
-			double effCross = EffectiveCrossValue( pane );
-
-			if ( !_crossAuto )
-				return pane.YAxis.Scale.Transform( effCross ) - pane.YAxis.Scale._maxPix;
-			else
-				return 0;
-		}
-		/*
-				override internal bool IsCrossed( GraphPane pane )
-				{
-					return !this.crossAuto && this.cross > pane.YAxis.Min && this.cross < pane.YAxis.Max;
-				}
-		*/
-		/// <summary>
-		/// Gets the "Cross" axis that corresponds to this axis.
-		/// </summary>
-		/// <remarks>
-		/// The cross axis is the axis which determines the of this Axis when the
-		/// <see cref="Axis.Cross" >Axis.Cross</see> property is used.  The
-		/// cross axis for any <see cref="XAxis" /> or <see cref="X2Axis" />
-		/// is always the primary <see cref="YAxis" />, and
-		/// the cross axis for any <see cref="YAxis" /> or <see cref="Y2Axis" /> is
-		/// always the primary <see cref="XAxis" />.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		override public Axis GetCrossAxis( GraphPane pane )
-		{
-			return pane.YAxis;
-		}
-
-		//		override internal float GetMinPix( GraphPane pane )
-		//		{
-		//			return pane.Chart._rect.Left;
-		//		}
-
-		#endregion
-	}
-}
-
-
-
diff --git a/BDInfo/ZedGraph/XAxis.cs b/BDInfo/ZedGraph/XAxis.cs
deleted file mode 100644
index 388e737748..0000000000
--- a/BDInfo/ZedGraph/XAxis.cs
+++ /dev/null
@@ -1,255 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// <see cref="XAxis"/> inherits from <see cref="Axis"/>, and defines the
-	/// special characteristics of a horizontal axis, specifically located at
-	/// the bottom of the <see cref="Chart.Rect"/> of the <see cref="GraphPane"/>
-	/// object
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.16 $ $Date: 2007/04/16 00:03:02 $ </version>
-	[Serializable]
-	public class XAxis : Axis, ICloneable, ISerializable
-	{
-
-		#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="XAxis"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			// Default X Axis properties
-			/// <summary>
-			/// The default display mode for the <see cref="XAxis"/>
-			/// (<see cref="Axis.IsVisible"/> property). true to display the scale
-			/// values, title, tic marks, false to hide the axis entirely.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// Determines if a line will be drawn at the zero value for the 
-			/// <see cref="XAxis"/>, that is, a line that
-			/// divides the negative values from positive values.
-			/// <seealso cref="MajorGrid.IsZeroLine"/>.
-			/// </summary>
-			public static bool IsZeroLine = false;
-		}
-		#endregion
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="XAxis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class
-		/// </summary>
-		public XAxis()
-			: this( "X Axis" )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="XAxis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class, except
-		/// for the axis title
-		/// </summary>
-		/// <param name="title">The <see cref="Axis.Title"/> for this axis</param>
-		public XAxis( string title )
-			: base( title )
-		{
-			_isVisible = Default.IsVisible;
-			_majorGrid._isZeroLine = Default.IsZeroLine;
-			_scale._fontSpec.Angle = 0F;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The XAxis object from which to copy</param>
-		public XAxis( XAxis rhs )
-			: base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public XAxis Clone()
-		{
-			return new XAxis( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected XAxis( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-		#endregion
-
-		#region Methods
-		/// <summary>
-		/// Setup the Transform Matrix to handle drawing of this <see cref="XAxis"/>
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void SetTransformMatrix( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			// Move the origin to the BottomLeft of the ChartRect, which is the left
-			// side of the X axis (facing from the label side)
-			g.TranslateTransform( pane.Chart._rect.Left, pane.Chart._rect.Bottom );
-		}
-
-		/// <summary>
-		/// Determines if this <see cref="Axis" /> object is a "primary" one.
-		/// </summary>
-		/// <remarks>
-		/// The primary axes are the <see cref="XAxis" /> (always), the first
-		/// <see cref="YAxis" /> in the <see cref="GraphPane.YAxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0),  and the first
-		/// <see cref="Y2Axis" /> in the <see cref="GraphPane.Y2AxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0).  Note that
-		/// <see cref="GraphPane.YAxis" /> and <see cref="GraphPane.Y2Axis" />
-		/// always reference the primary axes.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>true for a primary <see cref="Axis" /> (for the <see cref="XAxis" />,
-		/// this is always true), false otherwise</returns>
-		override internal bool IsPrimary( GraphPane pane )
-		{
-			return this == pane.XAxis;
-		}
-
-		/// <summary>
-		/// Calculate the "shift" size, in pixels, in order to shift the axis from its default
-		/// location to the value specified by <see cref="Axis.Cross"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>The shift amount measured in pixels</returns>
-		internal override float CalcCrossShift( GraphPane pane )
-		{
-			double effCross = EffectiveCrossValue( pane );
-
-			if ( !_crossAuto )
-				return pane.YAxis.Scale.Transform( effCross ) - pane.YAxis.Scale._maxPix;
-			else
-				return 0;
-		}
-		/*
-				override internal bool IsCrossed( GraphPane pane )
-				{
-					return !this.crossAuto && this.cross > pane.YAxis.Min && this.cross < pane.YAxis.Max;
-				}
-		*/
-		/// <summary>
-		/// Gets the "Cross" axis that corresponds to this axis.
-		/// </summary>
-		/// <remarks>
-		/// The cross axis is the axis which determines the of this Axis when the
-		/// <see cref="Axis.Cross" >Axis.Cross</see> property is used.  The
-		/// cross axis for any <see cref="XAxis" /> or <see cref="X2Axis" />
-		/// is always the primary <see cref="YAxis" />, and
-		/// the cross axis for any <see cref="YAxis" /> or <see cref="Y2Axis" /> is
-		/// always the primary <see cref="XAxis" />.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		override public Axis GetCrossAxis( GraphPane pane )
-		{
-			return pane.YAxis;
-		}
-
-//		override internal float GetMinPix( GraphPane pane )
-//		{
-//			return pane.Chart._rect.Left;
-//		}
-
-		#endregion
-	}
-}
-
-
-
diff --git a/BDInfo/ZedGraph/XDate.cs b/BDInfo/ZedGraph/XDate.cs
deleted file mode 100644
index 23749f210f..0000000000
--- a/BDInfo/ZedGraph/XDate.cs
+++ /dev/null
@@ -1,1732 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-
-namespace ZedGraph
-{
-	
-	/// <summary>
-	/// This struct encapsulates a date and time value, and handles associated
-	/// calculations and conversions between various formats.
-	/// </summary>
-	/// <remarks>
-	/// This format stored as a double value representing days since a reference date
-	/// (XL date 0.0 is December 30, 1899 at 00:00 hrs).
-	/// Negative values are permissible, and the
-	/// range of valid dates is from noon on January 1st, 4713 B.C. forward.  Internally, the
-	/// date calculations are done using Astronomical Julian Day numbers.  The Astronomical Julian
-	/// Day number is defined as the number of days since noon on January 1st, 4713 B.C.
-	/// (also referred to as 12:00 on January 1, -4712).
-	/// NOTE: MS Excel actually has an error in the Serial Date calculations because it
-	/// errantly assumes 1900 is a leap year.  The XDate calculations do not have this same
-	/// error.  Therefore, XDate and Excel Date Serial values are 1 day different up until
-	/// the date value of 60 (in Excel, this is February 29th, 1900, and in XDate, this is
-	/// February 28th, 1900).  At a value of 61 (March 1st, 1900) or greater, they agree with
-	/// eachother.
-	/// </remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.23 $ $Date: 2007/11/11 06:56:34 $ </version>
-	public struct XDate : IComparable
-	{
-	#region Fields & Constants
-		// =========================================================================
-		// Internal Variables
-		// =========================================================================
-	
-		/// <summary>
-		/// The actual date value in MS Excel format.  This is the only data field in
-		/// the <see cref="XDate"/> struct.
-		/// </summary>
-		private double _xlDate;
-		
-		/// <summary>
-		/// The Astronomical Julian Day number that corresponds to XL Date 0.0
-		/// </summary>
-		public const double XLDay1 = 2415018.5;
-
-		/// <summary>
-		/// The minimum valid Julian Day, which corresponds to January 1st, 4713 B.C.
-		/// </summary>
-		public const double JulDayMin = 0.0;
-		/// <summary>
-		/// The maximum valid Julian Day, which corresponds to December 31st, 9999 A.D.
-		/// </summary>
-		public const double JulDayMax = 5373483.5;
-		/// <summary>
-		/// The minimum valid Excel Day, which corresponds to January 1st, 4713 B.C.
-		/// </summary>
-		public const double XLDayMin = JulDayMin - XLDay1;
-		/// <summary>
-		/// The maximum valid Excel Day, which corresponds to December 31st, 9999 A.D.
-		/// </summary>
-		public const double XLDayMax = JulDayMax - XLDay1;
-
-		/// <summary>
-		/// The number of months in a year
-		/// </summary>
-		public const double MonthsPerYear = 12.0;
-		/// <summary>
-		/// The number of hours in a day
-		/// </summary>
-		public const double HoursPerDay = 24.0;
-		/// <summary>
-		/// The number of minutes in an hour
-		/// </summary>
-		public const double MinutesPerHour = 60.0;
-		/// <summary>
-		/// The number of seconds in a minute
-		/// </summary>
-		public const double SecondsPerMinute = 60.0;
-		/// <summary>
-		/// The number of minutes in a day
-		/// </summary>
-		public const double MinutesPerDay = 1440.0;
-		/// <summary>
-		/// The number of seconds in a day
-		/// </summary>
-		public const double SecondsPerDay = 86400.0;
-		/// <summary>
-		/// The number of milliseconds in a second
-		/// </summary>
-		public const double MillisecondsPerSecond = 1000.0;
-		/// <summary>
-		/// The number of milliseconds in a day
-		/// </summary>
-		public const double MillisecondsPerDay = 86400000.0;
-		/// <summary>
-		/// The default format string to be used in <see cref="ToString()"/> when
-		/// no format is provided
-		/// </summary>
-//		public const string DefaultFormatStr = "&d-&mmm-&yy &hh:&nn";
-		public const string DefaultFormatStr = "g";
-	#endregion
-	
-	#region Constructors
-		// =========================================================================
-		// Constructors
-		// =========================================================================
-
-		/// <summary>
-		/// Construct a date class from an XL date value.
-		/// </summary>
-		/// <param name="xlDate">
-		/// An XL Date value in floating point double format
-		/// </param>
-		public XDate( double xlDate )
-		{
-			_xlDate = xlDate;
-		}
-		
-		/// <summary>
-		/// Construct a date class from a <see cref="DateTime"/> struct.
-		/// </summary>
-		/// <param name="dateTime">
-		/// A <see cref="DateTime"/> struct containing the initial date information.
-		/// </param>
-		public XDate( DateTime dateTime )
-		{
-			_xlDate = CalendarDateToXLDate( dateTime.Year, dateTime.Month,
-							dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second,
-							dateTime.Millisecond );
-		}
-		
-		/// <summary>
-		/// Construct a date class from a calendar date (year, month, day).  Assumes the time
-		/// of day is 00:00 hrs
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.
-		/// It is permissible to have day numbers outside of the 1-31 range,
-		/// which will rollover to the previous or next month and year.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.  It is permissible to have months outside of the 1-12 range,
-		/// which will rollover to the previous or next year.</param>
-		public XDate( int year, int month, int day )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, 0, 0, 0 );
-		}
-		
-		/// <summary>
-		/// Construct a date class from a calendar date and time (year, month, day, hour, minute,
-		/// second). 
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.
-		/// It is permissible to have day numbers outside of the 1-31 range,
-		/// which will rollover to the previous or next month and year.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.  It is permissible to have months outside of the 1-12 range,
-		/// which will rollover to the previous or next year.</param>
-		/// <param name="hour">An integer value for the hour of the day, e.g. 15.
-		/// It is permissible to have hour values outside the 0-23 range, which
-		/// will rollover to the previous or next day.</param>
-		/// <param name="minute">An integer value for the minute, e.g. 45.
-		/// It is permissible to have hour values outside the 0-59 range, which
-		/// will rollover to the previous or next hour.</param>
-		/// <param name="second">An integer value for the second, e.g. 35.
-		/// It is permissible to have second values outside the 0-59 range, which
-		/// will rollover to the previous or next minute.</param>
-		public XDate( int year, int month, int day, int hour, int minute, int second )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second );
-		}
-		
-		/// <summary>
-		/// Construct a date class from a calendar date and time (year, month, day, hour, minute,
-		/// second), where seconds is a <see cref="System.Double" /> value (allowing fractional seconds). 
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.
-		/// It is permissible to have day numbers outside of the 1-31 range,
-		/// which will rollover to the previous or next month and year.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.  It is permissible to have months outside of the 1-12 range,
-		/// which will rollover to the previous or next year.</param>
-		/// <param name="hour">An integer value for the hour of the day, e.g. 15.
-		/// It is permissible to have hour values outside the 0-23 range, which
-		/// will rollover to the previous or next day.</param>
-		/// <param name="minute">An integer value for the minute, e.g. 45.
-		/// It is permissible to have hour values outside the 0-59 range, which
-		/// will rollover to the previous or next hour.</param>
-		/// <param name="second">A double value for the second, e.g. 35.75.
-		/// It is permissible to have second values outside the 0-59 range, which
-		/// will rollover to the previous or next minute.</param>
-		public XDate( int year, int month, int day, int hour, int minute, double second )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second );
-		}
-		
-		/// <summary>
-		/// Construct a date class from a calendar date and time (year, month, day, hour, minute,
-		/// second, millisecond). 
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.
-		/// It is permissible to have day numbers outside of the 1-31 range,
-		/// which will rollover to the previous or next month and year.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.  It is permissible to have months outside of the 1-12 range,
-		/// which will rollover to the previous or next year.</param>
-		/// <param name="hour">An integer value for the hour of the day, e.g. 15.
-		/// It is permissible to have hour values outside the 0-23 range, which
-		/// will rollover to the previous or next day.</param>
-		/// <param name="minute">An integer value for the minute, e.g. 45.
-		/// It is permissible to have hour values outside the 0-59 range, which
-		/// will rollover to the previous or next hour.</param>
-		/// <param name="second">An integer value for the second, e.g. 35.
-		/// It is permissible to have second values outside the 0-59 range, which
-		/// will rollover to the previous or next minute.</param>
-		/// <param name="millisecond">An integer value for the millisecond, e.g. 632.
-		/// It is permissible to have millisecond values outside the 0-999 range, which
-		/// will rollover to the previous or next second.</param>
-		public XDate( int year, int month, int day, int hour, int minute, int second, int millisecond )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second, millisecond );
-		}
-		
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The GraphPane object from which to copy</param>
-		public XDate( XDate rhs )
-		{
-			_xlDate = rhs._xlDate;
-		}
-/*
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public XDate Clone()
-		{
-			return new XDate( this );
-		}
-*/
-
-	#endregion
-	
-	#region Properties
-		// =========================================================================
-		// Properties
-		// =========================================================================
-	
-		/// <summary>
-		/// Gets or sets the date value for this item in MS Excel format.
-		/// </summary>
-		public double XLDate
-		{
-			get { return _xlDate; }
-			set { _xlDate = value; }
-		}
-
-		/// <summary>
-		/// Returns true if this <see cref="XDate" /> struct is in the valid date range
-		/// </summary>
-		public bool IsValidDate
-		{
-			get { return _xlDate >= XLDayMin && _xlDate <= XLDayMax; }
-		}
-		
-		/// <summary>
-		/// Gets or sets the date value for this item in .Net DateTime format.
-		/// </summary>
-		public DateTime DateTime
-		{
-			get { return XLDateToDateTime( _xlDate ); }
-			set { _xlDate = DateTimeToXLDate( value ); }
-		}
-		
-		/// <summary>
-		/// Gets or sets the date value for this item in Julain day format.  This is the
-		/// Astronomical Julian Day number, so a value of 0.0 corresponds to noon GMT on
-		/// January 1st, -4712.  Thus, Julian Day number 2,400,000.0 corresponds to
-		/// noon GMT on November 16, 1858.
-		/// </summary>
-		public double JulianDay
-		{
-			get { return XLDateToJulianDay( _xlDate ); }
-			set { _xlDate = JulianDayToXLDate( value ); }
-		}
-		
-		/// <summary>
-		/// Gets or sets the decimal year number (i.e., 1997.345) corresponding to this item.
-		/// </summary>
-		public double DecimalYear
-		{
-			get { return XLDateToDecimalYear( _xlDate ); }
-			set { _xlDate = DecimalYearToXLDate( value ); }
-		}
-	#endregion
-	
-	#region Get/Set Date Methods
-
-		/// <summary>
-		/// Returns true if the specified date value is in the valid range
-		/// </summary>
-		/// <param name="xlDate">The XL date value to be verified for validity</param>
-		/// <returns>true for a valid date, false otherwise</returns>
-		private static bool CheckValidDate( double xlDate )
-		{
-			return xlDate >= XLDayMin && xlDate <= XLDayMax;
-		}
-
-		/// <summary>
-		/// Take the specified date, and bound it to the valid date range for the XDate struct.
-		/// </summary>
-		/// <param name="xlDate">The date to be bounded</param>
-		/// <returns>An XLDate value that lies between the minimum and maximum valid date ranges
-		/// (see <see cref="XLDayMin" /> and <see cref="XLDayMax" />)</returns>
-		public static double MakeValidDate( double xlDate )
-		{
-			if ( xlDate < XLDayMin )
-				xlDate = XLDayMin;
-			if ( xlDate > XLDayMax )
-				xlDate = XLDayMax;
-			return xlDate;
-		}
-
-		/// <summary>
-		/// Get the calendar date (year, month, day) corresponding to this instance.
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.</param>
-		public void GetDate( out int year, out int month, out int day )
-		{
-			int hour, minute, second;
-			
-			XLDateToCalendarDate( _xlDate, out year, out month, out day, out hour, out minute, out second );
-		}
-		
-		/// <summary>
-		/// Set the calendar date (year, month, day) of this instance.
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.</param>
-		public void SetDate( int year, int month, int day )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, 0, 0, 0 );
-		}
-		
-		/// <summary>
-		/// Get the calendar date (year, month, day, hour, minute, second) corresponding
-		/// to this instance.
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.</param>
-		/// <param name="hour">An integer value for the hour of the day, e.g. 15.</param>
-		/// <param name="minute">An integer value for the minute, e.g. 45.</param>
-		/// <param name="second">An integer value for the second, e.g. 35.</param>
-		public void GetDate( out int year, out int month, out int day,
-						out int hour, out int minute, out int second )
-		{
-			XLDateToCalendarDate( _xlDate, out year, out month, out day, out hour, out minute, out second );
-		}
-
-		/// <summary>
-		/// Set the calendar date (year, month, day, hour, minute, second) of this instance.
-		/// </summary>
-		/// <param name="year">An integer value for the year, e.g., 1995.</param>
-		/// <param name="day">An integer value for the day of the month, e.g., 23.</param>
-		/// <param name="month">An integer value for the month of the year, e.g.,
-		/// 8 for August.</param>
-		/// <param name="hour">An integer value for the hour of the day, e.g. 15.</param>
-		/// <param name="minute">An integer value for the minute, e.g. 45.</param>
-		/// <param name="second">An integer value for the second, e.g. 35.</param>
-		public void SetDate( int year, int month, int day, int hour, int minute, int second )
-		{
-			_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second );
-		}
-		
-		/// <summary>
-		/// Get the day of year value (241.345 means the 241st day of the year)
-		/// corresponding to this instance.
-		/// </summary>
-		/// <returns>The day of the year in floating point double format.</returns>
-		public double GetDayOfYear()
-		{
-			return XLDateToDayOfYear( _xlDate );
-		}
-	#endregion
-	
-	#region Date Conversion Methods
-		// =========================================================================
-		// Conversion Routines
-		// =========================================================================
-	
-		/// <summary>
-		/// Calculate an XL Date from the specified Calendar date (year, month, day, hour, minute, second),
-		/// first normalizing all input data values.
-		/// </summary>
-		/// <remarks>
-		/// The Calendar date is always based on the Gregorian Calendar.  Note that the Gregorian calendar is really
-		/// only valid from October 15, 1582 forward.  The countries that adopted the Gregorian calendar
-		/// first did so on October 4, 1582, so that the next day was October 15, 1582.  Prior to that time
-		/// the Julian Calendar was used.  However, Prior to March 1, 4 AD the treatment of leap years was
-		/// inconsistent, and prior to 45 BC the Julian Calendar did not exist.  The <see cref="XDate"/>
-		/// struct projects only Gregorian dates backwards and does not deal with Julian calendar dates at all.  The
-		/// <see cref="ToString(double,string)"/> method will just append a "(BC)" notation to the end of any dates
-		/// prior to 1 AD, since the <see cref="DateTime"/> struct throws an exception when formatting earlier dates.
-		/// </remarks>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The integer millisecond value (e.g., 374 for 374 milliseconds past the second).
-		/// </param>
-		/// <returns>The corresponding XL date, expressed in double floating point format</returns>
-		public static double CalendarDateToXLDate( int year, int month, int day,
-			int hour, int minute, int second, int millisecond )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-			//double dsec = second + (double) millisecond / MillisecondsPerSecond;
-			double ms = millisecond;
-			NormalizeCalendarDate( ref year, ref month, ref day, ref hour, ref minute, ref second,
-						ref ms );
-		
-			return _CalendarDateToXLDate( year, month, day, hour, minute, second, ms );
-		}
-		
-		/// <summary>
-		/// Calculate an XL Date from the specified Calendar date (year, month, day, hour, minute, second),
-		/// first normalizing all input data values.
-		/// </summary>
-		/// <remarks>
-		/// The Calendar date is always based on the Gregorian Calendar.  Note that the Gregorian calendar is really
-		/// only valid from October 15, 1582 forward.  The countries that adopted the Gregorian calendar
-		/// first did so on October 4, 1582, so that the next day was October 15, 1582.  Prior to that time
-		/// the Julian Calendar was used.  However, Prior to March 1, 4 AD the treatment of leap years was
-		/// inconsistent, and prior to 45 BC the Julian Calendar did not exist.  The <see cref="XDate"/>
-		/// struct projects only Gregorian dates backwards and does not deal with Julian calendar dates at all.  The
-		/// <see cref="ToString(double,string)"/> method will just append a "(BC)" notation to the end of any dates
-		/// prior to 1 AD, since the <see cref="DateTime"/> struct throws an exception when formatting earlier dates.
-		/// </remarks>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <returns>The corresponding XL date, expressed in double floating point format</returns>
-		public static double CalendarDateToXLDate( int year, int month, int day,
-			int hour, int minute, int second )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-			double ms = 0;
-			NormalizeCalendarDate( ref year, ref month, ref day, ref hour, ref minute,
-					ref second, ref ms );
-		
-			return _CalendarDateToXLDate( year, month, day, hour, minute, second, ms );
-		}
-		
-		/// <summary>
-		/// Calculate an XL Date from the specified Calendar date (year, month, day, hour, minute, second),
-		/// first normalizing all input data values.  The seconds value is a double type, allowing fractional
-		/// seconds.
-		/// </summary>
-		/// <remarks>
-		/// The Calendar date is always based on the Gregorian Calendar.  Note that the Gregorian calendar is really
-		/// only valid from October 15, 1582 forward.  The countries that adopted the Gregorian calendar
-		/// first did so on October 4, 1582, so that the next day was October 15, 1582.  Prior to that time
-		/// the Julian Calendar was used.  However, Prior to March 1, 4 AD the treatment of leap years was
-		/// inconsistent, and prior to 45 BC the Julian Calendar did not exist.  The <see cref="XDate"/>
-		/// struct projects only Gregorian dates backwards and does not deal with Julian calendar dates at all.  The
-		/// <see cref="ToString(double,string)"/> method will just append a "(BC)" notation to the end of any dates
-		/// prior to 1 AD, since the <see cref="DateTime"/> struct throws an exception when formatting earlier dates.
-		/// </remarks>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The double second value (e.g., 42.3 for 42.3 seconds past the minute).
-		/// </param>
-		/// <returns>The corresponding XL date, expressed in double floating point format</returns>
-		public static double CalendarDateToXLDate( int year, int month, int day,
-			int hour, int minute, double second )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-			int sec = (int)second;
-			double ms = ( second - sec ) * MillisecondsPerSecond;
-			NormalizeCalendarDate( ref year, ref month, ref day, ref hour, ref minute, ref sec,
-					ref ms );
-		
-			return _CalendarDateToXLDate( year, month, day, hour, minute, sec, ms );
-		}
-		
-		/// <summary>
-		/// Calculate an Astronomical Julian Day number from the specified Calendar date
-		/// (year, month, day, hour, minute, second), first normalizing all input data values
-		/// </summary>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <returns>The corresponding Astronomical Julian Day number, expressed in double
-		/// floating point format</returns>
-		public static double CalendarDateToJulianDay( int year, int month, int day,
-			int hour, int minute, int second )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-			double ms = 0;
-			NormalizeCalendarDate( ref year, ref month, ref day, ref hour, ref minute,
-				ref second, ref ms );
-		
-			return _CalendarDateToJulianDay( year, month, day, hour, minute, second, ms );
-		}
-		
-		/// <summary>
-		/// Calculate an Astronomical Julian Day number from the specified Calendar date
-		/// (year, month, day, hour, minute, second), first normalizing all input data values
-		/// </summary>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The integer second value (e.g., 325 for 325 milliseconds past the minute).
-		/// </param>
-		/// <returns>The corresponding Astronomical Julian Day number, expressed in double
-		/// floating point format</returns>
-		public static double CalendarDateToJulianDay( int year, int month, int day,
-			int hour, int minute, int second, int millisecond )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-			double ms = millisecond;
-
-			NormalizeCalendarDate( ref year, ref month, ref day, ref hour, ref minute,
-						ref second, ref ms );
-		
-			return _CalendarDateToJulianDay( year, month, day, hour, minute, second, ms );
-		}
-		
-		/// <summary>
-		/// Normalize a set of Calendar date values (year, month, day, hour, minute, second) to make sure
-		/// that month is between 1 and 12, hour is between 0 and 23, etc.
-		/// </summary>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The double millisecond value (e.g., 325.3 for 325.3 milliseconds past the second).
-		/// </param>
-		private static void NormalizeCalendarDate( ref int year, ref int month, ref int day,
-											ref int hour, ref int minute, ref int second,
-											ref double millisecond )
-		{
-			// Normalize the data to allow for negative and out of range values
-			// In this way, setting month to zero would be December of the previous year,
-			// setting hour to 24 would be the first hour of the next day, etc.
-
-			// Normalize the milliseconds and carry over to seconds
-			int carry = (int)Math.Floor( millisecond / MillisecondsPerSecond );
-			millisecond -= carry * (int)MillisecondsPerSecond;
-			second += carry;
-
-			// Normalize the seconds and carry over to minutes
-			carry = (int)Math.Floor( second / SecondsPerMinute );
-			second -= carry * (int)SecondsPerMinute;
-			minute += carry;
-		
-			// Normalize the minutes and carry over to hours
-			carry = (int) Math.Floor( (double) minute / MinutesPerHour );
-			minute -= carry * (int) MinutesPerHour;
-			hour += carry;
-		
-			// Normalize the hours and carry over to days
-			carry = (int) Math.Floor( (double) hour / HoursPerDay );
-			hour -= carry * (int) HoursPerDay;
-			day += carry;
-		
-			// Normalize the months and carry over to years
-			carry = (int) Math.Floor( (double) month / MonthsPerYear );
-			month -= carry * (int) MonthsPerYear;
-			year += carry;
-		}
-		
-		/// <summary>
-		/// Calculate an XL date from the specified Calendar date (year, month, day, hour, minute, second).
-		/// This is the internal trusted version, where all values are assumed to be legitimate
-		/// ( month is between 1 and 12, minute is between 0 and 59, etc. )
-		/// </summary>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The double millisecond value (e.g., 325.3 for 325.3 milliseconds past the second).
-		/// </param>
-		/// <returns>The corresponding XL date, expressed in double floating point format</returns>
-		private static double _CalendarDateToXLDate( int year, int month, int day, int hour,
-					int minute, int second, double millisecond )
-		{
-			return JulianDayToXLDate( _CalendarDateToJulianDay( year, month, day, hour, minute,
-						second, millisecond ) );
-		}
-		
-		/// <summary>
-		/// Calculate an Astronomical Julian Day Number from the specified Calendar date
-		/// (year, month, day, hour, minute, second).
-		/// This is the internal trusted version, where all values are assumed to be legitimate
-		/// ( month is between 1 and 12, minute is between 0 and 59, etc. )
-		/// </summary>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The double millisecond value (e.g., 325.3 for 325.3 milliseconds past the second).
-		/// </param>
-		/// <returns>The corresponding Astronomical Julian Day number, expressed in double
-		/// floating point format</returns>
-		private static double _CalendarDateToJulianDay( int year, int month, int day, int hour,
-					int minute, int second, double millisecond )
-		{
-			// Taken from http://www.srrb.noaa.gov/highlights/sunrise/program.txt
-			// routine calcJD()
-		
-			if ( month <= 2 )
-			{
-				year -= 1;
-				month += 12;
-			}
-		
-			double A = Math.Floor( (double) year / 100.0 );
-			double B = 2 - A + Math.Floor( A / 4.0 );
-		
-			return	Math.Floor( 365.25 * ( (double) year + 4716.0 ) ) +
-					Math.Floor( 30.6001 * (double) ( month + 1 ) ) +
-					(double) day + B - 1524.5 +
-					hour  / HoursPerDay + minute / MinutesPerDay + second / SecondsPerDay +
-					millisecond / MillisecondsPerDay;
-		
-		}
-
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		public static void XLDateToCalendarDate( double xlDate, out int year, out int month,
-			out int day, out int hour, out int minute, out int second )
-		{
-			double jDay = XLDateToJulianDay( xlDate );
-			
-			JulianDayToCalendarDate( jDay, out year, out month, out day, out hour,
-				out minute, out second );
-		}
-		
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The integer millisecond value (e.g., 325 for 325 milliseconds past the second).
-		/// </param>
-		public static void XLDateToCalendarDate( double xlDate, out int year, out int month,
-			out int day, out int hour, out int minute, out int second, out int millisecond )
-		{
-			double jDay = XLDateToJulianDay( xlDate );
-			
-			double ms;
-			JulianDayToCalendarDate( jDay, out year, out month, out day, out hour,
-				out minute, out second, out ms );
-			millisecond = (int)ms;
-		}
-		
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The double second value (e.g., 42.3 for 42.3 seconds past the minute).
-		/// </param>
-		public static void XLDateToCalendarDate( double xlDate, out int year, out int month,
-			out int day, out int hour, out int minute, out double second )
-		{
-			double jDay = XLDateToJulianDay( xlDate );
-			
-			JulianDayToCalendarDate( jDay, out year, out month, out day, out hour,
-				out minute, out second );
-		}
-		
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the Astronomical Julian Day number
-		/// </summary>
-		/// <param name="jDay">
-		/// The Astronomical Julian Day number to be converted
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		public static void JulianDayToCalendarDate( double jDay, out int year, out int month,
-			out int day, out int hour, out int minute, out int second )
-		{
-			double ms = 0;
-
-			JulianDayToCalendarDate( jDay, out year, out month,
-					out day, out hour, out minute, out second, out ms );
-		}
-
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the Astronomical Julian Day number
-		/// </summary>
-		/// <param name="jDay">
-		/// The Astronomical Julian Day number to be converted
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The double second value (e.g., 42.3 for 42.3 seconds past the minute).
-		/// </param>
-		public static void JulianDayToCalendarDate( double jDay, out int year, out int month,
-			out int day, out int hour, out int minute, out double second )
-		{
-			int sec;
-			double ms;
-
-			JulianDayToCalendarDate( jDay, out year, out month,
-					out day, out hour, out minute, out sec, out ms );
-
-			second = sec + ms / MillisecondsPerSecond;
-		}
-
-		/// <summary>
-		/// Calculate a Calendar date (year, month, day, hour, minute, second) corresponding to
-		/// the Astronomical Julian Day number
-		/// </summary>
-		/// <param name="jDay">
-		/// The Astronomical Julian Day number to be converted
-		/// </param>
-		/// <param name="year">
-		/// The integer year value (e.g., 1994).
-		/// </param>
-		/// <param name="month">
-		/// The integer month value (e.g., 7 for July).
-		/// </param>
-		/// <param name="day">
-		/// The integer day value (e.g., 19 for the 19th day of the month).
-		/// </param>
-		/// <param name="hour">
-		/// The integer hour value (e.g., 14 for 2:00 pm).
-		/// </param>
-		/// <param name="minute">
-		/// The integer minute value (e.g., 35 for 35 minutes past the hour).
-		/// </param>
-		/// <param name="second">
-		/// The integer second value (e.g., 42 for 42 seconds past the minute).
-		/// </param>
-		/// <param name="millisecond">
-		/// The <see cref="System.Double" /> millisecond value (e.g., 342.5 for 342.5 milliseconds past
-		/// the second).
-		/// </param>
-		public static void JulianDayToCalendarDate( double jDay, out int year, out int month,
-			out int day, out int hour, out int minute, out int second, out double millisecond )
-		{
-			// add 5 ten-thousandths of a second to the day fraction to avoid roundoff errors
-			jDay += 0.0005 / SecondsPerDay;
-
-			double z = Math.Floor( jDay + 0.5);
-			double f = jDay + 0.5 - z;
-		
-			double alpha = Math.Floor( ( z - 1867216.25 ) / 36524.25 );
-			double A = z + 1.0 + alpha - Math.Floor( alpha / 4 );
-			double B = A + 1524.0;
-			double C = Math.Floor( ( B - 122.1 ) / 365.25 );
-			double D = Math.Floor( 365.25 * C );
-			double E = Math.Floor( ( B - D ) / 30.6001 );
-		
-			day = (int) Math.Floor( B - D - Math.Floor( 30.6001 * E ) + f );
-			month = (int) ( ( E < 14.0 ) ? E - 1.0 : E - 13.0 );
-			year = (int) ( ( month > 2 ) ? C - 4716 : C - 4715 );
-		
-			double fday =  ( jDay - 0.5 ) - Math.Floor( jDay - 0.5 );
-		
-			fday = ( fday - (long) fday ) * HoursPerDay;
-			hour = (int) fday;
-			fday = ( fday - (long) fday ) * MinutesPerHour;
-			minute = (int) fday;
-			fday = ( fday - (long) fday ) * SecondsPerMinute;
-			second = (int) fday;
-			fday = ( fday - (long) fday ) * MillisecondsPerSecond;
-			millisecond = fday;
-		}
-		
-		/// <summary>
-		/// Calculate an Astronomical Julian Day number corresponding to the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding Astronomical Julian Day number, expressed in double
-		/// floating point format</returns>
-		public static double XLDateToJulianDay( double xlDate )
-		{
-			return xlDate + XLDay1;
-		}
-		
-		/// <summary>
-		/// Calculate an XL Date corresponding to the specified Astronomical Julian Day number
-		/// </summary>
-		/// <param name="jDay">
-		/// The Astronomical Julian Day number in floating point double format.
-		/// </param>
-		/// <returns>The corresponding XL Date, expressed in double
-		/// floating point format</returns>
-		public static double JulianDayToXLDate( double jDay )
-		{
-			return jDay - XLDay1;
-		}
-		
-		/// <summary>
-		/// Calculate a decimal year value (e.g., 1994.6523) corresponding to the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding decimal year value, expressed in double
-		/// floating point format</returns>
-		public static double XLDateToDecimalYear( double xlDate )
-		{
-			int year, month, day, hour, minute, second;
-			
-			XLDateToCalendarDate( xlDate, out year, out month, out day, out hour, out minute, out second );
-			
-			double jDay1 = CalendarDateToJulianDay( year, 1, 1, 0, 0, 0 );
-			double jDay2 = CalendarDateToJulianDay( year + 1, 1, 1, 0, 0, 0 );
-			double jDayMid = CalendarDateToJulianDay( year, month, day, hour, minute, second );
-			
-			
-			return (double) year + ( jDayMid - jDay1 ) / ( jDay2 - jDay1 );
-		}
-		
-		/// <summary>
-		/// Calculate a decimal year value (e.g., 1994.6523) corresponding to the specified XL date
-		/// </summary>
-		/// <param name="yearDec">
-		/// The decimal year value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding XL Date, expressed in double
-		/// floating point format</returns>
-		public static double DecimalYearToXLDate( double yearDec )
-		{
-			int year = (int) yearDec;
-			
-			double jDay1 = CalendarDateToJulianDay( year, 1, 1, 0, 0, 0 );
-			double jDay2 = CalendarDateToJulianDay( year + 1, 1, 1, 0, 0, 0 );
-			
-			return JulianDayToXLDate( ( yearDec - (double) year ) * ( jDay2 - jDay1 ) + jDay1 );
-		}
-		
-		/// <summary>
-		/// Calculate a day-of-year value (e.g., 241.543 corresponds to the 241st day of the year)
-		/// corresponding to the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding day-of-year (DoY) value, expressed in double
-		/// floating point format</returns>
-		public static double XLDateToDayOfYear( double xlDate )
-		{
-			int year, month, day, hour, minute, second;
-			XLDateToCalendarDate( xlDate, out year, out month, out day,
-									out hour, out minute, out second );
-			return XLDateToJulianDay( xlDate ) - CalendarDateToJulianDay( year, 1, 1, 0, 0, 0 ) + 1.0;
-		}
-		
-		/// <summary>
-		/// Calculate a day-of-week value (e.g., Sun=0, Mon=1, Tue=2, etc.)
-		/// corresponding to the specified XL date
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding day-of-week (DoW) value, expressed in integer format</returns>
-		public static int XLDateToDayOfWeek( double xlDate )
-		{
-			return (int) ( XLDateToJulianDay( xlDate ) + 1.5 ) % 7;
-		}
-		
-		/// <summary>
-		/// Convert an XL date format to a .Net DateTime struct
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value in floating point double format.
-		/// </param>
-		/// <returns>The corresponding XL Date, expressed in double
-		/// floating point format</returns>
-		/// <returns>The corresponding date in the form of a .Net DateTime struct</returns>
-		public static DateTime XLDateToDateTime( double xlDate )
-		{
-			int year, month, day, hour, minute, second, millisecond;
-			XLDateToCalendarDate( xlDate, out year, out month, out day,
-									out hour, out minute, out second, out millisecond );
-			return new DateTime( year, month, day, hour, minute, second, millisecond );
-		}
-		
-		/// <summary>
-		/// Convert a .Net DateTime struct to an XL Format date
-		/// </summary>
-		/// <param name="dt">
-		/// The date value in the form of a .Net DateTime struct
-		/// </param>
-		/// <returns>The corresponding XL Date, expressed in double
-		/// floating point format</returns>
-		public static double DateTimeToXLDate( DateTime dt )
-		{
-			return CalendarDateToXLDate( dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second,
-										dt.Millisecond );
-		}
-	#endregion
-	
-	#region Date Math Methods
-		// =========================================================================
-		// Math Routines
-		// =========================================================================
-
-		/// <summary>
-		/// Add the specified number of milliseconds (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dMilliseconds">
-		/// The incremental number of milliseconds (negative or positive) in floating point double format.
-		/// </param>
-		public void AddMilliseconds( double dMilliseconds )
-		{
-			_xlDate += dMilliseconds / MillisecondsPerDay;
-		}
-
-		/// <summary>
-		/// Add the specified number of seconds (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dSeconds">
-		/// The incremental number of seconds (negative or positive) in floating point double format.
-		/// </param>
-		public void AddSeconds( double dSeconds )
-		{
-			_xlDate += dSeconds / SecondsPerDay;
-		}
-
-		/// <summary>
-		/// Add the specified number of minutes (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dMinutes">
-		/// The incremental number of minutes (negative or positive) in floating point double format.
-		/// </param>
-		public void AddMinutes( double dMinutes )
-		{
-			_xlDate += dMinutes / MinutesPerDay;
-		}
-		
-		/// <summary>
-		/// Add the specified number of hours (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dHours">
-		/// The incremental number of hours (negative or positive) in floating point double format.
-		/// </param>
-		public void AddHours( double dHours )
-		{
-			_xlDate += dHours / HoursPerDay;
-		}
-		
-		/// <summary>
-		/// Add the specified number of days (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dDays">
-		/// The incremental number of days (negative or positive) in floating point double format.
-		/// </param>
-		public void AddDays( double dDays )
-		{
-			_xlDate += dDays;
-		}
-		
-		/// <summary>
-		/// Add the specified number of Months (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dMonths">
-		/// The incremental number of months (negative or positive) in floating point double format.
-		/// </param>
-		public void AddMonths( double dMonths )
-		{
-			int iMon = (int) dMonths;
-			double monFrac = Math.Abs( dMonths - (double) iMon );
-			int sMon = Math.Sign( dMonths );
-			
-			int year, month, day, hour, minute, second;
-			
-			XLDateToCalendarDate( _xlDate, out year, out month, out day, out hour, out minute, out second );
-			if ( iMon != 0 )
-			{
-				month += iMon;
-				_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second );
-			}
-			
-			if ( sMon != 0 )
-			{
-				double xlDate2 = CalendarDateToXLDate( year, month+sMon, day, hour, minute, second );
-				_xlDate += (xlDate2 - _xlDate) * monFrac;
-			}
-		}
-		
-		/// <summary>
-		/// Add the specified number of years (can be fractional) to the current XDate instance.
-		/// </summary>
-		/// <param name="dYears">
-		/// The incremental number of years (negative or positive) in floating point double format.
-		/// </param>
-		public void AddYears( double dYears )
-		{
-			int iYear = (int) dYears;
-			double yearFrac = Math.Abs( dYears - (double) iYear );
-			int sYear = Math.Sign( dYears );
-			
-			int year, month, day, hour, minute, second;
-			
-			XLDateToCalendarDate( _xlDate, out year, out month, out day, out hour, out minute, out second );
-			if ( iYear != 0 )
-			{
-				year += iYear;
-				_xlDate = CalendarDateToXLDate( year, month, day, hour, minute, second );
-			}
-			
-			if ( sYear != 0 )
-			{
-				double xlDate2 = CalendarDateToXLDate( year+sYear, month, day, hour, minute, second );
-				_xlDate += (xlDate2 - _xlDate) * yearFrac;
-			}
-		}
-	#endregion
-	
-	#region Operator Overload Methods
-		// =========================================================================
-		// Operator Overloads
-		// =========================================================================
-	
-		/// <summary>
-		/// '-' operator overload.  When two XDates are subtracted, the number of days between dates
-		/// is returned.
-		/// </summary>
-		/// <param name="lhs">The left-hand-side of the '-' operator (an XDate class)</param>
-		/// <param name="rhs">The right-hand-side of the '-' operator (an XDate class)</param>
-		/// <returns>The days between dates, expressed as a floating point double</returns>
-		public static double operator -( XDate lhs, XDate rhs )
-		{
-			return lhs.XLDate - rhs.XLDate;
-		}
-		
-		/// <summary>
-		/// '-' operator overload.  When a double value is subtracted from an XDate, the result is a
-		/// new XDate with the number of days subtracted.
-		/// </summary>
-		/// <param name="lhs">The left-hand-side of the '-' operator (an XDate class)</param>
-		/// <param name="rhs">The right-hand-side of the '-' operator (a double value)</param>
-		/// <returns>An XDate with the rhs number of days subtracted</returns>
-		public static XDate operator -( XDate lhs, double rhs )
-		{
-			lhs._xlDate -= rhs;
-			return lhs;
-		}
-		
-		/// <summary>
-		/// '+' operator overload.  When a double value is added to an XDate, the result is a
-		/// new XDate with the number of days added.
-		/// </summary>
-		/// <param name="lhs">The left-hand-side of the '-' operator (an XDate class)</param>
-		/// <param name="rhs">The right-hand-side of the '+' operator (a double value)</param>
-		/// <returns>An XDate with the rhs number of days added</returns>
-		public static XDate operator +( XDate lhs, double rhs )
-		{
-			lhs._xlDate += rhs;
-			return lhs;
-		}
-		
-		/// <summary>
-		/// '++' operator overload.  Increment the date by one day.
-		/// </summary>
-		/// <param name="xDate">The XDate struct on which to operate</param>
-		/// <returns>An XDate one day later than the specified date</returns>
-		public static XDate operator ++( XDate xDate )
-		{
-			xDate._xlDate += 1.0;
-			return xDate;
-		}
-		
-		/// <summary>
-		/// '--' operator overload.  Decrement the date by one day.
-		/// </summary>
-		/// <param name="xDate">The XDate struct on which to operate</param>
-		/// <returns>An XDate one day prior to the specified date</returns>
-		public static XDate operator --( XDate xDate )
-		{
-			xDate._xlDate -= 1.0;
-			return xDate;
-		}
-		
-		/// <summary>
-		/// Implicit conversion from XDate to double (an XL Date).
-		/// </summary>
-		/// <param name="xDate">The XDate struct on which to operate</param>
-		/// <returns>A double floating point value representing the XL Date</returns>
-		public static implicit operator double( XDate xDate )
-		{
-			return xDate._xlDate;
-		}
-		
-		/// <summary>
-		/// Implicit conversion from XDate to float (an XL Date).
-		/// </summary>
-		/// <param name="xDate">The XDate struct on which to operate</param>
-		/// <returns>A double floating point value representing the XL Date</returns>
-		public static implicit operator float( XDate xDate )
-		{
-			return (float) xDate._xlDate;
-		}
-		
-		/// <summary>
-		/// Implicit conversion from double (an XL Date) to XDate.
-		/// </summary>
-		/// <param name="xlDate">The XDate struct on which to operate</param>
-		/// <returns>An XDate struct representing the specified xlDate value.</returns>
-		public static implicit operator XDate( double xlDate )
-		{
-			return new XDate( xlDate );
-		}
-		
-		/// <summary>
-		/// Implicit conversion from XDate to <see cref="DateTime"/>.
-		/// </summary>
-		/// <param name="xDate">The XDate struct on which to operate</param>
-		/// <returns>A <see cref="DateTime"/> struct representing the specified xDate value.</returns>
-		public static implicit operator DateTime( XDate xDate )
-		{
-			
-			return XLDateToDateTime( xDate );
-		}
-		
-		/// <summary>
-		/// Implicit conversion from <see cref="DateTime"/> to <see cref="XDate"/>.
-		/// </summary>
-		/// <param name="dt">The <see cref="DateTime"/> struct on which to operate</param>
-		/// <returns>An <see cref="XDate"/> struct representing the specified DateTime value.</returns>
-		public static implicit operator XDate( DateTime dt )
-		{
-			
-			return new XDate( DateTimeToXLDate( dt ) );
-		}
-	#endregion
-		
-	#region General Overrides
-		// =========================================================================
-		// System Stuff
-		// =========================================================================
-
-		/// <summary>
-		/// Tests whether <param>obj</param> is either an <see cref="XDate"/> structure or
-		/// a double floating point value that is equal to the same date as this <c>XDate</c>
-		/// struct instance.
-		/// </summary>
-		/// <param name="obj">The object to compare for equality with this XDate instance.
-		/// This object should be either a type XDate or type double.</param>
-		/// <returns>Returns <c>true</c> if <param>obj</param> is the same date as this
-		/// instance; otherwise, <c>false</c></returns>
-		public override bool Equals( object obj )
-		{
-			if ( obj is XDate )
-			{
-				return ((XDate) obj)._xlDate == _xlDate;
-			}
-			else if ( obj is double )
-			{
-				return ((double) obj) == _xlDate;
-			}
-			else
-				return false;
-		}
-		
-		/// <summary>
-		/// Returns the hash code for this <see cref="XDate"/> structure.  In this case, the
-		/// hash code is simply the equivalent hash code for the floating point double date value.
-		/// </summary>
-		/// <returns>An integer representing the hash code for this XDate value</returns>
-		public override int GetHashCode()
-		{
-			return _xlDate.GetHashCode();
-		}
-
-		/// <summary>
-		/// Compares one <see cref="XDate" /> object to another.
-		/// </summary>
-		/// <remarks>
-		/// This method will throw an exception if <paramref name="target"/> is not an
-		/// <see cref="XDate"/> object.
-		/// </remarks>
-		/// <param name="target">The second <see cref="XDate" /> object to be compared.</param>
-		/// <returns>zero if <paramref name="target" /> is equal to the current instance,
-		/// -1 if <paramref name="target"/> is less than the current instance, and
-		/// 1 if <paramref name="target"/> is greater than the current instance.</returns>
-		public int CompareTo( object target )
-		{
-			if ( ! (target is XDate) )
-				throw new ArgumentException();
-
-			return ( this.XLDate ).CompareTo( ((XDate)target).XLDate );
-		}
-
-	#endregion
-	
-	#region String Format Conversion Methods
-		// =========================================================================
-		// String Formatting Routines
-		// =========================================================================
-	
-		/// <summary>
-		/// Format this XDate value using the default format string (<see cref="DefaultFormatStr"/>).
-		/// </summary>
-		/// <remarks>
-		/// The formatting is done using the <see cref="DateTime"/> <see cref="System.DateTime.ToString(string)"/>
-		/// method in order to provide full localization capability.  The DateTime struct is limited to
-		/// dates from 1 AD onward.  However, all calendar dates in <see cref="XDate"/> and <see cref="DateTime"/>
-		/// are projected Gregorian calendar dates.  Since the Gregorian calendar was not implemented
-		/// until October 4, 1582 (or later in some countries), Gregorian dates prior to that time are
-		/// really dates that would have been, had the Gregorian calendar existed.  In order to avoid
-		/// throwing an exception, for dates prior to 1 AD, the year will be converted to a positive
-		/// year and the text "(BC)" is appended to the end of the formatted string.  Under this mode, the
-		/// year sequence is 2BC, 1BC, 1AD, 2AD, etc.  There is no year zero.
-		/// </remarks>
-		/// <param name="xlDate">
-		/// The XL date value to be formatted in floating point double format.
-		/// </param>
-		/// <returns>A string representation of the date</returns>
-		public string ToString( double xlDate )
-		{
-			return ToString( xlDate, DefaultFormatStr );
-		}
-		
-		/// <summary>
-		/// Format this XDate value using the default format string (see cref="DefaultFormatStr"/>).
-		/// </summary>
-		/// <remarks>
-		/// The formatting is done using the <see cref="DateTime" />
-		/// <see cref="System.DateTime.ToString(String)" />
-		/// method in order to provide full localization capability.  The DateTime struct is limited to
-		/// dates from 1 AD onward.  However, all calendar dates in <see cref="XDate" /> and
-		/// <see cref="DateTime" />
-		/// are projected Gregorian calendar dates.  Since the Gregorian calendar was not implemented
-		/// until October 4, 1582 (or later in some countries), Gregorian dates prior to that time are
-		/// really dates that would have been, had the Gregorian calendar existed.  In order to avoid
-		/// throwing an exception, for dates prior to 1 AD, the year will be converted to a positive
-		/// year and the text "(BC)" is appended to the end of the formatted string.  Under this mode, the
-		/// year sequence is 2BC, 1BC, 1AD, 2AD, etc.  There is no year zero.
-		/// </remarks>
-		/// <returns>A string representation of the date</returns>
-		public override string ToString()
-		{
-			return ToString( _xlDate, DefaultFormatStr );
-		}
-		
-		/// <summary>
-		/// Format this XL Date value using the specified format string.  The format
-		/// string is specified according to the <see cref="DateTime"/> class.
-		/// </summary>
-		/// <remarks>
-		/// The formatting is done using the <see cref="DateTime" />
-		/// <see cref="System.DateTime.ToString(String)" />
-		/// method in order to provide full localization capability.  The DateTime struct is limited to
-		/// dates from 1 AD onward.  However, all calendar dates in <see cref="XDate" /> and
-		/// <see cref="DateTime" />
-		/// are projected Gregorian calendar dates.  Since the Gregorian calendar was not implemented
-		/// until October 4, 1582 (or later in some countries), Gregorian dates prior to that time are
-		/// really dates that would have been, had the Gregorian calendar existed.  In order to avoid
-		/// throwing an exception, for dates prior to 1 AD, the year will be converted to a positive
-		/// year and the text "(BC)" is appended to the end of the formatted string.  Under this mode, the
-		/// year sequence is 2BC, 1BC, 1AD, 2AD, etc.  There is no year zero.
-		/// </remarks>
-		/// <param name="fmtStr">
-		/// The formatting string to be used for the date.  See
-		/// <see cref="System.Globalization.DateTimeFormatInfo" />
-		/// class for a list of the format types available.</param>
-		/// <returns>A string representation of the date</returns>
-		public string ToString( string fmtStr )
-		{
-			return ToString( this.XLDate, fmtStr );
-		}
-
-		/// <summary>
-		/// Format the specified XL Date value using the specified format string.  The format
-		/// string is specified according to the <see cref="DateTime" /> class.
-		/// </summary>
-		/// <remarks>
-		/// The formatting is done using the <see cref="DateTime" />
-		/// <see cref="System.DateTime.ToString(String)" />
-		/// method in order to provide full localization capability.  The DateTime struct is limited to
-		/// dates from 1 AD onward.  However, all calendar dates in <see cref="XDate" /> and
-		/// <see cref="DateTime" />
-		/// are projected Gregorian calendar dates.  Since the Gregorian calendar was not implemented
-		/// until October 4, 1582 (or later in some countries), Gregorian dates prior to that time are
-		/// really dates that would have been, had the Gregorian calendar existed.  In order to avoid
-		/// throwing an exception, for dates prior to 1 AD, the year will be converted to a positive
-		/// year and the text "(BC)" is appended to the end of the formatted string.  Under this mode, the
-		/// year sequence is 2BC, 1BC, 1AD, 2AD, etc.  There is no year zero.
-		/// </remarks>
-		/// <param name="xlDate">
-		/// The XL date value to be formatted in floating point double format.
-		/// </param>
-		/// <param name="fmtStr">
-		/// The formatting string to be used for the date.  See
-		/// <see cref="System.Globalization.DateTimeFormatInfo" />
-		/// for a list of the format types available.</param>
-		/// <returns>A string representation of the date</returns>
-		public static string ToString( double xlDate, string fmtStr )
-		{
-			int		year, month, day, hour, minute, second, millisecond;
-
-			if ( !CheckValidDate( xlDate ) )
-				return "Date Error";
-
-			XLDateToCalendarDate( xlDate, out year, out month, out day, out hour, out minute,
-											out second, out millisecond );
-			if ( year <= 0 )
-			{
-				year = 1 - year;
-				fmtStr = fmtStr + " (BC)";
-			}
-
-			if ( fmtStr.IndexOf("[d]") >= 0 )
-			{
-				fmtStr = fmtStr.Replace( "[d]", ((int) xlDate).ToString() );
-				xlDate -= (int) xlDate;
-			}
-			if ( fmtStr.IndexOf("[h]") >= 0 || fmtStr.IndexOf("[hh]") >= 0 )
-			{
-				fmtStr = fmtStr.Replace( "[h]", ((int) (xlDate * 24)).ToString("d") );
-				fmtStr = fmtStr.Replace( "[hh]", ((int) (xlDate * 24)).ToString("d2") );
-				xlDate = ( xlDate * 24 - (int) (xlDate * 24) ) / 24.0;
-			}
-			if ( fmtStr.IndexOf("[m]") >= 0 || fmtStr.IndexOf("[mm]") >= 0 )
-			{
-				fmtStr = fmtStr.Replace( "[m]", ((int) (xlDate * 1440)).ToString("d") );
-				fmtStr = fmtStr.Replace( "[mm]", ((int) (xlDate * 1440)).ToString("d2") );
-				xlDate = ( xlDate * 1440 - (int) (xlDate * 1440) ) / 1440.0;
-			}
-			if ( fmtStr.IndexOf("[s]") >= 0 || fmtStr.IndexOf("[ss]") >= 0 )
-			{
-				fmtStr = fmtStr.Replace( "[s]", ((int) (xlDate * 86400)).ToString("d") );
-				fmtStr = fmtStr.Replace( "[ss]", ((int) (xlDate * 86400)).ToString("d2") );
-				xlDate = ( xlDate * 86400 - (int) (xlDate * 86400) ) / 86400.0;
-			}
-			if ( fmtStr.IndexOf("[f]") >= 0 )
-				fmtStr = fmtStr.Replace( "[f]", ((int) (xlDate * 864000)).ToString("d") );
-			if ( fmtStr.IndexOf("[ff]") >= 0 )
-				fmtStr = fmtStr.Replace( "[ff]", ((int) (xlDate * 8640000)).ToString("d") );
-			if ( fmtStr.IndexOf("[fff]") >= 0 )
-				fmtStr = fmtStr.Replace( "[fff]", ((int) (xlDate * 86400000)).ToString("d") );
-			if ( fmtStr.IndexOf("[ffff]") >= 0 )
-				fmtStr = fmtStr.Replace( "[ffff]", ((int) (xlDate * 864000000)).ToString("d") );
-			if ( fmtStr.IndexOf("[fffff]") >= 0 )
-				fmtStr = fmtStr.Replace( "[fffff]", ((int) (xlDate * 8640000000)).ToString("d") );
-
-			//DateTime dt = XLDateToDateTime( xlDate );
-			if ( year > 9999 )
-				year = 9999;
-			DateTime dt = new DateTime( year, month, day, hour, minute, second, millisecond );
-			return dt.ToString( fmtStr );
-		}
-
-/*
-		/// <summary>
-		/// Format this XDate value using the specified format string
-		/// </summary>
-		/// <param name="fmtStr">
-		/// The formatting string to be used for the date.  The following formatting elements
-		/// will be replaced with the corresponding date values:
-		/// <list type="table">
-		///    <listheader>
-		///       <term>Variable</term>
-		///       <description>Description</description>
-		///    </listheader>
-		///    <item><term>&amp;mmmm</term><description>month name (e.g., January)</description></item>
-		///    <item><term>&amp;mmm</term><description>month abbreviation (e.g., Apr)</description></item>
-		///    <item><term>&amp;mm</term><description>padded month number (e.g. 04)</description></item>
-		///    <item><term>&amp;m</term><description>non-padded month number (e.g., 4)</description></item>
-		///    <item><term>&amp;dd</term><description>padded day number (e.g., 09)</description></item>
-		///    <item><term>&amp;d</term><description>non-padded day number (e.g., 9)</description></item>
-		///    <item><term>&amp;yyyy</term><description>4 digit year number (e.g., 1995)</description></item>
-		///    <item><term>&amp;yy</term><description>two digit year number (e.g., 95)</description></item>
-		///    <item><term>&amp;hh</term><description>padded 24 hour time value (e.g., 08)</description></item>
-		///    <item><term>&amp;h</term><description>non-padded 12 hour time value (e.g., 8)</description></item>
-		///    <item><term>&amp;nn</term><description>padded minute value (e.g, 05)</description></item>
-		///    <item><term>&amp;n</term><description>non-padded minute value (e.g., 5)</description></item>
-		///    <item><term>&amp;ss</term><description>padded second value (e.g., 03)</description></item>
-		///    <item><term>&amp;s</term><description>non-padded second value (e.g., 3)</description></item>
-		///    <item><term>&amp;a</term><description>"am" or "pm"</description></item>
-		///    <item><term>&amp;wwww</term><description>day of week (e.g., Wednesday)</description></item>
-		///    <item><term>&amp;www</term><description>day of week abbreviation (e.g., Wed)</description></item>
-		/// </list>
-		/// </param>
-		/// <example>
-		///   <para>"&amp;wwww, &amp;mmmm &amp;dd, &amp;yyyy &amp;h:&amp;nn &amp;a" ==> "Sunday, February 12, 1956 4:23 pm"</para>
-		///   <para>"&amp;dd-&amp;mmm-&amp;yy" ==> 12-Feb-56</para>
-		/// </example>
-		/// <returns>A string representation of the date</returns>
-		public string ToString( string fmtStr )
-		{
-			return ToString( this.xlDate, fmtStr );
-		}
-
-		/// <summary>
-		/// Format the specified XL Date value using the specified format string
-		/// </summary>
-		/// <param name="xlDate">
-		/// The XL date value to be formatted in floating point double format.
-		/// </param>
-		/// <param name="fmtStr">
-		/// The formatting string to be used for the date.  The following formatting elements
-		/// will be replaced with the corresponding date values:
-		/// <list type="table">
-		///    <listheader>
-		///       <term>Variable</term>
-		///       <description>Description</description>
-		///    </listheader>
-		///    <item><term>&amp;mmmm</term><description>month name (e.g., January)</description></item>
-		///    <item><term>&amp;mmm</term><description>month abbreviation (e.g., Apr)</description></item>
-		///    <item><term>&amp;mm</term><description>padded month number (e.g. 04)</description></item>
-		///    <item><term>&amp;m</term><description>non-padded month number (e.g., 4)</description></item>
-		///    <item><term>&amp;dd</term><description>padded day number (e.g., 09)</description></item>
-		///    <item><term>&amp;d</term><description>non-padded day number (e.g., 9)</description></item>
-		///    <item><term>&amp;yyyy</term><description>4 digit year number (e.g., 1995)</description></item>
-		///    <item><term>&amp;yy</term><description>two digit year number (e.g., 95)</description></item>
-		///    <item><term>&amp;hh</term><description>padded 24 hour time value (e.g., 08)</description></item>
-		///    <item><term>&amp;h</term><description>non-padded 12 hour time value (e.g., 8)</description></item>
-		///    <item><term>&amp;nn</term><description>padded minute value (e.g, 05)</description></item>
-		///    <item><term>&amp;n</term><description>non-padded minute value (e.g., 5)</description></item>
-		///    <item><term>&amp;ss</term><description>padded second value (e.g., 03)</description></item>
-		///    <item><term>&amp;s</term><description>non-padded second value (e.g., 3)</description></item>
-		///    <item><term>&amp;a</term><description>"am" or "pm"</description></item>
-		///    <item><term>&amp;wwww</term><description>day of week (e.g., Wednesday)</description></item>
-		///    <item><term>&amp;www</term><description>day of week abbreviation (e.g., Wed)</description></item>
-		/// </list>
-		/// </param>
-		/// <example>
-		///   <para>"&amp;wwww, &amp;mmmm &amp;dd, &amp;yyyy &amp;h:&amp;nn &amp;a" ==> "Sunday, February 12, 1956 4:23 pm"</para>
-		///   <para>"&amp;dd-&amp;mmm-&amp;yy" ==> 12-Feb-56</para>
-		/// </example>
-		/// <returns>A string representation of the date</returns>
-		public static string ToString( double xlDate, string fmtStr )
-		{
-			string[] longMonth = { "January", "February", "March", "April", "May", "June",
-						"July", "August", "September", "October", "November", "December" };
-			string[] shortMonth = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-						"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-			string[] longDoW = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
-								"Friday", "Saturday" };
-			string[] shortDoW = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-						
-			int year, month, day, hour, minute, second;
-			XLDateToCalendarDate( xlDate, out year, out month, out day, out hour, out minute, out second );
-			
-			string resultStr = fmtStr.Replace( "&mmmm", longMonth[ month - 1 ] );
-			resultStr = resultStr.Replace( "&mmm", shortMonth[ month - 1 ] );
-			resultStr = resultStr.Replace( "&mm", month.ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&m", month.ToString( "d" ) );
-			resultStr = resultStr.Replace( "&yyyy", year.ToString( "d" ) );
-			resultStr = resultStr.Replace( "&yy", (year%100).ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&dd", day.ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&d", day.ToString( "d" ) );
-			resultStr = resultStr.Replace( "&hh", hour.ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&h", (((hour+11)%12)+1).ToString( "d" ) );
-			resultStr = resultStr.Replace( "&nn", minute.ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&n", minute.ToString( "d" ) );
-			resultStr = resultStr.Replace( "&ss", second.ToString( "d2" ) );
-			resultStr = resultStr.Replace( "&s", second.ToString( "d" ) );
-			resultStr = resultStr.Replace( "&a", (hour>=12) ? "pm" : "am" );
-			resultStr = resultStr.Replace( "&wwww", longDoW[ XLDateToDayOfWeek( xlDate ) ] );
-			resultStr = resultStr.Replace( "&www", shortDoW[ XLDateToDayOfWeek( xlDate ) ] );
-			
-			
-			return resultStr;
-		}
-*/		
-
-	#endregion
-	}
-}
diff --git a/BDInfo/ZedGraph/Y2Axis.cs b/BDInfo/ZedGraph/Y2Axis.cs
deleted file mode 100644
index 90d7c4af4b..0000000000
--- a/BDInfo/ZedGraph/Y2Axis.cs
+++ /dev/null
@@ -1,255 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// <see cref="Y2Axis"/> inherits from <see cref="Axis"/>, and defines the
-	/// special characteristics of a vertical axis, specifically located on
-	/// the right side of the <see cref="Chart.Rect"/> of the <see cref="GraphPane"/>
-	/// object
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.16 $ $Date: 2007/04/16 00:03:05 $ </version>
-	[Serializable]
-	public class Y2Axis : Axis, ICloneable, ISerializable
-	{
-		#region Defaults
-		/// <summary>
-		/// A simple subclass of the <see cref="Default"/> class that defines the
-		/// default property values for the <see cref="Y2Axis"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			// Default Y2 Axis properties
-			/// <summary>
-			/// The default display mode for the <see cref="Y2Axis"/>
-			/// (<see cref="Axis.IsVisible"/> property). true to display the scale
-			/// values, title, tic marks, false to hide the axis entirely.
-			/// </summary>
-			public static bool IsVisible = false;
-			/// <summary>
-			/// Determines if a line will be drawn at the zero value for the 
-			/// <see cref="Y2Axis"/>, that is, a line that
-			/// divides the negative values from positive values.
-			/// <seealso cref="MajorGrid.IsZeroLine"/>.
-			/// </summary>
-			public static bool IsZeroLine = true;
-		}
-		#endregion
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="Y2Axis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class
-		/// </summary>
-		public Y2Axis()
-			: this( "Y2 Axis" )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="Y2Axis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class, except
-		/// for the axis title
-		/// </summary>
-		/// <param name="title">The <see cref="Axis.Title"/> for this axis</param>
-		public Y2Axis( string title )
-			: base( title )
-		{
-			_isVisible = Default.IsVisible;
-			_majorGrid._isZeroLine = Default.IsZeroLine;
-			_scale._fontSpec.Angle = -90.0F;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The Y2Axis object from which to copy</param>
-		public Y2Axis( Y2Axis rhs )
-			: base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Y2Axis Clone()
-		{
-			return new Y2Axis( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected Y2Axis( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-		#endregion
-
-		#region Methods
-
-		/// <summary>
-		/// Setup the Transform Matrix to handle drawing of this <see cref="Y2Axis"/>
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void SetTransformMatrix( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			// Move the origin to the BottomRight of the ChartRect, which is the left
-			// side of the Y2 axis (facing from the label side)
-			g.TranslateTransform( pane.Chart._rect.Right, pane.Chart._rect.Bottom );
-			// rotate so this axis is in the left-right direction
-			g.RotateTransform( -90 );
-		}
-
-		/// <summary>
-		/// Determines if this <see cref="Axis" /> object is a "primary" one.
-		/// </summary>
-		/// <remarks>
-		/// The primary axes are the <see cref="XAxis" /> (always), the first
-		/// <see cref="YAxis" /> in the <see cref="GraphPane.YAxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0),  and the first
-		/// <see cref="Y2Axis" /> in the <see cref="GraphPane.Y2AxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0).  Note that
-		/// <see cref="GraphPane.YAxis" /> and <see cref="GraphPane.Y2Axis" />
-		/// always reference the primary axes.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>true for a primary <see cref="Axis" />, false otherwise</returns>
-		override internal bool IsPrimary( GraphPane pane )
-		{
-			return this == pane.Y2Axis;
-		}
-
-		/// <summary>
-		/// Calculate the "shift" size, in pixels, in order to shift the axis from its default
-		/// location to the value specified by <see cref="Axis.Cross"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>The shift amount measured in pixels</returns>
-		internal override float CalcCrossShift( GraphPane pane )
-		{
-			double effCross = EffectiveCrossValue( pane );
-
-			if ( !_crossAuto )
-				return pane.XAxis.Scale.Transform( effCross ) - pane.XAxis.Scale._maxPix;
-			else
-				return 0;
-		}
-		/*
-				override internal bool IsCrossed( GraphPane pane )
-				{
-					return !this.crossAuto && this.cross > pane.XAxis.Min && this.cross < pane.XAxis.Max;
-				}
-		*/
-		/// <summary>
-		/// Gets the "Cross" axis that corresponds to this axis.
-		/// </summary>
-		/// <remarks>
-		/// The cross axis is the axis which determines the of this Axis when the
-		/// <see cref="Axis.Cross" >Axis.Cross</see> property is used.  The
-		/// cross axis for any <see cref="XAxis" /> or <see cref="X2Axis" />
-		/// is always the primary <see cref="YAxis" />, and
-		/// the cross axis for any <see cref="YAxis" /> or <see cref="Y2Axis" /> is
-		/// always the primary <see cref="XAxis" />.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		override public Axis GetCrossAxis( GraphPane pane )
-		{
-			return pane.XAxis;
-		}
-
-//		override internal float GetMinPix( GraphPane pane )
-//		{
-//			return pane.Chart._rect.Top;
-//		}
-
-		#endregion
-
-	}
-}
-
diff --git a/BDInfo/ZedGraph/Y2AxisList.cs b/BDInfo/ZedGraph/Y2AxisList.cs
deleted file mode 100644
index d269233785..0000000000
--- a/BDInfo/ZedGraph/Y2AxisList.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="YAxis"/> objects.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.3 $ $Date: 2006/06/24 20:26:43 $ </version>
-	[Serializable]
-	public class Y2AxisList : List<Y2Axis>, ICloneable
-	{
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor for the collection class.
-		/// </summary>
-		public Y2AxisList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="Y2AxisList"/> object from which to copy</param>
-		public Y2AxisList( Y2AxisList rhs )
-		{
-			foreach ( Y2Axis item in rhs )
-			{
-				this.Add( item.Clone() );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public Y2AxisList Clone()
-		{
-			return new Y2AxisList( this );
-		}
-
-		#endregion
-
-		#region List Methods
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="Axis"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="YAxis"/> object to be accessed.</param>
-		/// <value>An <see cref="Axis"/> object reference.</value>
-		public new Y2Axis this[int index]
-		{
-			get { return ( ( ( index < 0 || index >= this.Count ) ? null : base[index] ) ); }
-		}
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="Axis"/> object by
-		/// its <see cref="Axis.Title"/> string.
-		/// </summary>
-		/// <param name="title">The string title of the
-		/// <see cref="YAxis"/> object to be accessed.</param>
-		/// <value>A <see cref="Axis"/> object reference.</value>
-		public Y2Axis this[string title]
-		{
-			get
-			{
-				int index = IndexOf( title );
-				if ( index >= 0 )
-					return this[index];
-				else
-					return null;
-			}
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="Axis"/> with the specified <see cref="Axis.Title"/>.
-		/// </summary>
-		/// <remarks>The comparison of titles is not case sensitive, but it must include
-		/// all characters including punctuation, spaces, etc.</remarks>
-		/// <param name="title">The <see cref="String"/> label that is in the
-		/// <see cref="Axis.Title"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="Axis"/>,
-		/// or -1 if the <see cref="Axis.Title"/> was not found in the list</returns>
-		/// <seealso cref="IndexOfTag"/>
-		public int IndexOf( string title )
-		{
-			int index = 0;
-			foreach ( Y2Axis axis in this )
-			{
-				if ( String.Compare( axis.Title._text, title, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="Axis"/> with the specified <see cref="Axis.Tag" />.
-		/// </summary>
-		/// <remarks>In order for this method to work, the <see cref="Axis.Tag" />
-		/// property must be of type <see cref="String"/>.</remarks>
-		/// <param name="tagStr">The <see cref="String"/> tag that is in the
-		/// <see cref="Axis.Tag" /> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="Axis" />,
-		/// or -1 if the <see cref="Axis.Tag" /> string is not in the list</returns>
-		/// <seealso cref="IndexOf" />
-		public int IndexOfTag( string tagStr )
-		{
-			int index = 0;
-			foreach ( Y2Axis axis in this )
-			{
-				if ( axis.Tag is string &&
-					String.Compare( (string)axis.Tag, tagStr, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Create a new <see cref="Y2Axis" /> and add it to this list.
-		/// </summary>
-		/// <param name="title">The title string for the new axis</param>
-		/// <returns>An integer representing the ordinal position of the new <see cref="Y2Axis" /> in
-		/// this <see cref="Y2AxisList" />.  This is the value that you would set the
-		/// <see cref="CurveItem.YAxisIndex" /> property of a given <see cref="CurveItem" /> to 
-		/// assign it to this new <see cref="Y2Axis" />.  Note that, for a <see cref="Y2Axis" />,
-		/// you would also need to set the <see cref="CurveItem.IsY2Axis" /> property to true.</returns>
-		public int Add( string title )
-		{
-			Y2Axis axis = new Y2Axis( title );
-			Add( axis );
-
-			return Count - 1;
-		}
-
-		#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/YAxis.cs b/BDInfo/ZedGraph/YAxis.cs
deleted file mode 100644
index 06cfbf1434..0000000000
--- a/BDInfo/ZedGraph/YAxis.cs
+++ /dev/null
@@ -1,255 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// <see cref="YAxis"/> inherits from <see cref="Axis"/>, and defines the
-	/// special characteristics of a vertical axis, specifically located on
-	/// the right side of the <see cref="Chart.Rect"/> of the <see cref="GraphPane"/>
-	/// object
-	/// </summary>
-	/// 
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.16 $ $Date: 2007/04/16 00:03:06 $ </version>
-	[Serializable]
-	public class YAxis : Axis, ICloneable, ISerializable
-	{
-		#region Defaults
-		/// <summary>
-		/// A simple struct that defines the
-		/// default property values for the <see cref="YAxis"/> class.
-		/// </summary>
-		public new struct Default
-		{
-			// Default Y Axis properties
-			/// <summary>
-			/// The default display mode for the <see cref="YAxis"/>
-			/// (<see cref="Axis.IsVisible"/> property). true to display the scale
-			/// values, title, tic marks, false to hide the axis entirely.
-			/// </summary>
-			public static bool IsVisible = true;
-			/// <summary>
-			/// Determines if a line will be drawn at the zero value for the 
-			/// <see cref="YAxis"/>, that is, a line that
-			/// divides the negative values from positive values.
-			/// <seealso cref="MajorGrid.IsZeroLine"/>.
-			/// </summary>
-			public static bool IsZeroLine = true;
-		}
-		#endregion
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="YAxis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class
-		/// </summary>
-		public YAxis()
-			: this( "Y Axis" )
-		{
-		}
-
-		/// <summary>
-		/// Default constructor that sets all <see cref="YAxis"/> properties to
-		/// default values as defined in the <see cref="Default"/> class, except
-		/// for the axis title
-		/// </summary>
-		/// <param name="title">The <see cref="Axis.Title"/> for this axis</param>
-		public YAxis( string title )
-			: base( title )
-		{
-			_isVisible = Default.IsVisible;
-			_majorGrid._isZeroLine = Default.IsZeroLine;
-			_scale._fontSpec.Angle = 90.0F;
-			_title._fontSpec.Angle = -180F;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The YAxis object from which to copy</param>
-		public YAxis( YAxis rhs )
-			: base( rhs )
-		{
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public YAxis Clone()
-		{
-			return new YAxis( this );
-		}
-
-		#endregion
-
-		#region Serialization
-		/// <summary>
-		/// Current schema value that defines the version of the serialized file
-		/// </summary>
-		public const int schema2 = 10;
-
-		/// <summary>
-		/// Constructor for deserializing objects
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data
-		/// </param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data
-		/// </param>
-		protected YAxis( SerializationInfo info, StreamingContext context )
-			: base( info, context )
-		{
-			// The schema value is just a file version parameter.  You can use it to make future versions
-			// backwards compatible as new member variables are added to classes
-			int sch = info.GetInt32( "schema2" );
-
-		}
-		/// <summary>
-		/// Populates a <see cref="SerializationInfo"/> instance with the data needed to serialize the target object
-		/// </summary>
-		/// <param name="info">A <see cref="SerializationInfo"/> instance that defines the serialized data</param>
-		/// <param name="context">A <see cref="StreamingContext"/> instance that contains the serialized data</param>
-		[SecurityPermissionAttribute( SecurityAction.Demand, SerializationFormatter = true )]
-		public override void GetObjectData( SerializationInfo info, StreamingContext context )
-		{
-			base.GetObjectData( info, context );
-			info.AddValue( "schema2", schema2 );
-		}
-		#endregion
-
-		#region Methods
-		/// <summary>
-		/// Setup the Transform Matrix to handle drawing of this <see cref="YAxis"/>
-		/// </summary>
-		/// <param name="g">
-		/// A graphic device object to be drawn into.  This is normally e.Graphics from the
-		/// PaintEventArgs argument to the Paint() method.
-		/// </param>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <param name="scaleFactor">
-		/// The scaling factor to be used for rendering objects.  This is calculated and
-		/// passed down by the parent <see cref="GraphPane"/> object using the
-		/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
-		/// font sizes, etc. according to the actual size of the graph.
-		/// </param>
-		override public void SetTransformMatrix( Graphics g, GraphPane pane, float scaleFactor )
-		{
-			// Move the origin to the TopLeft of the ChartRect, which is the left
-			// side of the axis (facing from the label side)
-			g.TranslateTransform( pane.Chart._rect.Left, pane.Chart._rect.Top );
-			// rotate so this axis is in the left-right direction
-			g.RotateTransform( 90 );
-		}
-
-		/// <summary>
-		/// Determines if this <see cref="Axis" /> object is a "primary" one.
-		/// </summary>
-		/// <remarks>
-		/// The primary axes are the <see cref="XAxis" /> (always), the first
-		/// <see cref="YAxis" /> in the <see cref="GraphPane.YAxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0),  and the first
-		/// <see cref="Y2Axis" /> in the <see cref="GraphPane.Y2AxisList" /> 
-		/// (<see cref="CurveItem.YAxisIndex" /> = 0).  Note that
-		/// <see cref="GraphPane.YAxis" /> and <see cref="GraphPane.Y2Axis" />
-		/// always reference the primary axes.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>true for a primary <see cref="Axis" />, false otherwise</returns>
-		override internal bool IsPrimary( GraphPane pane )
-		{
-			return this == pane.YAxis;
-		}
-
-		/// <summary>
-		/// Calculate the "shift" size, in pixels, in order to shift the axis from its default
-		/// location to the value specified by <see cref="Axis.Cross"/>.
-		/// </summary>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		/// <returns>The shift amount measured in pixels</returns>
-		internal override float CalcCrossShift( GraphPane pane )
-		{
-			double effCross = EffectiveCrossValue( pane );
-
-			if ( !_crossAuto )
-				return pane.XAxis.Scale._minPix - pane.XAxis.Scale.Transform( effCross );
-			else
-				return 0;
-		}
-		/*
-				override internal bool IsCrossed( GraphPane pane )
-				{
-					return !this.crossAuto && this.cross > pane.XAxis.Min && this.cross < pane.XAxis.Max;
-				}
-		*/
-		/// <summary>
-		/// Gets the "Cross" axis that corresponds to this axis.
-		/// </summary>
-		/// <remarks>
-		/// The cross axis is the axis which determines the of this Axis when the
-		/// <see cref="Axis.Cross" >Axis.Cross</see> property is used.  The
-		/// cross axis for any <see cref="XAxis" /> or <see cref="X2Axis" />
-		/// is always the primary <see cref="YAxis" />, and
-		/// the cross axis for any <see cref="YAxis" /> or <see cref="Y2Axis" /> is
-		/// always the primary <see cref="XAxis" />.
-		/// </remarks>
-		/// <param name="pane">
-		/// A reference to the <see cref="GraphPane"/> object that is the parent or
-		/// owner of this object.
-		/// </param>
-		override public Axis GetCrossAxis( GraphPane pane )
-		{
-			return pane.XAxis;
-		}
-
-		//		override internal float GetMinPix( GraphPane pane )
-		//		{
-		//			return pane.Chart._rect.Top;
-		//		}
-
-
-		#endregion
-	}
-}
-
diff --git a/BDInfo/ZedGraph/YAxisList.cs b/BDInfo/ZedGraph/YAxisList.cs
deleted file mode 100644
index ef6132a1d3..0000000000
--- a/BDInfo/ZedGraph/YAxisList.cs
+++ /dev/null
@@ -1,187 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2005  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.Serialization;
-using System.Security.Permissions;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A collection class containing a list of <see cref="YAxis"/> objects.
-	/// </summary>
-	/// 
-	/// <author>John Champion</author>
-	/// <version> $Revision: 3.3 $ $Date: 2006/06/24 20:26:43 $ </version>
-	[Serializable]
-	public class YAxisList : List<YAxis>, ICloneable
-	{
-
-		#region Constructors
-
-		/// <summary>
-		/// Default constructor for the collection class.
-		/// </summary>
-		public YAxisList()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="YAxisList"/> object from which to copy</param>
-		public YAxisList( YAxisList rhs )
-		{
-			foreach ( YAxis item in rhs )
-			{
-				this.Add( item.Clone() );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public YAxisList Clone()
-		{
-			return new YAxisList( this );
-		}
-
-		#endregion
-
-		#region List Methods
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="Axis"/> object by
-		/// its ordinal position in the list.
-		/// </summary>
-		/// <param name="index">The ordinal position (zero-based) of the
-		/// <see cref="YAxis"/> object to be accessed.</param>
-		/// <value>An <see cref="Axis"/> object reference.</value>
-		public new YAxis this[int index]
-		{
-			get { return ( ( ( index < 0 || index >= this.Count ) ? null : base[index] ) ); }
-		}
-
-		/// <summary>
-		/// Indexer to access the specified <see cref="Axis"/> object by
-		/// its <see cref="Axis.Title"/> string.
-		/// </summary>
-		/// <param name="title">The string title of the
-		/// <see cref="YAxis"/> object to be accessed.</param>
-		/// <value>A <see cref="Axis"/> object reference.</value>
-		public YAxis this[string title]
-		{
-			get
-			{
-				int index = IndexOf( title );
-				if ( index >= 0 )
-					return this[index];
-				else
-					return null;
-			}
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="Axis"/> with the specified <see cref="Axis.Title"/>.
-		/// </summary>
-		/// <remarks>The comparison of titles is not case sensitive, but it must include
-		/// all characters including punctuation, spaces, etc.</remarks>
-		/// <param name="title">The <see cref="String"/> label that is in the
-		/// <see cref="Axis.Title"/> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="Axis"/>,
-		/// or -1 if the <see cref="Axis.Title"/> was not found in the list</returns>
-		/// <seealso cref="IndexOfTag"/>
-		public int IndexOf( string title )
-		{
-			int index = 0;
-			foreach ( YAxis axis in this )
-			{
-				if ( String.Compare( axis.Title._text, title, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Return the zero-based position index of the
-		/// <see cref="Axis"/> with the specified <see cref="Axis.Tag" />.
-		/// </summary>
-		/// <remarks>In order for this method to work, the <see cref="Axis.Tag" />
-		/// property must be of type <see cref="String"/>.
-		/// </remarks>
-		/// <param name="tagStr">The <see cref="String"/> tag that is in the
-		/// <see cref="Axis.Tag" /> attribute of the item to be found.
-		/// </param>
-		/// <returns>The zero-based index of the specified <see cref="Axis" />,
-		/// or -1 if the <see cref="Axis.Tag" /> string is not in the list</returns>
-		public int IndexOfTag( string tagStr )
-		{
-			int index = 0;
-			foreach ( YAxis axis in this )
-			{
-				if ( axis.Tag is string &&
-					String.Compare( (string)axis.Tag, tagStr, true ) == 0 )
-					return index;
-				index++;
-			}
-
-			return -1;
-		}
-
-		/// <summary>
-		/// Create a new <see cref="YAxis" /> and add it to this list.
-		/// </summary>
-		/// <param name="title">The title string for the new axis</param>
-		/// <returns>An integer representing the ordinal position of the new <see cref="YAxis" /> in
-		/// this <see cref="YAxisList" />.  This is the value that you would set the
-		/// <see cref="CurveItem.YAxisIndex" /> property of a given <see cref="CurveItem" /> to 
-		/// assign it to this new <see cref="YAxis" />.</returns>
-		public int Add( string title )
-		{
-			YAxis axis = new YAxis( title );
-			Add( axis );
-
-			return Count - 1;
-		}
-
-		#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ZedGraphControl.ContextMenu.cs b/BDInfo/ZedGraph/ZedGraphControl.ContextMenu.cs
deleted file mode 100644
index a37dac51f4..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.ContextMenu.cs
+++ /dev/null
@@ -1,897 +0,0 @@
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Text;
-using System.Windows.Forms;
-using System.Threading;
-using System.Drawing.Imaging;
-using System.IO;
-using System.Text;
-
-using System.Runtime.InteropServices;
-//using System.Diagnostics;
-
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-
-	#region ContextMenu
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Public enumeration that specifies the type of 
-		/// object present at the Context Menu's mouse location
-		/// </summary>
-		public enum ContextMenuObjectState
-		{
-			/// <summary>
-			/// The object is an Inactive Curve Item at the Context Menu's mouse position
-			/// </summary>
-			InactiveSelection,
-			/// <summary>
-			/// The object is an active Curve Item at the Context Menu's mouse position
-			/// </summary>
-			ActiveSelection,
-			/// <summary>
-			/// There is no selectable object present at the Context Menu's mouse position
-			/// </summary>
-			Background
-		}
-
-		//Revision: JCarpenter 10/06
-		/// <summary>
-		/// Find the object currently under the mouse cursor, and return its state.
-		/// </summary>
-		private ContextMenuObjectState GetObjectState()
-		{
-			ContextMenuObjectState objState = ContextMenuObjectState.Background;
-
-			// Determine object state
-			Point mousePt = this.PointToClient( Control.MousePosition );
-			int iPt;
-			GraphPane pane;
-			object nearestObj;
-
-			using ( Graphics g = this.CreateGraphics() )
-			{
-				if ( this.MasterPane.FindNearestPaneObject( mousePt, g, out pane,
-						out nearestObj, out iPt ) )
-				{
-					CurveItem item = nearestObj as CurveItem;
-
-					if ( item != null && iPt >= 0 )
-					{
-						if ( item.IsSelected )
-							objState = ContextMenuObjectState.ActiveSelection;
-						else
-							objState = ContextMenuObjectState.InactiveSelection;
-					}
-				}
-			}
-
-			return objState;
-		}
-
-		/// <summary>
-		/// protected method to handle the popup context menu in the <see cref="ZedGraphControl"/>.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		private void contextMenuStrip1_Opening( object sender, CancelEventArgs e )
-		{
-			// disable context menu by default
-			e.Cancel = true;
-			ContextMenuStrip menuStrip = sender as ContextMenuStrip;
-
-			//Revision: JCarpenter 10/06
-			ContextMenuObjectState objState = GetObjectState();
-
-			if ( _masterPane != null && menuStrip != null )
-			{
-				menuStrip.Items.Clear();
-
-				_isZooming = false;
-				_isPanning = false;
-				Cursor.Current = Cursors.Default;
-
-				_menuClickPt = this.PointToClient( Control.MousePosition );
-				GraphPane pane = _masterPane.FindPane( _menuClickPt );
-
-				if ( _isShowContextMenu )
-				{
-					string menuStr = string.Empty;
-
-					ToolStripMenuItem item = new ToolStripMenuItem();
-					item.Name = "copy";
-					item.Tag = "copy";
-					item.Text = "Copy Image to Clipboard";
-					item.Click += new System.EventHandler( this.MenuClick_Copy );
-					menuStrip.Items.Add( item );
-
-					item = new ToolStripMenuItem();
-					item.Name = "save_as";
-					item.Tag = "save_as";
-					item.Text = "Save Image As...";
-					item.Click += new System.EventHandler( this.MenuClick_SaveAs );
-					menuStrip.Items.Add( item );
-
-                    /*
-					item = new ToolStripMenuItem();
-					item.Name = "page_setup";
-					item.Tag = "page_setup";
-					item.Text = "Page Setup...";
-					item.Click += new System.EventHandler( this.MenuClick_PageSetup );
-					menuStrip.Items.Add( item );
-
-					item = new ToolStripMenuItem();
-					item.Name = "print";
-					item.Tag = "print";
-					item.Text = "Print...";
-					item.Click += new System.EventHandler( this.MenuClick_Print );
-					menuStrip.Items.Add( item );
-
-					item = new ToolStripMenuItem();
-					item.Name = "show_val";
-					item.Tag = "show_val";
-					item.Text = "Show Point Values";
-					item.Click += new System.EventHandler( this.MenuClick_ShowValues );
-					item.Checked = this.IsShowPointValues;
-					menuStrip.Items.Add( item );
-
-					item = new ToolStripMenuItem();
-					item.Name = "unzoom";
-					item.Tag = "unzoom";
-
-					if ( pane == null || pane.ZoomStack.IsEmpty )
-						menuStr = "Un-Zoom";
-					else
-					{
-						switch ( pane.ZoomStack.Top.Type )
-						{
-							case ZoomState.StateType.Zoom:
-							case ZoomState.StateType.WheelZoom:
-								menuStr = "Undo Zoom";
-								break;
-							case ZoomState.StateType.Pan:
-								menuStr = "Undo Pan";
-								break;
-							case ZoomState.StateType.Scroll:
-								menuStr = "Undo Scroll";
-								break;
-						}
-					}
-
-					//menuItem.Text = "Un-" + ( ( pane == null || pane.zoomStack.IsEmpty ) ?
-					//	"Zoom" : pane.zoomStack.Top.TypeString );
-					item.Text = menuStr;
-					item.Click += new EventHandler( this.MenuClick_ZoomOut );
-					if ( pane == null || pane.ZoomStack.IsEmpty )
-						item.Enabled = false;
-					menuStrip.Items.Add( item );
-                    */
-
-					item = new ToolStripMenuItem();
-					item.Name = "undo_all";
-					item.Tag = "undo_all";
-					menuStr = "Reset Image View";
-					item.Text = menuStr;
-					item.Click += new EventHandler( this.MenuClick_ZoomOutAll );
-					if ( pane == null || pane.ZoomStack.IsEmpty )
-						item.Enabled = false;
-					menuStrip.Items.Add( item );
-
-                    /*
-					item = new ToolStripMenuItem();
-					item.Name = "set_default";
-					item.Tag = "set_default";
-					menuStr = "Set Scale to Default";
-					item.Text = menuStr;
-					item.Click += new EventHandler( this.MenuClick_RestoreScale );
-					if ( pane == null )
-						item.Enabled = false;
-					menuStrip.Items.Add( item );
-                     */
-
-					// if e.Cancel is set to false, the context menu does not display
-					// it is initially set to false because the context menu has no items
-					e.Cancel = false;
-
-					// Provide Callback for User to edit the context menu
-					//Revision: JCarpenter 10/06 - add ContextMenuObjectState objState
-					if ( this.ContextMenuBuilder != null )
-						this.ContextMenuBuilder( this, menuStrip, _menuClickPt, objState );
-				}
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Copy" context menu item.  Copies the current image to a bitmap on the
-		/// clipboard.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_Copy( System.Object sender, System.EventArgs e )
-		{
-			Copy( _isShowCopyMessage );
-		}
-
-		/// <summary>
-		/// Handler for the "Copy" context menu item.  Copies the current image to a bitmap on the
-		/// clipboard.
-		/// </summary>
-		/// <param name="isShowMessage">boolean value that determines whether or not a prompt will be
-		/// displayed.  true to show a message of "Image Copied to ClipBoard".</param>
-		public void Copy( bool isShowMessage )
-		{
-			if ( _masterPane != null )
-			{
-				//Clipboard.SetDataObject( _masterPane.GetImage(), true );
-
-				// Threaded copy mode to avoid crash with MTA
-				// Contributed by Dave Moor
-				Thread ct = new Thread( new ThreadStart( this.ClipboardCopyThread ) );
-				//ct.ApartmentState = ApartmentState.STA;
-				ct.SetApartmentState( ApartmentState.STA );
-				ct.Start();
-				ct.Join();
-
-				if ( isShowMessage )
-				{
-					string str = "Image copied to clipboard.";
-					//MessageBox.Show( "Image Copied to ClipBoard" );
-					MessageBox.Show( str, "BDInfo", MessageBoxButtons.OK, MessageBoxIcon.Information );
-				}
-			}
-		}
-
-		/// <summary>
-		/// A threaded version of the copy method to avoid crash with MTA
-		/// </summary>
-		private void ClipboardCopyThread()
-		{
-			Clipboard.SetDataObject( ImageRender(), true );
-		}
-
-		// 
-		/// <summary>
-		/// Setup for creation of a new image, applying appropriate anti-alias properties and
-		/// returning the resultant image file
-		/// </summary>
-		/// <returns></returns>
-		private Image ImageRender()
-		{
-			return _masterPane.GetImage( _masterPane.IsAntiAlias );
-		}
-
-		/// <summary>
-		/// Special handler that copies the current image to an Emf file on the clipboard.
-		/// </summary>
-		/// <remarks>This version is similar to the regular <see cref="Copy" /> method, except that
-		/// it will place an Emf image (vector) on the ClipBoard instead of the regular bitmap.</remarks>
-		/// <param name="isShowMessage">boolean value that determines whether or not a prompt will be
-		/// displayed.  true to show a message of "Image Copied to ClipBoard".</param>
-		public void CopyEmf(bool isShowMessage)
-		{
-			if (_masterPane != null)
-			{
-				// Threaded copy mode to avoid crash with MTA
-				// Contributed by Dave Moor
-				Thread ct = new Thread(new ThreadStart(this.ClipboardCopyThreadEmf));
-				//ct.ApartmentState = ApartmentState.STA;
-				ct.SetApartmentState(ApartmentState.STA);
-				ct.Start();
-				ct.Join();
-
-				if (isShowMessage)
-				{
-					string str = "Image copied to clipboard";
-					MessageBox.Show(str);
-				}
-			}
-		}
-
-		/// <summary>
-		/// A threaded version of the copy method to avoid crash with MTA
-		/// </summary>
-		private void ClipboardCopyThreadEmf()
-		{
-			using (Graphics g = this.CreateGraphics())
-			{
-				IntPtr hdc = g.GetHdc();
-				Metafile metaFile = new Metafile(hdc, EmfType.EmfPlusOnly);
-				g.ReleaseHdc(hdc);
-
-				using (Graphics gMeta = Graphics.FromImage(metaFile))
-				{
-					this._masterPane.Draw( gMeta );
-				}
-
-				//IntPtr hMeta = metaFile.GetHenhmetafile();
-				ClipboardMetafileHelper.PutEnhMetafileOnClipboard( this.Handle, metaFile );
-				//System.Windows.Forms.Clipboard.SetDataObject(hMeta, true);
-
-				//g.Dispose();
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
-		/// file.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_SaveAs( System.Object sender, System.EventArgs e )
-		{
-			SaveAs();
-		}
-
-		/// <summary>
-		/// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
-		/// file in either the Emf (vector), or a variety of Bitmap formats.
-		/// </summary>
-		/// <remarks>
-		/// Note that <see cref="SaveAsBitmap" /> and <see cref="SaveAsEmf" /> methods are provided
-		/// which allow for Bitmap-only or Emf-only handling of the "Save As" context menu item.
-		/// </remarks>
-		public void SaveAs()
-		{
-			SaveAs( null );
-		}
-
-		/// <summary>
-		/// Copies the current image to the selected file in  
-		/// Emf (vector), or a variety of Bitmap formats.
-		/// </summary>
-		/// <param name="DefaultFileName">
-		/// Accepts a default file name for the file dialog (if "" or null, default is not used)
-		/// </param>
-		/// <returns>
-		/// The file name saved, or "" if cancelled.
-		/// </returns>
-		/// <remarks>
-		/// Note that <see cref="SaveAsBitmap" /> and <see cref="SaveAsEmf" /> methods are provided
-		/// which allow for Bitmap-only or Emf-only handling of the "Save As" context menu item.
-		/// </remarks>
-		public String SaveAs( String DefaultFileName )
-		{
-			if ( _masterPane != null )
-			{
-                _saveFileDialog.Filter =
-                    "PNG Format (*.PNG)|*.PNG|" +
-                    "JPEG Format (*.JPG)|*.JPG|" +
-                    "GIF Format (*.GIF)|*.GIF|" +
-                    "BMP Format (*.BMP)|*.BMP|" +
-                    "TIFF Format (*.TIF)|*.TIF|" +
-                    "EMF Format (*.EMF)|*.EMF";
-
-				if ( DefaultFileName != null && DefaultFileName.Length > 0 )
-				{
-					String ext = System.IO.Path.GetExtension( DefaultFileName ).ToLower();
-					switch (ext)
-					{
-                        case ".png": _saveFileDialog.FilterIndex = 1; break;
-                        case ".jpeg":
-                        case ".jpg": _saveFileDialog.FilterIndex = 2; break;
-						case ".gif": _saveFileDialog.FilterIndex = 3; break;
-                        case ".bmp": _saveFileDialog.FilterIndex = 4; break;
-                        case ".tiff":
-						case ".tif": _saveFileDialog.FilterIndex = 5; break;
-                        case ".emf": _saveFileDialog.FilterIndex = 6; break;
-                    }
-					//If we were passed a file name, not just an extension, use it
-					if ( DefaultFileName.Length > ext.Length )
-					{
-						_saveFileDialog.FileName = DefaultFileName;
-					}
-				}
-
-				if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
-				{
-                    
-					Stream myStream = _saveFileDialog.OpenFile();
-					if ( myStream != null )
-					{
-						if ( _saveFileDialog.FilterIndex == 6 )
-						{
-							myStream.Close();
-							SaveEmfFile( _saveFileDialog.FileName );
-						}
-						else
-						{
-							ImageFormat format = ImageFormat.Png;
-                            switch (_saveFileDialog.FilterIndex)
-							{
-                                case 1: format = ImageFormat.Png; break;
-                                case 2: format = ImageFormat.Jpeg; break;
-								case 3: format = ImageFormat.Gif; break;
-								case 4: format = ImageFormat.Bmp; break;
-								case 5: format = ImageFormat.Tiff; break;
-							}
-
-							ImageRender().Save( myStream, format );
-							//_masterPane.GetImage().Save( myStream, format );
-							myStream.Close();
-						}
-                        return _saveFileDialog.FileName;
-					}
-				}
-			}
-			return "";
-		}
-
-		/// <summary>
-		/// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
-		/// Bitmap file.
-		/// </summary>
-		/// <remarks>
-		/// Note that this handler saves as a bitmap only.  The default handler is
-		/// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats
-		/// </remarks>
-		public void SaveAsBitmap()
-		{
-			if ( _masterPane != null )
-			{
-				_saveFileDialog.Filter =
-					"PNG Format (*.png)|*.png|" +
-					"Gif Format (*.gif)|*.gif|" +
-					"Jpeg Format (*.jpg)|*.jpg|" +
-					"Tiff Format (*.tif)|*.tif|" +
-					"Bmp Format (*.bmp)|*.bmp";
-
-				if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
-				{
-					ImageFormat format = ImageFormat.Png;
-					if ( _saveFileDialog.FilterIndex == 2 )
-						format = ImageFormat.Gif;
-					else if ( _saveFileDialog.FilterIndex == 3 )
-						format = ImageFormat.Jpeg;
-					else if ( _saveFileDialog.FilterIndex == 4 )
-						format = ImageFormat.Tiff;
-					else if ( _saveFileDialog.FilterIndex == 5 )
-						format = ImageFormat.Bmp;
-
-					Stream myStream = _saveFileDialog.OpenFile();
-					if ( myStream != null )
-					{
-						//_masterPane.GetImage().Save( myStream, format );
-						ImageRender().Save( myStream, format );
-						myStream.Close();
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
-		/// Emf format file.
-		/// </summary>
-		/// <remarks>
-		/// Note that this handler saves as an Emf format only.  The default handler is
-		/// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats.
-		/// </remarks>
-		public void SaveAsEmf()
-		{
-			if ( _masterPane != null )
-			{
-				_saveFileDialog.Filter = "Emf Format (*.emf)|*.emf";
-
-				if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
-				{
-					Stream myStream = _saveFileDialog.OpenFile();
-					if ( myStream != null )
-					{
-						myStream.Close();
-						//_masterPane.GetMetafile().Save( _saveFileDialog.FileName );
-						SaveEmfFile(_saveFileDialog.FileName);
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Save the current Graph to the specified filename in EMF (vector) format.
-		/// See <see cref="SaveAsEmf()" /> for public access.
-		/// </summary>
-		/// <remarks>
-		/// Note that this handler saves as an Emf format only.  The default handler is
-		/// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats.
-		/// </remarks>
-		internal void SaveEmfFile( string fileName )
-		{
-			using (Graphics g = this.CreateGraphics())
-			{
-				IntPtr hdc = g.GetHdc();
-				Metafile metaFile = new Metafile(hdc, EmfType.EmfPlusOnly);
-				using (Graphics gMeta = Graphics.FromImage(metaFile))
-				{
-					//PaneBase.SetAntiAliasMode( gMeta, IsAntiAlias );
-					//gMeta.CompositingMode = CompositingMode.SourceCopy; 
-					//gMeta.CompositingQuality = CompositingQuality.HighQuality;
-					//gMeta.InterpolationMode = InterpolationMode.HighQualityBicubic;
-					//gMeta.SmoothingMode = SmoothingMode.AntiAlias;
-					//gMeta.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; 
-					this._masterPane.Draw(gMeta);
-					//gMeta.Dispose();
-				}
-
-				ClipboardMetafileHelper.SaveEnhMetafileToFile(metaFile, fileName );
-
-				g.ReleaseHdc(hdc);
-				//g.Dispose();
-			}
-
-		}
-
-		internal class ClipboardMetafileHelper
-		{
-			[DllImport("user32.dll")]
-			static extern bool OpenClipboard(IntPtr hWndNewOwner);
-			[DllImport("user32.dll")]
-			static extern bool EmptyClipboard();
-			[DllImport("user32.dll")]
-			static extern IntPtr SetClipboardData(uint uFormat, IntPtr hMem);
-			[DllImport("user32.dll")]
-			static extern bool CloseClipboard();
-			[DllImport("gdi32.dll")]
-			static extern IntPtr CopyEnhMetaFile(IntPtr hemfSrc, System.Text.StringBuilder hNULL);
-			[DllImport("gdi32.dll")]
-			static extern bool DeleteEnhMetaFile(IntPtr hemf);
-
-			static internal bool SaveEnhMetafileToFile( Metafile mf, string fileName )
-			{
-				bool bResult = false;
-				IntPtr hEMF;
-				hEMF = mf.GetHenhmetafile(); // invalidates mf 
-				if (!hEMF.Equals(new IntPtr(0)))
-				{
-					StringBuilder tempName = new StringBuilder(fileName);
-					CopyEnhMetaFile(hEMF, tempName);
-					DeleteEnhMetaFile(hEMF);
-				}
-				return bResult;
-			}
-
-			static internal bool SaveEnhMetafileToFile(Metafile mf)
-			{
-				bool bResult = false;
-				IntPtr hEMF;
-				hEMF = mf.GetHenhmetafile(); // invalidates mf 
-				if (!hEMF.Equals(new IntPtr(0)))
-				{
-					SaveFileDialog sfd = new SaveFileDialog();
-					sfd.Filter = "Extended Metafile (*.emf)|*.emf";
-					sfd.DefaultExt = ".emf";
-					if (sfd.ShowDialog() == DialogResult.OK)
-					{
-						StringBuilder temp = new StringBuilder(sfd.FileName);
-						CopyEnhMetaFile(hEMF, temp);
-					}
-					DeleteEnhMetaFile(hEMF);
-				}
-				return bResult;
-			}
-
-			// Metafile mf is set to a state that is not valid inside this function. 
-			static internal bool PutEnhMetafileOnClipboard(IntPtr hWnd, Metafile mf)
-			{
-				bool bResult = false;
-				IntPtr hEMF, hEMF2;
-				hEMF = mf.GetHenhmetafile(); // invalidates mf 
-				if (!hEMF.Equals(new IntPtr(0)))
-				{
-					hEMF2 = CopyEnhMetaFile(hEMF, null);
-					if (!hEMF2.Equals(new IntPtr(0)))
-					{
-						if (OpenClipboard(hWnd))
-						{
-							if (EmptyClipboard())
-							{
-								IntPtr hRes = SetClipboardData(14 /*CF_ENHMETAFILE*/, hEMF2);
-								bResult = hRes.Equals(hEMF2);
-								CloseClipboard();
-							}
-						}
-					}
-					DeleteEnhMetaFile(hEMF);
-				}
-				return bResult;
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Show Values" context menu item.  Toggles the <see cref="IsShowPointValues"/>
-		/// property, which activates the point value tooltips.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_ShowValues( object sender, System.EventArgs e )
-		{
-			ToolStripMenuItem item = sender as ToolStripMenuItem;
-			if ( item != null )
-				this.IsShowPointValues = !item.Checked;
-		}
-
-		/// <summary>
-		/// Handler for the "Set Scale to Default" context menu item.  Sets the scale ranging to
-		/// full auto mode for all axes.
-		/// </summary>
-		/// <remarks>
-		/// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
-		/// to full auto mode.  The <see cref="ZoomOutAll" /> method sets the scales to their initial
-		/// setting prior to any user actions (which may or may not be full auto mode).
-		/// </remarks>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_RestoreScale( object sender, EventArgs e )
-		{
-			if ( _masterPane != null )
-			{
-				GraphPane pane = _masterPane.FindPane( _menuClickPt );
-				RestoreScale( pane );
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Set Scale to Default" context menu item.  Sets the scale ranging to
-		/// full auto mode for all axes.
-		/// </summary>
-		/// <remarks>
-		/// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
-		/// to full auto mode.  The <see cref="ZoomOutAll" /> method sets the scales to their initial
-		/// setting prior to any user actions (which may or may not be full auto mode).
-		/// </remarks>
-		/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to have the
-		/// scale restored</param>
-		public void RestoreScale( GraphPane primaryPane )
-		{
-			if ( primaryPane != null )
-			{
-				//Go ahead and save the old zoomstates, which provides an "undo"-like capability
-				//ZoomState oldState = primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
-				ZoomState oldState = new ZoomState( primaryPane, ZoomState.StateType.Zoom );
-
-				using ( Graphics g = this.CreateGraphics() )
-				{
-					if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-					{
-						foreach ( GraphPane pane in _masterPane._paneList )
-						{
-							pane.ZoomStack.Push( pane, ZoomState.StateType.Zoom );
-							ResetAutoScale( pane, g );
-						}
-					}
-					else
-					{
-						primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
-						ResetAutoScale( primaryPane, g );
-					}
-
-					// Provide Callback to notify the user of zoom events
-					if ( this.ZoomEvent != null )
-						this.ZoomEvent( this, oldState, new ZoomState( primaryPane, ZoomState.StateType.Zoom ) );
-
-					//g.Dispose();
-				}
-				Refresh();
-			}
-		}
-
-		private void ResetAutoScale( GraphPane pane, Graphics g )
-		{
-			pane.XAxis.ResetAutoScale( pane, g );
-			pane.X2Axis.ResetAutoScale( pane, g );
-			foreach ( YAxis axis in pane.YAxisList )
-				axis.ResetAutoScale( pane, g );
-			foreach ( Y2Axis axis in pane.Y2AxisList )
-				axis.ResetAutoScale( pane, g );
-		}
-
-		/*
-				public void RestoreScale( GraphPane primaryPane )
-				{
-					if ( primaryPane != null )
-					{
-						Graphics g = this.CreateGraphics();
-						ZoomState oldState = new ZoomState( primaryPane, ZoomState.StateType.Zoom );
-						//ZoomState newState = null;
-
-						if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-						{
-							foreach ( GraphPane pane in _masterPane._paneList )
-							{
-								if ( pane == primaryPane )
-								{
-									pane.XAxis.ResetAutoScale( pane, g );
-									foreach ( YAxis axis in pane.YAxisList )
-										axis.ResetAutoScale( pane, g );
-									foreach ( Y2Axis axis in pane.Y2AxisList )
-										axis.ResetAutoScale( pane, g );
-								}
-							}
-						}
-						else
-						{
-							primaryPane.XAxis.ResetAutoScale( primaryPane, g );
-							foreach ( YAxis axis in primaryPane.YAxisList )
-								axis.ResetAutoScale( primaryPane, g );
-							foreach ( Y2Axis axis in primaryPane.Y2AxisList )
-								axis.ResetAutoScale( primaryPane, g );
-						}
-
-						// Provide Callback to notify the user of zoom events
-						if ( this.ZoomEvent != null )
-							this.ZoomEvent( this, oldState, new ZoomState( primaryPane, ZoomState.StateType.Zoom ) );
-
-						g.Dispose();
-						Refresh();
-					}
-				}
-		*/
-		/*
-				public void ZoomOutAll( GraphPane primaryPane )
-				{
-					if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
-					{
-						ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
-
-						ZoomState oldState = new ZoomState( primaryPane, type );
-						//ZoomState newState = pane.ZoomStack.PopAll( pane );
-						ZoomState newState = null;
-						if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-						{
-							foreach ( GraphPane pane in _masterPane._paneList )
-							{
-								ZoomState state = pane.ZoomStack.PopAll( pane );
-								if ( pane == primaryPane )
-									newState = state;
-							}
-						}
-						else
-							newState = primaryPane.ZoomStack.PopAll( primaryPane );
-
-						// Provide Callback to notify the user of zoom events
-						if ( this.ZoomEvent != null )
-							this.ZoomEvent( this, oldState, newState );
-
-						Refresh();
-					}
-				}
-
-		*/
-
-		/// <summary>
-		/// Handler for the "UnZoom/UnPan" context menu item.  Restores the scale ranges to the values
-		/// before the last zoom or pan operation.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_ZoomOut( System.Object sender, System.EventArgs e )
-		{
-			if ( _masterPane != null )
-			{
-				GraphPane pane = _masterPane.FindPane( _menuClickPt );
-				ZoomOut( pane );
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "UnZoom/UnPan" context menu item.  Restores the scale ranges to the values
-		/// before the last zoom, pan, or scroll operation.
-		/// </summary>
-		/// <remarks>
-		/// Triggers a <see cref="ZoomEvent" /> for any type of undo (including pan, scroll, zoom, and
-		/// wheelzoom).  This method will affect all the
-		/// <see cref="GraphPane" /> objects in the <see cref="MasterPane" /> if
-		/// <see cref="IsSynchronizeXAxes" /> or <see cref="IsSynchronizeYAxes" /> is true.
-		/// </remarks>
-		/// <param name="primaryPane">The primary <see cref="GraphPane" /> object which is to be
-		/// zoomed out</param>
-		public void ZoomOut( GraphPane primaryPane )
-		{
-			if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
-			{
-				ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
-
-				ZoomState oldState = new ZoomState( primaryPane, type );
-				ZoomState newState = null;
-				if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-				{
-					foreach ( GraphPane pane in _masterPane._paneList )
-					{
-						ZoomState state = pane.ZoomStack.Pop( pane );
-						if ( pane == primaryPane )
-							newState = state;
-					}
-				}
-				else
-					newState = primaryPane.ZoomStack.Pop( primaryPane );
-
-				// Provide Callback to notify the user of zoom events
-				if ( this.ZoomEvent != null )
-					this.ZoomEvent( this, oldState, newState );
-
-				Refresh();
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Undo All Zoom/Pan" context menu item.  Restores the scale ranges to the values
-		/// before all zoom and pan operations
-		/// </summary>
-		/// <remarks>
-		/// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
-		/// to their initial setting prior to any user actions.  The <see cref="RestoreScale" /> method
-		/// sets the scales to full auto mode (regardless of what the initial setting may have been).
-		/// </remarks>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_ZoomOutAll( System.Object sender, System.EventArgs e )
-		{
-			if ( _masterPane != null )
-			{
-				GraphPane pane = _masterPane.FindPane( _menuClickPt );
-				ZoomOutAll( pane );
-			}
-		}
-
-		/// <summary>
-		/// Handler for the "Undo All Zoom/Pan" context menu item.  Restores the scale ranges to the values
-		/// before all zoom and pan operations
-		/// </summary>
-		/// <remarks>
-		/// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
-		/// to their initial setting prior to any user actions.  The <see cref="RestoreScale" /> method
-		/// sets the scales to full auto mode (regardless of what the initial setting may have been).
-		/// </remarks>
-		/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to be zoomed out</param>
-		public void ZoomOutAll( GraphPane primaryPane )
-		{
-			if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
-			{
-				ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
-
-				ZoomState oldState = new ZoomState( primaryPane, type );
-				//ZoomState newState = pane.ZoomStack.PopAll( pane );
-				ZoomState newState = null;
-				if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-				{
-					foreach ( GraphPane pane in _masterPane._paneList )
-					{
-						ZoomState state = pane.ZoomStack.PopAll( pane );
-						if ( pane == primaryPane )
-							newState = state;
-					}
-				}
-				else
-					newState = primaryPane.ZoomStack.PopAll( primaryPane );
-
-				// Provide Callback to notify the user of zoom events
-				if ( this.ZoomEvent != null )
-					this.ZoomEvent( this, oldState, newState );
-
-				Refresh();
-			}
-		}
-
-	#endregion
-
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ZedGraphControl.Designer.cs b/BDInfo/ZedGraph/ZedGraphControl.Designer.cs
deleted file mode 100644
index ba3991cb86..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.Designer.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-		/// <summary> 
-		/// Required designer variable.
-		/// </summary>
-		private System.ComponentModel.IContainer components = null;
-
-		#region Component Designer generated code
-
-		/// <summary> 
-		/// Required method for Designer support - do not modify 
-		/// the contents of this method with the code editor.
-		/// </summary>
-		private void InitializeComponent()
-		{
-			this.components = new System.ComponentModel.Container();
-			this.vScrollBar1 = new System.Windows.Forms.VScrollBar();
-			this.hScrollBar1 = new System.Windows.Forms.HScrollBar();
-			this.pointToolTip = new System.Windows.Forms.ToolTip( this.components );
-			this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip( this.components );
-			this.SuspendLayout();
-			// 
-			// vScrollBar1
-			// 
-			this.vScrollBar1.Location = new System.Drawing.Point( 128, 0 );
-			this.vScrollBar1.Name = "vScrollBar1";
-			this.vScrollBar1.Size = new System.Drawing.Size( 17, 128 );
-			this.vScrollBar1.TabIndex = 0;
-			//this.vScrollBar1.MouseCaptureChanged += new System.EventHandler( this.ScrollBarMouseCaptureChanged );
-			this.vScrollBar1.Scroll += new System.Windows.Forms.ScrollEventHandler( this.vScrollBar1_Scroll );
-			// 
-			// hScrollBar1
-			// 
-			this.hScrollBar1.Location = new System.Drawing.Point( 0, 128 );
-			this.hScrollBar1.Name = "hScrollBar1";
-			this.hScrollBar1.Size = new System.Drawing.Size( 128, 17 );
-			this.hScrollBar1.TabIndex = 1;
-			//this.hScrollBar1.MouseCaptureChanged += new System.EventHandler( this.ScrollBarMouseCaptureChanged );
-			this.hScrollBar1.Scroll += new System.Windows.Forms.ScrollEventHandler( this.hScrollBar1_Scroll );
-			// 
-			// pointToolTip
-			// 
-			this.pointToolTip.AutoPopDelay = 5000;
-			this.pointToolTip.InitialDelay = 100;
-			this.pointToolTip.ReshowDelay = 0;
-			// 
-			// contextMenuStrip1
-			// 
-			this.contextMenuStrip1.Name = "contextMenuStrip1";
-			this.contextMenuStrip1.Size = new System.Drawing.Size( 61, 4 );
-			this.contextMenuStrip1.Opening += new System.ComponentModel.CancelEventHandler( this.contextMenuStrip1_Opening );
-			// 
-			// ZedGraphControl
-			// 
-			this.AutoScaleDimensions = new System.Drawing.SizeF( 6F, 13F );
-			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-			this.ContextMenuStrip = this.contextMenuStrip1;
-			this.Controls.Add( this.hScrollBar1 );
-			this.Controls.Add( this.vScrollBar1 );
-			this.Name = "ZedGraphControl";
-			this.Resize += new System.EventHandler( this.ZedGraphControl_ReSize );
-			this.KeyUp += new System.Windows.Forms.KeyEventHandler( this.ZedGraphControl_KeyUp );
-			this.KeyDown += new System.Windows.Forms.KeyEventHandler( this.ZedGraphControl_KeyDown );
-			this.MouseWheel += new System.Windows.Forms.MouseEventHandler( this.ZedGraphControl_MouseWheel );
-			this.ResumeLayout( false );
-
-		}
-
-		#endregion
-
-		private System.Windows.Forms.VScrollBar vScrollBar1;
-		private System.Windows.Forms.HScrollBar hScrollBar1;
-		private System.Windows.Forms.ToolTip pointToolTip;
-		private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
-	}
-}
diff --git a/BDInfo/ZedGraph/ZedGraphControl.Events.cs b/BDInfo/ZedGraph/ZedGraphControl.Events.cs
deleted file mode 100644
index b52db131f6..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.Events.cs
+++ /dev/null
@@ -1,1462 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Windows.Forms;
-
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-
-	#region Events
-
-		/// <summary>
-		/// A delegate that allows subscribing methods to append or modify the context menu.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="menuStrip">A reference to the <see cref="ContextMenuStrip"/> object
-		/// that contains the context menu.
-		/// </param>
-		/// <param name="mousePt">The point at which the mouse was clicked</param>
-		/// <param name="objState">The current context menu state</param>
-		/// <seealso cref="ContextMenuBuilder" />
-		public delegate void ContextMenuBuilderEventHandler( ZedGraphControl sender,
-			ContextMenuStrip menuStrip, Point mousePt, ContextMenuObjectState objState );
-		/// <summary>
-		/// Subscribe to this event to be able to modify the ZedGraph context menu.
-		/// </summary>
-		/// <remarks>
-		/// The context menu is built on the fly after a right mouse click.  You can add menu items
-		/// to this menu by simply modifying the <see paramref="menu"/> parameter.
-		/// </remarks>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to this event to be able to modify the ZedGraph context menu" )]
-		public event ContextMenuBuilderEventHandler ContextMenuBuilder;
-
-		/// <summary>
-		/// A delegate that allows notification of zoom and pan events.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="oldState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> before the zoom or pan event.</param>
-		/// <param name="newState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> after the zoom or pan event</param>
-		/// <seealso cref="ZoomEvent" />
-		public delegate void ZoomEventHandler( ZedGraphControl sender, ZoomState oldState,
-			ZoomState newState );
-
-		/// <summary>
-		/// Subscribe to this event to be notified when the <see cref="GraphPane"/> is zoomed or panned by the user,
-		/// either via a mouse drag operation or by the context menu commands.
-		/// </summary>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to this event to be notified when the graph is zoomed or panned" )]
-		public event ZoomEventHandler ZoomEvent;
-
-		/// <summary>
-		/// A delegate that allows notification of scroll events.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="scrollBar">The source <see cref="ScrollBar"/> object</param>
-		/// <param name="oldState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> before the scroll event.</param>
-		/// <param name="newState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> after the scroll event</param>
-		/// <seealso cref="ZoomEvent" />
-		public delegate void ScrollDoneHandler( ZedGraphControl sender, ScrollBar scrollBar,
-			ZoomState oldState, ZoomState newState );
-
-		/// <summary>
-		/// Subscribe to this event to be notified when the <see cref="GraphPane"/> is scrolled by the user
-		/// using the scrollbars.
-		/// </summary>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe this event to be notified when a scroll operation using the scrollbars is completed" )]
-		public event ScrollDoneHandler ScrollDoneEvent;
-
-		/// <summary>
-		/// A delegate that allows notification of scroll events.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="scrollBar">The source <see cref="ScrollBar"/> object</param>
-		/// <param name="oldState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> before the scroll event.</param>
-		/// <param name="newState">A <see cref="ZoomState"/> object that corresponds to the state of the
-		/// <see cref="GraphPane"/> after the scroll event</param>
-		/// <seealso cref="ZoomEvent" />
-		public delegate void ScrollProgressHandler( ZedGraphControl sender, ScrollBar scrollBar,
-			ZoomState oldState, ZoomState newState );
-
-		/// <summary>
-		/// Subscribe to this event to be notified when the <see cref="GraphPane"/> is scrolled by the user
-		/// using the scrollbars.
-		/// </summary>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe this event to be notified continuously as a scroll operation is taking place" )]
-		public event ScrollProgressHandler ScrollProgressEvent;
-
-		/// <summary>
-		/// Subscribe to this event to be notified when the <see cref="GraphPane"/> is scrolled by the user
-		/// using the scrollbars.
-		/// </summary>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe this event to be notified of general scroll events" )]
-		public event ScrollEventHandler ScrollEvent;
-
-		/// <summary>
-		/// A delegate that receives notification after a point-edit operation is completed.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="pane">The <see cref="GraphPane"/> object that contains the
-		/// point that has been edited</param>
-		/// <param name="curve">The <see cref="CurveItem"/> object that contains the point
-		/// that has been edited</param>
-		/// <param name="iPt">The integer index of the edited <see cref="PointPair"/> within the
-		/// <see cref="IPointList"/> of the selected <see cref="CurveItem"/>
-		/// </param>
-		/// <seealso cref="PointValueEvent" />
-		public delegate string PointEditHandler( ZedGraphControl sender, GraphPane pane,
-			CurveItem curve, int iPt );
-
-		/// <summary>
-		/// Subscribe to this event to receive notifcation and/or respond after a data
-		/// point has been edited via <see cref="IsEnableHEdit" /> and <see cref="IsEnableVEdit" />.
-		/// </summary>
-		/// <example>
-		/// <para>To subscribe to this event, use the following in your Form_Load method:</para>
-		/// <code>zedGraphControl1.PointEditEvent +=
-		/// new ZedGraphControl.PointEditHandler( MyPointEditHandler );</code>
-		/// <para>Add this method to your Form1.cs:</para>
-		/// <code>
-		///    private string MyPointEditHandler( object sender, GraphPane pane, CurveItem curve, int iPt )
-		///    {
-		///        PointPair pt = curve[iPt];
-		///        return "This value is " + pt.Y.ToString("f2") + " gallons";
-		///    }</code>
-		/// </example>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to this event to respond to data point edit actions" )]
-		public event PointEditHandler PointEditEvent;
-
-		/// <summary>
-		/// A delegate that allows custom formatting of the point value tooltips
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="pane">The <see cref="GraphPane"/> object that contains the point value of interest</param>
-		/// <param name="curve">The <see cref="CurveItem"/> object that contains the point value of interest</param>
-		/// <param name="iPt">The integer index of the selected <see cref="PointPair"/> within the
-		/// <see cref="IPointList"/> of the selected <see cref="CurveItem"/></param>
-		/// <seealso cref="PointValueEvent" />
-		public delegate string PointValueHandler( ZedGraphControl sender, GraphPane pane,
-			CurveItem curve, int iPt );
-
-		/// <summary>
-		/// Subscribe to this event to provide custom formatting for the tooltips
-		/// </summary>
-		/// <example>
-		/// <para>To subscribe to this event, use the following in your FormLoad method:</para>
-		/// <code>zedGraphControl1.PointValueEvent +=
-		/// new ZedGraphControl.PointValueHandler( MyPointValueHandler );</code>
-		/// <para>Add this method to your Form1.cs:</para>
-		/// <code>
-		///    private string MyPointValueHandler( object sender, GraphPane pane, CurveItem curve, int iPt )
-		///    {
-		///    #region
-		///        PointPair pt = curve[iPt];
-		///        return "This value is " + pt.Y.ToString("f2") + " gallons";
-		///    #endregion
-		///    }</code>
-		/// </example>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to this event to provide custom-formatting for data point tooltips" )]
-		public event PointValueHandler PointValueEvent;
-
-		/// <summary>
-		/// A delegate that allows notification of mouse events on Graph objects.
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="e">A <see cref="MouseEventArgs" /> corresponding to this event</param>
-		/// <seealso cref="MouseDownEvent" />
-		/// <returns>
-		/// Return true if you have handled the mouse event entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action (e.g., starting
-		/// a zoom operation).  Return false if ZedGraph should go ahead and process the
-		/// mouse event.
-		/// </returns>
-		public delegate bool ZedMouseEventHandler( ZedGraphControl sender, MouseEventArgs e );
-
-		/// <summary>
-		/// Subscribe to this event to provide notification of MouseDown clicks on graph
-		/// objects
-		/// </summary>
-		/// <remarks>
-		/// This event provides for a notification when the mouse is clicked on an object
-		/// within any <see cref="GraphPane"/> of the <see cref="MasterPane"/> associated
-		/// with this <see cref="ZedGraphControl" />.  This event will use the
-		/// <see cref="ZedGraph.MasterPane.FindNearestPaneObject"/> method to determine which object
-		/// was clicked.  The boolean value that you return from this handler determines whether
-		/// or not the <see cref="ZedGraphControl"/> will do any further handling of the
-		/// MouseDown event (see <see cref="ZedMouseEventHandler" />).  Return true if you have
-		/// handled the MouseDown event entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action (e.g., starting
-		/// a zoom operation).  Return false if ZedGraph should go ahead and process the
-		/// MouseDown event.
-		/// </remarks>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to be notified when the left mouse button is clicked down" )]
-		public event ZedMouseEventHandler MouseDownEvent;
-
-		/// <summary>
-		/// Hide the standard control MouseDown event so that the ZedGraphControl.MouseDownEvent
-		/// can be used.  This is so that the user must return true/false in order to indicate
-		/// whether or not we should respond to the event.
-		/// </summary>
-		[Bindable( false ), Browsable( false )]
-		public new event MouseEventHandler MouseDown;
-		/// <summary>
-		/// Hide the standard control MouseUp event so that the ZedGraphControl.MouseUpEvent
-		/// can be used.  This is so that the user must return true/false in order to indicate
-		/// whether or not we should respond to the event.
-		/// </summary>
-		[Bindable( false ), Browsable( false )]
-		public new event MouseEventHandler MouseUp;
-		/// <summary>
-		/// Hide the standard control MouseMove event so that the ZedGraphControl.MouseMoveEvent
-		/// can be used.  This is so that the user must return true/false in order to indicate
-		/// whether or not we should respond to the event.
-		/// </summary>
-		[Bindable( false ), Browsable( false )]
-		private new event MouseEventHandler MouseMove;
-		/// <summary>
-		/// Subscribe to this event to provide notification of MouseUp clicks on graph
-		/// objects
-		/// </summary>
-		/// <remarks>
-		/// This event provides for a notification when the mouse is clicked on an object
-		/// within any <see cref="GraphPane"/> of the <see cref="MasterPane"/> associated
-		/// with this <see cref="ZedGraphControl" />.  This event will use the
-		/// <see cref="ZedGraph.MasterPane.FindNearestPaneObject"/> method to determine which object
-		/// was clicked.  The boolean value that you return from this handler determines whether
-		/// or not the <see cref="ZedGraphControl"/> will do any further handling of the
-		/// MouseUp event (see <see cref="ZedMouseEventHandler" />).  Return true if you have
-		/// handled the MouseUp event entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action (e.g., starting
-		/// a zoom operation).  Return false if ZedGraph should go ahead and process the
-		/// MouseUp event.
-		/// </remarks>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to be notified when the left mouse button is released" )]
-		public event ZedMouseEventHandler MouseUpEvent;
-		/// <summary>
-		/// Subscribe to this event to provide notification of MouseMove events over graph
-		/// objects
-		/// </summary>
-		/// <remarks>
-		/// This event provides for a notification when the mouse is moving over on the control.
-		/// The boolean value that you return from this handler determines whether
-		/// or not the <see cref="ZedGraphControl"/> will do any further handling of the
-		/// MouseMove event (see <see cref="ZedMouseEventHandler" />).  Return true if you
-		/// have handled the MouseMove event entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action.
-		/// Return false if ZedGraph should go ahead and process the MouseMove event.
-		/// </remarks>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to be notified when the mouse is moved inside the control" )]
-		public event ZedMouseEventHandler MouseMoveEvent;
-
-		/// <summary>
-		/// Subscribe to this event to provide notification of Double Clicks on graph
-		/// objects
-		/// </summary>
-		/// <remarks>
-		/// This event provides for a notification when the mouse is double-clicked on an object
-		/// within any <see cref="GraphPane"/> of the <see cref="MasterPane"/> associated
-		/// with this <see cref="ZedGraphControl" />.  This event will use the
-		/// <see cref="ZedGraph.MasterPane.FindNearestPaneObject"/> method to determine which object
-		/// was clicked.  The boolean value that you return from this handler determines whether
-		/// or not the <see cref="ZedGraphControl"/> will do any further handling of the
-		/// DoubleClick event (see <see cref="ZedMouseEventHandler" />).  Return true if you have
-		/// handled the DoubleClick event entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action. 
-		/// Return false if ZedGraph should go ahead and process the
-		/// DoubleClick event.
-		/// </remarks>
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to be notified when the left mouse button is double-clicked" )]
-		public event ZedMouseEventHandler DoubleClickEvent;
-
-		/// <summary>
-		/// A delegate that allows notification of clicks on ZedGraph objects that have
-		/// active links enabled
-		/// </summary>
-		/// <param name="sender">The source <see cref="ZedGraphControl"/> object</param>
-		/// <param name="pane">The source <see cref="GraphPane" /> in which the click
-		/// occurred.
-		/// </param>
-		/// <param name="source">The source object which was clicked.  This is typically
-		/// a type of <see cref="CurveItem" /> if a curve point was clicked, or
-		/// a type of <see cref="GraphObj" /> if a graph object was clicked.
-		/// </param>
-		/// <param name="link">The <see cref="Link" /> object, belonging to
-		/// <paramref name="source" />, that contains the link information
-		/// </param>
-		/// <param name="index">An index value, typically used if a <see cref="CurveItem" />
-		/// was clicked, indicating the ordinal value of the actual point that was clicked.
-		/// </param>
-		/// <returns>
-		/// Return true if you have handled the LinkEvent entirely, and you do not
-		/// want the <see cref="ZedGraphControl"/> to do any further action.
-		/// Return false if ZedGraph should go ahead and process the LinkEvent.
-		/// </returns>
-		public delegate bool LinkEventHandler( ZedGraphControl sender, GraphPane pane,
-			object source, Link link, int index );
-
-		/// <summary>
-		/// Subscribe to this event to be able to respond to mouse clicks within linked
-		/// objects.
-		/// </summary>
-		/// <remarks>
-		/// Linked objects are typically either <see cref="GraphObj" /> type objects or
-		/// <see cref="CurveItem" /> type objects.  These object types can include
-		/// hyperlink information allowing for "drill-down" type operation.  
-		/// </remarks>
-		/// <seealso cref="LinkEventHandler"/>
-		/// <seealso cref="Link" />
-		/// <seealso cref="CurveItem.Link">CurveItem.Link</seealso>
-		/// <seealso cref="GraphObj.Link">GraphObj.Link</seealso>
-		// /// <seealso cref="ZedGraph.Web.IsImageMap" />
-		[Bindable( true ), Category( "Events" ),
-		 Description( "Subscribe to be notified when a link-enabled item is clicked" )]
-		public event LinkEventHandler LinkEvent;
-
-	#endregion
-
-	#region Mouse Events
-
-		/// <summary>
-		/// Handle a MouseDown event in the <see cref="ZedGraphControl" />
-		/// </summary>
-		/// <param name="sender">A reference to the <see cref="ZedGraphControl" /></param>
-		/// <param name="e">A <see cref="MouseEventArgs" /> instance</param>
-		protected void ZedGraphControl_MouseDown( object sender, MouseEventArgs e )
-		{
-			_isPanning = false;
-			_isZooming = false;
-			_isEditing = false;
-			_isSelecting = false;
-			_dragPane = null;
-
-			Point mousePt = new Point( e.X, e.Y );
-
-			// Callback for doubleclick events
-			if ( _masterPane != null && e.Clicks > 1 && this.DoubleClickEvent != null )
-			{
-				if ( this.DoubleClickEvent( this, e ) )
-					return;
-			}
-
-			// Provide Callback for MouseDown events
-			if ( _masterPane != null && this.MouseDownEvent != null )
-			{
-				if ( this.MouseDownEvent( this, e ) )
-					return;
-			}
-
-			if ( e.Clicks > 1 || _masterPane == null )
-				return;
-
-			// First, see if the click is within a Linkable object within any GraphPane
-			GraphPane pane = this.MasterPane.FindPane( mousePt );
-			if ( pane != null &&
-					e.Button == _linkButtons && Control.ModifierKeys == _linkModifierKeys )
-			{
-				object source;
-				Link link;
-				int index;
-				using ( Graphics g = this.CreateGraphics() )
-				{
-					float scaleFactor = pane.CalcScaleFactor();
-					if ( pane.FindLinkableObject( mousePt, g, scaleFactor, out source, out link, out index ) )
-					{
-						if ( LinkEvent != null && LinkEvent( this, pane, source, link, index ) )
-							return;
-
-						string url;
-						CurveItem curve = source as CurveItem;
-
-						if ( curve != null )
-							url = link.MakeCurveItemUrl( pane, curve, index );
-						else
-							url = link._url;
-
-						if ( url != string.Empty )
-						{
-							System.Diagnostics.Process.Start( url );
-							// linkable objects override any other actions with mouse
-							return;
-						}
-					}
-					//g.Dispose();
-				}
-			}
-
-			// Second, Check to see if it's within a Chart Rect
-			pane = this.MasterPane.FindChartRect( mousePt );
-			//Rectangle rect = new Rectangle( mousePt, new Size( 1, 1 ) );
-
-			if ( pane != null &&
-				( _isEnableHPan || _isEnableVPan ) &&
-				( ( e.Button == _panButtons && Control.ModifierKeys == _panModifierKeys ) ||
-				( e.Button == _panButtons2 && Control.ModifierKeys == _panModifierKeys2 ) ) )
-			{
-				_isPanning = true;
-				_dragStartPt = mousePt;
-				_dragPane = pane;
-				//_zoomState = new ZoomState( _dragPane, ZoomState.StateType.Pan );
-				ZoomStateSave( _dragPane, ZoomState.StateType.Pan );
-			}
-			else if ( pane != null && ( _isEnableHZoom || _isEnableVZoom ) &&
-				( ( e.Button == _zoomButtons && Control.ModifierKeys == _zoomModifierKeys ) ||
-				( e.Button == _zoomButtons2 && Control.ModifierKeys == _zoomModifierKeys2 ) ) )
-			{
-				_isZooming = true;
-				_dragStartPt = mousePt;
-				_dragEndPt = mousePt;
-				_dragEndPt.Offset( 1, 1 );
-				_dragPane = pane;
-				ZoomStateSave( _dragPane, ZoomState.StateType.Zoom );
-			}
-			//Revision: JCarpenter 10/06
-			else if ( pane != null && _isEnableSelection && e.Button == _selectButtons &&
-				( Control.ModifierKeys == _selectModifierKeys ||
-					Control.ModifierKeys == _selectAppendModifierKeys ) )
-			{
-				_isSelecting = true;
-				_dragStartPt = mousePt;
-				_dragEndPt = mousePt;
-				_dragEndPt.Offset( 1, 1 );
-				_dragPane = pane;
-			}
-			else if ( pane != null && ( _isEnableHEdit || _isEnableVEdit ) &&
-				 ( e.Button == EditButtons && Control.ModifierKeys == EditModifierKeys ) )
-			{
-
-				// find the point that was clicked, and make sure the point list is editable
-				// and that it's a primary Y axis (the first Y or Y2 axis)
-				if ( pane.FindNearestPoint( mousePt, out _dragCurve, out _dragIndex ) &&
-							_dragCurve.Points is IPointListEdit )
-				{
-					_isEditing = true;
-					_dragPane = pane;
-					_dragStartPt = mousePt;
-					_dragStartPair = _dragCurve[_dragIndex];
-				}
-			}
-		}
-
-		/// <summary>
-		/// Set the cursor according to the current mouse location.
-		/// </summary>
-		protected void SetCursor()
-		{
-			SetCursor( this.PointToClient( Control.MousePosition ) );
-		}
-
-		/// <summary>
-		/// Set the cursor according to the current mouse location.
-		/// </summary>
-		protected void SetCursor( Point mousePt )
-		{
-			if ( _masterPane != null )
-			{
-				GraphPane pane = _masterPane.FindChartRect( mousePt );
-				if ( ( _isEnableHPan || _isEnableVPan ) && ( Control.ModifierKeys == Keys.Shift || _isPanning ) &&
-					( pane != null || _isPanning ) )
-					this.Cursor = Cursors.Hand;
-				else if ( ( _isEnableVZoom || _isEnableHZoom ) && ( pane != null || _isZooming ) )
-					this.Cursor = Cursors.Cross;
-				else if ( _isEnableSelection && ( pane != null || _isSelecting ) )
-					this.Cursor = Cursors.Cross;
-				else
-					this.Cursor = Cursors.Default;
-
-				//			else if ( isZoomMode || isPanMode )
-				//				this.Cursor = Cursors.No;
-			}
-		}
-
-		/// <summary>
-		/// Handle a KeyUp event
-		/// </summary>
-		/// <param name="sender">The <see cref="ZedGraphControl" /> in which the KeyUp occurred.</param>
-		/// <param name="e">A <see cref="KeyEventArgs" /> instance.</param>
-		protected void ZedGraphControl_KeyUp( object sender, KeyEventArgs e )
-		{
-			SetCursor();
-		}
-
-		/// <summary>
-		/// Handle the Key Events so ZedGraph can Escape out of a panning or zooming operation.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void ZedGraphControl_KeyDown( object sender, System.Windows.Forms.KeyEventArgs e )
-		{
-			SetCursor();
-
-			if ( e.KeyCode == Keys.Escape )
-			{
-				if ( _isPanning )
-					HandlePanCancel();
-				if ( _isZooming )
-					HandleZoomCancel();
-				if ( _isEditing )
-					HandleEditCancel();
-				//if ( _isSelecting )
-				// Esc always cancels the selection
-				HandleSelectionCancel();
-
-				_isZooming = false;
-				_isPanning = false;
-				_isEditing = false;
-				_isSelecting = false;
-
-				Refresh();
-			}
-		}
-
-		/// <summary>
-		/// Handle a MouseUp event in the <see cref="ZedGraphControl" />
-		/// </summary>
-		/// <param name="sender">A reference to the <see cref="ZedGraphControl" /></param>
-		/// <param name="e">A <see cref="MouseEventArgs" /> instance</param>
-		protected void ZedGraphControl_MouseUp( object sender, MouseEventArgs e )
-		{
-			// Provide Callback for MouseUp events
-			if ( _masterPane != null && this.MouseUpEvent != null )
-			{
-				if ( this.MouseUpEvent( this, e ) )
-					return;
-			}
-
-			if ( _masterPane != null && _dragPane != null )
-			{
-				// If the MouseUp event occurs, the user is done dragging.
-				if ( _isZooming )
-					HandleZoomFinish( sender, e );
-				else if ( _isPanning )
-					HandlePanFinish();
-				else if ( _isEditing )
-					HandleEditFinish();
-				//Revision: JCarpenter 10/06
-				else if ( _isSelecting )
-					HandleSelectionFinish( sender, e );
-			}
-
-			// Reset the rectangle.
-			//dragStartPt = new Rectangle( 0, 0, 0, 0 );
-			_dragPane = null;
-			_isZooming = false;
-			_isPanning = false;
-			_isEditing = false;
-			_isSelecting = false;
-
-			Cursor.Current = Cursors.Default;
-		}
-
-		/// <summary>
-		/// Make a string label that corresponds to a user scale value.
-		/// </summary>
-		/// <param name="axis">The axis from which to obtain the scale value.  This determines
-		/// if it's a date value, linear, log, etc.</param>
-		/// <param name="val">The value to be made into a label</param>
-		/// <param name="iPt">The ordinal position of the value</param>
-		/// <param name="isOverrideOrdinal">true to override the ordinal settings of the axis,
-		/// and prefer the actual value instead.</param>
-		/// <returns>The string label.</returns>
-		protected string MakeValueLabel( Axis axis, double val, int iPt, bool isOverrideOrdinal )
-		{
-			if ( axis != null )
-			{
-				if ( axis.Scale.IsDate || axis.Scale.Type == AxisType.DateAsOrdinal )
-				{
-					return XDate.ToString( val, _pointDateFormat );
-				}
-				else if ( axis._scale.IsText && axis._scale._textLabels != null )
-				{
-					int i = iPt;
-					if ( isOverrideOrdinal )
-						i = (int)( val - 0.5 );
-
-					if ( i >= 0 && i < axis._scale._textLabels.Length )
-						return axis._scale._textLabels[i];
-					else
-						return ( i + 1 ).ToString();
-				}
-				else if ( axis.Scale.IsAnyOrdinal && axis.Scale.Type != AxisType.LinearAsOrdinal
-								&& !isOverrideOrdinal )
-				{
-					return iPt.ToString( _pointValueFormat );
-				}
-				else
-					return val.ToString( _pointValueFormat );
-			}
-			else
-				return "";
-		}
-
-		/// <summary>
-		/// protected method for handling MouseMove events to display tooltips over
-		/// individual datapoints.
-		/// </summary>
-		/// <param name="sender">
-		/// A reference to the control that has the MouseMove event.
-		/// </param>
-		/// <param name="e">
-		/// A MouseEventArgs object.
-		/// </param>
-		protected void ZedGraphControl_MouseMove( object sender, MouseEventArgs e )
-		{
-			if ( _masterPane != null )
-			{
-				Point mousePt = new Point( e.X, e.Y );
-
-				// Provide Callback for MouseMove events
-				if ( this.MouseMoveEvent != null && this.MouseMoveEvent( this, e ) )
-					return;
-
-				//Point tempPt = this.PointToClient( Control.MousePosition );
-
-				SetCursor( mousePt );
-
-				// If the mouse is being dragged,
-				// undraw and redraw the rectangle as the mouse moves.
-				if ( _isZooming )
-					HandleZoomDrag( mousePt );
-				else if ( _isPanning )
-					HandlePanDrag( mousePt );
-				else if ( _isEditing )
-					HandleEditDrag( mousePt );
-				else if ( _isShowCursorValues )
-					HandleCursorValues( mousePt );
-				else if ( _isShowPointValues )
-					HandlePointValues( mousePt );
-				//Revision: JCarpenter 10/06
-				else if ( _isSelecting )
-					HandleZoomDrag( mousePt );
-			}
-		}
-
-		private Point HandlePointValues( Point mousePt )
-		{
-			int iPt;
-			GraphPane pane;
-			object nearestObj;
-
-			using ( Graphics g = this.CreateGraphics() )
-			{
-
-				if ( _masterPane.FindNearestPaneObject( mousePt,
-					g, out pane, out nearestObj, out iPt ) )
-				{
-					if ( nearestObj is CurveItem && iPt >= 0 )
-					{
-						CurveItem curve = (CurveItem)nearestObj;
-						// Provide Callback for User to customize the tooltips
-						if ( this.PointValueEvent != null )
-						{
-							string label = this.PointValueEvent( this, pane, curve, iPt );
-							if ( label != null && label.Length > 0 )
-							{
-								this.pointToolTip.SetToolTip( this, label );
-								this.pointToolTip.Active = true;
-							}
-							else
-								this.pointToolTip.Active = false;
-						}
-						else
-						{
-
-							if ( curve is PieItem )
-							{
-								this.pointToolTip.SetToolTip( this,
-									( (PieItem)curve ).Value.ToString( _pointValueFormat ) );
-							}
-							//							else if ( curve is OHLCBarItem || curve is JapaneseCandleStickItem )
-							//							{
-							//								StockPt spt = (StockPt)curve.Points[iPt];
-							//								this.pointToolTip.SetToolTip( this, ( (XDate) spt.Date ).ToString( "MM/dd/yyyy" ) + "\nOpen: $" +
-							//								spt.Open.ToString( "N2" ) +
-							//								"\nHigh: $" +
-							//								spt.High.ToString( "N2" ) + "\nLow: $" +
-							//								spt.Low.ToString( "N2" ) + "\nClose: $" +
-							//								spt.Close.ToString
-							//								( "N2" ) );
-							//							}
-							else
-							{
-								PointPair pt = curve.Points[iPt];
-
-								if ( pt.Tag is string )
-									this.pointToolTip.SetToolTip( this, (string)pt.Tag );
-								else
-								{
-									double xVal, yVal, lowVal;
-									ValueHandler valueHandler = new ValueHandler( pane, false );
-									if ( ( curve is BarItem || curve is ErrorBarItem || curve is HiLowBarItem )
-											&& pane.BarSettings.Base != BarBase.X )
-										valueHandler.GetValues( curve, iPt, out yVal, out lowVal, out xVal );
-									else
-										valueHandler.GetValues( curve, iPt, out xVal, out lowVal, out yVal );
-
-									string xStr = MakeValueLabel( curve.GetXAxis( pane ), xVal, iPt,
-										curve.IsOverrideOrdinal );
-									string yStr = MakeValueLabel( curve.GetYAxis( pane ), yVal, iPt,
-										curve.IsOverrideOrdinal );
-
-									this.pointToolTip.SetToolTip( this, "( " + xStr + ", " + yStr + " )" );
-
-									//this.pointToolTip.SetToolTip( this,
-									//	curve.Points[iPt].ToString( this.pointValueFormat ) );
-								}
-							}
-
-							this.pointToolTip.Active = true;
-						}
-					}
-					else
-						this.pointToolTip.Active = false;
-				}
-				else
-					this.pointToolTip.Active = false;
-
-				//g.Dispose();
-			}
-			return mousePt;
-		}
-
-		private Point HandleCursorValues( Point mousePt )
-		{
-			GraphPane pane = _masterPane.FindPane( mousePt );
-			if ( pane != null && pane.Chart._rect.Contains( mousePt ) )
-			{
-				double x, x2, y, y2;
-				pane.ReverseTransform( mousePt, out x, out x2, out y, out y2 );
-				string xStr = MakeValueLabel( pane.XAxis, x, -1, true );
-				string yStr = MakeValueLabel( pane.YAxis, y, -1, true );
-				string y2Str = MakeValueLabel( pane.Y2Axis, y2, -1, true );
-
-				this.pointToolTip.SetToolTip( this, "( " + xStr + ", " + yStr + ", " + y2Str + " )" );
-				this.pointToolTip.Active = true;
-			}
-			else
-				this.pointToolTip.Active = false;
-			return mousePt;
-		}
-
-
-	#endregion
-
-	#region Mouse Wheel Zoom Events
-
-		/// <summary>
-		/// Handle a MouseWheel event in the <see cref="ZedGraphControl" />
-		/// </summary>
-		/// <param name="sender">A reference to the <see cref="ZedGraphControl" /></param>
-		/// <param name="e">A <see cref="MouseEventArgs" /> instance</param>
-		protected void ZedGraphControl_MouseWheel( object sender, MouseEventArgs e )
-		{
-			if ( ( _isEnableVZoom || _isEnableHZoom ) && _isEnableWheelZoom && _masterPane != null )
-			{
-				GraphPane pane = this.MasterPane.FindChartRect( new PointF( e.X, e.Y ) );
-				if ( pane != null && e.Delta != 0 )
-				{
-					ZoomState oldState = ZoomStateSave( pane, ZoomState.StateType.WheelZoom );
-					//ZoomState oldState = pane.ZoomStack.Push( pane, ZoomState.StateType.Zoom );
-
-					PointF centerPoint = new PointF( e.X, e.Y );
-					double zoomFraction = ( 1 + ( e.Delta < 0 ? 1.0 : -1.0 ) * ZoomStepFraction );
-
-					ZoomPane( pane, zoomFraction, centerPoint, _isZoomOnMouseCenter, false );
-
-					ApplyToAllPanes( pane );
-
-					using ( Graphics g = this.CreateGraphics() )
-					{
-						// always AxisChange() the dragPane
-						pane.AxisChange( g );
-
-						foreach ( GraphPane tempPane in _masterPane._paneList )
-						{
-							if ( tempPane != pane && ( _isSynchronizeXAxes || _isSynchronizeYAxes ) )
-								tempPane.AxisChange( g );
-						}
-					}
-
-					ZoomStatePush( pane );
-
-					// Provide Callback to notify the user of zoom events
-					if ( this.ZoomEvent != null )
-						this.ZoomEvent( this, oldState, new ZoomState( pane, ZoomState.StateType.WheelZoom ) );
-
-					this.Refresh();
-
-				}
-			}
-		}
-
-		/// <summary>
-		/// Zoom a specified pane in or out according to the specified zoom fraction.
-		/// </summary>
-		/// <remarks>
-		/// The zoom will occur on the <see cref="XAxis" />, <see cref="YAxis" />, and
-		/// <see cref="Y2Axis" /> only if the corresponding flag, <see cref="IsEnableHZoom" /> or
-		/// <see cref="IsEnableVZoom" />, is true.  Note that if there are multiple Y or Y2 axes, all of
-		/// them will be zoomed.
-		/// </remarks>
-		/// <param name="pane">The <see cref="GraphPane" /> instance to be zoomed.</param>
-		/// <param name="zoomFraction">The fraction by which to zoom, less than 1 to zoom in, greater than
-		/// 1 to zoom out.  For example, 0.9 will zoom in such that the scale is 90% of what it was
-		/// originally.</param>
-		/// <param name="centerPt">The screen position about which the zoom will be centered.  This
-		/// value is only used if <see paramref="isZoomOnCenter" /> is true.
-		/// </param>
-		/// <param name="isZoomOnCenter">true to cause the zoom to be centered on the point
-		/// <see paramref="centerPt" />, false to center on the <see cref="Chart.Rect" />.
-		/// </param>
-		/// <param name="isRefresh">true to force a refresh of the control, false to leave it unrefreshed</param>
-		protected void ZoomPane( GraphPane pane, double zoomFraction, PointF centerPt,
-					bool isZoomOnCenter, bool isRefresh )
-		{
-			double x;
-			double x2;
-			double[] y;
-			double[] y2;
-
-			pane.ReverseTransform( centerPt, out x, out x2, out y, out y2 );
-
-			if ( _isEnableHZoom )
-			{
-				ZoomScale( pane.XAxis, zoomFraction, x, isZoomOnCenter );
-				ZoomScale( pane.X2Axis, zoomFraction, x2, isZoomOnCenter );
-			}
-			if ( _isEnableVZoom )
-			{
-				for ( int i = 0; i < pane.YAxisList.Count; i++ )
-					ZoomScale( pane.YAxisList[i], zoomFraction, y[i], isZoomOnCenter );
-				for ( int i = 0; i < pane.Y2AxisList.Count; i++ )
-					ZoomScale( pane.Y2AxisList[i], zoomFraction, y2[i], isZoomOnCenter );
-			}
-
-			using ( Graphics g = this.CreateGraphics() )
-			{
-				pane.AxisChange( g );
-				//g.Dispose();
-			}
-
-			this.SetScroll( this.hScrollBar1, pane.XAxis, _xScrollRange.Min, _xScrollRange.Max );
-			this.SetScroll( this.vScrollBar1, pane.YAxis, _yScrollRangeList[0].Min,
-				_yScrollRangeList[0].Max );
-
-			if ( isRefresh )
-				Refresh();
-		}
-
-		/// <summary>
-		/// Zoom a specified pane in or out according to the specified zoom fraction.
-		/// </summary>
-		/// <remarks>
-		/// The zoom will occur on the <see cref="XAxis" />, <see cref="YAxis" />, and
-		/// <see cref="Y2Axis" /> only if the corresponding flag, <see cref="IsEnableHZoom" /> or
-		/// <see cref="IsEnableVZoom" />, is true.  Note that if there are multiple Y or Y2 axes, all of
-		/// them will be zoomed.
-		/// </remarks>
-		/// <param name="pane">The <see cref="GraphPane" /> instance to be zoomed.</param>
-		/// <param name="zoomFraction">The fraction by which to zoom, less than 1 to zoom in, greater than
-		/// 1 to zoom out.  For example, 0.9 will zoom in such that the scale is 90% of what it was
-		/// originally.</param>
-		/// <param name="centerPt">The screen position about which the zoom will be centered.  This
-		/// value is only used if <see paramref="isZoomOnCenter" /> is true.
-		/// </param>
-		/// <param name="isZoomOnCenter">true to cause the zoom to be centered on the point
-		/// <see paramref="centerPt" />, false to center on the <see cref="Chart.Rect" />.
-		/// </param>
-		public void ZoomPane( GraphPane pane, double zoomFraction, PointF centerPt, bool isZoomOnCenter )
-		{
-			ZoomPane( pane, zoomFraction, centerPt, isZoomOnCenter, true );
-		}
-
-
-		/// <summary>
-		/// Zoom the specified axis by the specified amount, with the center of the zoom at the
-		/// (optionally) specified point.
-		/// </summary>
-		/// <remarks>
-		/// This method is used for MouseWheel zoom operations</remarks>
-		/// <param name="axis">The <see cref="Axis" /> to be zoomed.</param>
-		/// <param name="zoomFraction">The zoom fraction, less than 1.0 to zoom in, greater than 1.0 to
-		/// zoom out.  That is, a value of 0.9 will zoom in such that the scale length is 90% of what
-		/// it previously was.</param>
-		/// <param name="centerVal">The location for the center of the zoom.  This is only used if
-		/// <see paramref="IsZoomOnMouseCenter" /> is true.</param>
-		/// <param name="isZoomOnCenter">true if the zoom is to be centered at the
-		/// <see paramref="centerVal" /> screen position, false for the zoom to be centered within
-		/// the <see cref="Chart.Rect" />.
-		/// </param>
-		protected void ZoomScale( Axis axis, double zoomFraction, double centerVal, bool isZoomOnCenter )
-		{
-			if ( axis != null && zoomFraction > 0.0001 && zoomFraction < 1000.0 )
-			{
-				Scale scale = axis._scale;
-				/*
-								if ( axis.Scale.IsLog )
-								{
-									double ratio = Math.Sqrt( axis._scale._max / axis._scale._min * zoomFraction );
-
-									if ( !isZoomOnCenter )
-										centerVal = Math.Sqrt( axis._scale._max * axis._scale._min );
-
-									axis._scale._min = centerVal / ratio;
-									axis._scale._max = centerVal * ratio;
-								}
-								else
-								{
-				*/
-				double minLin = axis._scale._minLinearized;
-				double maxLin = axis._scale._maxLinearized;
-				double range = ( maxLin - minLin ) * zoomFraction / 2.0;
-
-				if ( !isZoomOnCenter )
-					centerVal = ( maxLin + minLin ) / 2.0;
-
-				axis._scale._minLinearized = centerVal - range;
-				axis._scale._maxLinearized = centerVal + range;
-				//				}
-
-				axis._scale._minAuto = false;
-				axis._scale._maxAuto = false;
-			}
-		}
-
-	#endregion
-
-	#region Pan Events
-
-		private Point HandlePanDrag( Point mousePt )
-		{
-			double x1, x2, xx1, xx2;
-			double[] y1, y2, yy1, yy2;
-			//PointF endPoint = mousePt;
-			//PointF startPoint = ( (Control)sender ).PointToClient( this.dragRect.Location );
-
-			_dragPane.ReverseTransform( _dragStartPt, out x1, out xx1, out y1, out yy1 );
-			_dragPane.ReverseTransform( mousePt, out x2, out xx2, out y2, out yy2 );
-
-			if ( _isEnableHPan )
-			{
-				PanScale( _dragPane.XAxis, x1, x2 );
-				PanScale( _dragPane.X2Axis, xx1, xx2 );
-				this.SetScroll( this.hScrollBar1, _dragPane.XAxis, _xScrollRange.Min, _xScrollRange.Max );
-			}
-			if ( _isEnableVPan )
-			{
-				for ( int i = 0; i < y1.Length; i++ )
-					PanScale( _dragPane.YAxisList[i], y1[i], y2[i] );
-				for ( int i = 0; i < yy1.Length; i++ )
-					PanScale( _dragPane.Y2AxisList[i], yy1[i], yy2[i] );
-				this.SetScroll( this.vScrollBar1, _dragPane.YAxis, _yScrollRangeList[0].Min,
-					_yScrollRangeList[0].Max );
-			}
-
-			ApplyToAllPanes( _dragPane );
-
-			Refresh();
-
-			_dragStartPt = mousePt;
-
-			return mousePt;
-		}
-
-		private void HandlePanFinish()
-		{
-			// push the prior saved zoomstate, since the scale ranges have already been changed on
-			// the fly during the panning operation
-			if ( _zoomState != null && _zoomState.IsChanged( _dragPane ) )
-			{
-				//_dragPane.ZoomStack.Push( _zoomState );
-				ZoomStatePush( _dragPane );
-
-				// Provide Callback to notify the user of pan events
-				if ( this.ZoomEvent != null )
-					this.ZoomEvent( this, _zoomState,
-						new ZoomState( _dragPane, ZoomState.StateType.Pan ) );
-
-				_zoomState = null;
-			}
-		}
-
-		private void HandlePanCancel()
-		{
-			if ( _isPanning )
-			{
-				if ( _zoomState != null && _zoomState.IsChanged( _dragPane ) )
-				{
-					ZoomStateRestore( _dragPane );
-					//_zoomState.ApplyState( _dragPane );
-					//_zoomState = null;
-				}
-				_isPanning = false;
-				Refresh();
-
-				ZoomStateClear();
-			}
-		}
-
-		/// <summary>
-		/// Handle a panning operation for the specified <see cref="Axis" />.
-		/// </summary>
-		/// <param name="axis">The <see cref="Axis" /> to be panned</param>
-		/// <param name="startVal">The value where the pan started.  The scale range
-		/// will be shifted by the difference between <see paramref="startVal" /> and
-		/// <see paramref="endVal" />.
-		/// </param>
-		/// <param name="endVal">The value where the pan ended.  The scale range
-		/// will be shifted by the difference between <see paramref="startVal" /> and
-		/// <see paramref="endVal" />.
-		/// </param>
-		protected void PanScale( Axis axis, double startVal, double endVal )
-		{
-			if ( axis != null )
-			{
-				Scale scale = axis._scale;
-				double delta = scale.Linearize( startVal ) - scale.Linearize( endVal );
-
-				scale._minLinearized += delta;
-				scale._maxLinearized += delta;
-
-				scale._minAuto = false;
-				scale._maxAuto = false;
-
-				/*
-								if ( axis.Type == AxisType.Log )
-								{
-									axis._scale._min *= startVal / endVal;
-									axis._scale._max *= startVal / endVal;
-								}
-								else
-								{
-									axis._scale._min += startVal - endVal;
-									axis._scale._max += startVal - endVal;
-								}
-				*/
-			}
-		}
-
-	#endregion
-
-	#region Edit Point Events
-
-		private void HandleEditDrag( Point mousePt )
-		{
-			// get the scale values that correspond to the current point
-			double curX, curY;
-			_dragPane.ReverseTransform( mousePt, _dragCurve.IsX2Axis, _dragCurve.IsY2Axis,
-					_dragCurve.YAxisIndex, out curX, out curY );
-			double startX, startY;
-			_dragPane.ReverseTransform( _dragStartPt, _dragCurve.IsX2Axis, _dragCurve.IsY2Axis,
-					_dragCurve.YAxisIndex, out startX, out startY );
-
-			// calculate the new scale values for the point
-			PointPair newPt = new PointPair( _dragStartPair );
-
-			Scale xScale = _dragCurve.GetXAxis( _dragPane )._scale;
-			if ( _isEnableHEdit )
-				newPt.X = xScale.DeLinearize( xScale.Linearize( newPt.X ) +
-							xScale.Linearize( curX ) - xScale.Linearize( startX ) );
-
-			Scale yScale = _dragCurve.GetYAxis( _dragPane )._scale;
-			if ( _isEnableVEdit )
-				newPt.Y = yScale.DeLinearize( yScale.Linearize( newPt.Y ) +
-							yScale.Linearize( curY ) - yScale.Linearize( startY ) );
-
-			// save the data back to the point list
-			IPointListEdit list = _dragCurve.Points as IPointListEdit;
-			if ( list != null )
-				list[_dragIndex] = newPt;
-
-			// force a redraw
-			Refresh();
-		}
-
-		private void HandleEditFinish()
-		{
-			if ( this.PointEditEvent != null )
-				this.PointEditEvent( this, _dragPane, _dragCurve, _dragIndex );
-		}
-
-		private void HandleEditCancel()
-		{
-			if ( _isEditing )
-			{
-				IPointListEdit list = _dragCurve.Points as IPointListEdit;
-				if ( list != null )
-					list[_dragIndex] = _dragStartPair;
-				_isEditing = false;
-				Refresh();
-			}
-		}
-
-	#endregion
-
-	#region Zoom Events
-
-		private void HandleZoomDrag( Point mousePt )
-		{
-			// Hide the previous rectangle by calling the
-			// DrawReversibleFrame method with the same parameters.
-			Rectangle rect = CalcScreenRect( _dragStartPt, _dragEndPt );
-			ControlPaint.DrawReversibleFrame( rect, this.BackColor, FrameStyle.Dashed );
-
-			// Bound the zoom to the ChartRect
-			_dragEndPt = Point.Round( BoundPointToRect( mousePt, _dragPane.Chart._rect ) );
-			rect = CalcScreenRect( _dragStartPt, _dragEndPt );
-			// Draw the new rectangle by calling DrawReversibleFrame again.
-			ControlPaint.DrawReversibleFrame( rect, this.BackColor, FrameStyle.Dashed );
-		}
-
-		private const double ZoomResolution = 1e-300;
-
-		private void HandleZoomFinish( object sender, MouseEventArgs e )
-		{
-			PointF mousePtF = BoundPointToRect( new Point( e.X, e.Y ), _dragPane.Chart._rect );
-
-			// Only accept a drag if it covers at least 5 pixels in each direction
-			//Point curPt = ( (Control)sender ).PointToScreen( Point.Round( mousePt ) );
-			if ( ( Math.Abs( mousePtF.X - _dragStartPt.X ) > 4 || !_isEnableHZoom ) &&
-					( Math.Abs( mousePtF.Y - _dragStartPt.Y ) > 4 || !_isEnableVZoom ) )
-			{
-				// Draw the rectangle to be evaluated. Set a dashed frame style
-				// using the FrameStyle enumeration.
-				//ControlPaint.DrawReversibleFrame( this.dragRect,
-				//	this.BackColor, FrameStyle.Dashed );
-
-				double x1, x2, xx1, xx2;
-				double[] y1, y2, yy1, yy2;
-				//PointF startPoint = ( (Control)sender ).PointToClient( this.dragRect.Location );
-
-				_dragPane.ReverseTransform( _dragStartPt, out x1, out xx1, out y1, out yy1 );
-				_dragPane.ReverseTransform( mousePtF, out x2, out xx2, out y2, out yy2 );
-
-				bool zoomLimitExceeded = false;
-
-				if ( _isEnableHZoom )
-				{
-					double min1 = Math.Min( x1, x2 );
-					double max1 = Math.Max( x1, x2 );
-					double min2 = Math.Min( xx1, xx2 );
-					double max2 = Math.Max( xx1, xx2 );
-
-					if ( Math.Abs( x1 - x2 ) < ZoomResolution || Math.Abs( xx1 - xx2 ) < ZoomResolution )
-						zoomLimitExceeded = true;
-				}
-
-				if ( _isEnableVZoom && !zoomLimitExceeded )
-				{
-					for ( int i = 0; i < y1.Length; i++ )
-					{
-						if ( Math.Abs( y1[i] - y2[i] ) < ZoomResolution )
-						{
-							zoomLimitExceeded = true;
-							break;
-						}
-					}
-					for ( int i = 0; i < yy1.Length; i++ )
-					{
-						if ( Math.Abs( yy1[i] - yy2[i] ) < ZoomResolution )
-						{
-							zoomLimitExceeded = true;
-							break;
-						}
-					}
-				}
-
-				if ( !zoomLimitExceeded )
-				{
-
-					ZoomStatePush( _dragPane );
-					//ZoomState oldState = _dragPane.ZoomStack.Push( _dragPane,
-					//			ZoomState.StateType.Zoom );
-
-
-					if ( _isEnableHZoom )
-					{
-						_dragPane.XAxis._scale._min = Math.Min( x1, x2 );
-						_dragPane.XAxis._scale._minAuto = false;
-						_dragPane.XAxis._scale._max = Math.Max( x1, x2 );
-						_dragPane.XAxis._scale._maxAuto = false;
-
-						_dragPane.X2Axis._scale._min = Math.Min( xx1, xx2 );
-						_dragPane.X2Axis._scale._minAuto = false;
-						_dragPane.X2Axis._scale._max = Math.Max( xx1, xx2 );
-						_dragPane.X2Axis._scale._maxAuto = false;
-					}
-
-					if ( _isEnableVZoom )
-					{
-						for ( int i = 0; i < y1.Length; i++ )
-						{
-							_dragPane.YAxisList[i]._scale._min = Math.Min( y1[i], y2[i] );
-							_dragPane.YAxisList[i]._scale._max = Math.Max( y1[i], y2[i] );
-							_dragPane.YAxisList[i]._scale._minAuto = false;
-							_dragPane.YAxisList[i]._scale._maxAuto = false;
-						}
-						for ( int i = 0; i < yy1.Length; i++ )
-						{
-							_dragPane.Y2AxisList[i]._scale._min = Math.Min( yy1[i], yy2[i] );
-							_dragPane.Y2AxisList[i]._scale._max = Math.Max( yy1[i], yy2[i] );
-							_dragPane.Y2AxisList[i]._scale._minAuto = false;
-							_dragPane.Y2AxisList[i]._scale._maxAuto = false;
-						}
-					}
-
-					this.SetScroll( this.hScrollBar1, _dragPane.XAxis, _xScrollRange.Min, _xScrollRange.Max );
-					this.SetScroll( this.vScrollBar1, _dragPane.YAxis, _yScrollRangeList[0].Min,
-						_yScrollRangeList[0].Max );
-
-					ApplyToAllPanes( _dragPane );
-
-					// Provide Callback to notify the user of zoom events
-					if ( this.ZoomEvent != null )
-						this.ZoomEvent( this, _zoomState, //oldState,
-							new ZoomState( _dragPane, ZoomState.StateType.Zoom ) );
-
-					using ( Graphics g = this.CreateGraphics() )
-					{
-						// always AxisChange() the dragPane
-						_dragPane.AxisChange( g );
-
-						foreach ( GraphPane pane in _masterPane._paneList )
-						{
-							if ( pane != _dragPane && ( _isSynchronizeXAxes || _isSynchronizeYAxes ) )
-								pane.AxisChange( g );
-						}
-					}
-				}
-
-				Refresh();
-			}
-		}
-
-		private void HandleZoomCancel()
-		{
-			if ( _isZooming )
-			{
-				_isZooming = false;
-				Refresh();
-
-				ZoomStateClear();
-			}
-		}
-
-		private PointF BoundPointToRect( Point mousePt, RectangleF rect )
-		{
-			PointF newPt = new PointF( mousePt.X, mousePt.Y );
-
-			if ( mousePt.X < rect.X ) newPt.X = rect.X;
-			if ( mousePt.X > rect.Right ) newPt.X = rect.Right;
-			if ( mousePt.Y < rect.Y ) newPt.Y = rect.Y;
-			if ( mousePt.Y > rect.Bottom ) newPt.Y = rect.Bottom;
-
-			return newPt;
-		}
-
-		private Rectangle CalcScreenRect( Point mousePt1, Point mousePt2 )
-		{
-			Point screenPt = PointToScreen( mousePt1 );
-			Size size = new Size( mousePt2.X - mousePt1.X, mousePt2.Y - mousePt1.Y );
-			Rectangle rect = new Rectangle( screenPt, size );
-
-			if ( _isZooming )
-			{
-				Rectangle chartRect = Rectangle.Round( _dragPane.Chart._rect );
-
-				Point chartPt = PointToScreen( chartRect.Location );
-
-				if ( !_isEnableVZoom )
-				{
-					rect.Y = chartPt.Y;
-					rect.Height = chartRect.Height + 1;
-				}
-				else if ( !_isEnableHZoom )
-				{
-					rect.X = chartPt.X;
-					rect.Width = chartRect.Width + 1;
-				}
-			}
-
-			return rect;
-		}
-
-	#endregion
-
-	#region Selection Events
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Perform selection on curves within the drag pane, or under the mouse click.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		private void HandleSelectionFinish( object sender, MouseEventArgs e )
-		{
-			if ( e.Button != _selectButtons )
-			{
-				Refresh();
-				return;
-			}
-
-			PointF mousePtF = BoundPointToRect( new Point( e.X, e.Y ), _dragPane.Chart._rect );
-
-			PointF mousePt = BoundPointToRect( new Point( e.X, e.Y ), _dragPane.Rect );
-
-			Point curPt = ( (Control)sender ).PointToScreen( Point.Round( mousePt ) );
-
-			// Only accept a drag if it covers at least 5 pixels in each direction
-			//Point curPt = ( (Control)sender ).PointToScreen( Point.Round( mousePt ) );
-			if ( ( Math.Abs( mousePtF.X - _dragStartPt.X ) > 4 ) &&
-					  ( Math.Abs( mousePtF.Y - _dragStartPt.Y ) > 4 ) )
-			{
-
-				#region New Code to Select on Rubber Band
-
-				double x1, x2, xx1, xx2;
-				double[] y1, y2, yy1, yy2;
-				PointF startPoint = ( (Control)sender ).PointToClient( new Point( Convert.ToInt32( this._dragPane.Rect.X ), Convert.ToInt32( this._dragPane.Rect.Y ) ) );
-
-				_dragPane.ReverseTransform( _dragStartPt, out x1, out xx1, out y1, out yy1 );
-				_dragPane.ReverseTransform( mousePtF, out x2, out xx2, out y2, out yy2 );
-
-				CurveList objects = new CurveList();
-
-				double left = Math.Min( x1, x2 );
-				double right = Math.Max( x1, x2 );
-
-				double top = 0;
-				double bottom = 0;
-
-				for ( int i = 0; i < y1.Length; i++ )
-				{
-					bottom = Math.Min( y1[i], y2[i] );
-					top = Math.Max( y1[i], y2[i] );
-				}
-
-				for ( int i = 0; i < yy1.Length; i++ )
-				{
-					bottom = Math.Min( bottom, yy2[i] );
-					bottom = Math.Min( yy1[i], bottom );
-					top = Math.Max( top, yy2[i] );
-					top = Math.Max( yy1[i], top );
-				}
-
-				double w = right - left;
-				double h = bottom - top;
-
-				RectangleF rF = new RectangleF( (float)left, (float)top, (float)w, (float)h );
-
-				_dragPane.FindContainedObjects( rF, this.CreateGraphics(), out objects );
-
-				if ( Control.ModifierKeys == _selectAppendModifierKeys )
-					_selection.AddToSelection( _masterPane, objects );
-				else
-					_selection.Select( _masterPane, objects );
-				//				this.Select( objects );
-
-				//Graphics g = this.CreateGraphics();
-				//this._dragPane.AxisChange( g );
-				//g.Dispose();
-
-				#endregion
-			}
-			else   // It's a single-select
-			{
-				#region New Code to Single Select
-
-				//Point mousePt = new Point( e.X, e.Y );
-
-				int iPt;
-				GraphPane pane;
-				object nearestObj;
-
-				using ( Graphics g = this.CreateGraphics() )
-				{
-					if ( this.MasterPane.FindNearestPaneObject( mousePt, g, out pane,
-								out nearestObj, out iPt ) )
-					{
-						if ( nearestObj is CurveItem && iPt >= 0 )
-						{
-							if ( Control.ModifierKeys == _selectAppendModifierKeys )
-								_selection.AddToSelection( _masterPane, nearestObj as CurveItem );
-							else
-								_selection.Select( _masterPane, nearestObj as CurveItem );
-						}
-						else
-							_selection.ClearSelection( _masterPane );
-
-						Refresh();
-					}
-					else
-					{
-						_selection.ClearSelection( _masterPane );
-					}
-				}
-				#endregion New Code to Single Select
-			}
-
-			using ( Graphics g = this.CreateGraphics() )
-			{
-				// always AxisChange() the dragPane
-				_dragPane.AxisChange( g );
-
-				foreach ( GraphPane pane in _masterPane._paneList )
-				{
-					if ( pane != _dragPane && ( _isSynchronizeXAxes || _isSynchronizeYAxes ) )
-						pane.AxisChange( g );
-				}
-			}
-
-			Refresh();
-		}
-
-		private void HandleSelectionCancel()
-		{
-			_isSelecting = false;
-
-			_selection.ClearSelection( _masterPane );
-
-			Refresh();
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ZedGraphControl.Printing.cs b/BDInfo/ZedGraph/ZedGraphControl.Printing.cs
deleted file mode 100644
index c2e94e5024..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.Printing.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Windows.Forms;
-using System.Drawing.Imaging;
-using System.Drawing.Printing;
-using System.Threading;
-
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-
-	#region Printing
-
-		/// <summary>
-		/// Handler for the "Page Setup..." context menu item.   Displays a
-		/// <see cref="PageSetupDialog" />.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_PageSetup( object sender, EventArgs e )
-		{
-			DoPageSetup();
-		}
-
-		/// <summary>
-		/// Handler for the "Print..." context menu item.   Displays a
-		/// <see cref="PrintDialog" />.
-		/// </summary>
-		/// <param name="sender"></param>
-		/// <param name="e"></param>
-		protected void MenuClick_Print( object sender, EventArgs e )
-		{
-			DoPrint();
-		}
-
-		/// <summary>
-		/// Rendering method used by the print context menu items
-		/// </summary>
-		/// <param name="sender">The applicable <see cref="PrintDocument" />.</param>
-		/// <param name="e">A <see cref="PrintPageEventArgs" /> instance providing
-		/// page bounds, margins, and a Graphics instance for this printed output.
-		/// </param>
-		private void Graph_PrintPage( object sender, PrintPageEventArgs e )
-		{
-			PrintDocument pd = sender as PrintDocument;
-
-			MasterPane mPane = this.MasterPane;
-			bool[] isPenSave = new bool[mPane.PaneList.Count + 1];
-			bool[] isFontSave = new bool[mPane.PaneList.Count + 1];
-			isPenSave[0] = mPane.IsPenWidthScaled;
-			isFontSave[0] = mPane.IsFontsScaled;
-			for ( int i = 0; i < mPane.PaneList.Count; i++ )
-			{
-				isPenSave[i + 1] = mPane[i].IsPenWidthScaled;
-				isFontSave[i + 1] = mPane[i].IsFontsScaled;
-				if ( _isPrintScaleAll )
-				{
-					mPane[i].IsPenWidthScaled = true;
-					mPane[i].IsFontsScaled = true;
-				}
-			}
-
-			RectangleF saveRect = mPane.Rect;
-			SizeF newSize = mPane.Rect.Size;
-			if ( _isPrintFillPage && _isPrintKeepAspectRatio )
-			{
-				float xRatio = (float)e.MarginBounds.Width / (float)newSize.Width;
-				float yRatio = (float)e.MarginBounds.Height / (float)newSize.Height;
-				float ratio = Math.Min( xRatio, yRatio );
-
-				newSize.Width *= ratio;
-				newSize.Height *= ratio;
-			}
-			else if ( _isPrintFillPage )
-				newSize = e.MarginBounds.Size;
-
-			mPane.ReSize( e.Graphics, new RectangleF( e.MarginBounds.Left,
-				e.MarginBounds.Top, newSize.Width, newSize.Height ) );
-			mPane.Draw( e.Graphics );
-
-			using ( Graphics g = this.CreateGraphics() )
-			{
-				mPane.ReSize( g, saveRect );
-				//g.Dispose();
-			}
-
-			mPane.IsPenWidthScaled = isPenSave[0];
-			mPane.IsFontsScaled = isFontSave[0];
-			for ( int i = 0; i < mPane.PaneList.Count; i++ )
-			{
-				mPane[i].IsPenWidthScaled = isPenSave[i + 1];
-				mPane[i].IsFontsScaled = isFontSave[i + 1];
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="System.Drawing.Printing.PrintDocument" /> instance
-		/// that is used for all of the context menu printing functions.
-		/// </summary>
-		public PrintDocument PrintDocument
-		{
-			get
-			{
-				// Add a try/catch pair since the users of the control can't catch this one
-				try
-				{
-					if ( _pdSave == null )
-					{
-						_pdSave = new PrintDocument();
-						_pdSave.PrintPage += new PrintPageEventHandler( Graph_PrintPage );
-					}
-				}
-				catch ( Exception exception )
-				{
-					MessageBox.Show( exception.Message );
-				}
-
-				return _pdSave;
-			}
-			set { _pdSave = value; }
-		}
-
-		/// <summary>
-		/// Display a <see cref="PageSetupDialog" /> to the user, allowing them to modify
-		/// the print settings for this <see cref="ZedGraphControl" />.
-		/// </summary>
-		public void DoPageSetup()
-		{
-			PrintDocument pd = PrintDocument;
-
-			// Add a try/catch pair since the users of the control can't catch this one
-			try
-			{
-				if ( pd != null )
-				{
-					//pd.PrintPage += new PrintPageEventHandler( GraphPrintPage );
-					PageSetupDialog setupDlg = new PageSetupDialog();
-					setupDlg.Document = pd;
-
-					if ( setupDlg.ShowDialog() == DialogResult.OK )
-					{
-						pd.PrinterSettings = setupDlg.PrinterSettings;
-						pd.DefaultPageSettings = setupDlg.PageSettings;
-
-						// BUG in PrintDocument!!!  Converts in/mm repeatedly
-						// http://support.microsoft.com/?id=814355
-						// from http://www.vbinfozine.com/tpagesetupdialog.shtml, by Palo Mraz
-						//if ( System.Globalization.RegionInfo.CurrentRegion.IsMetric )
-						//{
-						//	setupDlg.Document.DefaultPageSettings.Margins = PrinterUnitConvert.Convert(
-						//	setupDlg.Document.DefaultPageSettings.Margins,
-						//	PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter );
-						//}
-					}
-				}
-			}
-
-			catch ( Exception exception )
-			{
-				MessageBox.Show( exception.Message );
-			}
-		}
-
-		/// <summary>
-		/// Display a <see cref="PrintDialog" /> to the user, allowing them to select a
-		/// printer and print the <see cref="MasterPane" /> contained in this
-		/// <see cref="ZedGraphControl" />.
-		/// </summary>
-		public void DoPrint()
-		{
-			// Add a try/catch pair since the users of the control can't catch this one
-			try
-			{
-				PrintDocument pd = PrintDocument;
-
-				if ( pd != null )
-				{
-					//pd.PrintPage += new PrintPageEventHandler( Graph_PrintPage );
-					PrintDialog pDlg = new PrintDialog();
-					pDlg.Document = pd;
-					if ( pDlg.ShowDialog() == DialogResult.OK )
-						pd.Print();
-				}
-			}
-			catch ( Exception exception )
-			{
-				MessageBox.Show( exception.Message );
-			}
-
-		}
-
-		/// <summary>
-		/// Display a <see cref="PrintPreviewDialog" />, allowing the user to preview and
-		/// subsequently print the <see cref="MasterPane" /> contained in this
-		/// <see cref="ZedGraphControl" />.
-		/// </summary>
-		public void DoPrintPreview()
-		{
-			// Add a try/catch pair since the users of the control can't catch this one
-			try
-			{
-				PrintDocument pd = PrintDocument;
-
-				if ( pd != null )
-				{
-					PrintPreviewDialog ppd = new PrintPreviewDialog();
-					//pd.PrintPage += new PrintPageEventHandler( Graph_PrintPage );
-					ppd.Document = pd;
-					ppd.Show( this );
-				}
-			}
-			catch ( Exception exception )
-			{
-				MessageBox.Show( exception.Message );
-			}
-		}
-
-	#endregion
-
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ZedGraphControl.Properties.cs b/BDInfo/ZedGraph/ZedGraphControl.Properties.cs
deleted file mode 100644
index 7bafcfd96a..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.Properties.cs
+++ /dev/null
@@ -1,1231 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Windows.Forms;
-
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-
-	#region Button and Key Properties
-
-		/// <summary>
-		/// Gets or sets a value that determines which mouse button will be used as a primary option
-		/// to trigger a zoom event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="ZoomModifierKeys"/> to determine the actual zoom combination.
-		/// A secondary zoom button/key combination option is available via <see cref="ZoomButtons2"/> and
-		/// <see cref="ZoomModifierKeys2"/>.  To not use this button/key combination, set the value
-		/// of <see cref="ZoomButtons"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Left ),
-		 Description( "Determines which mouse button is used as the primary for zooming" )]
-		public MouseButtons ZoomButtons
-		{
-			get { return _zoomButtons; }
-			set { _zoomButtons = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which mouse button will be used as the secondary option
-		/// to trigger a zoom event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="ZoomModifierKeys2"/> to determine the actual zoom combination.
-		/// The primary zoom button/key combination option is available via <see cref="ZoomButtons"/> and
-		/// <see cref="ZoomModifierKeys"/>.  To not use this button/key combination, set the value
-		/// of <see cref="ZoomButtons2"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.None ),
-		 Description( "Determines which mouse button is used as the secondary for zooming" )]
-		public MouseButtons ZoomButtons2
-		{
-			get { return _zoomButtons2; }
-			set { _zoomButtons2 = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a primary option
-		/// to trigger a zoom event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="ZoomButtons"/> to determine the actual zoom combination.
-		/// A secondary zoom button/key combination option is available via <see cref="ZoomButtons2"/> and
-		/// <see cref="ZoomModifierKeys2"/>.  To not use this button/key combination, set the value
-		/// of <see cref="ZoomButtons"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.None ),
-		 Description( "Determines which modifier key used as the primary for zooming" )]
-		public Keys ZoomModifierKeys
-		{
-			get { return _zoomModifierKeys; }
-			set { _zoomModifierKeys = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a secondary option
-		/// to trigger a zoom event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="ZoomButtons2"/> to determine the actual zoom combination.
-		/// A primary zoom button/key combination option is available via <see cref="ZoomButtons"/> and
-		/// <see cref="ZoomModifierKeys"/>.  To not use this button/key combination, set the value
-		/// of <see cref="ZoomButtons2"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.None ),
-		 Description( "Determines which modifier key used as the secondary for zooming" )]
-		public Keys ZoomModifierKeys2
-		{
-			get { return _zoomModifierKeys2; }
-			set { _zoomModifierKeys2 = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which mouse button will be used as a primary option
-		/// to trigger a pan event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="PanModifierKeys"/> to determine the actual pan combination.
-		/// A secondary pan button/key combination option is available via <see cref="PanButtons2"/> and
-		/// <see cref="PanModifierKeys2"/>.  To not use this button/key combination, set the value
-		/// of <see cref="PanButtons"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Left ),
-		 Description( "Determines which mouse button is used as the primary for panning" )]
-		public MouseButtons PanButtons
-		{
-			get { return _panButtons; }
-			set { _panButtons = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which mouse button will be used as the secondary option
-		/// to trigger a pan event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="PanModifierKeys2"/> to determine the actual pan combination.
-		/// The primary pan button/key combination option is available via <see cref="PanButtons"/> and
-		/// <see cref="PanModifierKeys"/>.  To not use this button/key combination, set the value
-		/// of <see cref="PanButtons2"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Middle ),
-		 Description( "Determines which mouse button is used as the secondary for panning" )]
-		public MouseButtons PanButtons2
-		{
-			get { return _panButtons2; }
-			set { _panButtons2 = value; }
-		}
-
-		// NOTE: The default value of PanModifierKeys is Keys.Shift. Because of an apparent bug in
-		// VS 2003, the initial value set in InitializeComponent by the code wizard is "Keys.Shift+None"
-		// which will not compile.  As a temporary workaround, I've hidden the value so that it won't
-		// have compile errors.  This problem does not exist in VS 2005.
-
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a primary option
-		/// to trigger a pan event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="PanButtons"/> to determine the actual pan combination.
-		/// A secondary pan button/key combination option is available via <see cref="PanButtons2"/> and
-		/// <see cref="PanModifierKeys2"/>.  To not use this button/key combination, set the value
-		/// of <see cref="PanButtons"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.Control ),
-		 Description( "Determines which modifier key is used as the primary for panning" )]
-		public Keys PanModifierKeys
-		{
-			get { return _panModifierKeys; }
-			set { _panModifierKeys = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a secondary option
-		/// to trigger a pan event.
-		/// </summary>
-		/// <remarks>
-		/// This value is combined with <see cref="PanButtons2"/> to determine the actual pan combination.
-		/// A primary pan button/key combination option is available via <see cref="PanButtons"/> and
-		/// <see cref="PanModifierKeys"/>.  To not use this button/key combination, set the value
-		/// of <see cref="PanButtons2"/> to <see cref="MouseButtons.None"/>.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.None ),
-		 Description( "Determines which modifier key is used as the secondary for panning" )]
-		public Keys PanModifierKeys2
-		{
-			get { return _panModifierKeys2; }
-			set { _panModifierKeys2 = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to edit point
-		/// data values
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHEdit" /> and/or
-		/// <see cref="IsEnableVEdit" /> are true.
-		/// </remarks>
-		/// <seealso cref="EditModifierKeys" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Right ),
-		 Description( "Specify mouse button for point editing" )]
-		public MouseButtons EditButtons
-		{
-			get { return _editButtons; }
-			set { _editButtons = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to edit point
-		/// data values
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHEdit" /> and/or
-		/// <see cref="IsEnableVEdit" /> are true.
-		/// </remarks>
-		/// <seealso cref="EditButtons" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.Alt ),
-		 Description( "Specify modifier key for point editing" )]
-		public Keys EditModifierKeys
-		{
-			get { return _editModifierKeys; }
-			set { _editModifierKeys = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to 
-		/// select <see cref="CurveItem" />'s.
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableSelection" /> is true.
-		/// </remarks>
-		/// <seealso cref="SelectModifierKeys" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Left ),
-		 Description( "Specify mouse button for curve selection" )]
-		public MouseButtons SelectButtons
-		{
-			get { return _selectButtons; }
-			set { _selectButtons = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which Modifier keys will be used to 
-		/// select <see cref="CurveItem" />'s.
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableSelection" /> is true.
-		/// </remarks>
-		/// <seealso cref="SelectButtons" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.Shift ),
-		 Description( "Specify modifier key for curve selection" )]
-		public Keys SelectModifierKeys
-		{
-			get { return _selectModifierKeys; }
-			set { _selectModifierKeys = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which Modifier keys will be used to 
-		/// append a <see cref="CurveItem" /> to the selection list.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.Shift | Keys.Alt ),
-		 Description( "Specify modifier key for append curve selection" )]
-		public Keys SelectAppendModifierKeys
-		{
-			get { return _selectAppendModifierKeys; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to click
-		/// on linkable objects
-		/// </summary>
-		/// <seealso cref="LinkModifierKeys" />
-		/// <seealso cref="LinkEvent"/>
-		// /// <seealso cref="ZedGraph.Web.IsImageMap"/>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( MouseButtons.Left ),
-		 Description( "Specify mouse button for clicking on linkable objects" )]
-		public MouseButtons LinkButtons
-		{
-			get { return _linkButtons; }
-			set { _linkButtons = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to click
-		/// on linkable objects
-		/// </summary>
-		/// <seealso cref="LinkButtons" />
-		/// <seealso cref="LinkEvent"/>
-		// /// <seealso cref="ZedGraph.Web.IsImageMap"/>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( Keys.Alt ),
-		 Description( "Specify modifier key for clicking on linkable objects" )]
-		public Keys LinkModifierKeys
-		{
-			get { return _linkModifierKeys; }
-			set { _linkModifierKeys = value; }
-		}
-
-	#endregion
-
-	#region Properties
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.MasterPane"/> property for the control
-		/// </summary>
-		[Bindable( false ), Browsable( false ),
-		 DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden )]
-		public MasterPane MasterPane
-		{
-			get { lock ( this ) return _masterPane; }
-			set { lock ( this ) _masterPane = value; }
-		}
-
-		// Testing for Designer attribute
-		/*
-		Class1 _class1 = null;
-		[ Bindable( true ), Browsable( true ), Category( "Data" ), NotifyParentProperty( true ),
-			DesignerSerializationVisibility( DesignerSerializationVisibility.Content ),
-			Description( "My Class1 Test" )]
-		public Class1 Class1
-		{
-			get { if ( _class1 == null ) _class1 = new Class1(); return _class1; }
-			set { _class1 = value; }
-		}
-		*/
-
-		/// <summary>
-		/// Gets or sets the <see cref="ZedGraph.GraphPane"/> property for the control
-		/// </summary>
-		/// <remarks>
-		/// <see cref="ZedGraphControl"/> actually uses a <see cref="MasterPane"/> object
-		/// to hold a list of <see cref="GraphPane"/> objects.  This property really only
-		/// accesses the first <see cref="GraphPane"/> in the list.  If there is more
-		/// than one <see cref="GraphPane"/>, use the <see cref="MasterPane"/>
-		/// indexer property to access any of the <see cref="GraphPane"/> objects.</remarks>
-		[
-			Bindable( false ), Browsable( false ),
-			DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden )
-		]
-		//[
-		//	Bindable( true ), Browsable( true ), Category( "Data" ), NotifyParentProperty( true ),
-		//	AttributeProvider( typeof( GraphPane ) ),
-		//	Description("Access to the primary GraphPane object associated with this control")
-		//]
-		public GraphPane GraphPane
-		{
-			get
-			{
-				// Just return the first GraphPane in the list
-				lock ( this )
-				{
-					if ( _masterPane != null && _masterPane.PaneList.Count > 0 )
-						return _masterPane[0];
-					else
-						return null;
-				}
-			}
-
-			set
-			{
-				lock ( this )
-				{
-					//Clear the list, and replace it with the specified Graphpane
-					if ( _masterPane != null )
-					{
-						_masterPane.PaneList.Clear();
-						_masterPane.Add( value );
-					}
-				}
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if all drawing operations for this control
-		/// will be forced to operate in Anti-alias mode.  Note that if this value is set to
-		/// "true", it overrides the setting for sub-objects.  Otherwise, the sub-object settings
-		/// (such as <see cref="FontSpec.IsAntiAlias"/>)
-		/// will be honored.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to force all objects to be draw in anti-alias mode" )]
-		public bool IsAntiAlias
-		{
-			get { return _masterPane.IsAntiAlias; }
-			set { _masterPane.IsAntiAlias = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not tooltips will be displayed
-		/// when the mouse hovers over data values.
-		/// </summary>
-		/// <remarks>The displayed values are taken from <see cref="PointPair.Tag"/>
-		/// if it is a <see cref="System.String"/> type, or <see cref="PointPairBase.ToString()"/>
-		/// otherwise (using the <see cref="PointValueFormat" /> as a format string).
-		/// Additionally, the user can custom format the values using the
-		/// <see cref="PointValueEvent" /> event.  Note that <see cref="IsShowPointValues" />
-		/// may be overridden by <see cref="IsShowCursorValues" />.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to display tooltips when the mouse hovers over data points" )]
-		public bool IsShowPointValues
-		{
-			get { return _isShowPointValues; }
-			set { _isShowPointValues = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not tooltips will be displayed
-		/// showing the current scale values when the mouse is within the
-		/// <see cref="Chart.Rect" />.
-		/// </summary>
-		/// <remarks>The displayed values are taken from the current mouse position, and formatted
-		/// according to <see cref="PointValueFormat" /> and/or <see cref="PointDateFormat" />.  If this
-		/// value is set to true, it overrides the <see cref="IsShowPointValues" /> setting.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to display tooltips showing the current mouse position within the Chart area" )]
-		public bool IsShowCursorValues
-		{
-			get { return _isShowCursorValues; }
-			set { _isShowCursorValues = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not editing of point data is allowed in
-		/// the horizontal direction.
-		/// </summary>
-		/// <remarks>
-		/// Editing is done by holding down the Alt key, and left-clicking on an individual point of
-		/// a given <see cref="CurveItem" /> to drag it to a new location.  The Mouse and Key
-		/// combination for this mode are modifiable using <see cref="EditButtons" /> and
-		/// <see cref="EditModifierKeys" />.
-		/// </remarks>
-		/// <seealso cref="EditButtons" />
-		/// <seealso cref="EditModifierKeys" />
-		/// <seealso cref="IsEnableVEdit" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to allow horizontal editing by alt-left-click-drag" )]
-		public bool IsEnableHEdit
-		{
-			get { return _isEnableHEdit; }
-			set { _isEnableHEdit = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not editing of point data is allowed in
-		/// the vertical direction.
-		/// </summary>
-		/// <remarks>
-		/// Editing is done by holding down the Alt key, and left-clicking on an individual point of
-		/// a given <see cref="CurveItem" /> to drag it to a new location.  The Mouse and Key
-		/// combination for this mode are modifiable using <see cref="EditButtons" /> and
-		/// <see cref="EditModifierKeys" />.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to allow vertical editing by alt-left-click-drag" )]
-		public bool IsEnableVEdit
-		{
-			get { return _isEnableVEdit; }
-			set { _isEnableVEdit = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not zooming is allowed for the control.
-		/// </summary>
-		/// <remarks>
-		/// Zooming is done by left-clicking inside the <see cref="Chart.Rect"/> to drag
-		/// out a rectangle, indicating the new scale ranges that will be part of the graph.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow horizontal and vertical zooming by left-click-drag" )]
-		public bool IsEnableZoom
-		{
-			set { _isEnableHZoom = value; _isEnableVZoom = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not zooming is allowed for the control in
-		/// the horizontal direction.
-		/// </summary>
-		/// <remarks>
-		/// Zooming is done by left-clicking inside the <see cref="Chart.Rect"/> to drag
-		/// out a rectangle, indicating the new scale ranges that will be part of the graph.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow horizontal zooming by left-click-drag" )]
-		public bool IsEnableHZoom
-		{
-			get { return _isEnableHZoom; }
-			set { _isEnableHZoom = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether or not zooming is allowed for the control in
-		/// the vertical direction.
-		/// </summary>
-		/// <remarks>
-		/// Zooming is done by left-clicking inside the <see cref="Chart.Rect"/> to drag
-		/// out a rectangle, indicating the new scale ranges that will be part of the graph.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow vertical zooming by left-click-drag" )]
-		public bool IsEnableVZoom
-		{
-			get { return _isEnableVZoom; }
-			set { _isEnableVZoom = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not zooming is allowed via the mouse wheel.
-		/// </summary>
-		/// <remarks>
-		/// Wheel zooming is done by rotating the mouse wheel.
-		/// Note that this property is used in combination with the <see cref="IsEnableHZoom"/> and
-		/// <see cref="IsEnableVZoom" /> properties to control zoom options.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow zooming with the mouse wheel" )]
-		public bool IsEnableWheelZoom
-		{
-			get { return _isEnableWheelZoom; }
-			set { _isEnableWheelZoom = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not panning is allowed for the control in
-		/// the horizontal direction.
-		/// </summary>
-		/// <remarks>
-		/// Panning is done by clicking the middle mouse button (or holding down the shift key
-		/// while clicking the left mouse button) inside the <see cref="Chart.Rect"/> and
-		/// dragging the mouse around to shift the scale ranges as desired.
-		/// </remarks>
-		/// <seealso cref="IsEnableVPan"/>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow horizontal panning by middle-mouse-drag or shift-left-drag" )]
-		public bool IsEnableHPan
-		{
-			get { return _isEnableHPan; }
-			set { _isEnableHPan = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not panning is allowed for the control in
-		/// the vertical direction.
-		/// </summary>
-		/// <remarks>
-		/// Panning is done by clicking the middle mouse button (or holding down the shift key
-		/// while clicking the left mouse button) inside the <see cref="Chart.Rect"/> and
-		/// dragging the mouse around to shift the scale ranges as desired.
-		/// </remarks>
-		/// <seealso cref="IsEnableHPan"/>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to allow vertical panning by middle-mouse-drag or shift-left-drag" )]
-		public bool IsEnableVPan
-		{
-			get { return _isEnableVPan; }
-			set { _isEnableVPan = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the context menu will be available.
-		/// </summary>
-		/// <remarks>The context menu is a menu that appears when you right-click on the
-		/// <see cref="ZedGraphControl"/>.  It provides options for Zoom, Pan, AutoScale, Clipboard
-		/// Copy, and toggle <see cref="IsShowPointValues"/>.
-		/// </remarks>
-		/// <value>true to allow the context menu, false to disable it</value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to enable the right mouse button context menu" )]
-		public bool IsShowContextMenu
-		{
-			get { return _isShowContextMenu; }
-			set { _isShowContextMenu = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not a message box will be shown
-		/// in response to a context menu "Copy" command.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if this property is set to false, the user will receive no
-		/// indicative feedback in response to a Copy action.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to show a message box after a 'Copy' context menu action completes" )]
-		public bool IsShowCopyMessage
-		{
-			get { return _isShowCopyMessage; }
-			set { _isShowCopyMessage = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the <see cref="SaveFileDialog" /> instance that will be used
-		/// by the "Save As..." context menu item.
-		/// </summary>
-		/// <remarks>
-		/// This provides the opportunity to modify the dialog, such as setting the
-		/// <see cref="FileDialog.InitialDirectory" /> property.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "Provides access to the SaveFileDialog for the 'Save As' menu item" )]
-		public SaveFileDialog SaveFileDialog
-		{
-			get { return _saveFileDialog; }
-			set { _saveFileDialog = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the visible aspect ratio of the
-		/// <see cref="MasterPane" /> <see cref="PaneBase.Rect" /> will be preserved
-		/// when printing this <see cref="ZedGraphControl" />.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to preserve the displayed aspect ratio when printing" )]
-		public bool IsPrintKeepAspectRatio
-		{
-			get { return _isPrintKeepAspectRatio; }
-			set { _isPrintKeepAspectRatio = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not the <see cref="MasterPane" />
-		/// <see cref="PaneBase.Rect" /> dimensions will be expanded to fill the
-		/// available space when printing this <see cref="ZedGraphControl" />.
-		/// </summary>
-		/// <remarks>
-		/// If <see cref="IsPrintKeepAspectRatio" /> is also true, then the <see cref="MasterPane" />
-		/// <see cref="PaneBase.Rect" /> dimensions will be expanded to fit as large
-		/// a space as possible while still honoring the visible aspect ratio.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to resize to fill the page when printing" )]
-		public bool IsPrintFillPage
-		{
-			get { return _isPrintFillPage; }
-			set { _isPrintFillPage = value; }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines whether the settings of
-		/// <see cref="ZedGraph.PaneBase.IsFontsScaled" /> and <see cref="PaneBase.IsPenWidthScaled" />
-		/// will be overridden to true during printing operations.
-		/// </summary>
-		/// <remarks>
-		/// Printing involves pixel maps that are typically of a dramatically different dimension
-		/// than on-screen pixel maps.  Therefore, it becomes more important to scale the fonts and
-		/// lines to give a printed image that looks like what is shown on-screen.  The default
-		/// setting for <see cref="ZedGraph.PaneBase.IsFontsScaled" /> is true, but the default
-		/// setting for <see cref="PaneBase.IsPenWidthScaled" /> is false.
-		/// </remarks>
-		/// <value>
-		/// A value of true will cause both <see cref="ZedGraph.PaneBase.IsFontsScaled" /> and
-		/// <see cref="PaneBase.IsPenWidthScaled" /> to be temporarily set to true during
-		/// printing operations.
-		/// </value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( true ),
-		 Description( "true to force font and pen width scaling when printing" )]
-		public bool IsPrintScaleAll
-		{
-			get { return _isPrintScaleAll; }
-			set { _isPrintScaleAll = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that controls whether or not the axis value range for the scroll
-		/// bars will be set automatically.
-		/// </summary>
-		/// <remarks>
-		/// If this value is set to true, then the range of the scroll bars will be set automatically
-		/// to the actual range of the data as returned by <see cref="CurveList.GetRange" /> at the
-		/// time that <see cref="AxisChange" /> was last called.  Note that a value of true
-		/// can override any setting of <see cref="ScrollMinX" />, <see cref="ScrollMaxX" />,
-		/// <see cref="ScrollMinY" />, <see cref="ScrollMaxY" />, 
-		/// <see cref="ScrollMinY2" />, and <see cref="ScrollMaxY2" />.  Note also that you must
-		/// call <see cref="AxisChange" /> from the <see cref="ZedGraphControl" /> for this to
-		/// work properly (e.g., don't call it directly from the <see cref="GraphPane" />.
-		/// Alternatively, you can call <see cref="SetScrollRangeFromData" /> at anytime to set
-		/// the scroll bar range.<br />
-		/// <b>In most cases, you will probably want to disable
-		/// <see cref="ZedGraph.GraphPane.IsBoundedRanges" /> before activating this option.</b>
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to automatically set the scroll bar range to the actual data range" )]
-		public bool IsAutoScrollRange
-		{
-			get { return _isAutoScrollRange; }
-			set { _isAutoScrollRange = value; }
-		}
-
-		/// <summary>
-		/// Set a "grace" value that leaves a buffer area around the data when
-		/// <see cref="IsAutoScrollRange" /> is true.
-		/// </summary>
-		/// <remarks>
-		/// This value represents a fraction of the total range around each axis.  For example, if the
-		/// axis ranges from 0 to 100, then a 0.05 value for ScrollGrace would set the scroll range
-		/// to -5 to 105.
-		/// </remarks>
-		public double ScrollGrace
-		{
-			get { return _scrollGrace; }
-			set { _scrollGrace = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the horizontal scroll bar will be visible.
-		/// </summary>
-		/// <remarks>This scroll bar allows the display to be scrolled in the horizontal direction.
-		/// Another option is display panning, in which the user can move the display around by
-		/// clicking directly on it and dragging (see <see cref="IsEnableHPan"/> and <see cref="IsEnableVPan"/>).
-		/// You can control the available range of scrolling with the <see cref="ScrollMinX"/> and
-		/// <see cref="ScrollMaxX"/> properties.  Note that the scroll range can be set automatically by
-		/// <see cref="IsAutoScrollRange" />.<br />
-		/// <b>In most cases, you will probably want to disable
-		/// <see cref="ZedGraph.GraphPane.IsBoundedRanges" /> before activating this option.</b>
-		/// </remarks>
-		/// <value>A boolean value.  true to display a horizontal scrollbar, false otherwise.</value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to display the horizontal scroll bar" )]
-		public bool IsShowHScrollBar
-		{
-			get { return _isShowHScrollBar; }
-			set { _isShowHScrollBar = value; ZedGraphControl_ReSize( this, new EventArgs() ); }
-		}
-		/// <summary>
-		/// Gets or sets a value that determines if the vertical scroll bar will be visible.
-		/// </summary>
-		/// <remarks>This scroll bar allows the display to be scrolled in the vertical direction.
-		/// Another option is display panning, in which the user can move the display around by
-		/// clicking directly on it and dragging (see <see cref="IsEnableHPan"/> and <see cref="IsEnableVPan"/>).
-		/// You can control the available range of scrolling with the <see cref="ScrollMinY"/> and
-		/// <see cref="ScrollMaxY"/> properties.
-		/// Note that the vertical scroll bar only affects the <see cref="YAxis"/>; it has no impact on
-		/// the <see cref="Y2Axis"/>.  The panning options affect both the <see cref="YAxis"/> and
-		/// <see cref="Y2Axis"/>.  Note also that the scroll range can be set automatically by
-		/// <see cref="IsAutoScrollRange" />.<br />
-		/// <b>In most cases, you will probably want to disable
-		/// <see cref="ZedGraph.GraphPane.IsBoundedRanges" /> before activating this option.</b>
-		/// </remarks>
-		/// <value>A boolean value.  true to display a vertical scrollbar, false otherwise.</value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to display the vertical scroll bar" )]
-		public bool IsShowVScrollBar
-		{
-			get { return _isShowVScrollBar; }
-			set { _isShowVScrollBar = value; ZedGraphControl_ReSize( this, new EventArgs() ); }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the <see cref="XAxis" /> <see cref="Scale" />
-		/// ranges for all <see cref="GraphPane" /> objects in the <see cref="MasterPane" /> will
-		/// be forced to match.
-		/// </summary>
-		/// <remarks>
-		/// If set to true (default is false), then all of the <see cref="GraphPane" /> objects
-		/// in the <see cref="MasterPane" /> associated with this <see cref="ZedGraphControl" />
-		/// will be forced to have matching scale ranges for the x axis.  That is, zoom, pan,
-		/// and scroll operations will result in zoom/pan/scroll for all graphpanes simultaneously.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to force the X axis ranges for all GraphPanes to match" )]
-		public bool IsSynchronizeXAxes
-		{
-			get { return _isSynchronizeXAxes; }
-			set
-			{
-				if ( _isSynchronizeXAxes != value )
-					ZoomStatePurge();
-				_isSynchronizeXAxes = value;
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the <see cref="YAxis" /> <see cref="Scale" />
-		/// ranges for all <see cref="GraphPane" /> objects in the <see cref="MasterPane" /> will
-		/// be forced to match.
-		/// </summary>
-		/// <remarks>
-		/// If set to true (default is false), then all of the <see cref="GraphPane" /> objects
-		/// in the <see cref="MasterPane" /> associated with this <see cref="ZedGraphControl" />
-		/// will be forced to have matching scale ranges for the y axis.  That is, zoom, pan,
-		/// and scroll operations will result in zoom/pan/scroll for all graphpanes simultaneously.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to force the Y axis ranges for all GraphPanes to match" )]
-		public bool IsSynchronizeYAxes
-		{
-			get { return _isSynchronizeYAxes; }
-			set
-			{
-				if ( _isSynchronizeYAxes != value )
-					ZoomStatePurge();
-				_isSynchronizeYAxes = value;
-			}
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines if the vertical scroll bar will affect the Y2 axis.
-		/// </summary>
-		/// <remarks>
-		/// The vertical scroll bar is automatically associated with the Y axis.  With this value, you
-		/// can choose to include or exclude the Y2 axis with the scrolling.  Note that the Y2 axis
-		/// scrolling is handled as a secondary.  The vertical scroll bar position always reflects
-		/// the status of the Y axis.  This can cause the Y2 axis to "jump" when first scrolled if
-		/// the <see cref="ScrollMinY2" /> and <see cref="ScrollMaxY2" /> values are not set to the
-		/// same proportions as <see cref="ScrollMinY" /> and <see cref="ScrollMaxY" /> with respect
-		/// to the actual <see cref="Scale.Min"/> and <see cref="Scale.Max" />.  Also note that
-		/// this property is actually just an alias to the <see cref="ScrollRange.IsScrollable" />
-		/// property of the first element of <see cref="YScrollRangeList" />.
-		/// </remarks>
-		/// <seealso cref="IsShowVScrollBar"/>
-		/// <seealso cref="ScrollMinY2"/>
-		/// <seealso cref="ScrollMaxY2"/>
-		/// <seealso cref="YScrollRangeList" />
-		/// <seealso cref="Y2ScrollRangeList" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to scroll the Y2 axis along with the Y axis" )]
-		public bool IsScrollY2
-		{
-			get
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-					return _y2ScrollRangeList[0].IsScrollable;
-				else
-					return false;
-			}
-			set
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-				{
-					ScrollRange tmp = _y2ScrollRangeList[0];
-					tmp.IsScrollable = value;
-					_y2ScrollRangeList[0] = tmp;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Access the <see cref="ScrollRangeList" /> for the Y axes.
-		/// </summary>
-		/// <remarks>
-		/// This list maintains the user scale ranges for the scroll bars for each axis
-		/// in the <see cref="ZedGraph.GraphPane.YAxisList" />.  Each ordinal location in
-		/// <see cref="YScrollRangeList" /> corresponds to an equivalent ordinal location
-		/// in <see cref="ZedGraph.GraphPane.YAxisList" />.
-		/// </remarks>
-		/// <seealso cref="ScrollMinY" />
-		/// <seealso cref="ScrollMaxY" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true )]
-		[Description( "Sets the manual scroll bar ranges for the collection of Y axes" )]
-		public ScrollRangeList YScrollRangeList
-		{
-			get { return _yScrollRangeList; }
-		}
-
-		/// <summary>
-		/// Access the <see cref="ScrollRangeList" /> for the Y2 axes.
-		/// </summary>
-		/// <remarks>
-		/// This list maintains the user scale ranges for the scroll bars for each axis
-		/// in the <see cref="ZedGraph.GraphPane.Y2AxisList" />.  Each ordinal location in
-		/// <see cref="Y2ScrollRangeList" /> corresponds to an equivalent ordinal location
-		/// in <see cref="ZedGraph.GraphPane.Y2AxisList" />.
-		/// </remarks>
-		/// <seealso cref="ScrollMinY2" />
-		/// <seealso cref="ScrollMaxY2" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true )]
-		[Description( "Sets the manual scroll bar ranges for the collection of Y2 axes" )]
-		public ScrollRangeList Y2ScrollRangeList
-		{
-			get { return _y2ScrollRangeList; }
-		}
-
-		/// <summary>
-		/// The minimum value for the X axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the minimum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Min"/> value to be set to <see cref="ScrollMinX"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableHPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.
-		/// </remarks>
-		/// <value>A double value indicating the minimum axis value</value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll minimum value for the X axis" )]
-		public double ScrollMinX
-		{
-			get { return _xScrollRange.Min; }
-			set { _xScrollRange.Min = value; }
-		}
-		/// <summary>
-		/// The maximum value for the X axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the maximum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Max"/> value to be set to <see cref="ScrollMaxX"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableHPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.
-		/// </remarks>
-		/// <value>A double value indicating the maximum axis value</value>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll maximum value for the X axis" )]
-		public double ScrollMaxX
-		{
-			get { return _xScrollRange.Max; }
-			set { _xScrollRange.Max = value; }
-		}
-		/// <summary>
-		/// The minimum value for the Y axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the minimum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Min"/> value to be set to <see cref="ScrollMinY"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableVPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.  Also note that
-		/// this property is actually just an alias to the <see cref="ScrollRange.Min" />
-		/// property of the first element of <see cref="YScrollRangeList" />.
-		/// </remarks>
-		/// <value>A double value indicating the minimum axis value</value>
-		/// <seealso cref="YScrollRangeList" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll minimum value for the Y axis" )]
-		public double ScrollMinY
-		{
-			get
-			{
-				if ( _yScrollRangeList != null && _yScrollRangeList.Count > 0 )
-					return _yScrollRangeList[0].Min;
-				else
-					return double.NaN;
-			}
-			set
-			{
-				if ( _yScrollRangeList != null && _yScrollRangeList.Count > 0 )
-				{
-					ScrollRange tmp = _yScrollRangeList[0];
-					tmp.Min = value;
-					_yScrollRangeList[0] = tmp;
-				}
-			}
-		}
-		/// <summary>
-		/// The maximum value for the Y axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the maximum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Max"/> value to be set to <see cref="ScrollMaxY"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableVPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.  Also note that
-		/// this property is actually just an alias to the <see cref="ScrollRange.Max" />
-		/// property of the first element of <see cref="YScrollRangeList" />.
-		/// </remarks>
-		/// <value>A double value indicating the maximum axis value</value>
-		/// <seealso cref="YScrollRangeList" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll maximum value for the Y axis" )]
-		public double ScrollMaxY
-		{
-			get
-			{
-				if ( _yScrollRangeList != null && _yScrollRangeList.Count > 0 )
-					return _yScrollRangeList[0].Max;
-				else
-					return double.NaN;
-			}
-			set
-			{
-				if ( _yScrollRangeList != null && _yScrollRangeList.Count > 0 )
-				{
-					ScrollRange tmp = _yScrollRangeList[0];
-					tmp.Max = value;
-					_yScrollRangeList[0] = tmp;
-				}
-			}
-		}
-		/// <summary>
-		/// The minimum value for the Y2 axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the minimum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Min"/> value to be set to <see cref="ScrollMinY2"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableVPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.  Also note that
-		/// this property is actually just an alias to the <see cref="ScrollRange.Min" />
-		/// property of the first element of <see cref="Y2ScrollRangeList" />.
-		/// </remarks>
-		/// <value>A double value indicating the minimum axis value</value>
-		/// <seealso cref="Y2ScrollRangeList" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll minimum value for the Y2 axis" )]
-		public double ScrollMinY2
-		{
-			get
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-					return _y2ScrollRangeList[0].Min;
-				else
-					return double.NaN;
-			}
-			set
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-				{
-					ScrollRange tmp = _y2ScrollRangeList[0];
-					tmp.Min = value;
-					_y2ScrollRangeList[0] = tmp;
-				}
-			}
-		}
-		/// <summary>
-		/// The maximum value for the Y2 axis scroll range.
-		/// </summary>
-		/// <remarks>
-		/// Effectively, the maximum endpoint of the scroll range will cause the
-		/// <see cref="Scale.Max"/> value to be set to <see cref="ScrollMaxY2"/>.  Note that this
-		/// value applies only to the scroll bar settings.  Axis panning (see <see cref="IsEnableVPan"/>)
-		/// is not affected by this value.  Note that this value can be overridden by
-		/// <see cref="IsAutoScrollRange" /> and <see cref="SetScrollRangeFromData" />.  Also note that
-		/// this property is actually just an alias to the <see cref="ScrollRange.Max" />
-		/// property of the first element of <see cref="Y2ScrollRangeList" />.
-		/// </remarks>
-		/// <value>A double value indicating the maximum axis value</value>
-		/// <seealso cref="Y2ScrollRangeList" />
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0 ),
-		 Description( "Sets the manual scroll maximum value for the Y2 axis" )]
-		public double ScrollMaxY2
-		{
-			get
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-					return _y2ScrollRangeList[0].Max;
-				else
-					return double.NaN;
-			}
-			set
-			{
-				if ( _y2ScrollRangeList != null && _y2ScrollRangeList.Count > 0 )
-				{
-					ScrollRange tmp = _y2ScrollRangeList[0];
-					tmp.Max = value;
-					_y2ScrollRangeList[0] = tmp;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Returns true if the user is currently scrolling via the scrollbar, or
-		/// false if no scrolling is taking place.
-		/// </summary>
-		/// <remarks>
-		/// This method just tests ScrollBar.Capture to see if the
-		/// mouse has been captured by the scroll bar.  If so, scrolling is active.
-		/// </remarks>
-		public Boolean IsScrolling
-		{
-			get
-			{
-				if ( hScrollBar1 != null && vScrollBar1 != null )
-					return hScrollBar1.Capture || vScrollBar1.Capture;
-				else
-					return false;
-			}
-		}
-
-
-		/// <summary>
-		/// Gets or sets the format for displaying tooltip values.
-		/// This format is passed to <see cref="PointPairBase.ToString(string)"/>.
-		/// </summary>
-		/// <remarks>
-		/// Use the <see cref="System.Globalization.NumberFormatInfo" /> type
-		/// to determine the format strings.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( PointPair.DefaultFormat ),
-		 Description( "Sets the numeric display format string for the point value tooltips" )]
-		public string PointValueFormat
-		{
-			get { return _pointValueFormat; }
-			set { _pointValueFormat = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the format for displaying tooltip values.
-		/// This format is passed to <see cref="XDate.ToString(string)"/>.
-		/// </summary>
-		/// <remarks>
-		/// Use the <see cref="System.Globalization.DateTimeFormatInfo" /> type
-		/// to determine the format strings.
-		/// </remarks>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( XDate.DefaultFormatStr ),
-		 Description( "Sets the date display format for the point value tooltips" )]
-		public string PointDateFormat
-		{
-			get { return _pointDateFormat; }
-			set { _pointDateFormat = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets the step size fraction for zooming with the mouse wheel.
-		/// A value of 0.1 will result in a 10% zoom step for each mouse wheel movement.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( 0.1 ),
-		 Description( "Sets the step size fraction for zooming with the mouse wheel" )]
-		public double ZoomStepFraction
-		{
-			get { return _zoomStepFraction; }
-			set { _zoomStepFraction = value; }
-		}
-
-		/// <summary>
-		/// Gets or sets a boolean value that determines if zooming with the wheel mouse
-		/// is centered on the mouse location, or centered on the existing graph.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-		 DefaultValue( false ),
-		 Description( "true to center the mouse wheel zoom at the current mouse location" )]
-		public bool IsZoomOnMouseCenter
-		{
-			get { return _isZoomOnMouseCenter; }
-			set { _isZoomOnMouseCenter = value; }
-		}
-
-		/// <summary>
-		/// Gets the graph pane's current image.
-		/// <seealso cref="Bitmap"/>
-		/// </summary>
-		/// <exception cref="ZedGraphException">
-		/// When the control has been disposed before this call.
-		/// </exception>
-		[Bindable( false ), Browsable( false ),
-		 DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden )]
-		public Image GetImage()
-		{
-			lock ( this )
-			{
-				if ( BeenDisposed || _masterPane == null || _masterPane[0] == null )
-					throw new ZedGraphException( "The control has been disposed" );
-
-				return _masterPane.GetImage();
-			}
-		}
-
-		/// <summary>
-		/// This checks if the control has been disposed.  This is synonymous with
-		/// the graph pane having been nulled or disposed.  Therefore this is the
-		/// same as <c>ZedGraphControl.GraphPane == null</c>.
-		/// </summary>
-		[Bindable( false ), Browsable( false ),
-		 DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden )]
-		public bool BeenDisposed
-		{
-			get
-			{
-				lock ( this ) return _masterPane == null;
-			}
-		}
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Readonly property that gets the list of selected CurveItems
-		/// </summary>
-		public Selection Selection
-		{
-			get { return _selection; }
-		}
-
-		/// <summary>
-		/// Gets or sets a value that determines whether or not selection is allowed for the control.
-		/// </summary>
-		[Bindable( true ), Category( "Display" ), NotifyParentProperty( true ),
-			DefaultValue( false ),
-			Description( "true to allow selecting Curves" )]
-		public bool IsEnableSelection
-		{
-			get { return _isEnableSelection; }
-			set
-			{
-				_isEnableSelection = value;
-
-				/*
-				if ( value )
-				{
-					this.Cursor = Cursors.Default;
-					this.IsEnableZoom = false;
-				}
-				else
-				{
-					this.Cursor = Cursors.Cross;
-					this.IsEnableZoom = true;
-				}
-				*/
-			}
-		}
-
-	#endregion
-
-	}
-}
\ No newline at end of file
diff --git a/BDInfo/ZedGraph/ZedGraphControl.ScrollBars.cs b/BDInfo/ZedGraph/ZedGraphControl.ScrollBars.cs
deleted file mode 100644
index 727002cdda..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.ScrollBars.cs
+++ /dev/null
@@ -1,395 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2007  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Windows.Forms;
-
-namespace ZedGraph
-{
-	partial class ZedGraphControl
-	{
-
-	#region ScrollBars
-
-		private void vScrollBar1_Scroll( object sender, ScrollEventArgs e )
-		{
-			if ( this.GraphPane != null )
-			{
-				if ( ( e.Type != ScrollEventType.ThumbPosition &&
-						 e.Type != ScrollEventType.ThumbTrack ) ||
-					  ( e.Type == ScrollEventType.ThumbTrack &&
-						 _zoomState == null ) )
-				{
-					ZoomStateSave( this.GraphPane, ZoomState.StateType.Scroll );
-				}
-				for ( int i = 0; i < this.GraphPane.YAxisList.Count; i++ )
-				{
-					ScrollRange scroll = _yScrollRangeList[i];
-					if ( scroll.IsScrollable )
-					{
-						Axis axis = this.GraphPane.YAxisList[i];
-						HandleScroll( axis, e.NewValue, scroll.Min, scroll.Max, vScrollBar1.LargeChange,
-										!axis.Scale.IsReverse );
-					}
-				}
-
-				for ( int i = 0; i < this.GraphPane.Y2AxisList.Count; i++ )
-				{
-					ScrollRange scroll = _y2ScrollRangeList[i];
-					if ( scroll.IsScrollable )
-					{
-						Axis axis = this.GraphPane.Y2AxisList[i];
-						HandleScroll( axis, e.NewValue, scroll.Min, scroll.Max, vScrollBar1.LargeChange,
-										!axis.Scale.IsReverse );
-					}
-				}
-
-				ApplyToAllPanes( this.GraphPane );
-
-				ProcessEventStuff( vScrollBar1, e );
-			}
-		}
-
-		private void ApplyToAllPanes( GraphPane primaryPane )
-		{
-			foreach ( GraphPane pane in _masterPane._paneList )
-			{
-				if ( pane != primaryPane )
-				{
-					if ( _isSynchronizeXAxes )
-						Synchronize( primaryPane.XAxis, pane.XAxis );
-					if ( _isSynchronizeYAxes )
-						Synchronize( primaryPane.YAxis, pane.YAxis );
-				}
-			}
-		}
-
-		private void Synchronize( Axis source, Axis dest )
-		{
-			dest._scale._min = source._scale._min;
-			dest._scale._max = source._scale._max;
-			dest._scale._majorStep = source._scale._majorStep;
-			dest._scale._minorStep = source._scale._minorStep;
-			dest._scale._minAuto = source._scale._minAuto;
-			dest._scale._maxAuto = source._scale._maxAuto;
-			dest._scale._majorStepAuto = source._scale._majorStepAuto;
-			dest._scale._minorStepAuto = source._scale._minorStepAuto;
-		}
-
-		private void hScrollBar1_Scroll( object sender, ScrollEventArgs e )
-		{
-			if ( this.GraphPane != null )
-			{
-				if ( ( e.Type != ScrollEventType.ThumbPosition &&
-						 e.Type != ScrollEventType.ThumbTrack ) ||
-					  ( e.Type == ScrollEventType.ThumbTrack &&
-						 _zoomState == null ) )
-					ZoomStateSave( this.GraphPane, ZoomState.StateType.Scroll );
-
-				HandleScroll( this.GraphPane.XAxis, e.NewValue, _xScrollRange.Min, _xScrollRange.Max,
-								hScrollBar1.LargeChange, this.GraphPane.XAxis.Scale.IsReverse );
-
-				ApplyToAllPanes( this.GraphPane );
-
-				ProcessEventStuff( hScrollBar1, e );
-			}
-		}
-
-		private void ProcessEventStuff( ScrollBar scrollBar, ScrollEventArgs e )
-		{
-			if ( e.Type == ScrollEventType.ThumbTrack )
-			{
-				if ( this.ScrollProgressEvent != null )
-					this.ScrollProgressEvent( this, hScrollBar1, _zoomState,
-								new ZoomState( this.GraphPane, ZoomState.StateType.Scroll ) );
-			}
-			else // if ( e.Type == ScrollEventType.ThumbPosition )
-			{
-				if ( _zoomState != null && _zoomState.IsChanged( this.GraphPane ) )
-				{
-					//this.GraphPane.ZoomStack.Push( _zoomState );
-					ZoomStatePush( this.GraphPane );
-
-					// Provide Callback to notify the user of pan events
-					if ( this.ScrollDoneEvent != null )
-						this.ScrollDoneEvent( this, hScrollBar1, _zoomState,
-									new ZoomState( this.GraphPane, ZoomState.StateType.Scroll ) );
-
-					_zoomState = null;
-				}
-			}
-
-			if ( this.ScrollEvent != null )
-				this.ScrollEvent( scrollBar, e );
-		}
-/*
-		/// <summary>
-		/// Use the MouseCaptureChanged as an indicator for the start and end of a scrolling operation
-		/// </summary>
-		private void ScrollBarMouseCaptureChanged( object sender, EventArgs e )
-		{
-			return;
-
-			ScrollBar scrollBar = sender as ScrollBar;
-			if ( scrollBar != null )
-			{
-				// If this is the start of a new scroll, then Capture will be true
-				if ( scrollBar.Capture )
-				{
-					// save the original zoomstate
-					//_zoomState = new ZoomState( this.GraphPane, ZoomState.StateType.Scroll );
-					ZoomStateSave( this.GraphPane, ZoomState.StateType.Scroll );
-				}
-				else
-				{
-					// push the prior saved zoomstate, since the scale ranges have already been changed on
-					// the fly during the scrolling operation
-					if ( _zoomState != null && _zoomState.IsChanged( this.GraphPane ) )
-					{
-						//this.GraphPane.ZoomStack.Push( _zoomState );
-						ZoomStatePush( this.GraphPane );
-
-						// Provide Callback to notify the user of pan events
-						if ( this.ScrollDoneEvent != null )
-							this.ScrollDoneEvent( this, scrollBar, _zoomState,
-										new ZoomState( this.GraphPane, ZoomState.StateType.Scroll ) );
-
-						_zoomState = null;
-					}
-				}
-			}
-		}
-*/
-
-		private void HandleScroll( Axis axis, int newValue, double scrollMin, double scrollMax,
-									int largeChange, bool reverse )
-		{
-			if ( axis != null )
-			{
-				if ( scrollMin > axis._scale._min )
-					scrollMin = axis._scale._min;
-				if ( scrollMax < axis._scale._max )
-					scrollMax = axis._scale._max;
-
-				int span = _ScrollControlSpan - largeChange;
-				if ( span <= 0 )
-					return;
-
-				if ( reverse )
-					newValue = span - newValue;
-
-				Scale scale = axis._scale;
-
-				double delta = scale._maxLinearized - scale._minLinearized;
-				double scrollMin2 = scale.Linearize( scrollMax ) - delta;
-				scrollMin = scale.Linearize( scrollMin );
-				//scrollMax = scale.Linearize( scrollMax );
-				double val = scrollMin + (double)newValue / (double)span *
-						( scrollMin2 - scrollMin );
-				scale._minLinearized = val;
-				scale._maxLinearized = val + delta;
-				/*
-								if ( axis.Scale.IsLog )
-								{
-									double ratio = axis._scale._max / axis._scale._min;
-									double scrollMin2 = scrollMax / ratio;
-
-									double val = scrollMin * Math.Exp( (double)newValue / (double)span *
-												( Math.Log( scrollMin2 ) - Math.Log( scrollMin ) ) );
-									axis._scale._min = val;
-									axis._scale._max = val * ratio;
-								}
-								else
-								{
-									double delta = axis._scale._max - axis._scale._min;
-									double scrollMin2 = scrollMax - delta;
-
-									double val = scrollMin + (double)newValue / (double)span *
-												( scrollMin2 - scrollMin );
-									axis._scale._min = val;
-									axis._scale._max = val + delta;
-								}
-				*/
-				this.Invalidate();
-			}
-		}
-
-		/// <summary>
-		/// Sets the value of the scroll range properties (see <see cref="ScrollMinX" />,
-		/// <see cref="ScrollMaxX" />, <see cref="YScrollRangeList" />, and 
-		/// <see cref="Y2ScrollRangeList" /> based on the actual range of the data for
-		/// each corresponding <see cref="Axis" />.
-		/// </summary>
-		/// <remarks>
-		/// This method is called automatically by <see cref="AxisChange" /> if
-		/// <see cref="IsAutoScrollRange" />
-		/// is true.  Note that this will not be called if you call AxisChange directly from the
-		/// <see cref="GraphPane" />.  For example, zedGraphControl1.AxisChange() works properly, but
-		/// zedGraphControl1.GraphPane.AxisChange() does not.</remarks>
-		public void SetScrollRangeFromData()
-		{
-			if ( this.GraphPane != null )
-			{
-				double grace = CalcScrollGrace( this.GraphPane.XAxis.Scale._rangeMin,
-							this.GraphPane.XAxis.Scale._rangeMax );
-
-				_xScrollRange.Min = this.GraphPane.XAxis.Scale._rangeMin - grace;
-				_xScrollRange.Max = this.GraphPane.XAxis.Scale._rangeMax + grace;
-				_xScrollRange.IsScrollable = true;
-
-				for ( int i = 0; i < this.GraphPane.YAxisList.Count; i++ )
-				{
-					Axis axis = this.GraphPane.YAxisList[i];
-					grace = CalcScrollGrace( axis.Scale._rangeMin, axis.Scale._rangeMax );
-					ScrollRange range = new ScrollRange( axis.Scale._rangeMin - grace,
-						axis.Scale._rangeMax + grace, _yScrollRangeList[i].IsScrollable );
-
-					if ( i >= _yScrollRangeList.Count )
-						_yScrollRangeList.Add( range );
-					else
-						_yScrollRangeList[i] = range;
-				}
-
-				for ( int i = 0; i < this.GraphPane.Y2AxisList.Count; i++ )
-				{
-					Axis axis = this.GraphPane.Y2AxisList[i];
-					grace = CalcScrollGrace( axis.Scale._rangeMin, axis.Scale._rangeMax );
-					ScrollRange range = new ScrollRange( axis.Scale._rangeMin - grace,
-							axis.Scale._rangeMax + grace, _y2ScrollRangeList[i].IsScrollable );
-
-					if ( i >= _y2ScrollRangeList.Count )
-						_y2ScrollRangeList.Add( range );
-					else
-						_y2ScrollRangeList[i] = range;
-				}
-
-				//this.GraphPane.CurveList.GetRange( out scrollMinX, out scrollMaxX,
-				//		out scrollMinY, out scrollMaxY, out scrollMinY2, out scrollMaxY2, false, false,
-				//		this.GraphPane );
-			}
-		}
-
-		private double CalcScrollGrace( double min, double max )
-		{
-			if ( Math.Abs( max - min ) < 1e-30 )
-			{
-				if ( Math.Abs( max ) < 1e-30 )
-					return _scrollGrace;
-				else
-					return max * _scrollGrace;
-			}
-			else
-				return ( max - min ) * _scrollGrace;
-		}
-
-		private void SetScroll( ScrollBar scrollBar, Axis axis, double scrollMin, double scrollMax )
-		{
-			if ( scrollBar != null && axis != null )
-			{
-				scrollBar.Minimum = 0;
-				scrollBar.Maximum = _ScrollControlSpan - 1;
-
-				if ( scrollMin > axis._scale._min )
-					scrollMin = axis._scale._min;
-				if ( scrollMax < axis._scale._max )
-					scrollMax = axis._scale._max;
-
-				int val = 0;
-
-				Scale scale = axis._scale;
-				double minLinearized = scale._minLinearized;
-				double maxLinearized = scale._maxLinearized;
-				scrollMin = scale.Linearize( scrollMin );
-				scrollMax = scale.Linearize( scrollMax );
-
-				double scrollMin2 = scrollMax - ( maxLinearized - minLinearized );
-				/*
-				if ( axis.Scale.IsLog )
-					scrollMin2 = scrollMax / ( axis._scale._max / axis._scale._min );
-				else
-					scrollMin2 = scrollMax - ( axis._scale._max - axis._scale._min );
-				*/
-				if ( scrollMin >= scrollMin2 )
-				{
-					//scrollBar.Visible = false;
-					scrollBar.Enabled = false;
-					scrollBar.Value = 0;
-				}
-				else
-				{
-					double ratio = ( maxLinearized - minLinearized ) / ( scrollMax - scrollMin );
-
-					/*
-					if ( axis.Scale.IsLog )
-						ratio = ( Math.Log( axis._scale._max ) - Math.Log( axis._scale._min ) ) /
-									( Math.Log( scrollMax ) - Math.Log( scrollMin ) );
-					else
-						ratio = ( axis._scale._max - axis._scale._min ) / ( scrollMax - scrollMin );
-					*/
-
-					int largeChange = (int)( ratio * _ScrollControlSpan + 0.5 );
-					if ( largeChange < 1 )
-						largeChange = 1;
-					scrollBar.LargeChange = largeChange;
-
-					int smallChange = largeChange / _ScrollSmallRatio;
-					if ( smallChange < 1 )
-						smallChange = 1;
-					scrollBar.SmallChange = smallChange;
-
-					int span = _ScrollControlSpan - largeChange;
-
-					val = (int)( ( minLinearized - scrollMin ) / ( scrollMin2 - scrollMin ) *
-									span + 0.5 );
-					/*
-					if ( axis.Scale.IsLog )
-						val = (int)( ( Math.Log( axis._scale._min ) - Math.Log( scrollMin ) ) /
-								( Math.Log( scrollMin2 ) - Math.Log( scrollMin ) ) * span + 0.5 );
-					else
-						val = (int)( ( axis._scale._min - scrollMin ) / ( scrollMin2 - scrollMin ) *
-								span + 0.5 );
-					*/
-					if ( val < 0 )
-						val = 0;
-					else if ( val > span )
-						val = span;
-
-					//if ( ( axis is XAxis && axis.IsReverse ) || ( ( ! axis is XAxis ) && ! axis.IsReverse ) )
-					if ( ( axis is XAxis ) == axis.Scale.IsReverse )
-						val = span - val;
-
-					if ( val < scrollBar.Minimum )
-						val = scrollBar.Minimum;
-					if ( val > scrollBar.Maximum )
-						val = scrollBar.Maximum;
-
-					scrollBar.Value = val;
-					scrollBar.Enabled = true;
-					//scrollBar.Visible = true;
-				}
-			}
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ZedGraphControl.cs b/BDInfo/ZedGraph/ZedGraphControl.cs
deleted file mode 100644
index 9e21de9f00..0000000000
--- a/BDInfo/ZedGraph/ZedGraphControl.cs
+++ /dev/null
@@ -1,852 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Text;
-using System.Drawing.Imaging;
-using System.Drawing.Printing;
-using System.Data;
-using System.Globalization;
-using System.IO;
-using System.Resources;
-using System.Reflection;
-using System.Text;
-using System.Windows.Forms;
-using System.Threading;
-
-namespace ZedGraph
-{
-/*
-	/// <summary>
-	/// 
-	/// </summary>
-	public struct DrawingThreadData
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		public Graphics _g;
-		/// <summary>
-		/// 
-		/// </summary>
-		public MasterPane _masterPane;
-
-//		public DrawingThread( Graphics g, MasterPane masterPane )
-//		{
-//			_g = g;
-//			_masterPane = masterPane;
-//		}
-	}
-*/
-
-	/// <summary>
-	/// The ZedGraphControl class provides a UserControl interface to the
-	/// <see cref="ZedGraph"/> class library.  This allows ZedGraph to be installed
-	/// as a control in the Visual Studio toolbox.  You can use the control by simply
-	/// dragging it onto a form in the Visual Studio form editor.  All graph
-	/// attributes are accessible via the <see cref="ZedGraphControl.GraphPane"/>
-	/// property.
-	/// </summary>
-	/// <author> John Champion revised by Jerry Vos </author>
-	/// <version> $Revision: 3.86 $ $Date: 2007/11/03 04:41:29 $ </version>
-	public partial class ZedGraphControl : UserControl
-	{
-
-	#region Private Fields
-
-		/// <summary>
-		/// This private field contains the instance for the MasterPane object of this control.
-		/// You can access the MasterPane object through the public property
-		/// <see cref="ZedGraphControl.MasterPane"/>. This is nulled when this Control is
-		/// disposed.
-		/// </summary>
-		private MasterPane _masterPane;
-
-		/// <summary>
-		/// private field that determines whether or not tooltips will be displayed
-		/// when the mouse hovers over data values.  Use the public property
-		/// <see cref="IsShowPointValues"/> to access this value.
-		/// </summary>
-		private bool _isShowPointValues = false;
-		/// <summary>
-		/// private field that determines whether or not tooltips will be displayed
-		/// showing the scale values while the mouse is located within the ChartRect.
-		/// Use the public property <see cref="IsShowCursorValues"/> to access this value.
-		/// </summary>
-		private bool _isShowCursorValues = false;
-		/// <summary>
-		/// private field that determines the format for displaying tooltip values.
-		/// This format is passed to <see cref="PointPairBase.ToString(string)"/>.
-		/// Use the public property <see cref="PointValueFormat"/> to access this
-		/// value.
-		/// </summary>
-		private string _pointValueFormat = PointPair.DefaultFormat;
-
-		/// <summary>
-		/// private field that determines whether or not the context menu will be available.  Use the
-		/// public property <see cref="IsShowContextMenu"/> to access this value.
-		/// </summary>
-		private bool _isShowContextMenu = true;
-
-		/// <summary>
-		/// private field that determines whether or not a message box will be shown in response to
-		/// a context menu "Copy" command.  Use the
-		/// public property <see cref="IsShowCopyMessage"/> to access this value.
-		/// </summary>
-		/// <remarks>
-		/// Note that, if this value is set to false, the user will receive no indicative feedback
-		/// in response to a Copy action.
-		/// </remarks>
-		private bool _isShowCopyMessage = true;
-
-		private SaveFileDialog _saveFileDialog = new SaveFileDialog();
-
-		/// <summary>
-		/// private field that determines whether the settings of
-		/// <see cref="ZedGraph.PaneBase.IsFontsScaled" /> and <see cref="PaneBase.IsPenWidthScaled" />
-		/// will be overridden to true during printing operations.
-		/// </summary>
-		/// <remarks>
-		/// Printing involves pixel maps that are typically of a dramatically different dimension
-		/// than on-screen pixel maps.  Therefore, it becomes more important to scale the fonts and
-		/// lines to give a printed image that looks like what is shown on-screen.  The default
-		/// setting for <see cref="ZedGraph.PaneBase.IsFontsScaled" /> is true, but the default
-		/// setting for <see cref="PaneBase.IsPenWidthScaled" /> is false.
-		/// </remarks>
-		/// <value>
-		/// A value of true will cause both <see cref="ZedGraph.PaneBase.IsFontsScaled" /> and
-		/// <see cref="PaneBase.IsPenWidthScaled" /> to be temporarily set to true during
-		/// printing operations.
-		/// </value>
-		private bool _isPrintScaleAll = true;
-		/// <summary>
-		/// private field that determines whether or not the visible aspect ratio of the
-		/// <see cref="MasterPane" /> <see cref="PaneBase.Rect" /> will be preserved
-		/// when printing this <see cref="ZedGraphControl" />.
-		/// </summary>
-		private bool _isPrintKeepAspectRatio = true;
-		/// <summary>
-		/// private field that determines whether or not the <see cref="MasterPane" />
-		/// <see cref="PaneBase.Rect" /> dimensions will be expanded to fill the
-		/// available space when printing this <see cref="ZedGraphControl" />.
-		/// </summary>
-		/// <remarks>
-		/// If <see cref="IsPrintKeepAspectRatio" /> is also true, then the <see cref="MasterPane" />
-		/// <see cref="PaneBase.Rect" /> dimensions will be expanded to fit as large
-		/// a space as possible while still honoring the visible aspect ratio.
-		/// </remarks>
-		private bool _isPrintFillPage = true;
-
-		/// <summary>
-		/// private field that determines the format for displaying tooltip date values.
-		/// This format is passed to <see cref="XDate.ToString(string)"/>.
-		/// Use the public property <see cref="PointDateFormat"/> to access this
-		/// value.
-		/// </summary>
-		private string _pointDateFormat = XDate.DefaultFormatStr;
-
-		/// <summary>
-		/// private value that determines whether or not zooming is enabled for the control in the
-		/// vertical direction.  Use the public property <see cref="IsEnableVZoom"/> to access this
-		/// value.
-		/// </summary>
-		private bool _isEnableVZoom = true;
-		/// <summary>
-		/// private value that determines whether or not zooming is enabled for the control in the
-		/// horizontal direction.  Use the public property <see cref="IsEnableHZoom"/> to access this
-		/// value.
-		/// </summary>
-		private bool _isEnableHZoom = true;
-
-		/// <summary>
-		/// private value that determines whether or not zooming is enabled with the mousewheel.
-		/// Note that this property is used in combination with the <see cref="IsEnableHZoom"/> and
-		/// <see cref="IsEnableVZoom" /> properties to control zoom options.
-		/// </summary>
-		private bool _isEnableWheelZoom = true;
-
-		/// <summary>
-		/// private value that determines whether or not point editing is enabled in the
-		/// vertical direction.  Use the public property <see cref="IsEnableVEdit"/> to access this
-		/// value.
-		/// </summary>
-		private bool _isEnableVEdit = false;
-		/// <summary>
-		/// private value that determines whether or not point editing is enabled in the
-		/// horizontal direction.  Use the public property <see cref="IsEnableHEdit"/> to access this
-		/// value.
-		/// </summary>
-		private bool _isEnableHEdit = false;
-
-		/// <summary>
-		/// private value that determines whether or not panning is allowed for the control in the
-		/// horizontal direction.  Use the
-		/// public property <see cref="IsEnableHPan"/> to access this value.
-		/// </summary>
-		private bool _isEnableHPan = true;
-		/// <summary>
-		/// private value that determines whether or not panning is allowed for the control in the
-		/// vertical direction.  Use the
-		/// public property <see cref="IsEnableVPan"/> to access this value.
-		/// </summary>
-		private bool _isEnableVPan = true;
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Internal variable that indicates if the control can manage selections. 
-		/// </summary>
-		private bool _isEnableSelection = false;
-
-		private double _zoomStepFraction = 0.1;
-
-		private ScrollRange _xScrollRange;
-
-		private ScrollRangeList _yScrollRangeList;
-		private ScrollRangeList _y2ScrollRangeList;
-
-		private bool _isShowHScrollBar = false;
-		private bool _isShowVScrollBar = false;
-		//private bool		isScrollY2 = false;
-		private bool _isAutoScrollRange = false;
-
-		private double _scrollGrace = 0.00; //0.05;
-
-		private bool _isSynchronizeXAxes = false;
-		private bool _isSynchronizeYAxes = false;
-
-		//private System.Windows.Forms.HScrollBar hScrollBar1;
-		//private System.Windows.Forms.VScrollBar vScrollBar1;
-
-		// The range of values to use the scroll control bars
-		private const int _ScrollControlSpan = int.MaxValue;
-		// The ratio of the largeChange to the smallChange for the scroll bars
-		private const int _ScrollSmallRatio = 10;
-
-		private bool _isZoomOnMouseCenter = false;
-
-		//private ResourceManager _resourceManager;
-
-		/// <summary>
-		/// private field that stores a <see cref="PrintDocument" /> instance, which maintains
-		/// a persistent selection of printer options.
-		/// </summary>
-		/// <remarks>
-		/// This is needed so that a "Print" action utilizes the settings from a prior
-		/// "Page Setup" action.</remarks>
-		private PrintDocument _pdSave = null;
-		//private PrinterSettings printSave = null;
-		//private PageSettings pageSave = null;
-
-		/// <summary>
-		/// This private field contains a list of selected CurveItems.
-		/// </summary>
-		//private List<CurveItem> _selection = new List<CurveItem>();
-		private Selection _selection = new Selection();
-
-	#endregion
-
-	#region Fields: Buttons & Keys Properties
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to click on
-		/// linkable objects
-		/// </summary>
-		/// <seealso cref="LinkModifierKeys" />
-		private MouseButtons _linkButtons = MouseButtons.Left;
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to click
-		/// on linkable objects
-		/// </summary>
-		/// <seealso cref="LinkButtons" />
-		private Keys _linkModifierKeys = Keys.Alt;
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to edit point
-		/// data values
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHEdit" /> and/or
-		/// <see cref="IsEnableVEdit" /> are true.
-		/// </remarks>
-		/// <seealso cref="EditModifierKeys" />
-		private MouseButtons _editButtons = MouseButtons.Right;
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to edit point
-		/// data values
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHEdit" /> and/or
-		/// <see cref="IsEnableVEdit" /> are true.
-		/// </remarks>
-		/// <seealso cref="EditButtons" />
-		private Keys _editModifierKeys = Keys.Alt;
-
-		/// <summary>
-		/// Gets or sets a value that determines which mouse button will be used to select
-		/// <see cref="CurveItem" />'s.
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableSelection" /> is true.
-		/// </remarks>
-		/// <seealso cref="SelectModifierKeys" />
-		private MouseButtons _selectButtons = MouseButtons.Left;
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to select
-		/// <see cref="CurveItem" />'s.
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableSelection" /> is true.
-		/// </remarks>
-		/// <seealso cref="SelectButtons" />
-		private Keys _selectModifierKeys = Keys.Shift;
-
-		private Keys _selectAppendModifierKeys = Keys.Shift | Keys.Control;
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to perform
-		/// zoom operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHZoom" /> and/or
-		/// <see cref="IsEnableVZoom" /> are true.
-		/// </remarks>
-		/// <seealso cref="ZoomModifierKeys" />
-		/// <seealso cref="ZoomButtons2" />
-		/// <seealso cref="ZoomModifierKeys2" />
-		private MouseButtons _zoomButtons = MouseButtons.Left;
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to perform
-		/// zoom operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHZoom" /> and/or
-		/// <see cref="IsEnableVZoom" /> are true.
-		/// </remarks>
-		/// <seealso cref="ZoomButtons" />
-		/// <seealso cref="ZoomButtons2" />
-		/// <seealso cref="ZoomModifierKeys2" />
-		private Keys _zoomModifierKeys = Keys.None;
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used as a
-		/// secondary option to perform zoom operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHZoom" /> and/or
-		/// <see cref="IsEnableVZoom" /> are true.
-		/// </remarks>
-		/// <seealso cref="ZoomModifierKeys2" />
-		/// <seealso cref="ZoomButtons" />
-		/// <seealso cref="ZoomModifierKeys" />
-		private MouseButtons _zoomButtons2 = MouseButtons.None;
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a
-		/// secondary option to perform zoom operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHZoom" /> and/or
-		/// <see cref="IsEnableVZoom" /> are true.
-		/// </remarks>
-		/// <seealso cref="ZoomButtons" />
-		/// <seealso cref="ZoomButtons2" />
-		/// <seealso cref="ZoomModifierKeys2" />
-		private Keys _zoomModifierKeys2 = Keys.None;
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used to perform
-		/// panning operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHPan" /> and/or
-		/// <see cref="IsEnableVPan" /> are true.  A Pan operation (dragging the graph with
-		/// the mouse) should not be confused with a scroll operation (using a scroll bar to
-		/// move the graph).
-		/// </remarks>
-		/// <seealso cref="PanModifierKeys" />
-		/// <seealso cref="PanButtons2" />
-		/// <seealso cref="PanModifierKeys2" />
-		private MouseButtons _panButtons = MouseButtons.Left;
-
-		// Setting this field to Keys.Shift here
-		// causes an apparent bug to crop up in VS 2003, by which it will have the value:
-		// "System.Windows.Forms.Keys.Shift+None", which won't compile
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used to perform
-		/// panning operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHPan" /> and/or
-		/// <see cref="IsEnableVPan" /> are true.  A Pan operation (dragging the graph with
-		/// the mouse) should not be confused with a scroll operation (using a scroll bar to
-		/// move the graph).
-		/// </remarks>
-		/// <seealso cref="PanButtons" />
-		/// <seealso cref="PanButtons2" />
-		/// <seealso cref="PanModifierKeys2" />
-		private Keys _panModifierKeys = Keys.Control;
-
-		/// <summary>
-		/// Gets or sets a value that determines which Mouse button will be used as a
-		/// secondary option to perform panning operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHPan" /> and/or
-		/// <see cref="IsEnableVPan" /> are true.  A Pan operation (dragging the graph with
-		/// the mouse) should not be confused with a scroll operation (using a scroll bar to
-		/// move the graph).
-		/// </remarks>
-		/// <seealso cref="PanModifierKeys2" />
-		/// <seealso cref="PanButtons" />
-		/// <seealso cref="PanModifierKeys" />
-		private MouseButtons _panButtons2 = MouseButtons.Middle;
-
-		// Setting this field to Keys.Shift here
-		// causes an apparent bug to crop up in VS 2003, by which it will have the value:
-		// "System.Windows.Forms.Keys.Shift+None", which won't compile
-		/// <summary>
-		/// Gets or sets a value that determines which modifier keys will be used as a
-		/// secondary option to perform panning operations
-		/// </summary>
-		/// <remarks>
-		/// This setting only applies if <see cref="IsEnableHPan" /> and/or
-		/// <see cref="IsEnableVPan" /> are true.  A Pan operation (dragging the graph with
-		/// the mouse) should not be confused with a scroll operation (using a scroll bar to
-		/// move the graph).
-		/// </remarks>
-		/// <seealso cref="PanButtons2" />
-		/// <seealso cref="PanButtons" />
-		/// <seealso cref="PanModifierKeys" />
-		private Keys _panModifierKeys2 = Keys.None;
-
-	#endregion
-
-	#region Fields: Temporary state variables
-
-		/// <summary>
-		/// Internal variable that indicates the control is currently being zoomed. 
-		/// </summary>
-		private bool _isZooming = false;
-		/// <summary>
-		/// Internal variable that indicates the control is currently being panned.
-		/// </summary>
-		private bool _isPanning = false;
-		/// <summary>
-		/// Internal variable that indicates a point value is currently being edited.
-		/// </summary>
-		private bool _isEditing = false;
-
-		// Revision: JCarpenter 10/06
-		/// <summary>
-		/// Internal variable that indicates the control is currently using selection. 
-		/// </summary>
-		private bool _isSelecting = false;
-
-		/// <summary>
-		/// Internal variable that stores the <see cref="GraphPane"/> reference for the Pane that is
-		/// currently being zoomed or panned.
-		/// </summary>
-		private GraphPane _dragPane = null;
-		/// <summary>
-		/// Internal variable that stores a rectangle which is either the zoom rectangle, or the incremental
-		/// pan amount since the last mousemove event.
-		/// </summary>
-		private Point _dragStartPt;
-		private Point _dragEndPt;
-
-		private int _dragIndex;
-		private CurveItem _dragCurve;
-		private PointPair _dragStartPair;
-		/// <summary>
-		/// private field that stores the state of the scale ranges prior to starting a panning action.
-		/// </summary>
-		private ZoomState _zoomState;
-		private ZoomStateStack _zoomStateStack;
-
-		//temporarily save the location of a context menu click so we can use it for reference
-		// Note that Control.MousePosition ends up returning the position after the mouse has
-		// moved to the menu item within the context menu.  Therefore, this point is saved so
-		// that we have the point at which the context menu was first right-clicked
-		internal Point _menuClickPt;
-
-	#endregion
-
-	#region Constructors
-
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public ZedGraphControl()
-		{
-			InitializeComponent();
-
-			// These commands do nothing, but they get rid of the compiler warnings for
-			// unused events
-			bool b = MouseDown == null || MouseUp == null || MouseMove == null;
-
-			// Link in these events from the base class, since we disable them from this class.
-			base.MouseDown += new System.Windows.Forms.MouseEventHandler( this.ZedGraphControl_MouseDown );
-			base.MouseUp += new System.Windows.Forms.MouseEventHandler( this.ZedGraphControl_MouseUp );
-			base.MouseMove += new System.Windows.Forms.MouseEventHandler( this.ZedGraphControl_MouseMove );
-
-			//this.MouseWheel += new System.Windows.Forms.MouseEventHandler( this.ZedGraphControl_MouseWheel );
-
-			// Use double-buffering for flicker-free updating:
-			SetStyle( ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint
-				| ControlStyles.DoubleBuffer | ControlStyles.ResizeRedraw, true );
-			//isTransparentBackground = false;
-			//SetStyle( ControlStyles.Opaque, false );
-			SetStyle( ControlStyles.SupportsTransparentBackColor, true );
-			//this.BackColor = Color.Transparent;
-
-            /*
-			_resourceManager = new ResourceManager( "ZedGraph.ZedGraph.ZedGraphLocale",
-				Assembly.GetExecutingAssembly() );
-             */
-
-			Rectangle rect = new Rectangle( 0, 0, this.Size.Width, this.Size.Height );
-			_masterPane = new MasterPane( "", rect );
-			_masterPane.Margin.All = 0;
-			_masterPane.Title.IsVisible = false;
-
-			string titleStr = "Title";
-			string xStr = "X Axis";
-			string yStr = "Y Axis";
-
-			//GraphPane graphPane = new GraphPane( rect, "Title", "X Axis", "Y Axis" );
-			GraphPane graphPane = new GraphPane( rect, titleStr, xStr, yStr );
-			using ( Graphics g = this.CreateGraphics() )
-			{
-				graphPane.AxisChange( g );
-				//g.Dispose();
-			}
-			_masterPane.Add( graphPane );
-
-			this.hScrollBar1.Minimum = 0;
-			this.hScrollBar1.Maximum = 100;
-			this.hScrollBar1.Value = 0;
-
-			this.vScrollBar1.Minimum = 0;
-			this.vScrollBar1.Maximum = 100;
-			this.vScrollBar1.Value = 0;
-
-			_xScrollRange = new ScrollRange( true );
-			_yScrollRangeList = new ScrollRangeList();
-			_y2ScrollRangeList = new ScrollRangeList();
-
-			_yScrollRangeList.Add( new ScrollRange( true ) );
-			_y2ScrollRangeList.Add( new ScrollRange( false ) );
-
-			_zoomState = null;
-			_zoomStateStack = new ZoomStateStack();
-		}
-
-		/// <summary>
-		/// Clean up any resources being used.
-		/// </summary>
-		/// <param name="disposing">true if the components should be
-		/// disposed, false otherwise</param>
-		protected override void Dispose( bool disposing )
-		{
-			lock ( this )
-			{
-				if ( disposing )
-				{
-					if ( components != null )
-						components.Dispose();
-				}
-				base.Dispose( disposing );
-
-				_masterPane = null;
-			}
-		}
-	
-	#endregion
-
-	#region Methods
-
-		/// <summary>
-		/// Called by the system to update the control on-screen
-		/// </summary>
-		/// <param name="e">
-		/// A PaintEventArgs object containing the Graphics specifications
-		/// for this Paint event.
-		/// </param>
-		protected override void OnPaint( PaintEventArgs e )
-		{
-			lock ( this )
-			{
-				if ( BeenDisposed || _masterPane == null || this.GraphPane == null )
-					return;
-
-				if ( hScrollBar1 != null && this.GraphPane != null &&
-					vScrollBar1 != null && _yScrollRangeList != null )
-				{
-					SetScroll( hScrollBar1, this.GraphPane.XAxis, _xScrollRange.Min, _xScrollRange.Max );
-					SetScroll( vScrollBar1, this.GraphPane.YAxis, _yScrollRangeList[0].Min,
-						_yScrollRangeList[0].Max );
-				}
-
-				base.OnPaint( e );
-
-				// Add a try/catch pair since the users of the control can't catch this one
-				try { _masterPane.Draw( e.Graphics ); }
-				catch { }
-			}
-
-/*
-			// first, see if an old thread is still running
-			if ( t != null && t.IsAlive )
-			{
-				t.Abort();
-			}
-
-			//dt = new DrawingThread( e.Graphics, _masterPane );
-			//g = e.Graphics;
-
-			// Fire off the new thread
-			t = new Thread( new ParameterizedThreadStart( DoDrawingThread ) );
-			//ct.ApartmentState = ApartmentState.STA;
-			//ct.SetApartmentState( ApartmentState.STA );
-			DrawingThreadData dtd;
-			dtd._g = e.Graphics;
-			dtd._masterPane = _masterPane;
-
-			t.Start( dtd );
-			//ct.Join();
-*/
-		}
-
-//		Thread t = null;
-		//DrawingThread dt = null;
-
-/*
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="dtdobj"></param>
-		public void DoDrawingThread( object dtdobj )
-		{
-			try
-			{
-				DrawingThreadData dtd = (DrawingThreadData) dtdobj;
-
-				if ( dtd._g != null && dtd._masterPane != null )
-					dtd._masterPane.Draw( dtd._g );
-
-				//				else
-				//				{
-				//					using ( Graphics g2 = CreateGraphics() )
-				//						_masterPane.Draw( g2 );
-				//				}
-			}
-			catch
-			{
-
-			}
-		}
-*/
-
-		/// <summary>
-		/// Called when the control has been resized.
-		/// </summary>
-		/// <param name="sender">
-		/// A reference to the control that has been resized.
-		/// </param>
-		/// <param name="e">
-		/// An EventArgs object.
-		/// </param>
-		protected void ZedGraphControl_ReSize( object sender, System.EventArgs e )
-		{
-			lock ( this )
-			{
-				if ( BeenDisposed || _masterPane == null )
-					return;
-
-				Size newSize = this.Size;
-
-				if ( _isShowHScrollBar )
-				{
-					hScrollBar1.Visible = true;
-					newSize.Height -= this.hScrollBar1.Size.Height;
-					hScrollBar1.Location = new Point( 0, newSize.Height );
-					hScrollBar1.Size = new Size( newSize.Width, hScrollBar1.Height );
-				}
-				else
-					hScrollBar1.Visible = false;
-
-				if ( _isShowVScrollBar )
-				{
-					vScrollBar1.Visible = true;
-					newSize.Width -= this.vScrollBar1.Size.Width;
-					vScrollBar1.Location = new Point( newSize.Width, 0 );
-					vScrollBar1.Size = new Size( vScrollBar1.Width, newSize.Height );
-				}
-				else
-					vScrollBar1.Visible = false;
-
-				using ( Graphics g = this.CreateGraphics() )
-				{
-					_masterPane.ReSize( g, new RectangleF( 0, 0, newSize.Width, newSize.Height ) );
-					//g.Dispose();
-				}
-				this.Invalidate();
-			}
-		}
-		/// <summary>This performs an axis change command on the graphPane.
-		/// </summary>
-		/// <remarks>
-		/// This is the same as
-		/// <c>ZedGraphControl.GraphPane.AxisChange( ZedGraphControl.CreateGraphics() )</c>, however,
-		/// this method also calls <see cref="SetScrollRangeFromData" /> if <see cref="IsAutoScrollRange" />
-		/// is true.
-		/// </remarks>
-		public virtual void AxisChange()
-		{
-			lock ( this )
-			{
-				if ( BeenDisposed || _masterPane == null )
-					return;
-
-				using ( Graphics g = this.CreateGraphics() )
-				{
-					_masterPane.AxisChange( g );
-					//g.Dispose();
-				}
-
-				if ( _isAutoScrollRange )
-					SetScrollRangeFromData();
-			}
-		}
-	#endregion
-
-	#region Zoom States
-
-		/// <summary>
-		/// Save the current states of the GraphPanes to a separate collection.  Save a single
-		/// (<see paramref="primaryPane" />) GraphPane if the panes are not synchronized
-		/// (see <see cref="IsSynchronizeXAxes" /> and <see cref="IsSynchronizeYAxes" />),
-		/// or save a list of states for all GraphPanes if the panes are synchronized.
-		/// </summary>
-		/// <param name="primaryPane">The primary GraphPane on which zoom/pan/scroll operations
-		/// are taking place</param>
-		/// <param name="type">The <see cref="ZoomState.StateType" /> that describes the
-		/// current operation</param>
-		/// <returns>The <see cref="ZoomState" /> that corresponds to the
-		/// <see paramref="primaryPane" />.
-		/// </returns>
-		private ZoomState ZoomStateSave( GraphPane primaryPane, ZoomState.StateType type )
-		{
-			ZoomStateClear();
-
-			if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-			{
-				foreach ( GraphPane pane in _masterPane._paneList )
-				{
-					ZoomState state = new ZoomState( pane, type );
-					if ( pane == primaryPane )
-						_zoomState = state;
-					_zoomStateStack.Add( state );
-				}
-			}
-			else
-				_zoomState = new ZoomState( primaryPane, type );
-
-			return _zoomState;
-		}
-
-		/// <summary>
-		/// Restore the states of the GraphPanes to a previously saved condition (via
-		/// <see cref="ZoomStateSave" />.  This is essentially an "undo" for live
-		/// pan and scroll actions.  Restores a single
-		/// (<see paramref="primaryPane" />) GraphPane if the panes are not synchronized
-		/// (see <see cref="IsSynchronizeXAxes" /> and <see cref="IsSynchronizeYAxes" />),
-		/// or save a list of states for all GraphPanes if the panes are synchronized.
-		/// </summary>
-		/// <param name="primaryPane">The primary GraphPane on which zoom/pan/scroll operations
-		/// are taking place</param>
-		private void ZoomStateRestore( GraphPane primaryPane )
-		{
-			if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-			{
-				for ( int i = 0; i < _masterPane._paneList.Count; i++ )
-				{
-					if ( i < _zoomStateStack.Count )
-						_zoomStateStack[i].ApplyState( _masterPane._paneList[i] );
-				}
-			}
-			else if ( _zoomState != null )
-				_zoomState.ApplyState( primaryPane );
-
-			ZoomStateClear();
-		}
-
-		/// <summary>
-		/// Place the previously saved states of the GraphPanes on the individual GraphPane
-		/// <see cref="ZedGraph.GraphPane.ZoomStack" /> collections.  This provides for an
-		/// option to undo the state change at a later time.  Save a single
-		/// (<see paramref="primaryPane" />) GraphPane if the panes are not synchronized
-		/// (see <see cref="IsSynchronizeXAxes" /> and <see cref="IsSynchronizeYAxes" />),
-		/// or save a list of states for all GraphPanes if the panes are synchronized.
-		/// </summary>
-		/// <param name="primaryPane">The primary GraphPane on which zoom/pan/scroll operations
-		/// are taking place</param>
-		/// <returns>The <see cref="ZoomState" /> that corresponds to the
-		/// <see paramref="primaryPane" />.
-		/// </returns>
-		private void ZoomStatePush( GraphPane primaryPane )
-		{
-			if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
-			{
-				for ( int i = 0; i < _masterPane._paneList.Count; i++ )
-				{
-					if ( i < _zoomStateStack.Count )
-						_masterPane._paneList[i].ZoomStack.Add( _zoomStateStack[i] );
-				}
-			}
-			else if ( _zoomState != null )
-				primaryPane.ZoomStack.Add( _zoomState );
-
-			ZoomStateClear();
-		}
-
-		/// <summary>
-		/// Clear the collection of saved states.
-		/// </summary>
-		private void ZoomStateClear()
-		{
-			_zoomStateStack.Clear();
-			_zoomState = null;
-		}
-
-		/// <summary>
-		/// Clear all states from the undo stack for each GraphPane.
-		/// </summary>
-		private void ZoomStatePurge()
-		{
-			foreach ( GraphPane pane in _masterPane._paneList )
-				pane.ZoomStack.Clear();
-		}
-
-	#endregion
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ZedGraphException.cs b/BDInfo/ZedGraph/ZedGraphException.cs
deleted file mode 100644
index 99f2e2f058..0000000000
--- a/BDInfo/ZedGraph/ZedGraphException.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-//============================================================================
-//ZedGraphException Class
-//Copyright © 2004  Jerry Vos
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-using System;
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// An exception thrown by ZedGraph.  A child class of <see cref="ApplicationException"/>.
-	/// </summary>
-	///
-	/// <author> Jerry Vos modified by John Champion</author>
-	/// <version> $Revision: 3.2 $ $Date: 2006/06/24 20:26:44 $ </version>
-	public class ZedGraphException : System.ApplicationException
-	{
-		/// <summary>
-		/// Initializes a new instance of the <see cref="ZedGraphException"/>
-		/// class with serialized data.
-		/// </summary>
-		/// <param name="info">The <see cref="System.Runtime.Serialization.SerializationInfo"/>
-		/// instance that holds the serialized object data about the exception being thrown.</param>
-		/// <param name="context">The <see cref="System.Runtime.Serialization.StreamingContext"/>
-		/// instance that contains contextual information about the source or destination.</param>
-		protected ZedGraphException( System.Runtime.Serialization.SerializationInfo info, 
-										System.Runtime.Serialization.StreamingContext context )
-			: base ( info, context )
-		{
-		}
-		
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Exception"/> class with a specified
-		/// error message and a reference to the inner exception that is the cause of this exception.
-		/// </summary>
-		/// <param name="message">The error message that explains the reason for the exception.</param>
-		/// <param name="innerException">The exception that is the cause of the current exception.
-		/// If the innerException parameter is not a null reference, the current exception is raised
-		/// in a catch block that handles the inner exception.</param>
-		public ZedGraphException( System.String message, System.Exception innerException )
-			: base ( message, innerException )
-		{
-
-		}
-	
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Exception"/> class with a specified error message.
-		/// </summary>
-		/// <param name="message">The error message that explains the reason for the exception.</param>
-		public ZedGraphException ( System.String message ) 
-			: base( message )
-		{
-		}
-		
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Exception"/> class.
-		/// </summary>
-		public ZedGraphException() 
-			: base()
-		{
-		}
-	}
-}
diff --git a/BDInfo/ZedGraph/ZoomState.cs b/BDInfo/ZedGraph/ZoomState.cs
deleted file mode 100644
index be65f5b908..0000000000
--- a/BDInfo/ZedGraph/ZoomState.cs
+++ /dev/null
@@ -1,191 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Text;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A class that captures all the scale range settings for a <see cref="GraphPane"/>.
-	/// </summary>
-	/// <remarks>
-	/// This class is used to store scale ranges in order to allow zooming out to
-	/// prior scale range states.  <see cref="ZoomState"/> objects are maintained in the
-	/// <see cref="ZoomStateStack"/> collection.  The <see cref="ZoomState"/> object holds
-	/// a <see cref="ScaleState"/> object for each of the three axes; the <see cref="XAxis"/>,
-	/// the <see cref="YAxis"/>, and the <see cref="Y2Axis"/>.
-	/// </remarks>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.15 $ $Date: 2007/04/16 00:03:07 $ </version>
-	public class ZoomState : ICloneable
-	{
-		/// <summary>
-		/// An enumeration that describes whether a given state is the result of a Pan or Zoom
-		/// operation.
-		/// </summary>
-		public enum StateType
-		{
-			/// <summary>
-			/// Indicates the <see cref="ZoomState"/> object is from a Zoom operation
-			/// </summary>
-			Zoom,
-			/// <summary>
-			/// Indicates the <see cref="ZoomState"/> object is from a Wheel Zoom operation
-			/// </summary>
-			WheelZoom,
-			/// <summary>
-			/// Indicates the <see cref="ZoomState"/> object is from a Pan operation
-			/// </summary>
-			Pan,
-			/// <summary>
-			/// Indicates the <see cref="ZoomState"/> object is from a Scroll operation
-			/// </summary>
-			Scroll
-		}
-
-		/// <summary>
-		/// <see cref="ScaleState"/> objects to store the state data from the axes.
-		/// </summary>
-		private ScaleState	_xAxis, _x2Axis;
-		private ScaleStateList _yAxis, _y2Axis;
-		/// <summary>
-		/// An enum value indicating the type of adjustment being made to the
-		/// scale range state.
-		/// </summary>
-		private StateType	_type;
-
-		/// <summary>
-		/// Gets a <see cref="StateType" /> value indicating the type of action (zoom or pan)
-		/// saved by this <see cref="ZoomState" />.
-		/// </summary>
-		public StateType Type
-		{
-			get { return _type; }
-		}
-
-		/// <summary>
-		/// Gets a string representing the type of adjustment that was made when this scale
-		/// state was saved.
-		/// </summary>
-		/// <value>A string representation for the state change type; typically
-		/// "Pan", "Zoom", or "Scroll".</value>
-		public string TypeString
-		{
-			get
-			{
-				switch ( _type )
-				{
-					case StateType.Pan:
-						return "Pan";
-					case StateType.WheelZoom:
-						return "WheelZoom";
-					case StateType.Zoom:
-					default:
-						return "Zoom";
-					case StateType.Scroll:
-						return "Scroll";
-				}
-			}
-		}
-
-		/// <summary>
-		/// Construct a <see cref="ZoomState"/> object from the scale ranges settings contained
-		/// in the specified <see cref="GraphPane"/>.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> from which to obtain the scale
-		/// range values.
-		/// </param>
-		/// <param name="type">A <see cref="StateType"/> enumeration that indicates whether
-		/// this saved state is from a pan or zoom.</param>
-		public ZoomState( GraphPane pane, StateType type )
-		{
-
-			_xAxis = new ScaleState( pane.XAxis );
-			_x2Axis = new ScaleState( pane.X2Axis );
-			_yAxis = new ScaleStateList( pane.YAxisList );
-			_y2Axis = new ScaleStateList( pane.Y2AxisList );
-			_type = type;
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ZoomState"/> object from which to copy</param>
-		public ZoomState( ZoomState rhs )
-		{
-			_xAxis = new ScaleState( rhs._xAxis );
-			_x2Axis = new ScaleState( rhs._x2Axis );
-			_yAxis = new ScaleStateList( rhs._yAxis );
-			_y2Axis = new ScaleStateList( rhs._y2Axis );
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ZoomState Clone()
-		{
-			return new ZoomState( this );
-		}
-
-
-		/// <summary>
-		/// Copy the properties from this <see cref="ZoomState"/> out to the specified <see cref="GraphPane"/>.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> to which the scale range properties should be
-		/// copied.</param>
-		public void ApplyState( GraphPane pane )
-		{
-			_xAxis.ApplyScale( pane.XAxis );
-			_x2Axis.ApplyScale( pane.X2Axis );
-			_yAxis.ApplyScale( pane.YAxisList );
-			_y2Axis.ApplyScale( pane.Y2AxisList );
-		}
-
-		/// <summary>
-		/// Determine if the state contained in this <see cref="ZoomState"/> object is different from
-		/// the state of the specified <see cref="GraphPane"/>.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> object with which to compare states.</param>
-		/// <returns>true if the states are different, false otherwise</returns>
-		public bool IsChanged( GraphPane pane )
-		{
-			return _xAxis.IsChanged( pane.XAxis ) ||
-					_x2Axis.IsChanged( pane.X2Axis ) ||
-					_yAxis.IsChanged( pane.YAxisList ) ||
-					_y2Axis.IsChanged( pane.Y2AxisList );
-		}
-
-	}
-}
diff --git a/BDInfo/ZedGraph/ZoomStateStack.cs b/BDInfo/ZedGraph/ZoomStateStack.cs
deleted file mode 100644
index 8089c4fcc9..0000000000
--- a/BDInfo/ZedGraph/ZoomStateStack.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-//============================================================================
-//ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
-//
-//This library is free software; you can redistribute it and/or
-//modify it under the terms of the GNU Lesser General Public
-//License as published by the Free Software Foundation; either
-//version 2.1 of the License, or (at your option) any later version.
-//
-//This library is distributed in the hope that it will be useful,
-//but WITHOUT ANY WARRANTY; without even the implied warranty of
-//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//Lesser General Public License for more details.
-//
-//You should have received a copy of the GNU Lesser General Public
-//License along with this library; if not, write to the Free Software
-//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//=============================================================================
-
-#region Using directives
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-#endregion
-
-namespace ZedGraph
-{
-	/// <summary>
-	/// A LIFO stack of prior <see cref="ZoomState"/> objects, used to allow zooming out to prior
-	/// states (of scale range settings).
-	/// </summary>
-	/// <author> John Champion </author>
-	/// <version> $Revision: 3.1 $ $Date: 2006/06/24 20:26:44 $ </version>
-	public class ZoomStateStack : List<ZoomState>, ICloneable
-	{
-		/// <summary>
-		/// Default Constructor
-		/// </summary>
-		public ZoomStateStack()
-		{
-		}
-
-		/// <summary>
-		/// The Copy Constructor
-		/// </summary>
-		/// <param name="rhs">The <see cref="ZoomStateStack"/> object from which to copy</param>
-		public ZoomStateStack( ZoomStateStack rhs )
-		{
-			foreach ( ZoomState state in rhs )
-			{
-				Add( new ZoomState( state ) );
-			}
-		}
-
-		/// <summary>
-		/// Implement the <see cref="ICloneable" /> interface in a typesafe manner by just
-		/// calling the typed version of <see cref="Clone" />
-		/// </summary>
-		/// <returns>A deep copy of this object</returns>
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-
-		/// <summary>
-		/// Typesafe, deep-copy clone method.
-		/// </summary>
-		/// <returns>A new, independent copy of this class</returns>
-		public ZoomStateStack Clone()
-		{
-			return new ZoomStateStack( this );
-		}
-
-
-		/// <summary>
-		/// Public readonly property that indicates if the stack is empty
-		/// </summary>
-		/// <value>true for an empty stack, false otherwise</value>
-		public bool IsEmpty
-		{
-			get { return this.Count == 0; }
-		}
-
-		/// <summary>
-		/// Add the scale range information from the specified <see cref="GraphPane"/> object as a
-		/// new <see cref="ZoomState"/> entry on the stack.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> object from which the scale range
-		/// information should be copied.</param>
-		/// <param name="type">A <see cref="ZoomState.StateType"/> enumeration that indicates whether this
-		/// state is the result of a zoom or pan operation.</param>
-		/// <returns>The resultant <see cref="ZoomState"/> object that was pushed on the stack.</returns>
-		public ZoomState Push( GraphPane pane, ZoomState.StateType type )
-		{
-			ZoomState state = new ZoomState( pane, type );
-			this.Add( state );
-			return state;
-		}
-
-		/// <summary>
-		/// Add the scale range information from the specified <see cref="ZoomState"/> object as a
-		/// new <see cref="ZoomState"/> entry on the stack.
-		/// </summary>
-		/// <param name="state">The <see cref="ZoomState"/> object to be placed on the stack.</param>
-		/// <returns>The <see cref="ZoomState"/> object (same as the <see paramref="state"/>
-		/// parameter).</returns>
-		public ZoomState Push( ZoomState state )
-		{
-			this.Add( state );
-			return state;
-		}
-
-		/// <summary>
-		/// Pop a <see cref="ZoomState"/> entry from the top of the stack, and apply the properties
-		/// to the specified <see cref="GraphPane"/> object.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> object to which the scale range
-		/// information should be copied.</param>
-		/// <returns>The <see cref="ZoomState"/> object that was "popped" from the stack and applied
-		/// to the specified <see cref="GraphPane"/>.  null if no <see cref="ZoomState"/> was
-		/// available (the stack was empty).</returns>
-		public ZoomState Pop( GraphPane pane )
-		{
-			if ( !this.IsEmpty )
-			{
-				ZoomState state = (ZoomState) this[ this.Count - 1 ];
-				this.RemoveAt( this.Count - 1 );
-
-				state.ApplyState( pane );
-				return state;
-			}
-			else
-				return null;
-		}
-
-		/// <summary>
-		/// Pop the <see cref="ZoomState"/> entry from the bottom of the stack, and apply the properties
-		/// to the specified <see cref="GraphPane"/> object.  Clear the stack completely.
-		/// </summary>
-		/// <param name="pane">The <see cref="GraphPane"/> object to which the scale range
-		/// information should be copied.</param>
-		/// <returns>The <see cref="ZoomState"/> object at the bottom of the stack that was applied
-		/// to the specified <see cref="GraphPane"/>.  null if no <see cref="ZoomState"/> was
-		/// available (the stack was empty).</returns>
-		public ZoomState PopAll( GraphPane pane )
-		{
-			if ( !this.IsEmpty )
-			{
-				ZoomState state = (ZoomState) this[ 0 ];
-				this.Clear();
-
-				state.ApplyState( pane );
-
-				return state;
-			}
-			else
-				return null;
-		}
-
-		/// <summary>
-		/// Gets a reference to the <see cref="ZoomState"/> object at the top of the stack,
-		/// without actually removing it from the stack.
-		/// </summary>
-		/// <value>A <see cref="ZoomState"/> object reference, or null if the stack is empty.</value>
-		public ZoomState Top
-		{
-			get
-			{
-				if ( !this.IsEmpty )
-					return (ZoomState) this[ this.Count - 1 ];
-				else
-					return null;
-			}
-		}
-	}
-}
diff --git a/BDInfo/packages.config b/BDInfo/packages.config
index 1c3748cf7c..869aeef655 100644
--- a/BDInfo/packages.config
+++ b/BDInfo/packages.config
@@ -3,4 +3,5 @@
   <package id="Discutils" version="0.11.0.2" targetFramework="net45" />
   <package id="Microsoft.WindowsAPICodePack-Core" version="1.1.0.2" targetFramework="net45" />
   <package id="Microsoft.WindowsAPICodePack-Shell" version="1.1.0.0" targetFramework="net45" />
+  <package id="ZedGraph" version="5.1.7" targetFramework="net45" />
 </packages>
\ No newline at end of file