/// <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>(); }