/// <summary> /// Construct a <see cref="ZoomState"/> object from the scale ranges settings contained /// in the specified <see cref="GraphPane"/>. /// </summary> /// <param name="pane">The <see cref="GraphPane"/> from which to obtain the scale /// range values. /// </param> /// <param name="type">A <see cref="StateType"/> enumeration that indicates whether /// this saved state is from a pan or zoom.</param> public ZoomState( GraphPane pane, StateType type ) { _xAxis = new ScaleState( pane.XAxis ); _x2Axis = new ScaleState( pane.X2Axis ); _yAxis = new ScaleStateList( pane.YAxisList ); _y2Axis = new ScaleStateList( pane.Y2AxisList ); _type = type; }
/// <summary> /// Basic constructor that saves a reference to the parent /// <see cref="GraphPane"/> object. /// </summary> /// <param name="pane">The parent <see cref="GraphPane"/> object.</param> /// <param name="initialize">A <see cref="bool"/> flag to indicate whether or /// not the drawing variables should be initialized. Initialization is not /// required if this is part of a ZedGraph internal draw operation (i.e., its in /// the middle of a call to <see cref="GraphPane.Draw"/>). Otherwise, you should /// initialize to make sure the drawing variables are configured. true to do /// an initialization, false otherwise.</param> public ValueHandler( GraphPane pane, bool initialize ) { _pane = pane; if ( initialize ) { // just create a dummy image, which results in a full draw operation using ( Image image = pane.GetImage() ) { } } }
/// <summary> /// 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> internal override bool IsXIndependent( GraphPane pane ) { return pane._barSettings.Base == BarBase.X || pane._barSettings.Base == BarBase.X2; }
/// <summary> /// Draw a legend key entry for this <see cref="BarItem"/> at the specified location /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the /// location for the legend key</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public override void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor ) { _bar.Draw( g, pane, rect, scaleFactor, true, false, null ); }
/// <summary> /// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />. /// </summary> /// <remarks> /// This method will go through the bars, create a label that corresponds to the bar value, /// and place it on the graph depending on user preferences. This works for horizontal or /// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types. This method /// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects. /// Call this method only after calling <see cref="GraphPane.AxisChange()" />. /// </remarks> /// <param name="pane">The GraphPane in which to place the text labels.</param> /// <param name="isBarCenter">true to center the labels inside the bars, false to /// place the labels just above the top of the bar.</param> /// <param name="valueFormat">The double.ToString string format to use for creating /// the labels. /// </param> /// <param name="fontColor">The color in which to draw the labels</param> /// <param name="fontFamily">The string name of the font family to use for the labels</param> /// <param name="fontSize">The floating point size of the font, in scaled points</param> /// <param name="isBold">true for a bold font type, false otherwise</param> /// <param name="isItalic">true for an italic font type, false otherwise</param> /// <param name="isUnderline">true for an underline font type, false otherwise</param> public static void CreateBarLabels( GraphPane pane, bool isBarCenter, string valueFormat, string fontFamily, float fontSize, Color fontColor, bool isBold, bool isItalic, bool isUnderline ) { bool isVertical = pane.BarSettings.Base == BarBase.X; // keep a count of the number of BarItems int curveIndex = 0; // Get a valuehandler to do some calculations for us ValueHandler valueHandler = new ValueHandler( pane, true ); // Loop through each curve in the list foreach ( CurveItem curve in pane.CurveList ) { // work with BarItems only BarItem bar = curve as BarItem; if ( bar != null ) { IPointList points = curve.Points; // ADD JKB 9/21/07 // The labelOffset should depend on whether the curve is YAxis or Y2Axis. // JHC - Generalize to any value axis // Make the gap between the bars and the labels = 1.5% of the axis range float labelOffset; Scale scale = curve.ValueAxis( pane ).Scale; labelOffset = (float)( scale._max - scale._min ) * 0.015f; // Loop through each point in the BarItem for ( int i = 0; i < points.Count; i++ ) { // Get the high, low and base values for the current bar // note that this method will automatically calculate the "effective" // values if the bar is stacked double baseVal, lowVal, hiVal; valueHandler.GetValues( curve, i, out baseVal, out lowVal, out hiVal ); // Get the value that corresponds to the center of the bar base // This method figures out how the bars are positioned within a cluster float centerVal = (float)valueHandler.BarCenterValue( bar, bar.GetBarWidth( pane ), i, baseVal, curveIndex ); // Create a text label -- note that we have to go back to the original point // data for this, since hiVal and lowVal could be "effective" values from a bar stack string barLabelText = ( isVertical ? points[i].Y : points[i].X ).ToString( valueFormat ); // Calculate the position of the label -- this is either the X or the Y coordinate // depending on whether they are horizontal or vertical bars, respectively float position; if ( isBarCenter ) position = (float)( hiVal + lowVal ) / 2.0f; else if ( hiVal >= 0 ) position = (float)hiVal + labelOffset; else position = (float)hiVal - labelOffset; // Create the new TextObj TextObj label; if ( isVertical ) label = new TextObj( barLabelText, centerVal, position ); else label = new TextObj( barLabelText, position, centerVal ); label.FontSpec.Family = fontFamily; // Configure the TextObj // CHANGE JKB 9/21/07 // CoordinateFrame should depend on whether curve is YAxis or Y2Axis. label.Location.CoordinateFrame = (isVertical && curve.IsY2Axis) ? CoordType.AxisXY2Scale : CoordType.AxisXYScale; label.FontSpec.Size = fontSize; label.FontSpec.FontColor = fontColor; label.FontSpec.IsItalic = isItalic; label.FontSpec.IsBold = isBold; label.FontSpec.IsUnderline = isUnderline; label.FontSpec.Angle = isVertical ? 90 : 0; label.Location.AlignH = isBarCenter ? AlignH.Center : ( hiVal >= 0 ? AlignH.Left : AlignH.Right ); label.Location.AlignV = AlignV.Center; label.FontSpec.Border.IsVisible = false; label.FontSpec.Fill.IsVisible = false; // Add the TextObj to the GraphPane pane.GraphObjList.Add( label ); } curveIndex++; } } }
/// <summary> /// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/> /// device. The format (stair-step or line) of the curve is /// defined by the <see cref="StepType"/> property. The routine /// only draws the line segments; the symbols are drawn by the /// <see cref="Symbol.Draw"/> method. This method /// is normally only called by the Draw method of the /// <see cref="CurveItem"/> object /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> public void DrawCurveOriginal( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor ) { Line source = this; if ( curve.IsSelected ) source = Selection.Line; float tmpX, tmpY, lastX = float.MaxValue, lastY = float.MaxValue; double curX, curY, lowVal; PointPair curPt, lastPt = new PointPair(); bool lastBad = true; IPointList points = curve.Points; ValueHandler valueHandler = new ValueHandler( pane, false ); Axis yAxis = curve.GetYAxis( pane ); Axis xAxis = curve.GetXAxis( pane ); bool xIsLog = xAxis._scale.IsLog; bool yIsLog = yAxis._scale.IsLog; float minX = pane.Chart.Rect.Left; float maxX = pane.Chart.Rect.Right; float minY = pane.Chart.Rect.Top; float maxY = pane.Chart.Rect.Bottom; using ( Pen pen = source.GetPen( pane, scaleFactor ) ) { if ( points != null && !_color.IsEmpty && this.IsVisible ) { //bool lastOut = false; bool isOut; // Loop over each point in the curve for ( int i = 0; i < points.Count; i++ ) { curPt = points[i]; if ( pane.LineType == LineType.Stack ) { if ( !valueHandler.GetValues( curve, i, out curX, out lowVal, out curY ) ) { curX = PointPair.Missing; curY = PointPair.Missing; } } else { curX = curPt.X; curY = curPt.Y; } // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if ( curX == PointPair.Missing || curY == PointPair.Missing || System.Double.IsNaN( curX ) || System.Double.IsNaN( curY ) || System.Double.IsInfinity( curX ) || System.Double.IsInfinity( curY ) || ( xIsLog && curX <= 0.0 ) || ( yIsLog && curY <= 0.0 ) ) { // If the point is invalid, then make a linebreak only if IsIgnoreMissing is false // LastX and LastY are always the last valid point, so this works out lastBad = lastBad || !pane.IsIgnoreMissing; isOut = true; } else { // Transform the current point from user scale units to // screen coordinates tmpX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curX ); tmpY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curY ); isOut = ( tmpX < minX && lastX < minX ) || ( tmpX > maxX && lastX > maxX ) || ( tmpY < minY && lastY < minY ) || ( tmpY > maxY && lastY > maxY ); if ( !lastBad ) { try { // GDI+ plots the data wrong and/or throws an exception for // outrageous coordinates, so we do a sanity check here if ( lastX > 5000000 || lastX < -5000000 || lastY > 5000000 || lastY < -5000000 || tmpX > 5000000 || tmpX < -5000000 || tmpY > 5000000 || tmpY < -5000000 ) InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen, lastX, lastY, tmpX, tmpY ); else if ( !isOut ) { if ( !curve.IsSelected && this._gradientFill.IsGradientValueType ) { using ( Pen tPen = GetPen( pane, scaleFactor, lastPt ) ) { if ( this.StepType == StepType.NonStep ) { g.DrawLine( tPen, lastX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardStep ) { g.DrawLine( tPen, lastX, lastY, tmpX, lastY ); g.DrawLine( tPen, tmpX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.RearwardStep ) { g.DrawLine( tPen, lastX, lastY, lastX, tmpY ); g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardSegment ) { g.DrawLine( tPen, lastX, lastY, tmpX, lastY ); } else { g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY ); } } } else { if ( this.StepType == StepType.NonStep ) { g.DrawLine( pen, lastX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardStep ) { g.DrawLine( pen, lastX, lastY, tmpX, lastY ); g.DrawLine( pen, tmpX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.RearwardStep ) { g.DrawLine( pen, lastX, lastY, lastX, tmpY ); g.DrawLine( pen, lastX, tmpY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardSegment ) { g.DrawLine( pen, lastX, lastY, tmpX, lastY ); } else if ( this.StepType == StepType.RearwardSegment ) { g.DrawLine( pen, lastX, tmpY, tmpX, tmpY ); } } } } catch { InterpolatePoint( g, pane, curve, lastPt, scaleFactor, pen, lastX, lastY, tmpX, tmpY ); } } lastPt = curPt; lastX = tmpX; lastY = tmpY; lastBad = false; //lastOut = isOut; } } } } }
/// <summary> /// Close off a <see cref="GraphicsPath"/> that defines a curve /// </summary> /// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object.</param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> /// <param name="arrPoints">An array of <see cref="PointF"/> values in screen pixel /// coordinates representing the current curve.</param> /// <param name="count">The number of points contained in the "arrPoints" /// parameter.</param> /// <param name="yMin">The Y axis value location where the X axis crosses.</param> /// <param name="path">The <see cref="GraphicsPath"/> class that represents the curve.</param> public void CloseCurve( GraphPane pane, CurveItem curve, PointF[] arrPoints, int count, double yMin, GraphicsPath path ) { // For non-stacked lines, the fill area is just the area between the curve and the X axis if ( pane.LineType != LineType.Stack ) { // Determine the current value for the bottom of the curve (usually the Y value where // the X axis crosses) float yBase; Axis yAxis = curve.GetYAxis( pane ); yBase = yAxis.Scale.Transform( yMin ); // Add three points to the path to move from the end of the curve (as defined by // arrPoints) to the X axis, from there to the start of the curve at the X axis, // and from there back up to the beginning of the curve. path.AddLine( arrPoints[count - 1].X, arrPoints[count - 1].Y, arrPoints[count - 1].X, yBase ); path.AddLine( arrPoints[count - 1].X, yBase, arrPoints[0].X, yBase ); path.AddLine( arrPoints[0].X, yBase, arrPoints[0].X, arrPoints[0].Y ); } // For stacked line types, the fill area is the area between this curve and the curve below it else { PointF[] arrPoints2; int count2; float tension = _isSmooth ? _smoothTension : 0f; // Find the next lower curve in the curveList that is also a LineItem type, and use // its smoothing properties for the lower side of the filled area. int index = pane.CurveList.IndexOf( curve ); if ( index > 0 ) { CurveItem tmpCurve; for ( int i = index - 1; i >= 0; i-- ) { tmpCurve = pane.CurveList[i]; if ( tmpCurve is LineItem ) { tension = ( (LineItem)tmpCurve ).Line.IsSmooth ? ( (LineItem)tmpCurve ).Line.SmoothTension : 0f; break; } } } // Build another points array consisting of the low points (which are actually the points for // the curve below the current curve) BuildLowPointsArray( pane, curve, out arrPoints2, out count2 ); // Add the new points to the GraphicsPath path.AddCurve( arrPoints2, 0, count2 - 2, tension ); } }
/// <summary> /// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents /// the low values for the current curve. /// </summary> /// <remarks>Note that this drawing routine ignores <see cref="PointPairBase.Missing"/> /// values, but it does not "break" the line to indicate values are missing. /// </remarks> /// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object.</param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> /// <param name="arrPoints">An array of <see cref="PointF"/> values in pixel /// coordinates representing the current curve.</param> /// <param name="count">The number of points contained in the "arrPoints" /// parameter.</param> /// <returns>true for a successful points array build, false for data problems</returns> public bool BuildLowPointsArray( GraphPane pane, CurveItem curve, out PointF[] arrPoints, out int count ) { arrPoints = null; count = 0; IPointList points = curve.Points; if ( this.IsVisible && !this.Color.IsEmpty && points != null ) { int index = 0; float curX, curY, lastX = 0, lastY = 0; double x, y, hiVal; ValueHandler valueHandler = new ValueHandler( pane, false ); // Step type plots get twice as many points. Always add three points so there is // room to close out the curve for area fills. arrPoints = new PointF[( _stepType == ZedGraph.StepType.NonStep ? 1 : 2 ) * ( pane.LineType == LineType.Stack ? 2 : 1 ) * points.Count + 1]; // Loop backwards over all points in the curve // In this case an array of points was already built forward by BuildPointsArray(). // This time we build backwards to complete a loop around the area between two curves. for ( int i = points.Count - 1; i >= 0; i-- ) { // Make sure the current point is valid if ( !points[i].IsInvalid ) { // Get the user scale values for the current point valueHandler.GetValues( curve, i, out x, out y, out hiVal ); if ( x == PointPair.Missing || y == PointPair.Missing ) continue; // Transform the user scale values to pixel locations Axis xAxis = curve.GetXAxis( pane ); curX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, x ); Axis yAxis = curve.GetYAxis( pane ); curY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, y ); // Add the pixel value pair into the points array // Two points are added for step type curves // ignore step-type setting for smooth curves if ( _isSmooth || index == 0 || this.StepType == StepType.NonStep ) { arrPoints[index].X = curX; arrPoints[index].Y = curY; } else if ( this.StepType == StepType.ForwardStep ) { arrPoints[index].X = curX; arrPoints[index].Y = lastY; index++; arrPoints[index].X = curX; arrPoints[index].Y = curY; } else if ( this.StepType == StepType.RearwardStep ) { arrPoints[index].X = lastX; arrPoints[index].Y = curY; index++; arrPoints[index].X = curX; arrPoints[index].Y = curY; } lastX = curX; lastY = curY; index++; } } // Make sure there is at least one valid point if ( index == 0 ) return false; // Add an extra point at the end, since the smoothing algorithm requires it arrPoints[index] = arrPoints[index - 1]; index++; count = index; return true; } else { return false; } }
/// <summary> /// Get the Y Axis instance (either <see cref="YAxis" /> or <see cref="Y2Axis" />) to /// which this <see cref="CurveItem" /> belongs. /// </summary> /// <remarks> /// This method safely retrieves a Y Axis instance from either the <see cref="GraphPane.YAxisList" /> /// or the <see cref="GraphPane.Y2AxisList" /> using the values of <see cref="YAxisIndex" /> and /// <see cref="IsY2Axis" />. If the value of <see cref="YAxisIndex" /> is out of bounds, the /// default <see cref="YAxis" /> or <see cref="Y2Axis" /> is used. /// </remarks> /// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param> /// <returns>Either a <see cref="YAxis" /> or <see cref="Y2Axis" /> to which this /// <see cref="CurveItem" /> belongs. /// </returns> public Axis GetYAxis( GraphPane pane ) { if ( _isY2Axis ) { if ( _yAxisIndex < pane.Y2AxisList.Count ) return pane.Y2AxisList[_yAxisIndex]; else return pane.Y2AxisList[0]; } else { if ( _yAxisIndex < pane.YAxisList.Count ) return pane.YAxisList[_yAxisIndex]; else return pane.YAxisList[0]; } }
/// <summary> /// Get the X Axis instance (either <see cref="XAxis" /> or <see cref="X2Axis" />) to /// which this <see cref="CurveItem" /> belongs. /// </summary> /// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param> /// <returns>Either a <see cref="XAxis" /> or <see cref="X2Axis" /> to which this /// <see cref="CurveItem" /> belongs. /// </returns> public Axis GetXAxis( GraphPane pane ) { if ( _isX2Axis ) return pane.X2Axis; else return pane.XAxis; }
/// <summary> /// 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 != PointPair.Missing ) ignoreInitial = false; if ( !ignoreInitial && !outOfBounds && curX != PointPair.Missing && curY != PointPair.Missing ) { if ( curX < xMin ) xMin = curX; if ( curX > xMax ) xMax = curX; if ( curY < yMin ) yMin = curY; if ( curY > yMax ) yMax = curY; if ( isZIncluded && isXIndependent && curZ != PointPair.Missing ) { if ( curZ < yMin ) yMin = curZ; if ( curZ > yMax ) yMax = curZ; } else if ( isZIncluded && curZ != PointPair.Missing ) { if ( curZ < xMin ) xMin = curZ; if ( curZ > xMax ) xMax = curZ; } } } }
/// <summary> /// 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> /// <returns>The width for an individual bar, in pixel units</returns> public float GetBarWidth( GraphPane pane ) { // Total axis width = // npts * ( nbars * ( bar + bargap ) - bargap + clustgap ) // cg * bar = cluster gap // npts = max number of points in any curve // nbars = total number of curves that are of type IsBar // bar = bar width // bg * bar = bar gap // therefore: // totwidth = npts * ( nbars * (bar + bg*bar) - bg*bar + cg*bar ) // totwidth = bar * ( npts * ( nbars * ( 1 + bg ) - bg + cg ) ) // solve for bar float barWidth; if ( this is ErrorBarItem ) barWidth = (float) ( ((ErrorBarItem)this).Bar.Symbol.Size * pane.CalcScaleFactor() ); // else if ( this is HiLowBarItem && pane._barSettings.Type != BarType.ClusterHiLow ) // barWidth = (float) ( ((HiLowBarItem)this).Bar.GetBarWidth( pane, // ((HiLowBarItem)this).BaseAxis(pane), pane.CalcScaleFactor() ) ); // barWidth = (float) ( ((HiLowBarItem)this).Bar.Size * // pane.CalcScaleFactor() ); else // BarItem or LineItem { // For stacked bar types, the bar width will be based on a single bar float numBars = 1.0F; if ( pane._barSettings.Type == BarType.Cluster ) numBars = pane.CurveList.NumClusterableBars; float denom = numBars * ( 1.0F + pane._barSettings.MinBarGap ) - pane._barSettings.MinBarGap + pane._barSettings.MinClusterGap; if ( denom <= 0 ) denom = 1; barWidth = pane.BarSettings.GetClusterWidth() / denom; } if ( barWidth <= 0 ) return 1; return barWidth; }
/// <summary> /// Draw a legend key entry for this <see cref="CurveItem"/> at the specified location. /// This abstract base method passes through to <see cref="BarItem.DrawLegendKey"/> or /// <see cref="LineItem.DrawLegendKey"/> to do the rendering. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the /// location for the legend key</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> 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="ZedGraph.CurveList"/> /// collection object. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="pos">The ordinal position of the current <see cref="Bar"/> /// curve.</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public abstract void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor );
/// <summary> /// This method just handles the case where one or more of the coordinates are outrageous, /// or GDI+ threw an exception. This method attempts to correct the outrageous coordinates by /// interpolating them to a point (along the original line) that lies at the edge of the ChartRect /// so that GDI+ will handle it properly. GDI+ will throw an exception, or just plot the data /// incorrectly if the coordinates are too large (empirically, this appears to be when the /// coordinate value is greater than 5,000,000 or less than -5,000,000). Although you typically /// would not see coordinates like this, if you repeatedly zoom in on a ZedGraphControl, eventually /// all your points will be way outside the bounds of the plot. /// </summary> private void InterpolatePoint( Graphics g, GraphPane pane, CurveItem curve, PointPair lastPt, float scaleFactor, Pen pen, float lastX, float lastY, float tmpX, float tmpY ) { try { RectangleF chartRect = pane.Chart._rect; // try to interpolate values bool lastIn = chartRect.Contains( lastX, lastY ); bool curIn = chartRect.Contains( tmpX, tmpY ); // If both points are outside the ChartRect, make a new point that is on the LastX/Y // side of the ChartRect, and fall through to the code that handles lastIn == true if ( !lastIn ) { float newX, newY; if ( Math.Abs( lastX ) > Math.Abs( lastY ) ) { newX = lastX < 0 ? chartRect.Left : chartRect.Right; newY = lastY + ( tmpY - lastY ) * ( newX - lastX ) / ( tmpX - lastX ); } else { newY = lastY < 0 ? chartRect.Top : chartRect.Bottom; newX = lastX + ( tmpX - lastX ) * ( newY - lastY ) / ( tmpY - lastY ); } lastX = newX; lastY = newY; } if ( !curIn ) { float newX, newY; if ( Math.Abs( tmpX ) > Math.Abs( tmpY ) ) { newX = tmpX < 0 ? chartRect.Left : chartRect.Right; newY = tmpY + ( lastY - tmpY ) * ( newX - tmpX ) / ( lastX - tmpX ); } else { newY = tmpY < 0 ? chartRect.Top : chartRect.Bottom; newX = tmpX + ( lastX - tmpX ) * ( newY - tmpY ) / ( lastY - tmpY ); } tmpX = newX; tmpY = newY; } /* if ( this.StepType == StepType.ForwardStep ) { g.DrawLine( pen, lastX, lastY, tmpX, lastY ); g.DrawLine( pen, tmpX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.RearwardStep ) { g.DrawLine( pen, lastX, lastY, lastX, tmpY ); g.DrawLine( pen, lastX, tmpY, tmpX, tmpY ); } else // non-step g.DrawLine( pen, lastX, lastY, tmpX, tmpY ); */ if ( !curve.IsSelected && this._gradientFill.IsGradientValueType ) { using ( Pen tPen = GetPen( pane, scaleFactor, lastPt ) ) { if ( this.StepType == StepType.NonStep ) { g.DrawLine( tPen, lastX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardStep ) { g.DrawLine( tPen, lastX, lastY, tmpX, lastY ); g.DrawLine( tPen, tmpX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.RearwardStep ) { g.DrawLine( tPen, lastX, lastY, lastX, tmpY ); g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardSegment ) { g.DrawLine( tPen, lastX, lastY, tmpX, lastY ); } else { g.DrawLine( tPen, lastX, tmpY, tmpX, tmpY ); } } } else { if ( this.StepType == StepType.NonStep ) { g.DrawLine( pen, lastX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardStep ) { g.DrawLine( pen, lastX, lastY, tmpX, lastY ); g.DrawLine( pen, tmpX, lastY, tmpX, tmpY ); } else if ( this.StepType == StepType.RearwardStep ) { g.DrawLine( pen, lastX, lastY, lastX, tmpY ); g.DrawLine( pen, lastX, tmpY, tmpX, tmpY ); } else if ( this.StepType == StepType.ForwardSegment ) { g.DrawLine( pen, lastX, lastY, tmpX, lastY ); } else if ( this.StepType == StepType.RearwardSegment ) { g.DrawLine( pen, lastX, tmpY, tmpX, tmpY ); } } } catch { } }
private bool IsFirstLine( GraphPane pane, CurveItem curve ) { CurveList curveList = pane.CurveList; for ( int j = 0; j < curveList.Count; j++ ) { CurveItem tCurve = curveList[j]; if ( tCurve is LineItem && tCurve.IsY2Axis == curve.IsY2Axis && tCurve.YAxisIndex == curve.YAxisIndex ) { return tCurve == curve; } } return false; }
/// <summary> /// Get the index of the Y Axis in the <see cref="YAxis" /> or <see cref="Y2Axis" /> list to /// which this <see cref="CurveItem" /> belongs. /// </summary> /// <remarks> /// This method safely retrieves a Y Axis index into either the <see cref="GraphPane.YAxisList" /> /// or the <see cref="GraphPane.Y2AxisList" /> using the values of <see cref="YAxisIndex" /> and /// <see cref="IsY2Axis" />. If the value of <see cref="YAxisIndex" /> is out of bounds, the /// default <see cref="YAxis" /> or <see cref="Y2Axis" /> is used, which is index zero. /// </remarks> /// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param> /// <returns>An integer value indicating which index position in the list applies to this /// <see cref="CurveItem" /> /// </returns> public int GetYAxisIndex( GraphPane pane ) { if ( _yAxisIndex >= 0 && _yAxisIndex < ( _isY2Axis ? pane.Y2AxisList.Count : pane.YAxisList.Count ) ) return _yAxisIndex; else return 0; }
/// <summary> /// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents /// the current curve. Note that this drawing routine ignores <see cref="PointPairBase.Missing"/> /// values, but it does not "break" the line to indicate values are missing. /// </summary> /// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object.</param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> /// <param name="arrPoints">An array of <see cref="PointF"/> values in pixel /// coordinates representing the current curve.</param> /// <param name="count">The number of points contained in the "arrPoints" /// parameter.</param> /// <returns>true for a successful points array build, false for data problems</returns> public bool BuildPointsArray( GraphPane pane, CurveItem curve, out PointF[] arrPoints, out int count ) { arrPoints = null; count = 0; IPointList points = curve.Points; if ( this.IsVisible && !this.Color.IsEmpty && points != null ) { int index = 0; float curX, curY, lastX = 0, lastY = 0; double x, y, lowVal; ValueHandler valueHandler = new ValueHandler( pane, false ); // Step type plots get twice as many points. Always add three points so there is // room to close out the curve for area fills. arrPoints = new PointF[( _stepType == ZedGraph.StepType.NonStep ? 1 : 2 ) * points.Count + 1]; // Loop over all points in the curve for ( int i = 0; i < points.Count; i++ ) { // make sure that the current point is valid if ( !points[i].IsInvalid ) { // Get the user scale values for the current point // use the valueHandler only for stacked types if ( pane.LineType == LineType.Stack ) { valueHandler.GetValues( curve, i, out x, out lowVal, out y ); } // otherwise, just access the values directly. Avoiding the valueHandler for // non-stacked types is an optimization to minimize overhead in case there are // a large number of points. else { x = points[i].X; y = points[i].Y; } if ( x == PointPair.Missing || y == PointPair.Missing ) continue; // Transform the user scale values to pixel locations Axis xAxis = curve.GetXAxis( pane ); curX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, x ); Axis yAxis = curve.GetYAxis( pane ); curY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, y ); if ( curX < -1000000 || curY < -1000000 || curX > 1000000 || curY > 1000000 ) continue; // Add the pixel value pair into the points array // Two points are added for step type curves // ignore step-type setting for smooth curves if ( _isSmooth || index == 0 || this.StepType == StepType.NonStep ) { arrPoints[index].X = curX; arrPoints[index].Y = curY; } else if ( this.StepType == StepType.ForwardStep || this.StepType == StepType.ForwardSegment ) { arrPoints[index].X = curX; arrPoints[index].Y = lastY; index++; arrPoints[index].X = curX; arrPoints[index].Y = curY; } else if ( this.StepType == StepType.RearwardStep || this.StepType == StepType.RearwardSegment ) { arrPoints[index].X = lastX; arrPoints[index].Y = curY; index++; arrPoints[index].X = curX; arrPoints[index].Y = curY; } lastX = curX; lastY = curY; index++; } } // Make sure there is at least one valid point if ( index == 0 ) return false; // Add an extra point at the end, since the smoothing algorithm requires it arrPoints[index] = arrPoints[index - 1]; index++; count = index; return true; } else { return false; } }
/// <summary> /// Do all rendering associated with this <see cref="ErrorBarItem"/> to the specified /// <see cref="Graphics"/> device. This method is normally only /// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/> /// collection object. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="pos">The ordinal position of the current <see cref="ErrorBarItem"/> /// curve.</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public override void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor ) { if ( _isVisible ) { _bar.Draw( g, pane, this, this.BaseAxis( pane ), this.ValueAxis( pane ), scaleFactor ); } }
/// <summary> /// Do all rendering associated with this <see cref="Line"/> to the specified /// <see cref="Graphics"/> device. This method is normally only /// called by the Draw method of the parent <see cref="LineItem"/> object. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> public void Draw( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor ) { // If the line is being shown, draw it if ( this.IsVisible ) { //How to handle fill vs nofill? //if ( isSelected ) // GraphPane.Default.SelectedLine. SmoothingMode sModeSave = g.SmoothingMode; if ( _isAntiAlias ) g.SmoothingMode = SmoothingMode.HighQuality; if ( curve is StickItem ) DrawSticks( g, pane, curve, scaleFactor ); else if ( this.IsSmooth || this.Fill.IsVisible ) DrawSmoothFilledCurve( g, pane, curve, scaleFactor ); else DrawCurve( g, pane, curve, scaleFactor ); g.SmoothingMode = sModeSave; } }
/// <summary> /// Draw a legend key entry for this <see cref="ErrorBarItem"/> at the specified location /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the /// location for the legend key</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public override void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor ) { float pixBase, pixValue, pixLowValue; if ( pane._barSettings.Base == BarBase.X ) { pixBase = rect.Left + rect.Width / 2.0F; pixValue = rect.Top; pixLowValue = rect.Bottom; } else { pixBase = rect.Top + rect.Height / 2.0F; pixValue = rect.Right; pixLowValue = rect.Left; } using ( Pen pen = new Pen( _bar.Color, _bar.PenWidth ) ) { this.Bar.Draw( g, pane, pane._barSettings.Base == BarBase.X, pixBase, pixValue, pixLowValue, scaleFactor, pen, false, null ); } }
/// <summary> /// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />. /// </summary> /// <remarks> /// This method will go through the bars, create a label that corresponds to the bar value, /// and place it on the graph depending on user preferences. This works for horizontal or /// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types. This method /// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects. /// Call this method only after calling <see cref="GraphPane.AxisChange()" />. /// </remarks> /// <param name="pane">The GraphPane in which to place the text labels.</param> /// <param name="isBarCenter">true to center the labels inside the bars, false to /// place the labels just above the top of the bar.</param> /// <param name="valueFormat">The double.ToString string format to use for creating /// the labels. /// </param> public static void CreateBarLabels( GraphPane pane, bool isBarCenter, string valueFormat ) { CreateBarLabels( pane, isBarCenter, valueFormat, TextObj.Default.FontFamily, TextObj.Default.FontSize, TextObj.Default.FontColor, TextObj.Default.FontBold, TextObj.Default.FontItalic, TextObj.Default.FontUnderline ); }
/// <summary> /// Gets a flag indicating if the Z data range should be included in the axis scaling calculations. /// </summary> /// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />. /// </param> /// <value>true if the Z data are included, false otherwise</value> internal override bool IsZIncluded( GraphPane pane ) { return true; }
/// <summary> /// Do all rendering associated with this <see cref="BarItem"/> to the specified /// <see cref="Graphics"/> device. This method is normally only /// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/> /// collection object. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="pos">The ordinal position of the current <see cref="Bar"/> /// curve.</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public override void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor ) { // Pass the drawing onto the bar class if ( _isVisible ) _bar.DrawBars( g, pane, this, BaseAxis( pane ), ValueAxis( pane ), this.GetBarWidth( pane ), pos, scaleFactor ); }
/// <summary> /// Render a single <see cref="Line"/> segment to the specified /// <see cref="Graphics"/> device. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <param name="x1">The x position of the starting point that defines the /// line segment in screen pixel units</param> /// <param name="y1">The y position of the starting point that defines the /// line segment in screen pixel units</param> /// <param name="x2">The x position of the ending point that defines the /// line segment in screen pixel units</param> /// <param name="y2">The y position of the ending point that defines the /// line segment in screen pixel units</param> public void DrawSegment( Graphics g, GraphPane pane, float x1, float y1, float x2, float y2, float scaleFactor ) { if ( _isVisible && !this.Color.IsEmpty ) { using ( Pen pen = GetPen( pane, scaleFactor ) ) { g.DrawLine( pen, x1, y1, x2, y2 ); } } }
/// <summary> /// Determine the coords for the rectangle associated with a specified point for /// this <see cref="CurveItem" /> /// </summary> /// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param> /// <param name="i">The index of the point of interest</param> /// <param name="coords">A list of coordinates that represents the "rect" for /// this point (used in an html AREA tag)</param> /// <returns>true if it's a valid point, false otherwise</returns> public override bool GetCoords( GraphPane pane, int i, out string coords ) { coords = string.Empty; if ( i < 0 || i >= _points.Count ) return false; Axis valueAxis = ValueAxis( pane ); Axis baseAxis = BaseAxis( pane ); // pixBase = pixel value for the bar center on the base axis // pixHiVal = pixel value for the bar top on the value axis // pixLowVal = pixel value for the bar bottom on the value axis float pixBase, pixHiVal, pixLowVal; float clusterWidth = pane.BarSettings.GetClusterWidth(); float barWidth = GetBarWidth( pane ); float clusterGap = pane._barSettings.MinClusterGap * barWidth; float barGap = barWidth * pane._barSettings.MinBarGap; // curBase = the scale value on the base axis of the current bar // curHiVal = the scale value on the value axis of the current bar // curLowVal = the scale value of the bottom of the bar double curBase, curLowVal, curHiVal; ValueHandler valueHandler = new ValueHandler( pane, false ); valueHandler.GetValues( this, i, out curBase, out curLowVal, out curHiVal ); // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if ( !_points[i].IsInvalid3D ) { // calculate a pixel value for the top of the bar on value axis pixLowVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curLowVal ); pixHiVal = valueAxis.Scale.Transform( _isOverrideOrdinal, i, curHiVal ); // calculate a pixel value for the center of the bar on the base axis pixBase = baseAxis.Scale.Transform( _isOverrideOrdinal, i, curBase ); // Calculate the pixel location for the side of the bar (on the base axis) float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F + pane.CurveList.GetBarItemPos( pane, this ) * ( barWidth + barGap ); // Draw the bar if ( baseAxis is XAxis || baseAxis is X2Axis ) coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}", pixSide, pixLowVal, pixSide + barWidth, pixHiVal ); else coords = String.Format( "{0:f0},{1:f0},{2:f0},{3:f0}", pixLowVal, pixSide, pixHiVal, pixSide + barWidth ); return true; } return false; }
/// <summary> /// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/> /// device using the specified smoothing property (<see cref="ZedGraph.Line.SmoothTension"/>). /// The routine draws the line segments and the area fill (if any, see <see cref="FillType"/>; /// the symbols are drawn by the <see cref="Symbol.Draw"/> method. This method /// is normally only called by the Draw method of the /// <see cref="CurveItem"/> object. Note that the <see cref="StepType"/> property /// is ignored for smooth lines (e.g., when <see cref="ZedGraph.Line.IsSmooth"/> is true). /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> public void DrawSmoothFilledCurve( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor ) { Line source = this; if ( curve.IsSelected ) source = Selection.Line; PointF[] arrPoints; int count; IPointList points = curve.Points; if ( this.IsVisible && !this.Color.IsEmpty && points != null && BuildPointsArray( pane, curve, out arrPoints, out count ) && count > 2 ) { float tension = _isSmooth ? _smoothTension : 0f; // Fill the curve if needed if ( this.Fill.IsVisible ) { Axis yAxis = curve.GetYAxis( pane ); using ( GraphicsPath path = new GraphicsPath( FillMode.Winding ) ) { path.AddCurve( arrPoints, 0, count - 2, tension ); double yMin = yAxis._scale._min < 0 ? 0.0 : yAxis._scale._min; CloseCurve( pane, curve, arrPoints, count, yMin, path ); RectangleF rect = path.GetBounds(); using ( Brush brush = source._fill.MakeBrush( rect ) ) { if ( pane.LineType == LineType.Stack && yAxis.Scale._min < 0 && this.IsFirstLine( pane, curve ) ) { float zeroPix = yAxis.Scale.Transform( 0 ); RectangleF tRect = pane.Chart._rect; tRect.Height = zeroPix - tRect.Top; if ( tRect.Height > 0 ) { Region reg = g.Clip; g.SetClip( tRect ); g.FillPath( brush, path ); g.SetClip( pane.Chart._rect ); } } else g.FillPath( brush, path ); //brush.Dispose(); } // restore the zero line if needed (since the fill tends to cover it up) yAxis.FixZeroLine( g, pane, scaleFactor, rect.Left, rect.Right ); } } // If it's a smooth curve, go ahead and render the path. Otherwise, use the // standard drawcurve method just in case there are missing values. if ( _isSmooth ) { using ( Pen pen = GetPen( pane, scaleFactor ) ) { // Stroke the curve g.DrawCurve( pen, arrPoints, 0, count - 2, tension ); //pen.Dispose(); } } else DrawCurve( g, pane, curve, scaleFactor ); } }
/// <summary> /// Gets a flag indicating if the Z data range should be included in the axis scaling calculations. /// </summary> /// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />. /// </param> /// <value>true if the Z data are included, false otherwise</value> internal override bool IsZIncluded( GraphPane pane ) { return this is HiLowBarItem; }
/// <summary> /// Render the <see cref="Line"/>'s as vertical sticks (from a <see cref="StickItem" />) to /// the specified <see cref="Graphics"/> device. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="CurveItem"/> representing this /// curve.</param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> public void DrawSticks( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor ) { Line source = this; if ( curve.IsSelected ) source = Selection.Line; Axis yAxis = curve.GetYAxis( pane ); Axis xAxis = curve.GetXAxis( pane ); float basePix = yAxis.Scale.Transform( 0.0 ); using ( Pen pen = source.GetPen( pane, scaleFactor ) ) { for ( int i = 0; i < curve.Points.Count; i++ ) { PointPair pt = curve.Points[i]; if ( pt.X != PointPair.Missing && pt.Y != PointPair.Missing && !System.Double.IsNaN( pt.X ) && !System.Double.IsNaN( pt.Y ) && !System.Double.IsInfinity( pt.X ) && !System.Double.IsInfinity( pt.Y ) && ( !xAxis._scale.IsLog || pt.X > 0.0 ) && ( !yAxis._scale.IsLog || pt.Y > 0.0 ) ) { float pixY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.Y ); float pixX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.X ); if ( pixX >= pane.Chart._rect.Left && pixX <= pane.Chart._rect.Right ) { if ( pixY > pane.Chart._rect.Bottom ) pixY = pane.Chart._rect.Bottom; if ( pixY < pane.Chart._rect.Top ) pixY = pane.Chart._rect.Top; if ( !curve.IsSelected && this._gradientFill.IsGradientValueType ) { using ( Pen tPen = GetPen( pane, scaleFactor, pt ) ) g.DrawLine( tPen, pixX, pixY, pixX, basePix ); } else g.DrawLine( pen, pixX, pixY, pixX, basePix ); } } } } }