internal Point GetAxisLabelPosition(Size desiredSize, Point originalPosition, Size textSize)
{
Point point = originalPosition;
ChartAxis axis = (XAxis.Orientation == Orientation.Vertical) ? XAxis : YAxis;
ChartAxis axis1 = (XAxis.Orientation != Orientation.Vertical) ? XAxis : YAxis;
point.Y -= textSize.Height / 2;
double left = 0;
var chartAxes = Chart.Axes.Where(axes => (axes.Orientation == axis.Orientation)).Where(position => (!position.OpposedPosition));
point.X -= axis1.ActualPlotOffset;
if (axis.OpposedPosition)
{
if (chartAxes.Count() > 0)
{
left = chartAxes.ElementAt(0).RenderedRect.Right;
}
point.X += (axis.RenderedRect.Left - left);
}
else
{
if (chartAxes.Count() > 0)
{
left = chartAxes.ElementAt(0).RenderedRect.Left;
}
point.X -= (textSize.Width + (left - axis.RenderedRect.Left));
}
return(point);
}
/// <summary>
/// Updates the gridlines.
/// </summary>
/// <param name="axis">The Relevant Axis</param>
/// <param name="linesRecycler">The Line Recycler</param>
/// <param name="requiredLinescount">The Required Lines Count</param>
/// <param name="isMajor">Check For Marjor Axis</param>
/// <param name="checkOrginFlag">Check For Origin Flag</param>
private static void UpdateGridlines(ChartAxis axis, UIElementsRecycler <Line> linesRecycler, int requiredLinescount, bool isMajor, bool checkOrginFlag)
{
if (linesRecycler == null || axis == null)
{
return;
}
foreach (var line in linesRecycler)
{
line.ClearValue(FrameworkElement.StyleProperty);
}
int totalLinesCount = requiredLinescount;
if (axis.ShowOrigin && checkOrginFlag)
{
totalLinesCount += 1;
}
if (!linesRecycler.BindingProvider.Keys.Contains(FrameworkElement.StyleProperty))
{
linesRecycler.BindingProvider.Add(FrameworkElement.StyleProperty, GetGridLineBinding(axis, isMajor));
}
if (linesRecycler.Count > 0)
{
foreach (var line in linesRecycler)
{
line.SetBinding(FrameworkElement.StyleProperty, GetGridLineBinding(axis, isMajor));
}
}
linesRecycler.GenerateElements(totalLinesCount);
var rangeStyles = axis.RangeStyles;
if (rangeStyles != null && rangeStyles.Count > 0)
{
var values = !isMajor ? axis.SmallTickPoints :
(from label in axis.VisibleLabels select label.Position).ToList();
for (int i = 0; i < values.Count; i++)
{
foreach (var chartAxisRangeStyle in rangeStyles)
{
var range = chartAxisRangeStyle.Range;
var style = isMajor ? chartAxisRangeStyle.MajorGridLineStyle : chartAxisRangeStyle.MinorGridLineStyle;
if (range.Start <= values[i] && range.End >= values[i] && style != null)
{
linesRecycler[i].SetBinding(FrameworkElement.StyleProperty, GetGridLineBinding(chartAxisRangeStyle, isMajor));
break;
}
}
}
}
//StrokeDashArray applied only for the first line element when it is applied through style.
//It is bug in the framework.
//And hence manually setting stroke dash array for each and every grid line.
ChartExtensionUtils.SetStrokeDashArray(linesRecycler);
}
/// <summary>
/// Adds the Gridlines for the axis.
/// </summary>
/// <param name="axis">The Axis</param>
public void UpdateGridLines(ChartAxis axis)
{
if (axis == null)
{
return;
}
if (axis.GridLinesRecycler == null)
{
axis.CreateLineRecycler();
}
int axesCount = 1;
if (axis.RegisteredSeries.Count > 0)
{
axesCount = axis.Orientation == Orientation.Horizontal
? Area.RowDefinitions.Count > 1 ? axis.AssociatedAxes.Count : (axis.AssociatedAxes.DistinctBy(Area.GetActualRow)).Count()
: Area.ColumnDefinitions.Count > 1 ? axis.AssociatedAxes.Count : (axis.AssociatedAxes.DistinctBy(Area.GetActualColumn)).Count();
}
int tickCount = axis.SmallTickPoints.Count * axesCount;
var categoryAxis = axis as CategoryAxis;
if (!(categoryAxis != null && categoryAxis.LabelPlacement == LabelPlacement.BetweenTicks))
{
tickCount = axis.VisibleLabels.Count * axesCount;
}
if (axis.smallTicksRequired)
{
ChartCartesianGridLinesPanel.UpdateGridlines(axis, axis.MinorGridLinesRecycler, axis.SmallTickPoints.Count * axesCount, false, false);
}
ChartCartesianGridLinesPanel.UpdateGridlines(axis, axis.GridLinesRecycler, tickCount, true, true);
}
/// <summary>
/// Gets the multiple area rectangle of the provided mouse point.
/// Also returns a <see cref="bool"/> value indicating whether the point is inside rect.
/// This bool is used since the <see cref="Rect"/> is value type and the null conditions for the outcoming rect cannot be checked.
/// </summary>
/// <param name="mousePoint">The mouse point.</param>
/// <param name="axis">The axis to be checked.</param>
/// <param name="isPointInsideRect">The property indicates whether the point is inside the axis area rectangle.</param>
/// <returns>Returns the point captured <see cref="Rect"/>.</returns>
internal static Rect GetAxisArrangeRect(Point mousePoint, ChartAxis axis, out bool isPointInsideRect)
{
Rect clipRect = new Rect();
double left = axis.ArrangeRect.Left;
double top = axis.ArrangeRect.Top;
foreach (var supportAxis in axis.AssociatedAxes)
{
if (axis.Orientation == Orientation.Horizontal)
{
top = supportAxis.ArrangeRect.Top;
clipRect = new Rect(left, top, axis.ArrangeRect.Width, supportAxis.ArrangeRect.Height);
}
else
{
left = supportAxis.ArrangeRect.Left;
clipRect = new Rect(left, top, supportAxis.ArrangeRect.Width, axis.ArrangeRect.Height);
}
if (clipRect.Contains(mousePoint))
{
isPointInsideRect = true;
return(clipRect);
}
}
isPointInsideRect = false;
return(clipRect);
}
private ChartData getDefaultData(string hTitle, List <DataTable> lstDataTable)
{
ChartData chartdata = new ChartData();
chartdata.IsBkColor_jb = true;
chartdata.sc_bkColor = Color.Red;
ChartTitle title = new Title();
title.title = "";
title.titleFont.size = 12;
title.titleFont.clr = Color.Red;
title.pos = new ChartPoint(40, 96);
chartdata.title = title;
ChartAxis hA = GetHorizChartAxis(hTitle);
chartdata.axislst.Add(hA);
ChartAxis vA = GetVerticalChartAxis(GetTitle1());
chartdata.axislst.Add(vA);
for (int i = 0; i < lstDataTable.Count; i++)
{
Color clrSeries = i == 0 ? Color.Red : Color.Green;
DataTable dt = lstDataTable[i];
ChartSeries sr = GetChartSeries(dt, hA, vA, clrSeries);
chartdata.serieslst.Add(sr);
}
return(chartdata);
}
/// <summary>
/// Sets up the chart axes.
/// </summary>
/// <param name="chartXy"></param>
private void SetupChartAxes(ChartXy chartXy)
{
// X Axis
ChartAxis axis = chartXy.AxisX;
axis.MinorTickmarks.TickmarkCount = 0;
axis.AxisMargins = 0;
axis.GridSpacing = 60;
axis.MajorGridLines.GridLinesVisualStyle.LineColor = Color.Gainsboro;
axis.MinorGridLines.GridLinesVisualStyle.LineColor = Color.WhiteSmoke;
// Y Axis
axis = chartXy.AxisY;
axis.AxisAlignment = AxisAlignment.Far;
//axis.MinorTickmarks.TickmarkCount = 0;
//axis.GridSpacing = 50;
axis.MajorGridLines.GridLinesVisualStyle.LineColor = Color.Gainsboro;
axis.MinorGridLines.GridLinesVisualStyle.LineColor = Color.WhiteSmoke;
// Display the alternate background.
axis.ChartAxisVisualStyle.AlternateBackground = new Background(Color.FromArgb(250, 250, 250));
axis.UseAlternateBackground = true;
}
/// <summary>
/// Called when [minimum maximum changed].
/// </summary>
/// <param name="axis">The axis.</param>
/// <param name="maximum">The maximum.</param>
/// <param name="minimum">The minimum.</param>
internal static void OnMinMaxChanged(ChartAxis axis, object maximum, object minimum)
{
try
{
if (minimum != null || maximum != null)
{
#if NETFX_CORE
double minimumValue = minimum == null ? double.NegativeInfinity : Convert.ToDouble(minimum);
double maximumValue = maximum == null ? double.PositiveInfinity : Convert.ToDouble(maximum);
axis.ActualRange = new DoubleRange(minimumValue, maximumValue);
#else
double minimumValue = minimum == null ? double.NegativeInfinity : ((double?)minimum).Value;
double maximumValue = maximum == null ? double.PositiveInfinity : ((double?)maximum).Value;
axis.ActualRange = new DoubleRange(minimumValue, maximumValue);
#endif
}
else
{
axis.ActualRange = DoubleRange.Empty;
}
if (axis.Area != null)
{
axis.Area.ScheduleUpdate();
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
private ChartSeries GetChartSeries(DataTable dtTable, ChartAxis hA, ChartAxis vA, Color clrSeries)
{
ChartSeries sr = new Series();
sr.VLineColor = Color.Black;
sr.HLineColor = Color.Black;
sr.horAxis = hA;
sr.verAxis = vA;
sr.Movable_SP = true;
sr.isShowNet = true;
sr.VKDSpac = 1;
sr.seriesType = SeriesType.ST_LINE;
sr.pointStyle = PointStyle.PS_STAR;
sr.isMarkOn = false;
sr.lineWidth = 1;
sr.pointSize = 3;
sr.clr = clrSeries;
vA.serieslst.Add(sr);
hA.serieslst.Add(sr);
sr.pointlst = GetLstSeriesPoint(dtTable);
sr.cx_spec = 2;
return(sr);
}
public static string xkcd()
{
float[] data = new float[] { 35, 30, 26, 22, 17, 5, 96, 5, 4, 3, 2, 2, 1, 1 };
string[] axisLabels = new string[] { ".00", ".02", ".04", ".06", ".08", ".10",
".12", ".14", ".16", ".18", ".20", ".22",
".24", ".26" };
ChartAxis bottomAxis = new ChartAxis(ChartAxisType.Bottom);
bottomAxis.SetRange(0, 30);
for (int i = 0; i < axisLabels.Length; i++)
{
bottomAxis.AddLabel(new ChartAxisLabel(axisLabels[i], i * 2));
}
ChartAxis bottomAxis2 = new ChartAxis(ChartAxisType.Bottom);
bottomAxis2.AddLabel(new ChartAxisLabel("Blood Alcohol Concentration (%)", 50));
LineChart lineChart = new LineChart(400, 200);
lineChart.SetTitle("Programming Skill", "000000", 14);
lineChart.SetData(data);
lineChart.AddAxis(bottomAxis);
lineChart.AddAxis(bottomAxis2);
return(lineChart.GetUrl());
}
internal Point GetAxisLabelPosition(Size desiredSize, Point originalPosition, Size textSize)
{
Point point = originalPosition;
ChartAxis axis = (XAxis.Orientation == Orientation.Horizontal) ? XAxis : YAxis;
ChartAxis axis1 = (XAxis.Orientation != Orientation.Horizontal) ? XAxis : YAxis;
point.X += (desiredSize.Width / 2);
point.X -= (textSize.Width / 2);
point.Y = axis.OpposedPosition ? point.Y : 0;
var chartAxes = Chart.Axes.Where(axes => (axes.Orientation == axis.Orientation))
.Where(position => (position.OpposedPosition));
double bottom = (chartAxes.Count() > 0) ? chartAxes.ElementAt(0).RenderedRect.Bottom : 0;
if (axis.OpposedPosition)
{
point.Y -= (textSize.Height);
if (Chart.Axes.IndexOf(axis) != 0)
{
point.Y -= (bottom - axis.RenderedRect.Bottom);
}
point.Y -= axis1.ActualPlotOffset;
}
else
{
point.Y += (axis.RenderedRect.Top - bottom);
}
return(point);
}
public void ChartAxisDisplayUnit()
{
//ExStart
//ExFor:AxisBuiltInUnit
//ExFor:ChartAxis.DisplayUnit
//ExFor:ChartAxis.MajorUnitIsAuto
//ExFor:ChartAxis.MajorUnitScale
//ExFor:ChartAxis.MinorUnitIsAuto
//ExFor:ChartAxis.MinorUnitScale
//ExFor:ChartAxis.TickLabelSpacing
//ExFor:ChartAxis.TickLabelAlignment
//ExFor:AxisDisplayUnit
//ExFor:AxisDisplayUnit.CustomUnit
//ExFor:AxisDisplayUnit.Unit
//ExSummary:Shows how to manipulate the tick marks and displayed values of a chart axis.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Insert a scatter chart, which is populated by default values
Shape shape = builder.InsertChart(ChartType.Scatter, 450, 250);
Chart chart = shape.Chart;
// Set they Y axis to show major ticks every at every 10 units and minor ticks at every 1 units
ChartAxis axis = chart.AxisY;
axis.MajorTickMark = AxisTickMark.Outside;
axis.MinorTickMark = AxisTickMark.Outside;
axis.MajorUnit = 10.0;
axis.MinorUnit = 1.0;
// Stretch out the bounds of the axis out to show 3 major ticks and 27 minor ticks
axis.Scaling.Minimum = new AxisBound(-10);
axis.Scaling.Maximum = new AxisBound(20);
// Do the same for the X-axis
axis = chart.AxisX;
axis.MajorTickMark = AxisTickMark.Inside;
axis.MinorTickMark = AxisTickMark.Inside;
axis.MajorUnit = 10.0;
axis.Scaling.Minimum = new AxisBound(-10);
axis.Scaling.Maximum = new AxisBound(30);
// We can also use this attribute to set minor tick spacing
axis.TickLabelSpacing = 2;
// We can define text alignment when axis tick labels are multi-line
// MS Word aligns them to the center by default
axis.TickLabelAlignment = ParagraphAlignment.Right;
// Get the axis to display values, but in millions
axis.DisplayUnit.Unit = AxisBuiltInUnit.Millions;
// Besides the built-in axis units we can choose from,
// we can also set the axis to display values in some custom denomination, using the following attribute
// The statement below is equivalent to the one above
axis.DisplayUnit.CustomUnit = 1000000.0;
doc.Save(ArtifactsDir + "Charts.ChartAxisDisplayUnit.docx");
//ExEnd
}
public void DateTimeValuesToAxis()
{
//ExStart:SetDateTimeValuesToAxis
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
Shape shape = builder.InsertChart(ChartType.Column, 432, 252);
Chart chart = shape.Chart;
chart.Series.Clear();
chart.Series.Add("Aspose Series 1",
new[]
{
new DateTime(2017, 11, 06), new DateTime(2017, 11, 09), new DateTime(2017, 11, 15),
new DateTime(2017, 11, 21), new DateTime(2017, 11, 25), new DateTime(2017, 11, 29)
},
new double[] { 1.2, 0.3, 2.1, 2.9, 4.2, 5.3 });
ChartAxis xAxis = chart.AxisX;
xAxis.Scaling.Minimum = new AxisBound(new DateTime(2017, 11, 05).ToOADate());
xAxis.Scaling.Maximum = new AxisBound(new DateTime(2017, 12, 03).ToOADate());
// Set major units to a week and minor units to a day.
xAxis.MajorUnit = 7;
xAxis.MinorUnit = 1;
xAxis.MajorTickMark = AxisTickMark.Cross;
xAxis.MinorTickMark = AxisTickMark.Outside;
doc.Save(ArtifactsDir + "WorkingWithCharts.DateTimeValuesToAxis.docx");
//ExEnd:SetDateTimeValuesToAxis
}
public static string axesLabelsTest()
{
int[] line1 = new int[] { 5, 10, 50, 34, 10, 25 };
int[] line2 = new int[] { 15, 20, 60, 44, 20, 35 };
List <int[]> dataset = new List <int[]>();
dataset.Add(line1);
dataset.Add(line2);
LineChart lineChart = new LineChart(250, 150);
lineChart.SetTitle("Axis Labels Test", "0000FF", 14);
lineChart.SetData(dataset);
lineChart.AddAxis(new ChartAxis(ChartAxisType.Bottom, new string[] { "b", "o", "t", "t", "o", "m" }));
lineChart.AddAxis(new ChartAxis(ChartAxisType.Left, new string[] { "l", "e", "f", "t" }));
ChartAxis rightAxis = new ChartAxis(ChartAxisType.Right);
rightAxis.AddLabel(new ChartAxisLabel("r"));
rightAxis.AddLabel(new ChartAxisLabel("i"));
rightAxis.AddLabel(new ChartAxisLabel("g"));
rightAxis.AddLabel(new ChartAxisLabel("h"));
rightAxis.AddLabel(new ChartAxisLabel("t"));
lineChart.AddAxis(rightAxis);
ChartAxis topAxis = new ChartAxis(ChartAxisType.Top);
topAxis.AddLabel(new ChartAxisLabel("t"));
topAxis.AddLabel(new ChartAxisLabel("o"));
topAxis.AddLabel(new ChartAxisLabel("p"));
lineChart.AddAxis(topAxis);
return(lineChart.GetUrl());
}
public void AxisCross()
{
//ExStart
//ExFor:Charts.ChartAxis.AxisBetweenCategories
//ExFor:Charts.ChartAxis.CrossesAt
//ExSummary:Shows how to get a graph axis to cross at a custom location.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Insert a column chart, which is populated by default values
Shape shape = builder.InsertChart(ChartType.Column, 450, 250);
Chart chart = shape.Chart;
// Get the Y-axis to cross at a value of 3.0, making 3.0 the new Y-zero of our column chart
// This effectively means that all the columns with Y-values about 3.0 will be above the Y-centre and point up,
// while ones below 3.0 will point down
ChartAxis axis = chart.AxisX;
axis.AxisBetweenCategories = true;
axis.Crosses = AxisCrosses.Custom;
axis.CrossesAt = 3.0;
doc.Save(ArtifactsDir + "Charts.AxisCross.docx");
//ExEnd
}
/// <summary>
/// To calculate the cartesian arrange rect based on StartAngle property
/// </summary>
/// <param name="center">The Center Point</param>
/// <param name="axis">The Axis</param>
private void CalculateCartesianArrangeRect(Point center, ChartAxis axis)
{
double left;
double top;
switch (CartesianAxis.PolarAngle)
{
case ChartPolarAngle.Rotate270:
{
left = axis.OpposedPosition ? center.X :
center.X - this.CartesianAxis.ComputedDesiredSize.Width;
CartesianAxis.ArrangeRect = new Rect(left,
center.Y - radius,
this.CartesianAxis.ComputedDesiredSize.Width, radius);
}
break;
case ChartPolarAngle.Rotate0:
{
top = axis.OpposedPosition ?
center.Y - this.CartesianAxis.ComputedDesiredSize.Height : center.Y;
CartesianAxis.ArrangeRect = new Rect(center.X, top, radius,
this.CartesianAxis.ComputedDesiredSize.Height);
}
break;
case ChartPolarAngle.Rotate90:
{
left = axis.OpposedPosition ? center.X :
center.X - this.CartesianAxis.ComputedDesiredSize.Width;
CartesianAxis.ArrangeRect = new Rect(
left,
center.Y,
this.CartesianAxis.DesiredSize.Width, radius);
}
break;
case ChartPolarAngle.Rotate180:
{
top = axis.OpposedPosition ?
center.Y - this.CartesianAxis.ComputedDesiredSize.Height : center.Y;
CartesianAxis.ArrangeRect = new Rect(center.X - radius,
top, radius,
this.CartesianAxis.ComputedDesiredSize.Height);
}
break;
default:
break;
}
}
internal static object GetLabelContent(ChartAxis axis, int pos, ChartSeriesBase actualSeries)
{
var isIndexed = (actualSeries is WaterfallSeries || actualSeries is HistogramSeries ||
actualSeries is ErrorBarSeries || actualSeries is PolarRadarSeriesBase) ?
true : (axis as CategoryAxis).IsIndexed;
if (actualSeries != null)
{
IEnumerable pointValues;
ChartValueType valueType;
pointValues = actualSeries.ActualXValues;
valueType = actualSeries.XAxisValueType;
var values = pointValues as List <double>;
if (values != null && pos < values.Count && pos >= 0)
{
switch (valueType)
{
case ChartValueType.DateTime:
{
DateTime xDateTime = values[pos].FromOADate();
return(xDateTime.ToString(axis.LabelFormat, CultureInfo.CurrentCulture));
}
case ChartValueType.TimeSpan:
{
TimeSpan xTimeSpanValue = TimeSpan.FromMilliseconds(values[pos]);
return(xTimeSpanValue.ToString(axis.LabelFormat, CultureInfo.CurrentCulture));
}
case ChartValueType.Double:
case ChartValueType.Logarithmic:
{
return(values[pos].ToString(axis.LabelFormat, CultureInfo.CurrentCulture));
}
}
}
else
{
List <string> StrValues = new List <string>();
StrValues = !isIndexed
? actualSeries.GroupedXValues
: pointValues as List <string>;
if (StrValues != null && pos < StrValues.Count && pos >= 0)
{
if (!String.IsNullOrEmpty(axis.LabelFormat))
{
return(String.Format(axis.LabelFormat, StrValues[pos]));
}
return(StrValues[pos]);
}
}
}
return(pos);
}
/// <summary>
/// Adds the elements inside the panel.
/// </summary>
public void UpdateElements()
{
List <UIElement> removedElements = new List <UIElement>();
if (Children == null)
{
return;
}
foreach (UIElement element in Children)
{
ChartAxis chartAxis = element as ChartAxis;
if (chartAxis != null &&
!Area.Axes.Contains(chartAxis))
{
if (chartAxis.GridLinesRecycler != null)
{
chartAxis.GridLinesRecycler.Clear();
}
if (chartAxis.MinorGridLinesRecycler != null)
{
chartAxis.MinorGridLinesRecycler.Clear();
}
removedElements.Add(chartAxis);
}
}
foreach (UIElement removedElement in removedElements)
{
panel.Children.Remove(removedElement);
}
removedElements.Clear();
var children = Children;
foreach (ChartAxis content in this.Area.Axes)
{
content.AxisLayoutPanel = null;
if (!children.Contains(content))
{
panel.Children.Add(content);
}
//To make the initialized depth axis as manhattan depth axis.
var chartAxisBase3D = content as ChartAxisBase3D;
if (chartAxisBase3D != null)
{
if (ChartCartesianAxisLayoutPanel.IsDeclaredSeriesManhattan(content.Area.VisibleSeries, chartAxisBase3D))
{
chartAxisBase3D.IsManhattanAxis = true;
}
else
{
chartAxisBase3D.IsManhattanAxis = false;
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ChartPolarTransformer"/> class.
/// </summary>
/// <param name="viewport">The viewport.</param>
/// <param name="xAxis">The x axis.</param>
/// <param name="yAxis">The y axis.</param>
public ChartPolarTransformer(Rect viewport, ChartAxis xAxis, ChartAxis yAxis)
{
m_viewport = viewport;
m_xAxis = xAxis;
m_yAxis = yAxis;
m_center = ChartLayoutUtils.GetCenter(m_viewport);
m_radius = 0.5 * Math.Min(m_viewport.Width, m_viewport.Height);
}
public void InsertChartWithDateTimeValues()
{
//ExStart
//ExFor:AxisBound
//ExFor:AxisBound.#ctor(Double)
//ExFor:AxisBound.#ctor(DateTime)
//ExFor:AxisScaling.Minimum
//ExFor:AxisScaling.Maximum
//ExFor:ChartAxis.Scaling
//ExFor:Charts.AxisTickMark
//ExFor:Charts.AxisTickLabelPosition
//ExFor:Charts.AxisTimeUnit
//ExFor:Charts.ChartAxis.BaseTimeUnit
//ExSummary:Shows how to insert chart with date/time values
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Insert chart.
Shape shape = builder.InsertChart(ChartType.Line, 432, 252);
Chart chart = shape.Chart;
// Clear demo data.
chart.Series.Clear();
// Fill data.
chart.Series.Add("Aspose Test Series",
new[]
{
new DateTime(2017, 11, 06), new DateTime(2017, 11, 09), new DateTime(2017, 11, 15),
new DateTime(2017, 11, 21), new DateTime(2017, 11, 25), new DateTime(2017, 11, 29)
},
new[] { 1.2, 0.3, 2.1, 2.9, 4.2, 5.3 });
ChartAxis xAxis = chart.AxisX;
ChartAxis yAxis = chart.AxisY;
// Set X axis bounds.
xAxis.Scaling.Minimum = new AxisBound(new DateTime(2017, 11, 05).ToOADate());
xAxis.Scaling.Maximum = new AxisBound(new DateTime(2017, 12, 03));
// Set major units to a week and minor units to a day.
xAxis.BaseTimeUnit = AxisTimeUnit.Days;
xAxis.MajorUnit = 7;
xAxis.MinorUnit = 1;
xAxis.MajorTickMark = AxisTickMark.Cross;
xAxis.MinorTickMark = AxisTickMark.Outside;
// Define Y axis properties.
yAxis.TickLabelPosition = AxisTickLabelPosition.High;
yAxis.MajorUnit = 100;
yAxis.MinorUnit = 50;
yAxis.DisplayUnit.Unit = AxisBuiltInUnit.Hundreds;
yAxis.Scaling.Minimum = new AxisBound(100);
yAxis.Scaling.Maximum = new AxisBound(700);
doc.Save(ArtifactsDir + "Charts.ChartAxisProperties.docx");
//ExEnd
}
private static void OnSmallTicksPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ChartAxis axis = d as ChartAxis;
if (axis != null && axis.Area != null)
{
axis.Area.ScheduleUpdate();
}
}
internal static void GenerateVisibleLabels(ChartAxis axis, LabelPlacement labelPlacement)
{
{
var actualSeries =
axis.Area.VisibleSeries
.Where(series => series.ActualXAxis == axis)
.Max(filteredSeries => filteredSeries.DataCount);
actualSeries = actualSeries != null ? actualSeries : axis.Area is SfChart ? (axis.Area as SfChart).TechnicalIndicators.Where(series => series.ActualXAxis == axis)
.Max(filteredSeries => filteredSeries.DataCount) : null;
if (actualSeries == null)
{
return;
}
var visibleRange = axis.VisibleRange;
double actualInterval = axis.ActualInterval;
double interval = axis.VisibleInterval;
double position = visibleRange.Start - (visibleRange.Start % actualInterval);
int count = 0;
var isPolarRadarSeries = actualSeries is PolarRadarSeriesBase;
var isIndexed = (actualSeries is WaterfallSeries || actualSeries is HistogramSeries ||
actualSeries is ErrorBarSeries || isPolarRadarSeries) ?
true : (axis as CategoryAxis).IsIndexed;
count = isIndexed ? actualSeries.DataCount : actualSeries.DistinctValuesIndexes.Count;
for (; position <= visibleRange.End; position += interval)
{
int pos = ((int)Math.Round(position));
if (visibleRange.Inside(pos) && pos < count && pos > -1)
{
object obj = null;
obj = GetLabelContent(axis, pos, actualSeries);
axis.VisibleLabels.Add(new ChartAxisLabel(pos, obj, pos));
}
}
position = visibleRange.Start - (visibleRange.Start % actualInterval);
if (isPolarRadarSeries)
{
return;
}
for (; position <= visibleRange.End; position += 1)
{
if (labelPlacement != LabelPlacement.BetweenTicks)
{
continue;
}
if (position == 0 && (axis.VisibleRange.Inside(-0.5)))
{
axis.m_smalltickPoints.Add(-0.5);
}
AddBetweenTicks(axis, position, 1d);
}
}
}
/// <summary>
/// Method declaration for UpdateElements
/// </summary>
public void UpdateElements()
{
if (this.Area != null && this.Area.InternalPrimaryAxis != null)
{
List <UIElement> removedElements = new List <UIElement>();
if (Children == null)
{
return;
}
PolarAxis = this.Area.InternalPrimaryAxis as ChartAxisBase2D;
PolarAxis.AxisLayoutPanel = this;
var angle = (this.Area.InternalSecondaryAxis as ChartAxisBase2D).PolarAngle;
if ((angle == ChartPolarAngle.Rotate0) || (angle == ChartPolarAngle.Rotate180)) // Based on StartAngle the oriention
{ //of secondary axis has changed
this.Area.InternalSecondaryAxis.Orientation = Orientation.Horizontal;
var numericalAxis = this.Area.InternalSecondaryAxis as NumericalAxis;
if (numericalAxis != null)
{
numericalAxis.RangePadding = NumericalPadding.Round;
}
}
else
{
this.Area.InternalSecondaryAxis.Orientation = Orientation.Vertical;
}
if (Children.Count > 0 && (angle == ChartPolarAngle.Rotate90 || angle == ChartPolarAngle.Rotate180))
{
this.Area.InternalSecondaryAxis.IsInversed = !this.Area.InternalSecondaryAxis.IsInversed;
}
CartesianAxis = this.Area.InternalSecondaryAxis as ChartAxisBase2D;
foreach (UIElement element in Children)
{
ChartAxis chartAxis = element as ChartAxis;
if (chartAxis != null && !Area.Axes.Contains(chartAxis))
{
removedElements.Add(chartAxis);
}
}
foreach (UIElement removedElement in removedElements)
{
panel.Children.Remove(removedElement);
}
removedElements.Clear();
removedElements = null;
var children = Children;
foreach (ChartAxis content in this.Area.Axes)
{
if (!children.Contains(content))
{
panel.Children.Add(content);
}
}
}
}
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
area = parameter as ChartArea;
double zoomingFactor = (double)values[0];
double zoomingPosition = (double)values[1];
this.axis = (ChartAxis)values[2];
return(axis.VisibleRange.End);
}
internal void DrawScaleBreakLines(ChartAxis axis)
{
if (Area == null || Area.AreaType != ChartAreaType.CartesianAxes)
{
ClearBreakElements();
return;
}
ChartAxisScaleBreak.DrawPath(this);
}
public ActionResult SearchChart(SearchRequest sr)
{
ChartAxis ca = new ChartAxis();
ca.flow = BusinessLogics.SearchFlow(sr.From, sr.To);
ca.press = BusinessLogics.SearchPressure(sr.From, sr.To);
ca.time = BusinessLogics.SearchTime(sr.From, sr.To);
ca.temp = BusinessLogics.SearchTemp(sr.From, sr.To);
return(Json(ca, JsonRequestBehavior.AllowGet));
}
public static string simpleAxis()
{
ChartAxis bottomAxis = new ChartAxis(ChartAxisType.Bottom);
int[] line1 = new int[] { 5, 10, 50, 34, 10, 25 };
LineChart lineChart = new LineChart(150, 150);
lineChart.AddAxis(bottomAxis);
lineChart.SetData(line1);
return(lineChart.GetUrl());
}
/// <summary>
/// Sets up the chart axes.
/// </summary>
/// <param name="chartXy"></param>
private void SetupChartAxes(ChartXy chartXy)
{
// X Axis
ChartAxis axis = chartXy.AxisX;
// axis.AxisMargins = 75;
axis.MajorTickmarks.StaggerLabels = false;
axis.MinorTickmarks.TickmarkCount = 1;
axis.MinorGridLines.Visible = false;
axis.MajorGridLines.GridLinesVisualStyle.LineColor = Color.PowderBlue;
// Let's add a title associated with the axis.
axis.Title.Text = "Process ID";
ChartTitleVisualStyle tstyle = axis.Title.ChartTitleVisualStyle;
tstyle.Font = new Font("Georgia", 11);
tstyle.TextColor = Color.Navy;
tstyle.Padding = new DevComponents.DotNetBar.Charts.Style.Padding(0, 6, 0, 0);
tstyle.Alignment = Alignment.MiddleCenter;
axis.MajorTickmarks.LabelVisualStyle.TextFormat = "ID##;\"\";";
// Y Axis
axis = chartXy.AxisY;
axis.AxisAlignment = AxisAlignment.Far;
axis.GridSpacing = 1;
//axis.AxisMargins = 100;
axis.MinorTickmarks.TickmarkCount = 1;
axis.MinorGridLines.Visible = false;
axis.MajorGridLines.GridLinesVisualStyle.LineColor = Color.PowderBlue;
// Let's add a title associated with the axis.
axis.Title.Text = "Memory Usage (KB)";
tstyle = axis.Title.ChartTitleVisualStyle;
tstyle.Font = new Font("Georgia", 11);
axis.MajorTickmarks.LabelVisualStyle.TextFormat = "##;\"\";";
tstyle.TextColor = Color.Navy;
tstyle.Padding = new DevComponents.DotNetBar.Charts.Style.Padding(8, 0, 8, 0);
tstyle.Alignment = Alignment.MiddleCenter;
}
internal static ClientChartAxis CreateChartAxis(this ChartAxis a)
{
var ca = new ClientChartAxis();
ca.Format = a.Format;
if (ca.Format == ChartAxisFormat.Continuous)
{
ca.Min = a.Min;
ca.Max = a.Max;
}
return(ca);
}
protected override void OnXAxisChanged(ChartAxis oldAxis, ChartAxis newAxis)
{
base.OnXAxisChanged(oldAxis, newAxis);
if (newAxis is DateTimeAxis)
{
newAxis.ActualRangeChanged += ErrorBarSeries_ActualRangeChanged;
}
if (oldAxis is DateTimeAxis)
{
oldAxis.ActualRangeChanged -= ErrorBarSeries_ActualRangeChanged;
}
}
/// <summary>
/// Calculates actual interval
/// </summary>
/// <param name="axis"></param>
/// <param name="range"></param>
/// <param name="availableSize"></param>
/// <param name="interval"></param>
/// <returns></returns>
internal static double CalculateActualInterval(ChartAxis axis, DoubleRange range, Size availableSize, object interval)
{
if (interval == null)
{
return(Math.Max(1d, Math.Floor(range.Delta / axis.GetActualDesiredIntervalsCount(availableSize))));
}
#if NETFX_CORE
return(Convert.ToDouble(interval));
#else
return(((double?)interval).Value);
#endif
}
public ActionResult Index(string team)
{
var burndownColor = Color.SteelBlue;
var velocityColor = Color.YellowGreen;
var scopeColor = Color.Orange;
var configuration = GetConfiguration(team);
var burndown = GetBurndownData(configuration.Project, configuration.Label, configuration.HistoricalDataPath);
var encoding = new GoogleExtendedEncoding();
var burnChart = new BurndownChart(burndown, encoding) {
StartDate = burndown.Min(item => item.Date),
EndDate = configuration.EndDate ?? burndown.Max(item => item.Date),
VelocityMax = 25
};
var yAxis = new ChartAxis(Axis.Y, new Tuple<int, int>(0, burnChart.ChartMax), new string[0], new int[0]);
var xAxis = new ChartAxis(Axis.X, new Tuple<int, int>(0, 1), new[]{ burnChart.StartDate.ToShortDateString(), burnChart.EndDate.ToShortDateString() }, new[]{0, 1});
var velocityAxis = new ChartAxis(Axis.Right, new Tuple<int, int>(0, burnChart.VelocityMax), new []{ "0", "5", "10", "15", "20", "Velocity" }, new []{ 0, 5, 10, 15, 20, 25 });
var burnLine = burnChart.CreateBurnLine(Color.FromArgb(128, Color.Firebrick));
var velocity = burnChart.CreateVelocitySeries(velocityColor);
var velocityMean = burnChart.CreateVelocityMeanSeries(Color.FromArgb(128, velocityColor));
var scope = burnChart.CreateScopeSeries(scopeColor);
var pointsRemaining = burnChart.CreatePointsRemainingSeries(burndownColor);
var chart = new Chart(
string.Format("{0}: {1} points remaining. Velocity {2}. {3}",
configuration.Title,
burndown.PointsRemaining,
burnChart.MeanVelocity,
EstimateRemainingDisplay(burndown, burnChart.MeanVelocity)), 800, 300,
new []{ xAxis, yAxis, velocityAxis },
new [] {
pointsRemaining,
velocity,
scope,
burnLine,
velocityMean
}.SelectMany(x => new [] { x.X, x.Y }),
new []{
ChartMarker.NewCircle(burndownColor, 0, MarkerPoints.All, 8),
ChartMarker.NewCircle(Color.White, 0, MarkerPoints.All, 4)
},
ChartMode.XYLine, encoding, new[]{ pointsRemaining.Style, velocity.Style, scope.Style, burnLine.Style, velocityMean.Style});
return View(new ChartView { Name = configuration.Title, DisplayMarkup = "<img src='" + chart.ToString() + "'/>" });
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
LicenseManager.Key = License.Key;
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// get chart from view
chart = FindViewById<FlexChart>(Resource.Id.flexchart);
// set title/footer
chart.Header = "FlexChart Sales";
chart.Footer = "GrapeCity Xuni";
chart.Legend.BorderWidth = 1;
chart.Legend.BorderColor = System.Drawing.Color.Gray.ToArgb();
// set palette
chart.SetPalette(Palettes.Modern);
// bind X axis to display category names
chart.BindingX = "Date";
// create series with binding
ChartSeries sales = new ChartSeries(chart, "Sales", "Sales"); // new Series(chart, legend name, binding property)
ChartSeries expenses = new ChartSeries(chart, "Expenses", "Expenses");
ChartSeries downloads = new ChartSeries(chart, "Downloads", "Downloads");
downloads.ChartType = ChartType.Line;
chart.Series.Add(sales);
chart.Series.Add(expenses);
chart.Series.Add(downloads);
// set data source
chart.ItemsSource = SalesData.GetSalesDataList();
// configure default axes
chart.AxisX.LabelAngle = 45;
chart.AxisX.Format = "d";
chart.AxisY.Format = "c0";
chart.AxisY.Title = "Dollars";
// add second Y axis
ChartAxis y2 = new ChartAxis(chart, ChartPositionType.Right);
y2.Name = "y2";
y2.Format = "n0";
y2.MajorGridVisible = false;
y2.MinorGridVisible = false;
y2.LabelsVisible = true;
y2.Title = "Downloads";
chart.Axes.Add(y2);
downloads.AxisY = "y2";
// customize tooltip
chart.Tooltip.Content = new MyTooltip(chart, chart.Context);
// customize plot element
chart.PlotElementLoading += chart_PlotElementLoading;
// configure animation
chart.LoadAnimation.AnimationMode = AnimationMode.Point;
}
