/// <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;
//.........这里部分代码省略.........
/// <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 );
//.........这里部分代码省略.........
/// <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;
//.........这里部分代码省略.........
/// <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;
//.........这里部分代码省略.........
/// <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 );
客服电话
APP下载
官方微信
请发表评论