C# Graph.GraphPane类代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="ZoomState"/> class. 
 /// 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 RequestState is from a pan or zoom.
 /// </param>
 public ZoomState(GraphPane pane, StateType type)
 {
     this._xAxis = new ScaleState(pane.XAxis);
     this._x2Axis = new ScaleState(pane.X2Axis);
     this._yAxis = new ScaleStateList(pane.YAxisList);
     this._y2Axis = new ScaleStateList(pane.Y2AxisList);
     this._type = type;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ValueHandler"/> class. 
 /// 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)
 {
     this._pane = pane;
     if (initialize)
     {
         // just create a dummy image, which results in a full draw operation
         using (Image image = pane.GetImage())
         {
         }
     }
 }

 /// <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>
 /// <returns>
 /// The <see cref="bool"/>.
 /// </returns>
 internal override bool IsXIndependent(GraphPane pane)
 {
     return true;
 }

        /// <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="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="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)
        {
            // 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;
            this._line.Fill.Draw(g, rect);

            this._line.DrawSegment(g, pane, rect.Left, yMid, rect.Right, yMid, scaleFactor);

            // Draw a sample symbol to the left of the label text
            this._symbol.DrawSymbol(g, pane, xMid, yMid, scaleFactor, false, null);
        }

        /// <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="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>
        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 && !this._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 = PointPairBase.Missing;
                                curY = PointPairBase.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 == PointPairBase.Missing || curY == PointPairBase.Missing || double.IsNaN(curX) || double.IsNaN(curY)
                            || double.IsInfinity(curX) || 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)
//.........这里部分代码省略.........

        /// <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 = this._isSmooth ? this._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)
                this.BuildLowPointsArray(pane, curve, out arrPoints2, out count2);

                // Add the new points to the GraphicsPath
                path.AddCurve(arrPoints2, 0, count2 - 2, tension);
            }
        }

        /// <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[(this._stepType == 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 == PointPairBase.Missing || y == PointPairBase.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 (this._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];
//.........这里部分代码省略.........

        /// <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>
        /// <param name="g">
        /// The g.
        /// </param>
        /// <param name="pane">
        /// The pane.
        /// </param>
        /// <param name="curve">
        /// The curve.
        /// </param>
        /// <param name="lastPt">
        /// The last Pt.
        /// </param>
        /// <param name="scaleFactor">
        /// The scale Factor.
        /// </param>
        /// <param name="pen">
        /// The pen.
        /// </param>
        /// <param name="lastX">
        /// The last X.
        /// </param>
        /// <param name="lastY">
        /// The last Y.
        /// </param>
        /// <param name="tmpX">
        /// The tmp X.
        /// </param>
        /// <param name="tmpY">
        /// The tmp Y.
        /// </param>
        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 )
                {
//.........这里部分代码省略.........

        /// <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 (this._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 (this._isCrossInside)
            {
                g.DrawLine(pen, pixVal, 0.0f, pixVal, -scaledTic);
            }

            // draw the opposite tic
            if (this.IsOpposite)
            {
                g.DrawLine(pen, pixVal, topPix, pixVal, topPix + scaledTic);
            }
        }

        /// <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"/>
        public virtual 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 != PointPairBase.Missing)
                {
                    ignoreInitial = false;
                }

                if (!ignoreInitial && !outOfBounds && curX != PointPairBase.Missing && curY != PointPairBase.Missing)
                {
                    if (curX < xMin)
                    {
//.........这里部分代码省略.........

 /// <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 abstract bool GetCoords(GraphPane pane, int i, out string coords);

        /// <summary>
        /// Calculate the width of each bar, depending on the actual bar type
        /// </summary>
        /// <param name="pane">
        /// The pane.
        /// </param>
        /// <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 = ((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>
 /// 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="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="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 abstract void DrawLegendKey(Graphics g, GraphPane pane, RectangleF rect, float scaleFactor);

 /// <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="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="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="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 abstract void Draw(Graphics g, GraphPane pane, int pos, float scaleFactor);

        /// <summary>
        /// Returns a reference to the <see cref="Axis"/> object that is the "base" (independent axis) from which the values are drawn. 
        /// </summary>
        /// <param name="pane">
        /// The pane.
        /// </param>
        /// <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"/>
        /// <returns>
        /// The <see cref="Axis"/>.
        /// </returns>
        public virtual Axis BaseAxis(GraphPane pane)
        {
            BarBase barBase;

            if (this is BarItem || this is ErrorBarItem || this is HiLowBarItem)
            {
                barBase = pane._barSettings.Base;
            }
            else
            {
                barBase = this._isX2Axis ? BarBase.X2 : BarBase.X;
            }

            if (barBase == BarBase.X)
            {
                return pane.XAxis;
            }

            if (barBase == BarBase.X2)
            {
                return pane.X2Axis;
            }

            if (barBase == BarBase.Y)
            {
                return pane.YAxis;
            }

            return pane.Y2Axis;
        }