/// <summary>
/// Modifies the source data before passing it to the target for display in the UI.
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="language"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, string language)
{
ChartAdornment adornment = value as ChartAdornment;
if (adornment == null)
{
return(value);
}
ChartSeriesBase series = adornment.Series;
ChartBase area = series.ActualArea;
var selectableSegment = series as ISegmentSelectable;
if (area.SelectedSeriesCollection.Contains(series) &&
area.GetSeriesSelectionBrush(series) != null && series is ChartSeries &&
series.adornmentInfo.HighlightOnSelection && area.GetEnableSeriesSelection())
{
return(area.GetSeriesSelectionBrush(series));
}
else if (series.SelectedSegmentsIndexes.Contains(series.ActualData.IndexOf(adornment.Item)) &&
selectableSegment != null && series.adornmentInfo.HighlightOnSelection &&
selectableSegment.SegmentSelectionBrush != null)
{
return(selectableSegment.SegmentSelectionBrush);
}
else
{
return(adornment.BorderBrush);
}
}
internal int GetDoughnutSeriesIndex(ChartSeriesBase currentSeries)
{
int index = 0;
var doughnutSeries = (from series in parentSeries.Area.VisibleSeries where series is DoughnutSeries select series).ToList();//Exception is thrown when we get the index of the segment in custom doughnut series-WPF-18315
return((index = doughnutSeries.IndexOf(currentSeries)) >= 0 ? index : -1);
}
internal int GetPieSeriesIndex(ChartSeriesBase currentSeries)
{
int index = 0;
var pieSeries = (from series in parentSeries.Area.VisibleSeries where series is PieSeries select series).ToList();
return((index = pieSeries.IndexOf(currentSeries)) >= 0 ? index : -1);
}
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>
/// Called when instance created for TechnicalIndicatorSegment
/// </summary>
/// <param name="xVals"></param>
/// <param name="yVals"></param>
/// <param name="stroke"></param>
/// <param name="series"></param>
/// <param name="length"></param>
public TechnicalIndicatorSegment(List <double> xVals, List <double> yVals, Brush stroke, ChartSeriesBase series, int length)
{
Series = series;
if (Series is FinancialTechnicalIndicator)
{
base.customTemplate = (Series as FinancialTechnicalIndicator).CustomTemplate;
}
}
public FastBarBitmapSegment(ChartSeriesBase series)
{
x1Values = new List <float>();
x2Values = new List <float>();
y1Values = new List <float>();
y2Values = new List <float>();
fastBarSeries = series as ChartSeries;
}
internal static Brush GetInterior(ChartSeriesBase series, int segmentIndex)
{
ChartSeriesBase serObj = series;
if (serObj != null)
{
if (serObj.Interior != null)
{
return(serObj.Interior);
}
else if (serObj.SegmentColorPath != null && serObj.ColorValues.Count > 0)
{
if (segmentIndex != -1 && segmentIndex < serObj.ActualData.Count)
{
if (!(serObj.ColorValues[segmentIndex] == null))
{
return(serObj.ColorValues[segmentIndex]);
}
else if (serObj.Palette != ChartColorPalette.None && (serObj.ColorValues[segmentIndex] == null))
{
serObj.ColorValues[segmentIndex] = serObj.ColorModel.GetBrush(segmentIndex);
return(serObj.ColorModel.GetBrush(segmentIndex));
}
else
{
int serIndex = serObj.ActualArea.GetSeriesIndex(serObj);
serObj.ColorValues[segmentIndex] = serObj.ActualArea.ColorModel.GetBrush(serIndex);
return(serObj.ActualArea.ColorModel.GetBrush(serIndex));
}
}
}
else if (serObj.Palette != ChartColorPalette.None)
{
if (segmentIndex != -1 && serObj.ColorModel != null)
{
return(serObj.ColorModel.GetBrush(segmentIndex));
}
}
else if (serObj.ActualArea != null &&
serObj.ActualArea.Palette != ChartColorPalette.None && serObj.ActualArea.ColorModel != null)
{
int serIndex = serObj.ActualArea.GetSeriesIndex(serObj);
SfChart chart = serObj.ActualArea as SfChart;
if (serIndex >= 0)
{
return(serObj.ActualArea.ColorModel.GetBrush(serIndex));
}
else if (chart != null && chart.TechnicalIndicators != null && chart.TechnicalIndicators.Count > 0)
{
serIndex = chart.TechnicalIndicators.IndexOf(serObj as ChartSeries);
return(serObj.ActualArea.ColorModel.GetBrush(serIndex));
}
}
}
return(new SolidColorBrush(Windows.UI.Colors.Transparent));
}
/// <summary>
/// Called when instance created for ChartAdornment
/// </summary>
/// <param name="xVal"></param>
/// <param name="yVal"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="startDepth"></param>
/// <param name="series"></param>
public ChartAdornment3D(double xVal, double yVal, double x, double y, double startDepth, ChartSeriesBase series)
{
StartDepth = startDepth;
XData = xVal;
YData = yVal;
XPos = x;
YPos = y;
Series = series;
}
/// <summary>
/// Returns the stacked value of the series.
/// </summary>
/// <param name="series">The ChartSeries</param>
/// <returns>StackedYValues class instance.</returns>
public StackingValues GetCumulativeStackValues(ChartSeriesBase series)
{
if (Area.StackedValues == null || !Area.StackedValues.Keys.Contains(series))
{
this.CalculateStackingValues();
}
return(Area.StackedValues != null && Area.StackedValues.Keys.Contains(series) ? Area.StackedValues[series] : null);
}
/// <summary>
/// Called when instance created for EmptyPointSegment with following arguments
/// </summary>
/// <param name="xData"></param>
/// <param name="yData"></param>
/// <param name="series"></param>
/// <param name="isEmptyPointInterior"></param>
public EmptyPointSegment(double xData, double yData, ChartSeriesBase series, bool isEmptyPointInterior)
{
base.Series = series;
ScatterWidth = EmptyPointSymbolWidth;
ScatterHeight = EmptyPointSymbolHeight;
this.IsEmptySegmentInterior = isEmptyPointInterior;
this.XData = xData;
this.YData = yData;
base.SetData(xData, yData);
}
/// <summary>
/// Method used to get selection brush for series selection.
/// </summary>
/// <param name="series"></param>
/// <returns></returns>
public virtual Brush GetSeriesSelectionBrush(ChartSeriesBase series)
{
if (series.SeriesSelectionBrush != null)
{
return(series.SeriesSelectionBrush);
}
else
{
return(null);
}
}
/// <summary>
/// Method used to get the bool value for series or segment has dragging base.
/// </summary>
private bool IsDraggableSeries(ChartSeriesBase chartSeries)
{
if (ChartExtensionUtils.IsDraggable(chartSeries))
{
ChangeSelectionCursor(false);
return(true);
}
else
{
return(false);
}
}
private static IList <double> GetYValues(ChartSeriesBase chartSeries)
{
return(chartSeries is XyDataSeries
? (chartSeries as XyDataSeries).YValues
: chartSeries is RangeSeriesBase
? (chartSeries as RangeSeriesBase).HighValues.Union((chartSeries as RangeSeriesBase).LowValues)
.ToList()
: chartSeries is FinancialSeriesBase
? (chartSeries as FinancialSeriesBase).HighValues.Union(
(chartSeries as FinancialSeriesBase).LowValues).ToList()
: new List <double>());
}
internal static bool IsDraggable(ChartSeriesBase chartSeries)
{
if ((chartSeries is RangeSegmentDraggingBase && (chartSeries as RangeSegmentDraggingBase).EnableSegmentDragging) ||
(chartSeries is XySegmentDraggingBase && (chartSeries as XySegmentDraggingBase).EnableSegmentDragging) ||
(chartSeries is XySeriesDraggingBase && (chartSeries as XySeriesDraggingBase).EnableSeriesDragging))
{
return(true);
}
else
{
return(false);
}
}
protected IList <double> GetYValuesBasedOnIndex(double x, ChartSeriesBase series)
{
List <double> Values = new List <double>();
if (x < series.DataCount)
{
for (int i = 0; i < series.ActualSeriesYValues.Count(); i++)
{
Values.Add(series.ActualSeriesYValues[i][(int)x]);
}
}
return(Values);
}
public FastCandleBitmapSegment(ChartSeriesBase series)
{
xValues = new List <float>();
x1Values = new List <float>();
x2Values = new List <float>();
openValue = new List <float>();
closeValue = new List <float>();
highValue = new List <float>();
highValue1 = new List <float>();
lowValue = new List <float>();
lowValue1 = new List <float>();
isBull = new List <bool>();
isHollow = new List <bool>();
fastCandleBitmapSeries = series as ChartSeries;
}
/// <summary>
/// Initializes a new instance of the <see cref="ChartPolarTransformer"/> class.
/// </summary>
/// <param name="viewport">The viewport.</param>
/// <param name="series">The series.</param>
public ChartPolarTransformer(Rect viewport, ChartSeriesBase series)
{
m_viewport = viewport;
m_xAxis = series.ActualXAxis;
m_yAxis = series.ActualYAxis;
m_center = ChartLayoutUtils.GetCenter(m_viewport);
m_radius = 0.5 * Math.Min(m_viewport.Width, m_viewport.Height);
x_IsLogarithmic = series.ActualXAxis is LogarithmicAxis;
y_IsLogarithmic = series.ActualYAxis is LogarithmicAxis;
if (x_IsLogarithmic)
{
xlogarithmicBase = (series.ActualXAxis as LogarithmicAxis).LogarithmicBase;
}
if (y_IsLogarithmic)
{
ylogarithmicBase = (series.ActualYAxis as LogarithmicAxis).LogarithmicBase;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ChartCartesianTransformer"/> class.
/// </summary>
/// <param name="viewport">The viewport.</param>
/// <param name="series">The series.</param>
public ChartCartesianTransformer(Size viewport, ChartSeriesBase series)
{
if (series.ActualXAxis == null || series.ActualYAxis == null)
{
return;
}
m_viewport = viewport;
XAxis = series.ActualXAxis;
YAxis = series.ActualYAxis;
//WPF-25942: Invalid Cast Exception is thrown in ChartCartesianTransformer when OS set to French
ChartAxis logXAxis = null;
if (XAxis is LogarithmicAxis)
{
logXAxis = XAxis as LogarithmicAxis;
}
ChartAxis logYAxis = null;
if (YAxis is LogarithmicAxis)
{
logYAxis = YAxis as LogarithmicAxis;
}
if (logXAxis != null)
{
x_IsLogarithmic = true;
if (logXAxis is LogarithmicAxis)
{
xlogarithmicBase = ((LogarithmicAxis)series.ActualXAxis).LogarithmicBase;
}
}
if (logYAxis != null)
{
y_IsLogarithmic = true;
if (logYAxis is LogarithmicAxis)
{
ylogarithmicBase = ((LogarithmicAxis)series.ActualYAxis).LogarithmicBase;
}
}
m_IsRoated = series.IsActualTransposed; //When we rotate Second series defined with XAxis and YAxis then series not render.
}
internal void ComputeToggledSegment(ChartSeriesBase series, LegendItem legendItem)
{
var toggledSegment = GetSegment(series.Segments, legendItem.Item);
var circularSeries = series as CircularSeriesBase;
int toggledIndex = circularSeries != null && !double.IsNaN(circularSeries.GroupTo) ? series.Segments.IndexOf(toggledSegment) : series.ActualData.IndexOf(legendItem.Item);
if (toggledSegment != null && toggledSegment.IsSegmentVisible)
{
series.ToggledLegendIndex.Add(toggledIndex);
toggledSegment.IsSegmentVisible = false;
legendItem.Opacity = 0.5d;
}
else
{
series.ToggledLegendIndex.Remove(toggledIndex);
toggledSegment.IsSegmentVisible = true;
legendItem.Opacity = 1d;
}
ChartArea.ScheduleUpdate();
}
/// <summary>
/// Method implementation for Get LabelContent for given position
/// </summary>
/// <param name="axis"></param>
/// <param name="position"></param>
/// <returns></returns>
internal static object GetLabelContent(ChartAxis axis, double position)
{
ChartSeriesBase actualSeries =
axis.Area.VisibleSeries
.Where(series => series.ActualXAxis == axis)
.Max(filteredSeries => filteredSeries.DataCount);
if (actualSeries != null)
{
if (axis.CustomLabels.Count > 0 || axis.LabelsSource != null)
{
return(axis.GetCustomLabelContent(position) ?? GetLabelContent(axis, (int)Math.Round(position), actualSeries) ?? string.Empty);
}
else
{
return(GetLabelContent(axis, (int)Math.Round(position), actualSeries) ?? string.Empty);
}
}
return(position);
}
/// <summary>
/// Method implementation for Get LabelContent for given position
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
public override object GetLabelContent(double position)
{
ChartSeriesBase actualSeries =
Area.VisibleSeries
.Where(series => series.ActualXAxis == this)
.Max(filteredSeries => filteredSeries.DataCount);
if (actualSeries != null)
{
if (CustomLabels.Count > 0 || LabelsSource != null)
{
return(GetCustomLabelContent(position) ?? GetLabelContent((int)Math.Round(position), actualSeries));
}
else
{
return(GetLabelContent((int)Math.Round(position), actualSeries));
}
}
return(position);
}
private static void OnEnableSegmentSelectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ChartBase chartBase = (d as ChartSelectionBehavior).ChartArea;
if (chartBase != null && !(bool)e.NewValue)
{
foreach (var series in chartBase.VisibleSeries)
{
for (int i = 0; i < series.ActualData.Count; i++)
{
if (series.SelectedSegmentsIndexes.Contains(i))
{
series.SelectedSegmentsIndexes.Remove(i);
series.OnResetSegment(i);
}
}
var selectableSegment = series as ISegmentSelectable;
if (selectableSegment != null)
{
selectableSegment.SelectedIndex = -1;
}
series.SelectedSegmentsIndexes.Clear();
}
}
else if (chartBase != null && (bool)e.NewValue)
{
for (int index = 0; index < chartBase.VisibleSeries.Count; index++)
{
ChartSeriesBase series = chartBase.VisibleSeries[index];
var selectableSegment = series as ISegmentSelectable;
if (selectableSegment != null && selectableSegment.SelectedIndex != -1)
{
series.SelectedIndexChanged(selectableSegment.SelectedIndex, -1);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <param name="selector"></param>
/// <returns></returns>
public static ChartSeriesBase Max(this IEnumerable <ChartSeriesBase> source, Func <ChartSeriesBase, double> selector)
{
var chartSeries = source as ChartSeriesBase[] ?? source.ToArray();
if (chartSeries.Any())
{
ChartSeriesBase maxObject = chartSeries[0];
double maxVal = selector(maxObject);
for (int i = 0; i < chartSeries.Count(); i++)
{
double value = selector(chartSeries[i]);
if (value > maxVal)
{
maxVal = value;
maxObject = chartSeries[i];
}
}
return(maxObject);
}
return(null);
}
internal void Dispose()
{
if (PropertyChanged != null)
{
var invocationList = PropertyChanged.GetInvocationList();
foreach (var handler in invocationList)
{
PropertyChanged -= handler as PropertyChangedEventHandler;
}
PropertyChanged = null;
}
segment = null;
item = null;
series = null;
trendline = null;
legend = null;
XFormsLabelStyle = null;
XFormsLegendItem = null;
}
/// <summary>
/// Return object value from the given double value
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
private object GetLabelContent(int pos, ChartSeriesBase actualSeries)
{
if (actualSeries != null)
{
var xValues = actualSeries.ActualXValues as List <double>;
if (xValues != null && pos < xValues.Count && pos >= 0)
{
DateTime xDateTime = xValues[pos].FromOADate();
return(xDateTime.ToString(this.LabelFormat, CultureInfo.CurrentCulture));
}
else
{
var xStrValues = actualSeries.ActualXValues as List <string>;
if (xStrValues != null && pos < xStrValues.Count && pos >= 0)
{
return(xStrValues[pos]);
}
}
}
return(pos);
}
/// <summary>
/// Method implementation for Create Adornments
/// </summary>
/// <param name="series">The series.</param>
/// <param name="xVal">The x value.</param>
/// <param name="yVal">The y value.</param>
/// <param name="xPos">The x position.</param>
/// <param name="yPos">The y position.</param>
/// <param name="startDepth">The start depth.</param>
/// <returns>Returns the created adornment.</returns>
protected virtual ChartAdornment CreateAdornment(ChartSeriesBase series, double xVal, double yVal, double xPos, double yPos, double startDepth)
{
return(new ChartAdornment3D(xVal, yVal, xPos, yPos, startDepth, series));
}
/// <summary>
/// Returns the value of side by side position for a series.
/// </summary>
/// <param name="currentseries">The ChartSeries.</param>
/// <returns>The DoubleRange side by side Info</returns>
internal DoubleRange GetZSideBySideInfo(ChartSeriesBase currentseries)
{
if (this.ActualArea != null)
{
if (this.ActualArea.InternalPrimaryAxis == null || this.ActualArea.InternalSecondaryAxis == null ||
this.ActualArea.InternalDepthAxis == null)
{
return(DoubleRange.Empty);
}
if (!this.ActualArea.SBSInfoCalculated || !this.ActualArea.SeriesPosition.ContainsKey(currentseries))
{
this.CalculateSideBySidePositions(false);
}
double width = 1 - ChartSeriesBase.GetSpacing(this);
double minWidth = 0d;
int all = 0;
// MinPointsDelta is assigned to field since whenever the value is get the MinPointsDelta is calculated.
double minPointsDelta = (this.ActualArea as SfChart3D).ZMinPointsDelta;
if (!double.IsNaN(minPointsDelta))
{
minWidth = minPointsDelta;
}
var xyzDataSeries = currentseries as XyzDataSeries3D;
int rowPos = currentseries.IsActualTransposed
? ActualArea.GetActualRow(xyzDataSeries.ActualZAxis)
: ActualArea.GetActualRow(xyzDataSeries.ActualYAxis);
int columnPos = currentseries.IsActualTransposed
? ActualArea.GetActualColumn(xyzDataSeries.ActualYAxis)
: ActualArea.GetActualColumn(xyzDataSeries.ActualZAxis);
var rowID = currentseries.ActualYAxis == null ? 0 : rowPos;
var colID = xyzDataSeries.ActualZAxis == null ? 0 : columnPos;
if ((rowID < this.ActualArea.SbsSeriesCount.GetLength(0)) && (colID < this.ActualArea.SbsSeriesCount.GetLength(1)))
{
all = this.ActualArea.SbsSeriesCount[rowID, colID];
}
else
{
return(DoubleRange.Empty);
}
if (!this.ActualArea.SeriesPosition.ContainsKey(currentseries))
{
return(DoubleRange.Empty);
}
int pos = this.ActualArea.SeriesPosition[currentseries];
if (all == 0)
{
all = 1;
pos = 1;
}
double div = minWidth * width / all;
double start = div * (pos - 1) - minWidth * width / 2;
double end = start + div;
// For adding additional space on both ends of side by side info series.
this.CalculateSideBySideInfoPadding(minWidth, all, pos, false);
return(new DoubleRange(start, end));
}
else
{
return(DoubleRange.Empty);
}
}
/// <summary>
/// Method used to get selection brush for series selection.
/// </summary>
/// <param name="series">The Series</param>
/// <returns>The series selection brush.</returns>
public virtual Brush GetSeriesSelectionBrush(ChartSeriesBase series)
{
return(series.SeriesSelectionBrush);
}
public FastBarBitmapSegment(IList <double> x1Values, IList <double> y1Values, IList <double> x2Values, IList <double> y2Values, ChartSeriesBase series)
: this(series)
{
base.Series = series;
if (Series.ActualXAxis is CategoryAxis && !(Series.ActualXAxis as CategoryAxis).IsIndexed)
{
base.Item = series.GroupedActualData;
}
else
{
base.Item = series.ActualData;
}
}
public BoxAndWhiskerSegment(ChartSeriesBase series)
{
this.Series = series;
Outliers = new List <double>();
}