A flexible charting library for .NET[from]

喜欢ヅ旅行 2021-10-26 15:48 232阅读 0赞

from [http://www.codeproject.com/csharp/zedgraph.asp][http_www.codeproject.com_csharp_zedgraph.asp] 内容好多~

<table> 
 <tbody> 
  <tr> 
   <td></td> 
  </tr> 
  <tr> 
   <td><span> </span> 
    <div> 
     <ul> 
      <li><a href="http://www.codeproject.com/csharp/zedgraph/zedgraph_source_v508_458.zip" rel="nofollow">Download source files (.Net 1.1 and .Net 2.0)</a> </li> 
      <li><a href="http://www.codeproject.com/csharp/zedgraph/zedgraph_dll_v508_458.zip" rel="nofollow">Download dll only (.Net 1.1 and .Net 2.0)</a> </li> 
      <li><a href="http://www.codeproject.com/csharp/zedgraph/ZedGraphSampleCS_v508.zip" rel="nofollow">Download C# Sample Project</a> </li> 
      <li><a href="http://www.codeproject.com/csharp/zedgraph/ZedGraphSampleVB_v508.zip" rel="nofollow">Download VB Sample Project</a> </li> 
      <li><a href="http://sourceforge.net/project/showfiles.php?group_id=114675" rel="nofollow">Download the <strong>latest versions</strong> from SourceForge</a> </li> 
     </ul> 
     <p><img height="401" src="http://www.codeproject.com/csharp/zedgraph/main_sample.png" width="598" alt="main_sample.png"></p> 
     <h2>Introduction</h2> 
     <p>ZedGraph is a class library, Windows Forms UserControl, and ASP web-accessible control for creating 2D line, bar, and pie graphs of arbitrary datasets. The classes provide a high degree of flexibility - almost every aspect of the graph can be user-modified. At the same time, usage of the classes is kept simple by providing default values for all of the graph attributes. The classes include code for choosing appropriate scale ranges and step sizes based on the range of data values being plotted.</p> 
     <p>ZedGraph is maintained as an open-source development project on <a href="http://sourceforge.net/projects/zedgraph" rel="nofollow">SourceForge</a>. The site includes a <a href="http://zedgraph.org/" rel="nofollow">project Wiki</a>, <a href="http://zedgraph.sourceforge.net/documentation/default.html" rel="nofollow">documentation</a>, <a href="http://zedgraph.cvs.sourceforge.net/zedgraph/" rel="nofollow">interim (CVS) updates</a>, and all <a href="http://sourceforge.net/project/showfiles.php?group_id=114675" rel="nofollow">release versions</a>.</p> 
     <p>A set of <a href="http://zedgraph.org/wiki/index.php?title=Sample_Graphs" rel="nofollow">sample graphs</a> is also available on the Wiki, complete with source code (many of the samples include C# and VB code).</p> 
     <p><strong>ZedGraph now supports both .NET 2.0 and .NET 1.1.</strong></p> 
     <ul> 
      <li>For .NET 2.0, use ZedGraph version 5.0+. </li> 
      <li>For .NET 1.1, use ZedGraph version 4.5+. </li> 
     </ul> 
     <h2>Background</h2> 
     <p>There are many graphing libraries out there, but none seemed to fit what I needed. I found MSChart too quirky, and many of the other options did not have the flexibility I needed to achieve a polished look. Of course, most of the commercial packages would do the trick, but I needed something that was free. So, ZedGraph was born.</p> 
     <p>These classes will generate a variety of line, bar, or pie charts on a form or web page, given a location rectangle and some data points. ZedGraph handles 2D line/scatter graphs, horizontal/vertical bar graphs, stacked bar charts, stacked percent bar charts, error bar charts, open-high-low-close charts, Japanese candlestick charts, and pie charts - it does not yet handle 2.5D or 3D surfaces or charts. The charts can be dressed up with axis labels and titles, a legend, text labels and arrows (as shown in the example above), images, etc.</p> 
     <p>The <a href="http://zedgraph.org/" rel="nofollow">ZedGraphWiki</a> and the <a href="http://zedgraph.sourceforge.net/documentation/default.html" rel="nofollow">online class documentation</a> provide lots of helpful tips and descriptions. Refer to them for more details - ZedGraph has a tremendous number of options that are not documented in this tutorial.</p> 
     <h2>VB users</h2> 
     <p>This article uses C# exclusively for examples, however, all the code samples for the tutorial, plus other examples are available for Visual Basic, on the <a href="http://zedgraph.org/wiki/index.php?title=Sample_Graphs" rel="nofollow">ZedGraphWiki Sample Graphs section</a>.</p> 
     <h2>Using ZedGraph as a web control</h2> 
     <p>ZedGraph now includes a class derived from the <code>Control</code> class that facilitates access from ASPX web page code. The demo project download above demonstrates this functionality. Also, the <a href="http://zedgraph.org/" rel="nofollow">ZedGraphWiki</a> includes detailed examples of web control usage for two rendering modes, <a href="http://zedgraph.org/wiki/index.php?title=Use_RenderMode.RawImage_in_a_web_page" rel="nofollow"><code>RawImage</code></a> and <a href="http://zedgraph.org/wiki/index.php?title=Use_RenderMode.ImageTag_in_a_web_page" rel="nofollow"><code>ImageTag</code></a>.</p> 
     <h2>Using ZedGraph as a UserControl</h2> 
     <p>ZedGraph is accessible as a control from the control toolbox in Visual Studio .NET. To access ZedGraph, first launch Visual Studio .NET, and create a new Windows Application (Forms) project. Open the form design so that it appears in the current window. View the toolbox using the <em>View/Toolbox</em> menu command. Right-click inside the "General" or "Components" sub-pane of the tool box, and select the "Choose Items..." option. Click "Browse...", and navigate to the <em>zedgraph.dll</em> file. Once this file is added, you should see a <code>ZedGraphControl</code> option in the toolbox.</p> 
     <ol> 
      <li>In your project, under the <em>Project</em> menu, select the "Add Reference..." option. Use the <em>Browse</em> button to find <em>ZedGraph.dll</em>, and click OK. Repeat this for ZedGraph.Web.dll. This will include all the functionality of ZedGraph into your project. </li> 
      <li>Add a <code>using ZedGraph;</code> entry to your main form code. </li> 
      <li>In the form designer, drag the <code>ZedGraphControl</code> from the Toolbox over to the form, and drag/size it as desired. You now have a ZedGraph control in your form. </li> 
      <li>All of the ZedGraph functionality is accessible through the <code>ZedGraphControl.MasterPane</code> property. A <code>ZedGraphControl.GraphPane</code> is also provided, which simply references the first <code>GraphPane</code> in the <code>MasterPane</code> list (this is explained below). </li> 
      <li>In the Form designer, double click the form (not the <code>ZedGraphControl</code>). This will place a <code>Form1_Load()</code> template in your code file. </li> 
      <li>Again, in the Form designer, with the form selected, go to Properties, pick the yellow lightning bolt to see the events, put the cursor in the box to the right of the <code>Resize</code> event, and hit Enter to add a <code>Form1_Resize</code> event method to your code file. </li> 
      <li>Modify the <code>Form1_Load()</code> and <code>Form1_Resize</code> methods, and add the <code>CreateGraph()</code> and <code>SetSize()</code> methods as shown below (this code assumes the name of your control is '<code>zedGraphControl1</code>'). &lt;Note: A complete solution containing this code can be download from <a href="http://zedgraph.org/wiki/index.php?title=Sample_Graphs" rel="nofollow">the ZedGraph Wiki</a>: 
       <div> 
        <img height="9" src="http://www.codeproject.com/images/minus.gif" width="9" alt="minus.gif"> 
        <span> Collapse</span> 
       </div> <pre><span>// Respond to the form 'Resize' event</span>
                private void Form1_Resize( object sender, EventArgs e )
                {
                SetSize();
                }
                <span>// SetSize() is separate from Resize() so we can </span>
                <span>// call it independently from the Form1_Load() method</span>
                <span>// This leaves a 10 px margin around the outside of the control</span>
                <span>// Customize this to fit your needs</span>
                private void SetSize()
                {
                zedGraphControl1.Location = new Point( 10, 10 );
                <span>// Leave a small margin around the outside of the control</span>
                zedGraphControl1.Size = new Size( ClientRectangle.Width - 20,
                ClientRectangle.Height - 20 );
                }
                <span>// Respond to form 'Load' event</span>
                private void Form1_Load( object sender, EventArgs e )
                {
                <span>// Setup the graph</span>
                CreateGraph( zedGraphControl1 );
                <span>// Size the control to fill the form with a margin</span>
                SetSize();
                }
                <span>// Build the Chart</span>
                private void CreateGraph( ZedGraphControl zgc )
                {
                <span>// get a reference to the GraphPane</span>
                GraphPane myPane = zgc.GraphPane;
                <span>// Set the Titles</span>
                myPane.Title.Text = <span>"My Test Graph\n(For CodeProject Sample)"</span>;
                myPane.XAxis.Title.Text = <span>"My X Axis"</span>;
                myPane.YAxis.Title.Text = <span>"My Y Axis"</span>;
                <span>// Make up some data arrays based on the Sine function</span>
                double x, y1, y2;
                PointPairList list1 = new PointPairList();
                PointPairList list2 = new PointPairList();
                for ( int i = 0; i &lt; 36; i++ )
                {
                x = (double)i + 5;
                y1 = 1.5 + Math.Sin( (double)i * 0.2 );
                y2 = 3.0 * ( 1.5 + Math.Sin( (double)i * 0.2 ) );
                list1.Add( x, y1 );
                list2.Add( x, y2 );
                }
                <span>// Generate a red curve with diamond</span>
                <span>// symbols, and "Porsche" in the legend</span>
                LineItem myCurve = myPane.AddCurve( <span>"Porsche"</span>,
                list1, Color.Red, SymbolType.Diamond );
                <span>// Generate a blue curve with circle</span>
                <span>// symbols, and "Piper" in the legend</span>
                LineItem myCurve2 = myPane.AddCurve( <span>"Piper"</span>,
                list2, Color.Blue, SymbolType.Circle );
                <span>// Tell ZedGraph to refigure the</span>
                <span>// axes since the data have changed</span>
                zgc.AxisChange();
                }</pre> <p>Note that the <code>AxisChange()</code> method call must be made any time you add or change the data. This tells ZedGraph to go ahead and recalculate all the axis ranges. (<strong>Note</strong>: This is all <code>AxisChange()</code> does - you can call it anytime you like, and it will update the axis ranges based on the current set of data points. You can also avoid calling AxisChange() if you do not want the axes rescaled.)</p> </li> 
     </ol> 
     <p>The above code will generate the following output:</p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/example_1.png" width="508" alt="example_1.png"></p> 
     <h2>Enhancing the graph</h2> 
     <p>ZedGraph allows you to modify the graph attributes in a wide variety of ways. Each of the parts of the graph is encapsulated in a class structure, which has modifiable properties to control the output. The following are some of the classes provided in ZedGraph (Note that these classes are XML documented. See the <a href="http://zedgraph.sourceforge.net/documentation/default.html" rel="nofollow">ZedGraph documentation</a> for details about each class.):</p> 
     <table> 
      <tbody> 
       <tr> 
        <th>Class</th> 
        <th>Description</th> 
       </tr> 
       <tr> 
        <td><code>MasterPane</code></td> 
        <td>A class to manage multiple <code>GraphPane</code> objects, derived from <code>PaneBase</code>. Use of the <code>MasterPane</code> class is optional, as the <code>GraphPane</code> class can be used directly for a single pane. Also provides methods for layout, arrangement, and management of the individual <code>GraphPane</code> objects.</td> 
       </tr> 
       <tr> 
        <td><code>GraphPane</code></td> 
        <td>The primary class for the graph, derived from <code>PaneBase</code>. Includes all other classes as properties. Also controls the pane title, the pane frame and axis frame, backgrounds, etc.</td> 
       </tr> 
       <tr> 
        <td><code>XAxis</code>, <code>YAxis</code>, <code>Y2Axis</code></td> 
        <td>Children of the <code>Axis</code> class. These classes include many aspects of the axis display, including tics, grids, colors, pens, fonts, labels, and styles.</td> 
       </tr> 
       <tr> 
        <td><code>Scale</code></td> 
        <td>A class instance maintained by the <code>Axis</code> class. Contains the scale range, step sizes, formats, and display options for the scale. Comes in variants for <code>Linear</code>, <code>Log</code>, <code>Text</code>, <code>Date</code>, <code>Ordinal</code>, <code>Exponent</code>, <code>LinearAsOrdinal</code>, and <code>DateAsOrdinal</code> scales.</td> 
       </tr> 
       <tr> 
        <td><code>Legend</code></td> 
        <td>The class that describes the location, font, colors, etc., used to draw the legend.</td> 
       </tr> 
       <tr> 
        <td><code>CurveItem</code></td> 
        <td>An <code><span>abstract</span></code> base class that contains data for a single curve. <code>LineItem</code>, <code>BarItem</code>, <code>HiLowBarItem</code>, <code>ErrorBarItem</code>, <code>PieItem</code>, <code>StickItem</code>, <code>OHLCBarItem</code>, and <code>JapaneseCandleStickItem</code> are all derived from this class.</td> 
       </tr> 
       <tr> 
        <td><code>CurveList</code></td> 
        <td>A collection class to maintain a list of <code>CurveItem</code> objects. The order of the curves in the list controls the Z-Order for drawing. The last curve in the list will appear behind all other curves.</td> 
       </tr> 
       <tr> 
        <td><code>GraphObj</code></td> 
        <td>An <code><span>abstract</span></code> base class that includes position information for a variety of supplemental graphic objects on a plot. <code>TextObj</code>, <code>ImageObj</code>, <code>LineObj</code>, <code>ArrowObj</code>, <code>EllipseObj</code>, <code>BoxObj</code>, and <code>PolyObj</code> are derived from <code>GraphObj</code>.</td> 
       </tr> 
       <tr> 
        <td><code>GraphObjList</code></td> 
        <td>A collection class to maintain a list of <code>GraphObj</code> objects. The order of the objects in the list, plus a <code>ZOrder</code> property, control the Z-Order for drawing. The last item in the list will appear behind all other items with the same <code>ZOrder</code> value.</td> 
       </tr> 
       <tr> 
        <td><code>FontSpec</code></td> 
        <td>A utility class that includes information about the font family, color, angle, size, style, frame, and background fill of the text on the graph. Each class that includes text information will contain one or more <code>FontSpec</code> objects to specifically describe the associated fonts.</td> 
       </tr> 
       <tr> 
        <td><code>Fill</code></td> 
        <td>A utility class that includes characteristics of background color fills. Each object that has color fill capability will contain one or more <code>Fill</code> objects to specifically describe the associated color fill.</td> 
       </tr> 
       <tr> 
        <td><code>Border</code></td> 
        <td>A utility class that includes characteristics of object borders. Each object that has border capability will contain one or more <code>Border</code> objects to specifically describe the associated border color and line properties.</td> 
       </tr> 
       <tr> 
        <td><code>Location</code></td> 
        <td>A general class for handling the location of graphic objects on the plot.</td> 
       </tr> 
       <tr> 
        <td><code>PointPair</code></td> 
        <td>A data <code><span>struct</span></code> that encapsulates a single pair of <code><span>double</span></code> values representing an (X,Y) data point. This is the internal data storage format for the value arrays in each <code>CurveItem</code>.</td> 
       </tr> 
       <tr> 
        <td><code>PointPairList</code></td> 
        <td>A collection class to maintain a list of <code>PointPair</code> objects.</td> 
       </tr> 
       <tr> 
        <td><code>XDate</code></td> 
        <td>This class encapsulates a single date-time value (stored as a <code>System.Double</code>), plus a wide array of methods to convert between XL date, Astronomical Julian Day number, Gregorian Calendar date, fractional year, etc. See the discussion of <a href="http://www.codeproject.com/csharp/zedgraph.asp#datetime" rel="nofollow">Date-Time</a> axes below, for details.</td> 
       </tr> 
      </tbody> 
     </table> 
     <p>The graph is modified by accessing properties in each of the above classes. For example, if you include the following lines of code in your <code>CreateGraph()</code> method, after the code samples shown previously, the plot will be modified accordingly:</p> 
     <div> 
      <img height="9" src="http://www.codeproject.com/images/minus.gif" width="9" alt="minus.gif"> 
      <span> Collapse</span> 
     </div> 
     <pre><span>// Change the color of the title</span>
            myPane.Title.FontSpec.FontColor = Color.Green;
            <span>// Add gridlines to the plot, and make them gray</span>
            myPane.XAxis.MajorGrid.IsVisible = true;
            myPane.YAxis.MajorGrid.IsVisible = true;
            myPane.XAxis.MajorGrid.Color = Color.LightGray;
            myPane.YAxis.MajorGrid.Color = Color.LightGray;
            <span>// Move the legend location</span>
            myPane.Legend.Position = ZedGraph.LegendPos.Bottom;
            <span>// Make both curves thicker</span>
            myCurve.Line.Width = 2.0F;
            myCurve2.Line.Width = 2.0F;
            <span>// Fill the area under the curves</span>
            myCurve.Line.Fill = new Fill( Color.White, Color.Red, 45F );
            myCurve2.Line.Fill = new Fill( Color.White, Color.Blue, 45F );
            <span>// Increase the symbol sizes, and fill them with solid white</span>
            myCurve.Symbol.Size = 8.0F;
            myCurve2.Symbol.Size = 8.0F;
            myCurve.Symbol.Fill = new Fill( Color.White );
            myCurve2.Symbol.Fill = new Fill( Color.White );
            <span>// Add a background gradient fill to the axis frame</span>
            myPane.Chart.Fill = new Fill( Color.White,
            Color.FromArgb( 255, 255, 210 ), -45F );
            <span>// Add a caption and an arrow</span>
            TextObj myText = new TextObj( <span>"Interesting\nPoint"</span>, 230F, 70F );
            myText.FontSpec.FontColor = Color.Red;
            myText.Location.AlignH = AlignH.Center;
            myText.Location.AlignV = AlignV.Top;
            myPane.GraphObjList.Add( myText );
            ArrowObj myArrow = new ArrowObj( Color.Red, 12F, 230F, 70F, 280F, 55F );
            myPane.GraphObjList.Add( myArrow );</pre> 
     <p>The final "dressed-up" graph will look like this:</p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/example_1b.png" width="508" alt="example_1b.png"></p> 
     <p>Many more graph attributes can be modified, but listing them all in this article would be tedious. Please refer to the <a href="http://zedgraph.sourceforge.net/documentation/default.html" rel="nofollow">online documentation</a> for more details. Also see the <a href="http://zedgraph.org/wiki/index.php?title=Sample_Graphs" rel="nofollow">demo graphs on the Wiki</a> for samples with code.</p> 
     <h2>Interesting tidbits</h2> 
     <p>Drawing line graphs is no big deal, but there are some aspects of the drawing classes that proved to be interesting. The flexibility afforded by the transform matrix of the GDI+ drawing library is very cool. This allowed the same code to be employed for drawing all three of the axes. The coordinate system is transformed to accommodate the axis location and orientation. In each case, the coordinate system is translated and rotated so that the axis is oriented along the X direction and the origin is located at the left edge of the axis when facing from the label side. A few "if" exceptions were required to account for the fact that the "left" side of the X and Y2 axes is the minimum value and the "left" side of the Y axis is the maximum value.</p> 
     <h2>Choosing scales</h2> 
     <h4>Range and step size</h4> 
     <p>ZedGraph is set up to automatically select appropriate scale minimum, maximum, and step size values based on the range of data values in the curves. Alternatively, you can manually set any or all of the values, and the scale picking logic will attempt to pick the appropriate values for the remaining parameters that are left in the automatic mode. The scale picking logic is based on the assumption that the most humanly palatable step sizes will be even divisors of 10. That is, step sizes should be 1, 2, or 5 times some power of 10. The heart of the scale picking logic is found in the <code>CalcStepSize()</code> method:</p> 
     <pre>protected double CalcStepSize( double range, double targetSteps )
            {
            <span>// Calculate an initial guess at step size</span>
            double tempStep = range / targetSteps;
            <span>// Get the magnitude of the step size</span>
            double mag = Math.Floor( Math.Log10( tempStep ) );
            double magPow = Math.Pow( (double) 10.0, mag );
            <span>// Calculate most significant digit of the new step size</span>
            double magMsd =  ( (int) (tempStep / magPow + .5) );
            <span>// promote the MSD to either 1, 2, or 5</span>
            if ( magMsd &gt; 5.0 )
            magMsd = 10.0;
            else if ( magMsd &gt; 2.0 )
            magMsd = 5.0;
            else if ( magMsd &gt; 1.0 )
            magMsd = 2.0;
            return magMsd * magPow;
            }</pre> 
     <p>The initial guess at the step size is calculated using a default number of steps named <code>targetSteps</code> (this value is defaulted to 7), which is the typical number of major steps you want on an axis. The actual number of steps will usually end up being this number or more. A magnitude of the initial step size is determined using <code>Floor( Log10( stepSize ) )</code>. This magnitude is reduced to a most significant digit, which is then promoted to either 1, 2, or 5 to make the scale an even divisor of 10. In general, I find that this logic is very good at picking scales based on the data range.</p> 
     <h4>Zero lever</h4> 
     <p>Another aspect of the scale selection is whether or not the scale should be extended to include the zero value. For example, if the scale range is 1 to 10, you would typically want to go ahead and start it at zero. This is accomplished with the <code>ZeroLever</code> default parameter. The <code>ZeroLever</code> is the allowable fraction that the scale range can be extended to include the zero value. This applies below the scale range for positive scales, or above the scale range for negative scale values. As an example, if the <code>ZeroLever</code> is 0.25 and the data range is from 2.0 to 12.0, then the scale would be extended to a range of 0.0 to 12.0 since the zero value lies 20% outside the actual data range (which is within the 25% allowed).</p> 
     <h4>Grace</h4> 
     <p>Finally, ZedGraph includes "grace" properties that allow you to include extra space on the scale range before and after the minimum and maximum data values, respectively. The reason for this is to avoid having the minimum and/or maximum data points fall right on the axes. Note that the grace values apply only to the non-ordinal axis types (<code>AxisType.Log</code>, <code>AxisType.Linear</code>, and <code>AxisType.Date</code>). The grace values are controlled by <code>Axis.Scale.MinGrace</code> and <code>Axis.Scale.MaxGrace</code>. These values are expressed as a fraction of the total data range. For example, if <code>MinGrace</code> and <code>MaxGrace</code> are both set to 0.1, then 10% of the data range will be padded before and after the actual data range. For example, if the data values go from 50.0 to 150.0, then the data range is 100.0. 10% of this range is 10.0. Adding this before and after the range gives an effective data range of 40.0 to 160.0. The grace properties will not cause the range to extend across the zero point. That is, if both the min and max data values are zero or greater, then the axis will not be extended to negative values regardless of the grace setting. The default values for <code>MinGrace</code> and <code>MaxGrace</code> are handled by <code>Scale.Default.MinGrace</code> and <code>Scale.Default.MaxGrace</code>, respectively. Both values are set to 0.1 initially.</p> 
     <h2>Axis types</h2> 
     <p>Each axis now has a property called <code>Type</code>, which can be set to one of these eight values:</p> 
     <ul> 
      <li><code>AxisType.Linear</code>: This is the default type, which is just a regular Cartesian axis. </li> 
      <li><code>AxisType.Log</code>: This is a base 10 logarithmic scale. </li> 
      <li><code>AxisType.Exponent</code>: This is an exponential scale. </li> 
      <li><code>AxisType.Date</code>: This is a date-time axis, in which the corresponding values are <code>XDate</code> types. See <a href="http://www.codeproject.com/csharp/zedgraph.asp#datetime" rel="nofollow">Date-Time Axes</a> below. </li> 
      <li><code>AxisType.Text</code>: This is an ordinal type, in which the data values for this axis are actually not used. All points or bars will be evenly spaced on the graph. The first point will have a value of 1.0, the second will be 2.0, etc. The actual value labels will be determined by an array of strings in <code>Axis.TextLabels</code>. See <a href="http://www.codeproject.com/csharp/zedgraph.asp#texttype" rel="nofollow">Text Axes</a> below. </li> 
      <li><code>AxisType.Ordinal</code>: This is another ordinal type, in which the data values for this axis are not used. All points or bars will be evenly spaced on the graph. The first point will have a value of 1.0, the second will be 2.0, etc. The actual value labels are just determined by the numeric ordinal values (1.0, 2.0, etc.). </li> 
      <li><code>AxisType.LinearAsOrdinal</code>: This is another ordinal type, essentially the same as <code>AxisType.Ordinal</code>, except that the axis scale values will be displayed based on the data values (although the axis will still be treated as ordinal, with 1.0 for the first label, 2.0 for the second, etc.). </li> 
      <li><code>AxisType.DateAsOrdinal</code>: This is another ordinal type, essentially the same as <code>AxisType.Ordinal</code>, except that the axis scale values will be displayed based on the data values as dates. This mode is a good choice if you have weekday values and you want to skip the weekends without leaving gaps in the data. </li> 
     </ul> 
     <h2><a rel="nofollow">Date-time axes</a></h2> 
     <p>ZedGraph includes the capability to handle date-time axes, e.g., the axis labels can be based on an encoded date-time value, displayed in anything from seconds to years. At the heart of the date-time axis is the <code>XDate</code> <code><span>struct</span></code>, which captures a time value, and handles conversions to/from a wide range of date-time formats. You're probably wondering why I reinvented the wheel on this, rather than just using the built-in <code>DateTime</code> class (or equivalent). The main reason I made my own class is because an <code>XDate</code> stores its date-time information as a <code>System.Double</code> value. Therefore, <code>XDate</code> values can just be stored in an ordinary array of <code><span>double</span></code>s, just like any other array of data that is passed to ZedGraph. The <code>XDate</code> <code><span>struct</span></code> and format are described in detail in <a href="http://zedgraph.org/wiki/index.php?title=What_is_an_XDate_struct%3F" rel="nofollow">the Wiki</a>. If you are using <code>DateTime</code> structs to store your data, you can convert directly to <code><span>double</span></code>s which are compatible with ZedGraph, by using the <code>DateTime.ToOADate()</code> method.</p> 
     <p>To use a date-time axis in ZedGraph, you need to change to <code>AxisType.Date</code> as follows:</p> 
     <pre>myPane.XAxis.Type = AxisType.Date;</pre> 
     <p>ZedGraph will then assume that the X array <code><span>double</span></code> values are actually <code>XDate</code> values. <code>XAxis.Scale.Min</code> and <code>XAxis.Scale.Max</code> will also be <code>XDate</code> values, but the units of <code>XAxis.Scale.MajorStep</code> and <code>XAxis.Scale.MinorStep</code> will depend on the setting of <code>XAxis.Scale.MajorUnit</code> and <code>XAxis.Scale.MinorUnit</code>, respectively. <code>XAxis.Scale.MajorUnit</code> and <code>XAxis.Scale.MinorUnit</code> can be set to one of the following values: <code>DateUnit.Year</code>, <code>DateUnit.Month</code>, <code>DateUnit.Day</code>, <code>DateUnit.Hour</code>, <code>DateUnit.Minute</code>, <code>DateUnit.Second</code>, and <code>DateUnit.Millisecond</code>. Note again that <code>XDate</code> values are actually units of days (actually, days since a reference date). However, if <code>XAxis.Scale.MajorUnit = DateUnit.Year</code>, then a value of 0.25 for <code>XAxis.Scale.MajorStep</code> means that the step size is 1/4<sup>th</sup> of a year. One more extra property is used for the date-time axes: the <code>Scale.Format</code>. This is a string that defines the format of the major tic labels for the axis. For example, <code>XAxis.Scale.Format = <span>"dd-MMM-yy"</span></code> would give labels like "12-Dec-95". A wide range of formatting options is available - see <a href="http://zedgraph.org/wiki/index.php?title=What_is_an_XDate_struct%3F" rel="nofollow">the Wiki</a> for details. Note that the formatting is based on <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp" rel="nofollow"><code>DateTimeFormatInfo</code></a>, which is the same as the <code>DateTime</code> <code><span>struct</span></code>.</p> 
     <p>Assuming <code>XAxis.Scale.MinAuto</code>, <code>XAxis.Scale.MajorStepAuto</code>, and <code>XAxis.Scale.MaxAuto</code> are all set to <code><span>true</span></code>, ZedGraph will attempt to select an axis range that fits the span of the dates. This means that the auto-scaling feature will automatically set the following properties: <code>Axis.Scale.Min</code>, <code>Axis.Scale.Max</code>, <code>Axis.Scale.MajorStep</code>, <code>Axis.Scale.MinorStep</code>, <code>Axis.Scale.MajorUnit</code>, <code>Axis.Scale.MinorUnit</code>, and <code>Axis.Scale.Format</code>.</p> 
     <p>If you want to try this out, here's the code for an example graph, which has a data point for the first day of each month, for 30 months starting with 1-Jan-1995:</p> 
     <div> 
      <img height="9" src="http://www.codeproject.com/images/minus.gif" width="9" alt="minus.gif"> 
      <span> Collapse</span> 
     </div> 
     <pre><span>// Build the Chart</span>
            private void CreateGraph( ZedGraphControl zg1 )
            {
            <span>// Get a reference to the GraphPane</span>
            GraphPane myPane = zg1.GraphPane;
            <span>// Set the titles</span>
            myPane.Title.Text = <span>"My Test Date Graph"</span>;
            myPane.XAxis.Title.Text = <span>"Date"</span>;
            myPane.XAxis.Title.Text = <span>"My Y Axis"</span>;
            <span>// Make up some random data points</span>
            double x, y;
            PointPairList list = new PointPairList();
            for ( int i=0; i&lt;36; i++ )
            {
            x = (double) new XDate( 1995, 5, i+11 );
            y = Math.Sin( (double) i * Math.PI / 15.0 );
            list.Add( x, y );
            }
            <span>// Generate a red curve with diamond</span>
            <span>// symbols, and "My Curve" in the legend</span>
            CurveItem myCurve = myPane.AddCurve( <span>"My Curve"</span>,
            list, Color.Red, SymbolType.Diamond );
            <span>// Set the XAxis to date type</span>
            myPane.XAxis.Type = AxisType.Date;
            <span>// Tell ZedGraph to refigure the axes since the data </span>
            <span>// have changed</span>
            zg1.AxisChange();
            }</pre> 
     <p>The above code generates the following graph:</p> 
     <p><img height="340" src="http://www.codeproject.com/csharp/zedgraph/example_2.gif" width="500" alt="example_2.gif"></p> 
     <p>In this case, ZedGraph selected a major step size of six days, and a minor step size of one day. You can easily adjust the selected format, if desired. For example, if you want to use 1 month for the minor step size, just set <code>myPane.XAxis.Scale.MinorStep = 1.0</code> and <code>myPane.XAxis.Scale.MinorUnit = DateUnit.Month</code> just before the <code>AxisChange()</code> call. If you change the <code>XAxis.Scale.MajorStep</code> value, you will also have to manually set <code>XAxis.Scale.MajorUnit</code>, <code>XAxis.Scale.MinorUnit</code>, <code>XAxis.Scale.MinorStep</code>, and <code>XAxis.Scale.Format</code>. This is because <code>XAxis.Scale.MajorStepAuto == false</code> since you have chosen to manually select the step size.</p> 
     <h2><a rel="nofollow">Text axis</a></h2> 
     <p>ZedGraph also handles a text axis. This is an axis in which the tic labels are arbitrary, user supplied text strings instead of value labels. Internally, a text axis is handled using ordinal values just like an ordinary axis. In this case, the first major label has a value of 1.0, the second major label has a value of 2.0, etc. It is permissible to use fractional values if you want to place points in-between the labels.</p> 
     <p>To make a text axis, you set <code>Axis.Type = AxisType.Text</code>. This informs ZedGraph to use the labels supplied by the user in <code>Axis.Scale.TextLabels</code>. The number of labels will determine the axis range. That is, 10 labels means the axis will be ranged from 1.0 to 10.0. Optionally, when you add a curve to ZedGraph, you can just skip any value array that is associated with a text axis. A default array of ordinal values will be generated. For example, if the <code>XAxis</code> is of type <code>Text</code> with 10 labels, you can add a curve, leaving the X array <code><span>null</span></code>, and an X array will be generated internally with values from 1.0 to 10.0. The bar chart below shows the usage of the <code>AxisType.Text</code>.</p> 
     <h2>Bar charts</h2> 
     <p>ZedGraph includes bar charting capability for vertical and horizontal bar charts, stacked bar charts, percent stacked bar charts, overlay bar charts, error bar charts, high-low bar charts, open-high-low-close bar charts, and Japanese candlestick bar charts. A bar chart is created similar to a line graph, except that you use <code>GraphPane.AddBar()</code>, <code>GraphPane.AddErrorBar()</code>, or <code>GraphPane.AddHiLowBar()</code> to create the bar instance. It is possible to mix bars, lines, and symbols on the same graph, by simply adding the different types.</p> 
     <p>Bars can be made horizontal or vertical, by setting the "base" axis to the X or Y axis. Under the ZedGraph terminology, the "base" axis determines the bar position, and the "value" axis determines the height of the bar.</p> 
     <p>Typically, bar charts would be created with <code>XAxis.Type = AxisType.Text</code> or <code>XAxis.Type = AxisType.Ordinal</code> (both types use ordinal values), such that the bars are drawn at integral values along the "base" axis, starting with 1 (e.g., the first bar cluster is at 1.0, the second is at 2.0, etc.). However, the ordinal axis type is not a requirement for bar charts. It is possible to create a bar chart that is not evenly spaced, by providing X values and using <code>AxisType.Linear</code> (in this case, you may need to use the <code>GraphPane.ClusterScaleWidth</code> property to tell ZedGraph how wide the bars should be. See <a href="http://zedgraph.org/wiki/index.php?title=How_is_BarItem_affected_by_AxisType%3F" rel="nofollow">this wiki page</a> for details). For bar charts, the tic marks are typically between the bar clusters, which can be accomplished with the <code>Axis.MajorTic.IsBetweenLabels</code> property. However, this property is only applicable for <code>AxisType.Text</code> axes.</p> 
     <p>ZedGraph actually has six distinct bar types, any of which can be horizontal or vertical:</p> 
     <ul> 
      <li><code>BarItem</code> - is for regular bars, stacked bars, percent stacked bars, overlay bars, and sorted overlay bars. </li> 
      <li><code>ErrorBarItem</code> - is for error bars, which are "I-Beam" bars with a symbol at each end, based on the upper and lower values that are user-defined. </li> 
      <li><code>HiLowBarItem</code> - is for rectangular bars that have both upper and lower values that are user-defined. </li> 
     </ul> 
     <p>Other "bar-like" types are also available:</p> 
     <ul> 
      <li><code>OHLCBarItem</code> - is for open-high-low-close stock charts, similar to an error bar, and showing the open, close, high, and low prices for the day. </li> 
      <li><code>JapaneseCandleStickItem</code> - another stock chart type showing a narrow vertical line depicting the high-low range of prices for the day, plus a colored bar showing the open and close with a different color for rising and falling days. </li> 
      <li><code>StickItem</code> - a chart with a narrow line at each value going back to the X axis. </li> 
     </ul> 
     <p>The following is an example of a <code>JapaneseCandleStickItem</code> chart, used to show High-Low-Open-Close data for the stock market:</p> 
     <p><img height="346" src="http://www.codeproject.com/csharp/zedgraph/example_3.png" width="504" alt="example_3.png"></p> 
     <p>The orientation (horizontal or vertical) and the size of the <code>BarItem</code> bars are determined globally by <code>GraphPane.BarSettings.Base</code> and other <code>GraphPane.BarSettings</code> properties. Therefore, all <code>BarItem</code> bars will have similar properties, and the size of the bars is scaled automatically to fill the available space. In contrast, the size of <code>ErrorBarItem</code> bars and <code>HiLowBarItem</code> bars are controlled by individual properties for each bar item, e.g., <code>ErrorBarItem.Bar.Size</code>. These bar types are actually similar to symbols, since the bar width is specified in points (1/72 inch). A single plot can have a variety of different <code>ErrorBarItem</code>s and <code>HiLowBarItem</code>s with different sizes.</p> 
     <p>Two properties are included in the <code>GraphPane</code> class to control the gaps between <code>BarItem</code> bars; <code>GraphPane.BarSettings.MinBarGap</code> (default = 0.2) is the minimum size of the gap between each bar within a bar cluster (multiple bars that share the same X value), and <code>GraphPane.BarSettings.MinClusterGap</code> (default = 1.0) is the minimum size of the gap between the bar clusters. Both of these parameters are expressed as a fraction of the individual bar size, i.e., a value of 1.0 would make the gap the same size as the bars. Note that these properties apply only to <code>BarItem</code> bars (not <code>ErrorBarItem</code> or <code>HiLowBarItem</code> bars). A new <code>Bar</code> class has been added to the <code>BarItem</code> class to control the properties of the bars. This <code>Bar</code> class has properties for <code>Fill</code>, <code>FrameColor</code>, <code>FrameWidth</code>, and <code>IsFramed</code>. The following example generates a simple bar chart:</p> 
     <div> 
      <img height="9" src="http://www.codeproject.com/images/minus.gif" width="9" alt="minus.gif"> 
      <span> Collapse</span> 
     </div> 
     <pre><span>// Build the Chart</span>
            private void CreateGraph( ZedGraphControl zg1 )
            {
            <span>// get a reference to the GraphPane</span>
            GraphPane myPane = zg1.GraphPane;
            <span>// Set the Titles</span>
            myPane.Title.Text = <span>"My Test Bar Graph"</span>;
            myPane.XAxis.Title.Text = <span>"Label"</span>;
            myPane.YAxis.Title.Text = <span>"My Y Axis"</span>;
            <span>// Make up some random data points</span>
            string[] labels = { <span>"Panther"</span>, <span>"Lion"</span>, <span>"Cheetah"</span>,
            <span>"Cougar"</span>, <span>"Tiger"</span>, <span>"Leopard"</span> };
            double[] y = { 100, 115, 75, 22, 98, 40 };
            double[] y2 = { 90, 100, 95, 35, 80, 35 };
            double[] y3 = { 80, 110, 65, 15, 54, 67 };
            double[] y4 = { 120, 125, 100, 40, 105, 75 };
            <span>// Generate a red bar with "Curve 1" in the legend</span>
            BarItem myBar = myPane.AddBar( <span>"Curve 1"</span>, null, y,
            Color.Red );
            myBar.Bar.Fill = new Fill( Color.Red, Color.White,
            Color.Red );
            <span>// Generate a blue bar with "Curve 2" in the legend</span>
            myBar = myPane.AddBar( <span>"Curve 2"</span>, null, y2, Color.Blue );
            myBar.Bar.Fill = new Fill( Color.Blue, Color.White,
            Color.Blue );
            <span>// Generate a green bar with "Curve 3" in the legend</span>
            myBar = myPane.AddBar( <span>"Curve 3"</span>, null, y3, Color.Green );
            myBar.Bar.Fill = new Fill( Color.Green, Color.White,
            Color.Green );
            <span>// Generate a black line with "Curve 4" in the legend</span>
            LineItem myCurve = myPane.AddCurve( <span>"Curve 4"</span>,
            null, y4, Color.Black, SymbolType.Circle );
            myCurve.Line.Fill = new Fill( Color.White,
            Color.LightSkyBlue, -45F );
            <span>// Fix up the curve attributes a little</span>
            myCurve.Symbol.Size = 8.0F;
            myCurve.Symbol.Fill = new Fill( Color.White );
            myCurve.Line.Width = 2.0F;
            <span>// Draw the X tics between the labels instead of </span>
            <span>// at the labels</span>
            myPane.XAxis.MajorTic.IsBetweenLabels = true;
            <span>// Set the XAxis labels</span>
            myPane.XAxis.Scale.TextLabels = labels;
            <span>// Set the XAxis to Text type</span>
            myPane.XAxis.Type = AxisType.Text;
            <span>// Fill the Axis and Pane backgrounds</span>
            myPane.Chart.Fill = new Fill( Color.White,
            Color.FromArgb( 255, 255, 166), 90F );
            myPane.Fill = new Fill( Color.FromArgb( 250, 250, 255) );
            <span>// Tell ZedGraph to refigure the</span>
            <span>// axes since the data have changed</span>
            zg1.AxisChange();
            }</pre> 
     <p>The above code generates the following graph:</p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/example_4.png" width="508" alt="example_4.png"></p> 
     <h2>Bar types</h2> 
     <p>ZedGraph can draw <code>BarItem</code> bar charts in a variety of types according to the <code>GraphPane.BarSettings.Type</code> property. This can be one of the following values:</p> 
     <table> 
      <tbody> 
       <tr> 
        <th>BarType</th> 
        <th>Description</th> 
       </tr> 
       <tr> 
        <td><code>BarType.Cluster</code></td> 
        <td>This is the normal format in which various bar series are grouped together in clusters at each base value (like the first example chart above).</td> 
       </tr> 
       <tr> 
        <td><code>BarType.ClusterHiLow</code></td> 
        <td>This format draws a hi-low (bars have a top and bottom that are user defined) in a cluster format, so multiple high-low bars can be grouped together at each base value.</td> 
       </tr> 
       <tr> 
        <td><code>BarType.Overlay</code></td> 
        <td>In this format, the bars are drawn on top of each other, with the first <code>BarItem</code> drawn at the back, and the last <code>BarItem</code> drawn at the front.</td> 
       </tr> 
       <tr> 
        <td><code>BarType.SortedOverlay</code></td> 
        <td>This is similar to <code>Overlay</code>, but the bars are sorted on value, and the highest value is drawn at the back, and the lowest value is drawn at the front.</td> 
       </tr> 
       <tr> 
        <td><code>BarType.Stack</code></td> 
        <td>The bars are stacked on top of each other, accumulating in value.</td> 
       </tr> 
       <tr> 
        <td><code>BarType.PercentStack</code></td> 
        <td>The bars are stacked on top of each other, and plotted as a percentile, with the total height always being 100%.</td> 
       </tr> 
      </tbody> 
     </table> 
     <p>The following samples show horizontal and stacked bar types:</p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/example_5.png" width="508" alt="example_5.png"></p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/example_6.png" width="508" alt="example_6.png"></p> 
     <h2>Pie charts</h2> 
     <p>Pie charts are created in the normal fashion using the <code>GraphPane.AddPieSlice()</code>, which returns a <code>PieItem</code>. One <code>PieItem</code> is added for each slice of the pie. Note that, unlike the other <code>CurveItem</code> - derived classes, the <code>PieItem</code> does not use the <code>PointPairList</code> to store the data value. Since the pie has only a single data value, it is stored in <code>PieItem.PieValue</code>. The pie charts support text labels, a legend, color fills, etc. in the typical ZedGraph fashion.</p> 
     <p>Although it is technically possible to combine pie charts with line graphs on the same <code>GraphPane</code>, it is not recommended. If a particular <code>GraphPane</code> contains only <code>PieItem</code> objects, then the <code>AxisChange()</code> method will automatically make the axes invisible by setting the <code>Axis.IsVisible</code> property to <code><span>false</span></code>.</p> 
     <p>The following is an example of a ZedGraph pie chart:</p> 
     <p><img height="356" src="http://www.codeproject.com/csharp/zedgraph/example_pie.png" width="495" alt="example_pie.png"></p> 
     <h2>The MasterPane</h2> 
     <p>The <code>MasterPane</code> is designed to help facilitate the handling of multiple <code>GraphPane</code> objects on a page. This is done by maintaining a list of <code>GraphPane</code> objects, and providing utility functions for layout, rendering, mouse point location, etc. See the <a href="http://zedgraph.org/wiki/index.php?title=MasterPane:_Handling_Multiple_Graphs" rel="nofollow">ZedGraphWiki</a> for details on the <code>MasterPane</code> class. The following is an example of a chart based on the <code>MasterPane</code> class:</p> 
     <p><img height="377" src="http://www.codeproject.com/csharp/zedgraph/example_master.png" width="545" alt="example_master.png"></p> 
     <h2>Pan/Zoom functions</h2> 
     <p>The <code>ZedGraphControl</code> class now provides some interactive functionality for zooming and panning. To zoom, left click inside the <code>AxisRect</code> area, and drag out a new rectangle to indicate the scale region into which to zoom. To pan, either click with the middle mouse button or hold down the shift key, and left click to drag the graph around (the zoom/pan key combinations are user-modifiable as well). You can also add scrollbars to the control with <code>IsShowHScrollBar</code> and <code>IsShowVScrollBar</code>. The mouse-wheel can also be used for zooming. There is also a context menu that allows you to un-zoom and un-pan to prior states, to restore the scale to full auto mode, to show point value tool tips, and to copy the graph (bitmap form) to the clipboard. Event options are provided to allow for customization of pan, zoom, point values, etc.</p> 
     <h2>The Fill class</h2> 
     <p>The <code>Fill</code> class is an important addition to ZedGraph, so it deserves a special mention. This class handles solid, linear gradient, and texture fills for the pane background, the axis background, the legend background, all text backgrounds, the symbol fill, and for filling the area under a line. Each of these classes will have one or more <code>Fill</code> classes to control the fill properties (e.g., <code>CurveItem.Line.Fill</code> controls the filling of the area under the curve). The <code>Fill</code> class has a number of constructors to make it flexible and easy to use:</p> 
     <table> 
      <tbody> 
       <tr> 
        <td><code>Fill( Color )</code></td> 
        <td>Makes a solid color fill with the specified color.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Color, Color )</code></td> 
        <td>Makes a linear gradient fill from <code>color1</code> to <code>color2</code>, with a gradient angle of 0 degrees.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Color, Color, float angle )</code></td> 
        <td>Makes a linear gradient fill from <code>color1</code> to <code>color2</code>, with a gradient angle as specified.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Image, WrapMode )</code></td> 
        <td>Specifies an image to be used for filling.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Brush )</code></td> 
        <td>Uses the specified brush directly, scaling the brush to fill the destination object bounding box.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Brush, bool isScaled )</code></td> 
        <td>Uses the specified brush, allowing you to disable the scaling.</td> 
       </tr> 
       <tr> 
        <td><code>Fill( Brush, AlignH, AlignV )</code></td> 
        <td>Uses the specified brush, with no scaling, but the source brush alignment is specified.</td> 
       </tr> 
      </tbody> 
     </table> 
     <p>Internally, the <code>Fill</code> class keeps a <code>FillType</code> enumeration (the <code>Type</code> property) to determine what type of fill is used, as follows:</p> 
     <ul> 
      <li><code>FillType.None</code>: No filling will be done - the background will be transparent. </li> 
      <li><code>FillType.Solid</code>: A solid color fill will be done using the <code>SolidBrush</code> class with the <code>Fill.Color</code> value. </li> 
      <li><code>FillType.Brush</code>: A fancy fill will be done using the user-supplied brush specified in <code>Fill.Brush</code>. If <code>Fill.Brush</code> is <code><span>null</span></code>, then a <code>LinearGradientBrush</code> will be automatically created using <code>Fill.Color</code> and <code>Color.White</code> as the gradient colors, with a gradient angle of zero degrees. </li> 
      <li><code>FillType.GradientByX</code>: This mode is intended to be used with <code>Symbol.Fill</code>. A linear gradient is maintained internally in the <code>Fill</code> class, and each symbol point is filled with a solid color that is taken from the internal gradient based on the X data value for that point. Essentially, you get a scatter plot in which each data point is colored according to its X value. The data ranges for color assignment are user assigned with the <code>Fill.RangeMin</code> and <code>Fill.RangeMax</code> properties. </li> 
      <li><code>FillType.GradientByY</code>: This is the same as <code>GradientByX</code> except that the Y data values are used instead of X data values. </li> 
      <li><code>FillType.GradientByZ</code>: This is the same as <code>GradientByX</code> except that the Z data values are used instead of X data values. </li> 
      <li><code>FillType.GradientByColorValue</code>: This is the same as <code>GradientByX</code> except that the 'ColorValue' property values are used instead of X data values. </li> 
     </ul> 
     <p>The following graph is an example of <code>FillType.GradientByZ</code> usage, in which seemingly scattered data gains visual coherency using the color attribute:</p> 
     <p><img height="343" src="http://www.codeproject.com/csharp/zedgraph/gradientbyz.png" width="508" alt="gradientbyz.png"></p> 
     <p>The following shows an example of using an image to fill in the bars of a bar chart:</p> 
     <p><img height="207" src="http://www.codeproject.com/csharp/zedgraph/example_7.gif" width="436" alt="example_7.gif"></p> 
     <h2>Z-Order</h2> 
     <p>The graphic items in the display are contained in two lists; <code>GraphPane.CurveList</code> and <code>GraphPane.GraphObjList</code>. <code>CurveList</code> contains all of the curves, including bars, lines, etc. <code>GraphObjList</code> contains text items, images, shapes, arrows, etc. In both lists, the Z-Order is controlled by the order of the objects in the list; the first objects in the list appear in front of the later objects in the list. You can modify the order of any object relative to other objects in the same collection (list), with the <code>Move()</code> method in the collection class. Further, the <code>GraphObj</code> class has a <code>ZOrder</code> property that controls the depth of each individual <code>GraphObj</code> relative to other, non-<code>GraphObj</code> objects. The <code>ZOrder</code> is an enumeration type with the following values:</p> 
     <table> 
      <tbody> 
       <tr> 
        <th>ZOrder</th> 
        <th>Description</th> 
       </tr> 
       <tr> 
        <td><code>ZOrder.A_InFront</code></td> 
        <td>The topmost depth, in front of all other objects.</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.B_BehindLegend</code></td> 
        <td>Drawn behind the <code>Legend</code> object.</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.C_BehindChartBorder</code></td> 
        <td>Drawn behind the <code>Chart</code> frame border.</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.D_BehindAxis</code></td> 
        <td>Drawn behind the <code>Axis</code> objects (behind the scale labels, etc.).</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.E_BehindCurves</code></td> 
        <td>Drawn behind all the <code>CurveItem</code> objects.</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.F_BehindTitle</code></td> 
        <td>Drawn behind the <code>GraphPane</code> title.</td> 
       </tr> 
       <tr> 
        <td><code>ZOrder.G_BehindAll</code></td> 
        <td>Drawn behind the <code>Chart</code> rectangle fill (but still in front of the pane rectangle fill).</td> 
       </tr> 
      </tbody> 
     </table> 
     <h2>Utility methods</h2> 
     <p>ZedGraph is being used as a class library in interactive parent applications that need information about the graph. The following are some utility methods that are worth mentioning (these are documented in the <em>ZedGraph.chm</em> doc file):</p> 
     <ul> 
      <li><code>FindPane()</code> is a method in the <code>MasterPane</code> class that, given a mouse point location, returns the <code>GraphPane</code> object under the mouse. </li> 
      <li><code>FindAxisRect()</code> is a method in the <code>MasterPane</code> class that, given a mouse point location, returns the <code>GraphPane</code> object for the <code>AxisRect</code> in which the mouse point lies. </li> 
      <li><code>FindNearestObject()</code> is a method in the <code>GraphPane</code> class that, given a mouse point location, returns the closest object and a corresponding index number for the object. This method may return <code>Curve</code> points, the <code>GraphPane</code>, <code>GraphItem</code>s, axes, the legend, etc., depending on what was clicked. </li> 
      <li><code>FindNearestPoint()</code> is a method in the <code>GraphPane</code> class that, given a mouse point location, returns the closest <code>CurveItem</code> and the index number of the closest point within that <code>CurveItem</code>. This routine will only consider points that are within <code>Def.Pane.NearestTol</code> pixels of the specified mouse point location. The default tolerance is 7 pixels. </li> 
      <li><code>ReverseTransform()</code> is a method in the <code>GraphPane</code> class that, given a mouse point location, returns the X, Y, and Y2 axis values that correspond to that location. </li> 
      <li><code>GeneralTransform()</code> is a method in the <code>GraphPane</code> class that, given an (X,Y) value pair, returns the corresponding (X,Y) screen pixel coordinates. The (X,Y) value pair can be expressed in a variety of coordinate systems, as follows: </li> 
     </ul> 
     <ul> 
      <li> 
       <ul> 
        <li><code>CoordType.AxisXYScale</code>: the coordinate values are from the X and left Y axes. </li> 
        <li><code>CoordType.AxisXY2Scale</code>: the coordinate values are from the X and right Y (Y2) axes. </li> 
        <li><code>CoordType.ChartFraction</code>: the coordinate values are expressed as a fraction of the total <code>Chart.Rect</code> width and height (0.5 is the center of the <code>Chart.Rect</code>, 1.1 is just to the right or just above the <code>AxisRect</code>). </li> 
        <li><code>CoordType.PaneFraction</code>: the coordinate values are expressed as a fraction of the total <code>PaneRect</code> width and height. The value should be from 0.0 to 1.0, since values outside this range are clipped. </li> 
        <li><code>XChartFractionYPaneFraction</code>: the X coordinate is a fraction of the total <code>Chart.Rect</code>, and the Y coordinate is a fraction of the total <code>Pane.Rect</code>. </li> 
        <li><code>XPaneFractionYChartFraction</code>: the X coordinate is a fraction of the total <code>Pane.Rect</code>, and the Y coordinate is a fraction of the total <code>Chart.Rect</code>. </li> 
        <li><code>XScaleYChartFraction</code>: the X coordinate is an X scale value, and the Y coordinate is fraction of the total <code>Chart.Rect</code>. </li> 
        <li><code>XChartFractionYScale</code>: the X coordinate is a fraction of the total <code>Chart.Rect</code>, and the Y coordinate is a Y scale value. </li> 
        <li><code>XChartFractionY2Scale</code>: the X coordinate is a fraction of the total <code>Chart.Rect</code>, and the Y coordinate is a Y2 scale value. </li> 
       </ul></li> 
     </ul> 
     <ul> 
      <li><code>CalcChartRect()</code> is a method in the <code>GraphPane</code> class that will calculate the chart rectangle (screen coordinates), given the current configuration. If, for some reason, you need to manually set the chart rectangle (to make it line up perfectly with other items, etc.), you can use this method to get the default rectangle, modify it as desired, then set <code>GraphPane.Chart.Rect = yourRect</code>. Changing the <code>Chart.Rect</code> will automatically set <code>GraphPane.Chart.IsRectAuto</code> to <code><span>false</span></code> so that the <code>Chart.Rect</code> will remain as you set it. </li> 
     </ul> 
     <h2>Acknowledgements</h2> 
     <p>I would like to thank all those who have tested the code, reported issues, and contributed code to the ZedGraph project. I would especially like to acknowledge the contributions of the volunteer developers who made ZedGraph possible: Jerry R. Vos, Bob Kaye, Darren Martz, and Benjamin Mayrargue.</p> 
     <h2>Latest update</h2> 
     <ul> 
      <li>See the <a href="http://zedgraph.org/wiki/index.php?title=Revision_History" rel="nofollow">Revision History</a> page for the latest updates. </li> 
      <li>Also, check out the <a href="http://zedgraph.org/" rel="nofollow">Main Wiki Page</a> for the latest news. </li> 
     </ul> 
    </div> <h2>JChampion</h2> 
    <div> 
     <table> 
      <tbody> 
       <tr> 
        <td><br></td> 
        <td> <p>Click <a href="http://www.codeproject.com/script/profile/whos_who.asp?vt=arts&amp;id=204832" rel="nofollow">here</a> to view JChampion's online profile.</p> </td> 
       </tr> 
      </tbody> 
     </table> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

转载于:https://www.cnblogs.com/lxinxuan/archive/2007/04/27/729771.html

[http_www.codeproject.com_csharp_zedgraph.asp]: http://www.codeproject.com/csharp/zedgraph.asp