/// <summary>
/// Method used to calculate the segment's rendering rect.
/// </summary>
/// <param name="transformer"></param>
/// <param name="segment"></param>
/// <returns></returns>
private Rect CalculateSegmentRect(IChartTransformer transformer)
{
double spacing = (Series is HistogramSeries) ? 0.0 : (Series as ISegmentSpacing).SegmentSpacing;
Point tlpoint = transformer.TransformToVisible(Left, Top);
Point rbpoint = transformer.TransformToVisible(Right, Bottom);
Rect segmentRect = new Rect(tlpoint, rbpoint);
if (spacing > 0.0 && spacing <= 1)
{
if (Series.IsActualTransposed == true)
{
double leftpos = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing,
segmentRect.Bottom, segmentRect.Top);
segmentRect.Y = leftpos;
Height = segmentRect.Height = (1 - spacing) * segmentRect.Height;
}
else
{
double leftpos = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, segmentRect.Right,
segmentRect.Left);
segmentRect.X = leftpos;
Width = segmentRect.Width = (1 - spacing) * segmentRect.Width;
}
}
return(segmentRect);
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastHiLoOpenCloseSeries.Area.GetFastRenderSurface();
if (transformer != null && fastHiLoOpenCloseSeries.DataCount > 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
xValues.Clear();
yHiValues.Clear();
yLoValues.Clear();
yOpenStartValues.Clear();
yOpenEndValues.Clear();
yCloseValues.Clear();
yCloseEndValues.Clear();
isBull.Clear();
x_isInversed = cartesianTransformer.XAxis.IsInversed;
y_isInversed = cartesianTransformer.YAxis.IsInversed;
sbsInfo = (fastHiLoOpenCloseSeries as ChartSeriesBase).GetSideBySideInfo(fastHiLoOpenCloseSeries as ChartSeriesBase);
center = sbsInfo.Median;
Left = sbsInfo.Start;
Right = sbsInfo.End;
//Removed the screen point calculation methods and added the Transform to Visible method.
CalculatePoint(cartesianTransformer);
UpdateVisual(true);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (transformer != null)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
double xStart = cartesianTransformer.XAxis.VisibleRange.Start;
double xEnd = cartesianTransformer.XAxis.VisibleRange.End;
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic;
double edgeValue = xIsLogarithmic ? Math.Log(xVal, xBase) : xVal;
if (edgeValue >= xStart && edgeValue <= xEnd && ((!double.IsNaN(highValue) && !double.IsNaN(lowValue)) || Series.ShowEmptyPoints))
{
Point hipoint = transformer.TransformToVisible(xVal, highValue);
Point lopoint = transformer.TransformToVisible(xVal, lowValue);
segLine.X1 = hipoint.X;
segLine.Y1 = hipoint.Y;
segLine.X2 = lopoint.X;
segLine.Y2 = lopoint.Y;
}
else
{
segLine.ClearUIValues();
}
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
var adornment3D = this as ChartAdornment3D;
if (this.Series is XyzDataSeries3D && !string.IsNullOrEmpty((this.Series as XyzDataSeries3D).ZBindingPath))
{
var vector3D = (transformer as ChartTransform.ChartCartesianTransformer).TransformToVisible3D(XPos, YPos, adornment3D.StartDepth);
this.X = vector3D.X;
this.Y = vector3D.Y;
adornment3D.ActualStartDepth = vector3D.Z;
}
else
{
if (Series is RangeColumnSeries && !Series.IsMultipleYPathRequired)
{
YPos = (Series.ActualYAxis.VisibleRange.End - Math.Abs(Series.ActualYAxis.VisibleRange.Start)) / 2;
}
Point point = transformer.TransformToVisible(XPos, YPos);
this.X = point.X;
this.Y = point.Y;
if (adornment3D != null)
{
adornment3D.ActualStartDepth = adornment3D.StartDepth;
}
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
PathFigure figure = new PathFigure();
int startIndex = 0;
int endIndex = AreaPoints.Count - 1;
if (AreaPoints.Count > 0)
{
figure.StartPoint = transformer.TransformToVisible(AreaPoints[0].X, AreaPoints[0].Y);
for (int i = startIndex; i < AreaPoints.Count; i += 2)
{
WindowsLinesegment lineSeg = new WindowsLinesegment();
lineSeg.Point = transformer.TransformToVisible(AreaPoints[i].X, AreaPoints[i].Y);
figure.Segments.Add(lineSeg);
}
for (int i = endIndex; i >= 1; i -= 2)
{
WindowsLinesegment lineSeg = new WindowsLinesegment();
lineSeg.Point = transformer.TransformToVisible(AreaPoints[i].X, AreaPoints[i].Y);
figure.Segments.Add(lineSeg);
}
figure.IsClosed = true;
Series.SeriesRootPanel.Clip = null;
}
PathGeometry segmentGeometry = new PathGeometry();
segmentGeometry.Figures.Add(figure);
segPath.Data = segmentGeometry;
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (Series == null || Series.ActualArea == null)
{
return;
}
if (!this.IsSegmentVisible)
{
segmentPath.Visibility = Visibility.Collapsed;
}
else
{
segmentPath.Visibility = Visibility.Visible;
}
if (IsMultipleCircleDoughnut)
{
DrawMultipleDoughnut(transformer);
}
else
{
DrawSingleDoughnut(transformer);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastCandleBitmapSeries.Area.GetFastRenderSurface();
if (transformer != null && fastCandleBitmapSeries.DataCount > 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
count = (int)(Math.Ceiling(xEnd));
count = (int)Math.Min(count, xChartVals.Count);
x_isInversed = cartesianTransformer.XAxis.IsInversed;
y_isInversed = cartesianTransformer.YAxis.IsInversed;
xStart = cartesianTransformer.XAxis.VisibleRange.Start;
xEnd = cartesianTransformer.XAxis.VisibleRange.End;
yStart = cartesianTransformer.YAxis.VisibleRange.Start;
yEnd = cartesianTransformer.YAxis.VisibleRange.End;
if (fastCandleBitmapSeries.IsActualTransposed)
{
ySize = cartesianTransformer.YAxis.RenderedRect.Width;
xSize = cartesianTransformer.XAxis.RenderedRect.Height;
yOffset = cartesianTransformer.YAxis.RenderedRect.Left - fastCandleBitmapSeries.Area.SeriesClipRect.Left;
xOffset = cartesianTransformer.XAxis.RenderedRect.Top - fastCandleBitmapSeries.Area.SeriesClipRect.Top;
}
else
{
ySize = cartesianTransformer.YAxis.RenderedRect.Height;
xSize = cartesianTransformer.XAxis.RenderedRect.Width;
yOffset = cartesianTransformer.YAxis.RenderedRect.Top - fastCandleBitmapSeries.Area.SeriesClipRect.Top;
xOffset = cartesianTransformer.XAxis.RenderedRect.Left - fastCandleBitmapSeries.Area.SeriesClipRect.Left;
}
if (x_isInversed)
{
double temp = xStart;
xStart = xEnd;
xEnd = temp;
}
if (y_isInversed)
{
double temp = yStart;
yStart = yEnd;
yEnd = temp;
}
isHollow.Clear();
isBull.Clear();
xValues.Clear();
x1Values.Clear();
x2Values.Clear();
openValue.Clear();
closeValue.Clear();
highValue.Clear();
highValue1.Clear();
lowValue.Clear();
lowValue1.Clear();
//Removed the screen point calculation methods and added the point to value method.
CalculatePoints(cartesianTransformer);
UpdateVisual();
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastBarSeries.Area.GetFastRenderSurface();
if (transformer != null && fastBarSeries.DataCount != 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer =
transformer as ChartTransform.ChartCartesianTransformer;
bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic ||
cartesianTransformer.YAxis.IsLogarithmic;
x_isInversed = cartesianTransformer.XAxis.IsInversed;
y_isInversed = cartesianTransformer.YAxis.IsInversed;
xStart = cartesianTransformer.XAxis.VisibleRange.Start;
xEnd = cartesianTransformer.XAxis.VisibleRange.End;
yStart = cartesianTransformer.YAxis.VisibleRange.Start;
yEnd = cartesianTransformer.YAxis.VisibleRange.End;
width = cartesianTransformer.XAxis.RenderedRect.Height;
height = cartesianTransformer.YAxis.RenderedRect.Width;
// WPF-14441 - Calculating Bar Position for the Series
left = fastBarSeries.Area.SeriesClipRect.Right - cartesianTransformer.YAxis.RenderedRect.Right;
top = fastBarSeries.Area.SeriesClipRect.Bottom - cartesianTransformer.XAxis.RenderedRect.Bottom;
availableSize = new Size(width, height);
if (x_isInversed)
{
double temp = xStart;
xStart = xEnd;
xEnd = temp;
}
if (y_isInversed)
{
double temp = yStart;
yStart = yEnd;
yEnd = temp;
}
x1Values.Clear();
x2Values.Clear();
y1Values.Clear();
y2Values.Clear();
//Removed the screen point calculation methods and added the point to value method.
if (!isLogarithmic)
{
CalculatePoints(cartesianTransformer);
}
else
{
CalculateLogPoints(cartesianTransformer);
}
UpdateVisual();
}
}
/// <summary>
/// Updates the <see cref="ChartTrendlinePanel"/>.
/// </summary>
/// <param name="finalSize">The Final Size</param>
internal void Update(Size finalSize)
{
IChartTransformer chartTransformer = Trend.Series.CreateTransformer(finalSize, true);
foreach (var segment in Trend.TrendlineSegments)
{
segment.Update(chartTransformer);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (transformer != null)
{
if (isSegmentUpdated)
{
Series.SeriesRootPanel.Clip = null;
}
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic;
double xStart = cartesianTransformer.XAxis.VisibleRange.Start;
double xEnd = cartesianTransformer.XAxis.VisibleRange.End;
double left = xIsLogarithmic ? Math.Log(Point1.X, xBase) : Point1.X;
double right = xIsLogarithmic ? Math.Log(Point4.X, xBase) : Point4.X;
if ((left <= xEnd && right >= xStart))
{
PathFigure figure = new PathFigure();
BezierSegment bezierSeg = new BezierSegment();
PathGeometry segGeometry = new PathGeometry();
P1 = figure.StartPoint = transformer.TransformToVisible(Point1.X, Point1.Y);
Q1 = bezierSeg.Point1 = transformer.TransformToVisible(Point2.X, Point2.Y);
Q2 = bezierSeg.Point2 = transformer.TransformToVisible(Point3.X, Point3.Y);
P2 = bezierSeg.Point3 = transformer.TransformToVisible(Point4.X, Point4.Y);
figure.Segments.Add(bezierSeg);
segGeometry.Figures = new PathFigureCollection()
{
figure
};
var path = this.segPath;
if (path != null)
{
path.Data = segGeometry;
}
else
{
Data = segGeometry;
}
}
else
{
if (segPath != null)
{
this.segPath.Data = null;
}
else if (Data != null)
{
Data = null;
}
}
isSegmentUpdated = true;
}
}
/// <summary>
/// This method is used to gets the selected data point segment pixel positions
/// </summary>
internal void GenerateColumnPixels()
{
if (!double.IsNaN(dataPoint.YData))
{
WriteableBitmap bmp = Area.fastRenderSurface;
IChartTransformer chartTransformer = CreateTransformer(
new Size(
Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height),
true);
bool x_isInversed = ActualXAxis.IsInversed;
bool y_isInversed = ActualYAxis.IsInversed;
DoubleRange sbsInfo = GetSideBySideInfo(this);
double origin = ActualXAxis != null ? ActualXAxis.Origin : 0;
double x1 = x_isInversed ? dataPoint.XData + sbsInfo.End : dataPoint.XData + sbsInfo.Start;
double x2 = x_isInversed ? dataPoint.XData + sbsInfo.Start : dataPoint.XData + sbsInfo.End;
double y1 = y_isInversed ? origin : dataPoint.YData;
double y2 = y_isInversed ? dataPoint.YData : origin;
Point tlpoint = chartTransformer.TransformToVisible(x1, y1);
Point rbpoint = chartTransformer.TransformToVisible(x2, y2);
double _x1 = tlpoint.X;
double _x2 = rbpoint.X;
double _y1 = y1 > 0 ? tlpoint.Y : rbpoint.Y;
double _y2 = y1 > 0 ? rbpoint.Y : tlpoint.Y;
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
var spacingSegment = this as ISegmentSpacing;
if (spacingSegment != null)
{
double spacing = spacingSegment.SegmentSpacing;
if (spacing > 0 && spacing <= 1)
{
double leftpos = spacingSegment.CalculateSegmentSpacing(spacing, _x2, _x1);
double rightpos = spacingSegment.CalculateSegmentSpacing(spacing, _x1, _x2);
_x1 = (float)(leftpos);
_x2 = (float)(rightpos);
}
}
selectedSegmentPixels.Clear();
if (_y1 < _y2)
{
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)(_x1), (int)_y1, (int)_x2, (int)_y2, selectedSegmentPixels);
}
else
{
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)(_x1), (int)_y2, (int)_x2, (int)_y1, selectedSegmentPixels);
}
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
double bottom;
Point center = ChartLayoutUtils.GetCenter(transformer.Viewport);
bottom = center.Y;
center.Y = 0;
center.Y += ((CurrY * bottom) * 2) - (Height / 2) * 4;
this.X = center.X;
this.Y = center.Y;
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
this.Points = new PointCollection();
foreach (var item in distributionPoints)
{
Point point = transformer.TransformToVisible(item.X, item.Y);
Points.Add(point);
}
this.polyLine.Points = Points;
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastRangeAreaBitmapSeries.Area.GetFastRenderSurface();
if (transformer != null && fastRangeAreaBitmapSeries.DataCount > 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
// Removed the screen point calculation methods and added the point to value method.
CalculatePoints(cartesianTransformer);
UpdateVisual();
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (Series is RangeColumnSeries && !Series.IsMultipleYPathRequired)
{
YPos = (Series.ActualYAxis.VisibleRange.End - Math.Abs(Series.ActualYAxis.VisibleRange.Start)) / 2;
}
Point point = transformer.TransformToVisible(XPos, YPos);
this.X = point.X;
this.Y = point.Y;
}
/// <summary>
/// Updates the real coordinates of segment.
/// </summary>
/// <param name="transformer">Instance of class that implements <see cref="IChartTransformer"/> interface.</param>
public override void Update(IChartTransformer transformer)
{
if (this.Interior.CanFreeze)
{
this.Interior.Freeze();
}
if (this.Stroke.CanFreeze)
{
this.Stroke.Freeze();
}
// Generate the Spline Curve Geomentry
PathFigure figure = new PathFigure();
figure.StartPoint = transformer.TransformToVisible(AreaPoints[0].X, 0);
figure.Segments.Add(new LineSegment(transformer.TransformToVisible(AreaPoints[0].X, AreaPoints[0].Y), true));
int i;
for (i = 1; i < CorrespondingPoints.Length; i++)
{
Point point1 = transformer.TransformToVisible(i, CorrespondingPoints[i].DataPoint.Y);
Point point2 = transformer.TransformToVisible(i, CorrespondingPoints[i].DataPoint.Y);
Point point3 = transformer.TransformToVisible(i, CorrespondingPoints[i].DataPoint.Y);
figure.Segments.Add(new BezierSegment(point1, point2, point3, true));
}
Point point11 = transformer.TransformToVisible(CorrespondingPoints[CorrespondingPoints.Length - 1].DataPoint.X, CorrespondingPoints[CorrespondingPoints.Length - 1].DataPoint.Y);
Point point21 = transformer.TransformToVisible(CorrespondingPoints[CorrespondingPoints.Length - 1].DataPoint.X, CorrespondingPoints[CorrespondingPoints.Length - 1].DataPoint.Y);
Point point31 = transformer.TransformToVisible(CorrespondingPoints[CorrespondingPoints.Length - 1].DataPoint.X, m_HybirdLineValue.Y);
figure.Segments.Add(new BezierSegment(point11, point21, point31, true));
figure.Segments.Add(new LineSegment(transformer.TransformToVisible(0, m_HybirdLineValue.Y), false));
figure.IsClosed = true;
PathGeometry pathgeomentry = new PathGeometry();
pathgeomentry.Figures.Add(figure);
PathFigureCollection PathFigurecoll = new PathFigureCollection();
PathFigurecoll.Add(figure);
//Initialize the Spline curve Geometry data
this.Geometry = pathgeomentry;
// Calculates the value for HybridLine
Point point = transformer.TransformToVisible(0d, m_HybirdLineValue.Y);
this.HybirdMargin = new Thickness(0, point.Y, 0, 0);
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer"></param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastSeries.Area.GetFastRenderSurface();
if (transformer != null && fastSeries.DataCount > 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
xValues.Clear();
yValues.Clear(); //WPF-14440 In seconday axis scrolling not apply for FastStepLineBitmapSeries
//Removed the existing screen point calculation methods and added the TransformVisible method.
CalculatePoints(cartesianTransformer);
UpdateVisual();
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (transformer != null)
{
Point position = transformer.TransformToVisible(XData, YData);
this.X = position.X - (EmptyPointSymbolWidth / 2);
this.Y = position.Y - (EmptyPointSymbolHeight / 2);
}
if (Series.EmptyPointSymbolTemplate == null)
{
base.Update(transformer);
}
}
internal void UpdateSegment(int index, NotifyCollectionChangedAction action, IChartTransformer transformer)
{
if (action == NotifyCollectionChangedAction.Remove)
{
this.Points.RemoveAt(index);
}
else if (action == NotifyCollectionChangedAction.Add)
{
Point point = transformer.TransformToVisible(xChartVals[index], yChartVals[index]);
Points.Add(point);
UpdateVisual(false);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (!this.IsSegmentVisible)
{
segmentPath.Visibility = Visibility.Collapsed;
}
else
{
segmentPath.Visibility = Visibility.Visible;
}
Rect rect = new Rect(0, 0, transformer.Viewport.Width, transformer.Viewport.Height);
PyramidSeries series = Series as PyramidSeries;
if (rect.IsEmpty)
{
this.segmentPath.Data = null;
}
else
{
if (this.isExploded)
{
rect.X += explodedOffset;
}
double top = y;
double bottom = y + height;
double topRadius = 0.5d * (1d - y);
double bottomRadius = 0.5d * (1d - bottom);
PathFigure figure = new PathFigure();
figure.StartPoint = new Point(rect.X + topRadius * rect.Width, rect.Y + top * rect.Height);
Linesegment lineSeg1 = new Linesegment();
lineSeg1.Point = new Point(rect.X + (1 - topRadius) * rect.Width, rect.Y + top * rect.Height);
figure.Segments.Add(lineSeg1);
Linesegment lineSeg3 = new Linesegment();
lineSeg3.Point = new Point(rect.X + (1 - bottomRadius) * rect.Width, rect.Y + bottom * rect.Height - series.StrokeThickness / 2);
figure.Segments.Add(lineSeg3);
Linesegment lineSeg4 = new Linesegment();
lineSeg4.Point = new Point(rect.X + bottomRadius * rect.Width, rect.Y + bottom * rect.Height - series.StrokeThickness / 2);
figure.Segments.Add(lineSeg4);
figure.IsClosed = true;
this.segmentGeometry = new PathGeometry();
this.segmentGeometry.Figures = new PathFigureCollection()
{
figure
};
segmentPath.Data = segmentGeometry;
height = ((bottom - top) * rect.Height) / 2;
}
}
private void DrawMultipleDoughnut(IChartTransformer transformer)
{
if (IsSegmentVisible)
{
var segmentStartAngle = ActualStartAngle;
var segmentEndAngle = ActualEndAngle;
var center = parentSeries.Center;
double actualRadius = parentSeries.InternalDoughnutSize * Math.Min(transformer.Viewport.Width, transformer.Viewport.Height) / 2;
double remainingWidth = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
double equalParts = (remainingWidth / doughnutSegmentsCount) * parentSeries.InternalDoughnutCoefficient;
double radius = actualRadius - (equalParts * (doughnutSegmentsCount - (DoughnutSegmentIndex + 1)));
parentSeries.Radius = actualRadius - equalParts;
double innerRadius = radius - equalParts;
double outerRadius = radius - equalParts * parentSeries.SegmentSpacing;
innerRadius = ChartMath.MaxZero(innerRadius);
if (parentSeries.Segments.IndexOf(this) == 0)
{
parentSeries.InnerRadius = innerRadius;
}
this.pathGeometry = GetDoughnutGeometry(center, outerRadius, innerRadius, segmentStartAngle, segmentEndAngle, false);
this.segmentPath.Data = pathGeometry;
//Rendering the back segments.
var seriesStartAngle = parentSeries.DegreeToRadianConverter(parentSeries.StartAngle);
var seriesEndAngle = parentSeries.DegreeToRadianConverter(parentSeries.EndAngle);
var totalArcLength = Math.PI * 2;
var arcLength = seriesEndAngle - seriesStartAngle;
if (Math.Abs(Math.Round(arcLength, 2)) > totalArcLength)
{
arcLength = arcLength % totalArcLength;
}
seriesEndAngle = arcLength + seriesStartAngle;
this.circularPathGeometry = GetDoughnutGeometry(center, outerRadius, innerRadius, seriesStartAngle, seriesEndAngle, true);
this.CircularDoughnutPath.Data = circularPathGeometry;
}
else
{
this.pathGeometry = null;
this.segmentPath.Data = null;
this.circularPathGeometry = null;
this.CircularDoughnutPath.Data = null;
}
}
internal void UpdateMeanSymbol(IChartTransformer cartesianTransformer, bool showMedian)
{
if (showMedian)
{
averagePath.Visibility = Visibility.Visible;
Point averagePoint = cartesianTransformer.TransformToVisible(Center, average);
double sizeRatio = 0.25, CenterX, CenterY;
if (this.Series.IsActualTransposed)
{
//To retain with the path size when the size is increased.
double widthFactor = rect.Height * sizeRatio;
widthFactor = widthFactor > averagePathSize ? averagePathSize : widthFactor;
averagePath.Width = widthFactor;
averagePath.Height = widthFactor;
CenterX = averagePoint.X;
CenterY = (rect.Top + rect.Height / 2);
}
else
{
double widthFactor = rect.Width * sizeRatio;
widthFactor = widthFactor > averagePathSize ? averagePathSize : widthFactor;
averagePath.Width = widthFactor;
averagePath.Height = widthFactor;
CenterX = (rect.X + rect.Width / 2);
CenterY = averagePoint.Y;
}
Canvas.SetLeft(averagePath, CenterX - averagePath.Width / 2);
Canvas.SetTop(averagePath, CenterY - averagePath.Height / 2);
if (!segmentCanvas.Children.Contains(averagePath))
{
segmentCanvas.Children.Add(averagePath);
}
}
else
{
if (segmentCanvas.Children.Contains(averagePath))
{
segmentCanvas.Children.Remove(averagePath);
}
}
}
/// <summary>
/// Updates the panel.
/// </summary>
/// <param name="finalSize"></param>
internal void Update(Size finalSize)
{
bool canUpdate = !(Series is ISupportAxes);
if (Series is ISupportAxes &&
Series.ActualXAxis != null && Series.ActualYAxis != null)
{
canUpdate = true;
if (Series.Area != null)
{
Series.Area.ClearBuffer();
}
}
if (canUpdate)
{
IChartTransformer chartTransformer = Series.CreateTransformer(finalSize, true);
if (Series is CircularSeriesBase)
{
CircularSeriesBase circularSeries = Series as CircularSeriesBase;
Rect rect = ChartLayoutUtils.Subtractthickness(new Rect(new Point(), finalSize), Series.Margin);
chartTransformer = Series.CreateTransformer(new Size(rect.Width, rect.Height), true);
var pieSeries = circularSeries as PieSeries;
double coefficient = pieSeries != null ? pieSeries.InternalPieCoefficient : (circularSeries as DoughnutSeries).InternalDoughnutCoefficient;
double radius = coefficient * Math.Min(chartTransformer.Viewport.Width, chartTransformer.Viewport.Height) / 2;
circularSeries.Center = circularSeries.GetActualCenter(new Point(chartTransformer.Viewport.Width * 0.5d, chartTransformer.Viewport.Height * 0.5d), radius);
}
Series.Pixels.Clear();
Series.bitmapPixels.Clear();
Series.bitmapRects.Clear();
foreach (ChartSegment segment in Series.Segments)
{
segment.Update(chartTransformer);
}
if (Series.CanAnimate && Series.Segments.Count > 0)
{
Series.Animate();
Series.CanAnimate = false;
}
if (Series.IsLoading)
{
Series.IsLoading = false;
}
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastHiloSeries.Area.GetFastRenderSurface();
if (transformer != null && fastHiloSeries.DataCount > 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
xValues.Clear();
yHiValues.Clear();
yLoValues.Clear();
x_isInversed = cartesianTransformer.XAxis.IsInversed;
y_isInversed = cartesianTransformer.YAxis.IsInversed;
//Removed the screen point calculation methods and added the point to value method.
CalculatePoints(cartesianTransformer);
UpdateVisual(true);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
bitmap = fastColumnSeries.Area.GetFastRenderSurface();
if (transformer != null && fastColumnSeries.DataCount != 0)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
x_isInversed = cartesianTransformer.XAxis.IsInversed;
y_isInversed = cartesianTransformer.YAxis.IsInversed;
x1Values.Clear();
x2Values.Clear();
y1Values.Clear();
y2Values.Clear();
actualIndexes.Clear();
//Removed the existing screen point calculation methods and added the TransformVisible method.
CalculatePoints(cartesianTransformer);
UpdateVisual(true);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
PathFigure figure = new PathFigure();
if (AreaPoints.Count > 1)
{
int endIndex = AreaPoints.Count - 1;
WindowsLineSegment lineSegment = new WindowsLineSegment();
figure.StartPoint = transformer.TransformToVisible(AreaPoints[0].X, AreaPoints[0].Y);
lineSegment.Point = transformer.TransformToVisible(AreaPoints[1].X, AreaPoints[1].Y);
figure.Segments.Add(lineSegment);
for (int i = 2; i < AreaPoints.Count - 1; i += 6)
{
BezierSegment segment = new BezierSegment();
segment.Point1 = transformer.TransformToVisible(AreaPoints[i].X, AreaPoints[i].Y);
segment.Point2 = transformer.TransformToVisible(AreaPoints[i + 1].X, AreaPoints[i + 1].Y);
segment.Point3 = transformer.TransformToVisible(AreaPoints[i + 2].X, AreaPoints[i + 2].Y);
figure.Segments.Add(segment);
}
lineSegment = new WindowsLineSegment();
lineSegment.Point = transformer.TransformToVisible(AreaPoints[endIndex].X, AreaPoints[endIndex].Y);
figure.Segments.Add(lineSegment);
for (int i = endIndex - 1; i > 1; i -= 6)
{
BezierSegment segment = new BezierSegment();
segment.Point1 = transformer.TransformToVisible(AreaPoints[i].X, AreaPoints[i].Y);
segment.Point2 = transformer.TransformToVisible(AreaPoints[i - 1].X, AreaPoints[i - 1].Y);
segment.Point3 = transformer.TransformToVisible(AreaPoints[i - 2].X, AreaPoints[i - 2].Y);
figure.Segments.Add(segment);
}
}
PathGeometry segmentGeometry = new PathGeometry();
segmentGeometry.Figures.Add(figure);
this.segPath.Data = segmentGeometry;
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (transformer != null)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic;
double xStart = cartesianTransformer.XAxis.VisibleRange.Start;
double xEnd = cartesianTransformer.XAxis.VisibleRange.End;
double pos = xIsLogarithmic ? Math.Log(xPos, xBase) : xPos;
if (pos >= xStart && pos <= xEnd && (!double.IsNaN(yPos) || Series.ShowEmptyPoints))
{
Point point1 = transformer.TransformToVisible(xPos, yPos);
if (ellipseSegment != null)
{
ellipseSegment.Visibility = Visibility.Visible;
ellipseSegment.Height = ellipseSegment.Width = 2 * this.segmentRadius;
ellipseSegment.SetValue(Canvas.LeftProperty, point1.X - this.segmentRadius);
ellipseSegment.SetValue(Canvas.TopProperty, point1.Y - this.segmentRadius);
}
else
{
control.Visibility = Visibility.Visible;
RectX = point1.X - this.segmentRadius;
RectY = point1.Y - this.segmentRadius;
Size = SegmentRadius = 2 * this.segmentRadius;
}
}
else if (customTemplate == null)
{
ellipseSegment.Visibility = Visibility.Collapsed;
}
else
{
control.Visibility = Visibility.Collapsed;
}
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (!this.Series.IsMultipleYPathRequired)
{
var axisYRange = Series.ActualYAxis.VisibleRange;
var median = (axisYRange.End - Math.Abs(axisYRange.Start)) / 2;
var segmentMiddle = Top / 2;
Top = median + segmentMiddle;
Bottom = median - segmentMiddle;
var index = Series.Segments.IndexOf(this);
YData = (Series as RangeSeriesBase).High == null ? (Series as RangeSeriesBase).LowValues[index] : (Series as RangeSeriesBase).HighValues[index];
}
else
{
High = Top;
Low = Bottom;
}
base.Update(transformer);
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (Length == 0)
{
base.Update(transformer);
}
else
if (transformer != null && fastSeries.DataCount > 1)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic || cartesianTransformer.YAxis.IsLogarithmic;
if (!isLogarithmic)
{
TransformToScreenCo(cartesianTransformer);
}
else
{
TransformToScreenCoInLog(cartesianTransformer);
}
UpdateVisual(true);
}
}
/// <summary>
/// Updates the segments based on its data point value. This method is not
/// intended to be called explicitly outside the Chart but it can be overridden by
/// any derived class.
/// </summary>
/// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>
public override void Update(IChartTransformer transformer)
{
if (transformer != null)
{
ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer;
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic;
double left = xIsLogarithmic ? Math.Log(Left, xBase) : Left;
double right = xIsLogarithmic ? Math.Log(Right, xBase) : Right;
double xStart = Math.Floor(cartesianTransformer.XAxis.VisibleRange.Start);
double xEnd = Math.Ceiling(cartesianTransformer.XAxis.VisibleRange.End);
if (!double.IsNaN(Top) && !double.IsNaN(Bottom) &&
(left <= xEnd && right >= xStart))
{
//Calculate the rect for segment rendering.
rect = CalculateSegmentRect(transformer);
segmentCanvas.Visibility = Visibility.Visible;
if (WaterfallRectSegment != null)
{
WaterfallRectSegment.SetValue(Canvas.LeftProperty, rect.X);
WaterfallRectSegment.SetValue(Canvas.TopProperty, rect.Y);
WaterfallRectSegment.Visibility = Visibility.Visible;
Width = WaterfallRectSegment.Width = rect.Width;
Height = WaterfallRectSegment.Height = rect.Height;
//set position for connector line.
UpdateConnectorLine(transformer);
}
}
else
{
segmentCanvas.Visibility = Visibility.Collapsed;
}
}
}
