/// <summary>
/// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />.
/// </summary>
/// <remarks>
/// This method will go through the bars, create a label that corresponds to the bar value,
/// and place it on the graph depending on user preferences. This works for horizontal or
/// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types. This method
/// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects.
/// Call this method only after calling <see cref="GraphPane.AxisChange()" />.
/// </remarks>
/// <param name="pane">The GraphPane in which to place the text labels.</param>
/// <param name="isBarCenter">true to center the labels inside the bars, false to
/// place the labels just above the top of the bar.</param>
/// <param name="valueFormat">The double.ToString string format to use for creating
/// the labels.
/// </param>
/// <param name="fontColor">The color in which to draw the labels</param>
/// <param name="fontFamily">The string name of the font family to use for the labels</param>
/// <param name="fontSize">The floating point size of the font, in scaled points</param>
/// <param name="isBold">true for a bold font type, false otherwise</param>
/// <param name="isItalic">true for an italic font type, false otherwise</param>
/// <param name="isUnderline">true for an underline font type, false otherwise</param>
public static void CreateBarLabels(GraphPane pane, bool isBarCenter, string valueFormat,
string fontFamily, float fontSize, Color fontColor, bool isBold, bool isItalic,
bool isUnderline)
{
bool isVertical = pane.BarSettings.Base == BarBase.X;
// keep a count of the number of BarItems
int curveIndex = 0;
// Get a valuehandler to do some calculations for us
ValueHandler valueHandler = new ValueHandler(pane, true);
// Loop through each curve in the list
foreach (CurveItem curve in pane.CurveList)
{
// work with BarItems only
BarItem bar = curve as BarItem;
if (bar != null)
{
IPointList points = curve.Points;
// ADD JKB 9/21/07
// The labelOffset should depend on whether the curve is YAxis or Y2Axis.
// JHC - Generalize to any value axis
// Make the gap between the bars and the labels = 1.5% of the axis range
float labelOffset;
Scale scale = curve.ValueAxis(pane).Scale;
labelOffset = (float)(scale._max - scale._min) * 0.015f;
// Loop through each point in the BarItem
for (int i = 0; i < points.Count; i++)
{
// Get the high, low and base values for the current bar
// note that this method will automatically calculate the "effective"
// values if the bar is stacked
double baseVal, lowVal, hiVal;
valueHandler.GetValues(curve, i, out baseVal, out lowVal, out hiVal);
// Get the value that corresponds to the center of the bar base
// This method figures out how the bars are positioned within a cluster
float centerVal = (float)valueHandler.BarCenterValue(bar,
bar.GetBarWidth(pane), i, baseVal, curveIndex);
// Create a text label -- note that we have to go back to the original point
// data for this, since hiVal and lowVal could be "effective" values from a bar stack
string barLabelText = (isVertical ? points[i].Y : points[i].X).ToString(valueFormat);
// Calculate the position of the label -- this is either the X or the Y coordinate
// depending on whether they are horizontal or vertical bars, respectively
float position;
if (isBarCenter)
{
position = (float)(hiVal + lowVal) / 2.0f;
}
else if (hiVal >= 0)
{
position = (float)hiVal + labelOffset;
}
else
{
position = (float)hiVal - labelOffset;
}
// Create the new TextObj
TextObj label;
if (isVertical)
{
label = new TextObj(barLabelText, centerVal, position);
}
else
{
label = new TextObj(barLabelText, position, centerVal);
}
label.FontSpec.Family = fontFamily;
// Configure the TextObj
// CHANGE JKB 9/21/07
// CoordinateFrame should depend on whether curve is YAxis or Y2Axis.
label.Location.CoordinateFrame =
(isVertical && curve.IsY2Axis) ? CoordType.AxisXY2Scale : CoordType.AxisXYScale;
label.FontSpec.Size = fontSize;
label.FontSpec.FontColor = fontColor;
label.FontSpec.IsItalic = isItalic;
label.FontSpec.IsBold = isBold;
label.FontSpec.IsUnderline = isUnderline;
label.FontSpec.Angle = isVertical ? 90 : 0;
label.Location.AlignH = isBarCenter ? AlignH.Center :
(hiVal >= 0 ? AlignH.Left : AlignH.Right);
label.Location.AlignV = AlignV.Center;
label.FontSpec.Border.IsVisible = false;
label.FontSpec.Fill.IsVisible = false;
// Add the TextObj to the GraphPane
pane.GraphObjList.Add(label);
}
curveIndex++;
}
}
}
/// <summary>
/// Determine the coords for the rectangle associated with a specified point for
/// this <see cref="CurveItem" />
/// </summary>
/// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
/// <param name="i">The index of the point of interest</param>
/// <param name="coords">A list of coordinates that represents the "rect" for
/// this point (used in an html AREA tag)</param>
/// <returns>true if it's a valid point, false otherwise</returns>
override public bool GetCoords(GraphPane pane, int i, out string coords)
{
coords = string.Empty;
if (i < 0 || i >= _points.Count)
{
return(false);
}
Axis valueAxis = ValueAxis(pane);
Axis baseAxis = BaseAxis(pane);
// pixBase = pixel value for the bar center on the base axis
// pixHiVal = pixel value for the bar top on the value axis
// pixLowVal = pixel value for the bar bottom on the value axis
float pixBase, pixHiVal, pixLowVal;
float clusterWidth = pane.BarSettings.GetClusterWidth();
float barWidth = GetBarWidth(pane);
float clusterGap = pane._barSettings.MinClusterGap * barWidth;
float barGap = barWidth * pane._barSettings.MinBarGap;
// curBase = the scale value on the base axis of the current bar
// curHiVal = the scale value on the value axis of the current bar
// curLowVal = the scale value of the bottom of the bar
double curBase, curLowVal, curHiVal;
ValueHandler valueHandler = new ValueHandler(pane, false);
valueHandler.GetValues(this, i, out curBase, out curLowVal, out curHiVal);
// Any value set to double max is invalid and should be skipped
// This is used for calculated values that are out of range, divide
// by zero, etc.
// Also, any value <= zero on a log scale is invalid
if (!_points[i].IsInvalid3D)
{
// calculate a pixel value for the top of the bar on value axis
pixLowVal = valueAxis.Scale.Transform(_isOverrideOrdinal, i, curLowVal);
pixHiVal = valueAxis.Scale.Transform(_isOverrideOrdinal, i, curHiVal);
// calculate a pixel value for the center of the bar on the base axis
pixBase = baseAxis.Scale.Transform(_isOverrideOrdinal, i, curBase);
// Calculate the pixel location for the side of the bar (on the base axis)
float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F +
pane.CurveList.GetBarItemPos(pane, this) * (barWidth + barGap);
// Draw the bar
if (baseAxis is XAxis || baseAxis is X2Axis)
{
coords = String.Format("{0:f0},{1:f0},{2:f0},{3:f0}",
pixSide, pixLowVal,
pixSide + barWidth, pixHiVal);
}
else
{
coords = String.Format("{0:f0},{1:f0},{2:f0},{3:f0}",
pixLowVal, pixSide,
pixHiVal, pixSide + barWidth);
}
return(true);
}
return(false);
}
/// <summary>
/// Draw this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
/// device as a symbol at each defined point. The routine
/// only draws the symbols; the lines are draw by the
/// <see cref="Line.DrawCurve"/> method. This method
/// is normally only called by the Draw method of the
/// <see cref="CurveItem"/> object
/// </summary>
/// <param name="g">
/// A graphic device object to be drawn into. This is normally e.Graphics from the
/// PaintEventArgs argument to the Paint() method.
/// </param>
/// <param name="pane">
/// A reference to the <see cref="GraphPane"/> object that is the parent or
/// owner of this object.
/// </param>
/// <param name="curve">A <see cref="LineItem"/> representing this
/// curve.</param>
/// <param name="scaleFactor">
/// The scaling factor to be used for rendering objects. This is calculated and
/// passed down by the parent <see cref="GraphPane"/> object using the
/// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
/// font sizes, etc. according to the actual size of the graph.
/// </param>
/// <param name="isSelected">Indicates that the <see cref="Symbol" /> should be drawn
/// with attributes from the <see cref="Selection" /> class.
/// </param>
public void Draw(Graphics g, GraphPane pane, LineItem curve, float scaleFactor,
bool isSelected)
{
Symbol source = this;
int tmpX, tmpY;
int minX = (int)pane.Chart.Rect.Left;
int maxX = (int)pane.Chart.Rect.Right;
int minY = (int)pane.Chart.Rect.Top;
int maxY = (int)pane.Chart.Rect.Bottom;
// (Dale-a-b) we'll set an element to true when it has been drawn
bool[,] isPixelDrawn = new bool[maxX + 1, maxY + 1];
double curX, curY, lowVal;
IPointList points = curve.Points;
if (points != null && (_border.IsVisible || _fill.IsVisible))
{
SmoothingMode sModeSave = g.SmoothingMode;
if (_isAntiAlias)
{
g.SmoothingMode = SmoothingMode.HighQuality;
}
// For the sake of speed, go ahead and create a solid brush and a pen
// If it's a gradient fill, it will be created on the fly for each symbol
//SolidBrush brush = new SolidBrush( this.fill.Color );
using (Pen pen = source._border.GetPen(pane, scaleFactor))
using (GraphicsPath path = MakePath(g, scaleFactor))
{
RectangleF rect = path.GetBounds();
using (Brush brush = source.Fill.MakeBrush(rect))
{
ValueHandler valueHandler = new ValueHandler(pane, false);
Scale xScale = curve.GetXAxis(pane).Scale;
Scale yScale = curve.GetYAxis(pane).Scale;
bool xIsLog = xScale.IsLog;
bool yIsLog = yScale.IsLog;
bool xIsOrdinal = xScale.IsAnyOrdinal;
double xMin = xScale.Min;
double xMax = xScale.Max;
// Loop over each defined point
for (int i = 0; i < points.Count; i++)
{
// Get the user scale values for the current point
// use the valueHandler only for stacked types
if (pane.LineType == LineType.Stack)
{
valueHandler.GetValues(curve, i, out curX, out lowVal, out curY);
}
// otherwise, just access the values directly. Avoiding the valueHandler for
// non-stacked types is an optimization to minimize overhead in case there are
// a large number of points.
else
{
curX = points[i].X;
if (curve is StickItem)
{
curY = points[i].Z;
}
else
{
curY = points[i].Y;
}
}
// Any value set to double max is invalid and should be skipped
// This is used for calculated values that are out of range, divide
// by zero, etc.
// Also, any value <= zero on a log scale is invalid
if (curX != PointPair.Missing &&
curY != PointPair.Missing &&
!System.Double.IsNaN(curX) &&
!System.Double.IsNaN(curY) &&
!System.Double.IsInfinity(curX) &&
!System.Double.IsInfinity(curY) &&
(curX > 0 || !xIsLog) &&
(!yIsLog || curY > 0.0) &&
(xIsOrdinal || (curX >= xMin && curX <= xMax)))
{
// Transform the user scale values to pixel locations
tmpX = (int)xScale.Transform(curve.IsOverrideOrdinal, i, curX);
tmpY = (int)yScale.Transform(curve.IsOverrideOrdinal, i, curY);
// Maintain an array of "used" pixel locations to avoid duplicate drawing operations
if (tmpX >= minX && tmpX <= maxX && tmpY >= minY && tmpY <= maxY) // guard against the zoom-in case
{
if (isPixelDrawn[tmpX, tmpY])
{
continue;
}
isPixelDrawn[tmpX, tmpY] = true;
}
// If the fill type for this symbol is a Gradient by value type,
// the make a brush corresponding to the appropriate current value
if (_fill.IsGradientValueType || _border._gradientFill.IsGradientValueType)
{
using (Brush tBrush = _fill.MakeBrush(rect, points[i]))
using (Pen tPen = _border.GetPen(pane, scaleFactor, points[i]))
this.DrawSymbol(g, tmpX, tmpY, path, tPen, tBrush);
}
else
{
// Otherwise, the brush is already defined
// Draw the symbol at the specified pixel location
this.DrawSymbol(g, tmpX, tmpY, path, pen, brush);
}
}
}
}
}
g.SmoothingMode = sModeSave;
}
}
