private void DataMouseDown(object sender, MouseEventArgs e)
{
var result = ActualSeries.SelectMany(x => x.ActualValues.GetPoints(x))
.FirstOrDefault(x =>
{
var pointView = x.View as PointView;
return(pointView != null && Equals(pointView.HoverShape, sender));
});
OnDataClick(sender, result);
}
private void PrepareWeight()
{
if (!ActualSeries.Any(x => x is IBubbleSeriesView || x is IHeatSeries))
{
return;
}
var vs = ActualSeries.Select(x => x.ActualValues.Limit3).ToArray();
Value3CoreLimit = new CoreLimit(vs.Select(x => x.Min).DefaultIfEmpty(0).Min(),
vs.Select(x => x.Max).DefaultIfEmpty(0).Max());
}
private void PrepareVerticalStackedAreas()
{
if (!ActualSeries.Any(x => x is IVerticalStackedAreaSeriesViewView))
{
return;
}
var isPercentage =
ActualSeries.Any(x => x is IStackModelableSeriesView && x is IVerticalStackedAreaSeriesViewView &&
((IStackModelableSeriesView)x).StackMode == StackMode.Percentage);
foreach (var group in ActualSeries.OfType <IVerticalStackedAreaSeriesViewView>().GroupBy(x => x.ScalesXAt))
{
StackPoints(group, AxisTags.X, group.Key, isPercentage ? StackMode.Percentage : StackMode.Values);
}
}
private void PrepareStackedColumns()
{
if (!ActualSeries.Any(x => x is IStackedColumnSeriesView))
{
return;
}
var isPercentage =
ActualSeries.Any(x => x is IStackModelableSeriesView && x is IStackedColumnSeriesView &&
((IStackModelableSeriesView)x).StackMode == StackMode.Percentage);
foreach (var group in ActualSeries.OfType <IStackedColumnSeriesView>().GroupBy(x => x.ScalesYAt))
{
StackPoints(group, AxisOrientation.Y, group.Key, isPercentage ? StackMode.Percentage : StackMode.Values);
}
}
private void DataMouseLeave(object sender, EventArgs e)
{
TooltipTimeoutTimer.Stop();
TooltipTimeoutTimer.Start();
var source = ActualSeries.SelectMany(x => x.ActualValues.GetPoints(x));
var senderPoint = source.FirstOrDefault(x => x.View != null &&
Equals(((PointView)x.View).HoverShape, sender));
if (senderPoint == null)
{
return;
}
if (Hoverable)
{
senderPoint.View.OnHoverLeave(senderPoint);
}
}
private void DataMouseEnter(object sender, EventArgs e)
{
TooltipTimeoutTimer.Stop();
var source = ActualSeries.SelectMany(x => x.ActualValues.GetPoints(x)).ToList();
var senderPoint = source.FirstOrDefault(x => x.View != null &&
Equals(((PointView)x.View).HoverShape, sender));
if (senderPoint == null)
{
return;
}
if (Hoverable)
{
senderPoint.View.OnHover(senderPoint);
}
if (DataTooltip != null)
{
if (DataTooltip.Parent == null)
{
Panel.SetZIndex(DataTooltip, int.MaxValue);
AddToView(DataTooltip);
Canvas.SetTop(DataTooltip, 0d);
Canvas.SetLeft(DataTooltip, 0d);
}
ActiveTooltip = DataTooltip;
var lcTooltip = DataTooltip as IChartTooltip;
if (lcTooltip == null)
{
throw new LiveChartsException("The current tooltip is not valid, ensure it implements IChartsTooltip");
}
if (lcTooltip.SelectionMode == null)
{
lcTooltip.SelectionMode = senderPoint.SeriesView.Model.PreferredSelectionMode;
}
var coreModel = ChartFunctions.GetTooltipData(senderPoint, Model, lcTooltip.SelectionMode.Value);
lcTooltip.Data = new TooltipData
{
XFormatter = coreModel.XFormatter,
YFormatter = coreModel.YFormatter,
SharedValue = coreModel.Shares,
SelectionMode = lcTooltip.SelectionMode ?? TooltipSelectionMode.OnlySender,
Points = coreModel.Points.Select(x => new DataPointViewModel
{
Series = new SeriesViewModel
{
PointGeometry = ((Series)x.SeriesView).PointGeometry ??
Geometry.Parse("M 0,0.5 h 1,0.5 Z"),
Fill = ((Series)x.SeriesView) is IFondeable
? ((IFondeable)x.SeriesView).PointForeround
: ((Series)x.SeriesView).Fill,
Stroke = ((Series)x.SeriesView).Stroke,
StrokeThickness = ((Series)x.SeriesView).StrokeThickness,
Title = ((Series)x.SeriesView).Title,
},
ChartPoint = x
}).ToList()
};
DataTooltip.Visibility = Visibility.Visible;
DataTooltip.UpdateLayout();
var location = GetTooltipPosition(senderPoint);
location = new Point(Canvas.GetLeft(DrawMargin) + location.X, Canvas.GetTop(DrawMargin) + location.Y);
if (lcTooltip.IsWrapped)
{
var container = (FrameworkElement)DataTooltip.Parent;
var positionTransform = TransformToAncestor(container);
var pos = positionTransform.Transform(new Point(0, 0));
location.X += pos.X;
location.Y += pos.Y;
if (location.X < 0)
{
location.X = 0;
}
if (location.X + DataTooltip.ActualWidth > container.ActualWidth)
{
var dif = container.ActualWidth - (location.X + DataTooltip.ActualWidth);
dif *= container.ActualWidth / 2 > senderPoint.ChartLocation.X ? 1 : -1;
location.X += dif;
}
}
if (DisableAnimations)
{
Canvas.SetLeft(DataTooltip, location.X);
Canvas.SetTop(DataTooltip, location.Y);
}
else
{
DataTooltip.BeginAnimation(Canvas.LeftProperty,
new DoubleAnimation(location.X, TimeSpan.FromMilliseconds(200)));
DataTooltip.BeginAnimation(Canvas.TopProperty,
new DoubleAnimation(location.Y, TimeSpan.FromMilliseconds(200)));
}
}
}
private void DataMouseEnter(object sender, PointerRoutedEventArgs e)
{
TooltipTimeoutTimer.Stop();
var source = ActualSeries.SelectMany(x => x.ActualValues.GetPoints(x)).ToList();
var senderPoint = source.FirstOrDefault(x => x.View != null &&
Equals(((PointView)x.View).HoverShape, sender));
if (senderPoint == null)
{
return;
}
if (Hoverable)
{
senderPoint.View.OnHover(senderPoint);
}
if (DataTooltip != null)
{
if (DataTooltip.Parent == null)
{
Canvas.SetZIndex(DataTooltip, short.MaxValue);
AddToView(DataTooltip);
Canvas.SetTop(DataTooltip, 0d);
Canvas.SetLeft(DataTooltip, 0d);
}
if (ActiveTooltip != null)
{
ActiveTooltip.Visibility = Visibility.Collapsed;
}
ActiveTooltip = DataTooltip;
var lcTooltip = DataTooltip as IChartTooltip;
if (lcTooltip == null)
{
throw new LiveChartsException(
"The current tooltip is not valid, ensure it implements IChartsTooltip");
}
if (lcTooltip.SelectionMode == TooltipSelectionMode.Auto)
{
lcTooltip.SelectionMode = senderPoint.SeriesView.Model.PreferredSelectionMode;
}
var coreModel = ChartFunctions.GetTooltipData(senderPoint, Model, lcTooltip.SelectionMode);
lcTooltip.Data = new TooltipData
{
XFormatter = coreModel.XFormatter,
YFormatter = coreModel.YFormatter,
SharedValue = coreModel.Shares,
SelectionMode =
lcTooltip.SelectionMode == TooltipSelectionMode.Auto
? TooltipSelectionMode.OnlySender
: lcTooltip.SelectionMode,
Points = coreModel.Points.Select(x => new DataPointViewModel
{
Series = new SeriesViewModel
{
PointGeometry = ((Series)x.SeriesView).PointGeometry == DefaultGeometries.None
? new PointGeometry("M 0, 0.5 h 1, 0.5 Z").Parse()
: ((Series)x.SeriesView).PointGeometry.Parse(),
Fill = ((Series)x.SeriesView) is IFondeable &&
!(x.SeriesView is IVerticalStackedAreaSeriesView ||
x.SeriesView is IStackedAreaSeriesView)
? ((IFondeable)x.SeriesView).PointForeround
: ((Series)x.SeriesView).Fill,
Stroke = ((Series)x.SeriesView).Stroke,
StrokeThickness = ((Series)x.SeriesView).StrokeThickness,
Title = ((Series)x.SeriesView).Title,
},
ChartPoint = x
}).ToList()
};
DataTooltip.Visibility = Visibility.Visible;
DataTooltip.UpdateLayout();
var location = GetTooltipPosition(senderPoint);
location = new Point(Canvas.GetLeft(DrawMargin) + location.X, Canvas.GetTop(DrawMargin) + location.Y);
if (lcTooltip.IsWrapped)
{
var container = (FrameworkElement)DataTooltip.Parent;
var positionTransform = TransformToVisual(container);
var pos = positionTransform.TransformPoint(new Point(0, 0));
location.X += pos.X;
location.Y += pos.Y;
if (location.X < 0)
{
location.X = 0;
}
if (location.X + DataTooltip.ActualWidth > container.ActualWidth)
{
var dif = container.ActualWidth - (location.X + DataTooltip.ActualWidth);
dif *= container.ActualWidth / 2 > senderPoint.ChartLocation.X ? 1 : -1;
location.X += dif;
}
}
if (DisableAnimations)
{
Canvas.SetLeft(DataTooltip, location.X);
Canvas.SetTop(DataTooltip, location.Y);
}
else
{
var storyBoard = new Storyboard();
var xAnimation = new DoubleAnimation()
{
To = location.X,
Duration = TimeSpan.FromMilliseconds(200)
};
var yAnimation = new DoubleAnimation()
{
To = location.Y,
Duration = TimeSpan.FromMilliseconds(200)
};
storyBoard.Children.Add(xAnimation);
storyBoard.Children.Add(yAnimation);
Storyboard.SetTarget(xAnimation, DataTooltip);
Storyboard.SetTargetProperty(xAnimation, "(Canvas.Left)");
Storyboard.SetTarget(yAnimation, DataTooltip);
Storyboard.SetTargetProperty(yAnimation, "(Canvas.Top)");
storyBoard.Begin();
}
}
}
public override void PrepareAxes()
{
PivotZoomingAxis = AxisTags.X;
base.PrepareAxes();
if (ActualSeries.Any(x => !(x.Model is ICartesianSeries)))
{
throw new LiveChartsException(
"There is a invalid series in the series collection, " +
"verify that all the series implement ICartesianSeries.");
}
var cartesianSeries = ActualSeries.Select(x => x.Model).Cast <ICartesianSeries>().ToArray();
for (var index = 0; index < AxisX.Count; index++)
{
var xi = AxisX[index];
xi.CalculateSeparator(this, AxisTags.X);
xi.MinLimit = xi.MinValue ?? cartesianSeries.Where(x => x.View.ScalesXAt == index)
.Select(x => x.GetMinX(xi))
.DefaultIfEmpty(0).Min();
xi.MaxLimit = xi.MaxValue ?? cartesianSeries.Where(x => x.View.ScalesXAt == index)
.Select(x => x.GetMaxX(xi))
.DefaultIfEmpty(0).Max();
if (Math.Abs(xi.MinLimit - xi.MaxLimit) < xi.S * .01)
{
xi.MinLimit -= xi.S;
xi.MaxLimit += xi.S;
}
}
for (var index = 0; index < AxisY.Count; index++)
{
var yi = AxisY[index];
yi.CalculateSeparator(this, AxisTags.Y);
yi.MinLimit = yi.MinValue ?? cartesianSeries.Where(x => x.View.ScalesYAt == index)
.Select(x => x.GetMinY(yi))
.DefaultIfEmpty(0).Min();
yi.MaxLimit = yi.MaxValue ?? cartesianSeries.Where(x => x.View.ScalesYAt == index)
.Select(x => x.GetMaxY(yi))
.DefaultIfEmpty(0).Max();
if (Math.Abs(yi.MinLimit - yi.MaxLimit) < yi.S * .01)
{
yi.MinLimit -= yi.S;
yi.MaxLimit += yi.S;
}
}
PrepareSeries();
CalculateComponentsAndMargin();
for (var index = 0; index < AxisX.Count; index++)
{
var xi = AxisX[index];
foreach (var section in xi.Sections)
{
section.View.DrawOrMove(AxisTags.X, index);
}
}
for (var index = 0; index < AxisY.Count; index++)
{
var yi = AxisY[index];
foreach (var section in yi.Sections)
{
section.View.DrawOrMove(AxisTags.Y, index);
}
}
}
internal void SetLegendItemsSource(ChartLegend legend, int index)
{
if (legend == null || ActualSeries == null)
{
return;
}
legend.ChartArea = this;
//HasDataPointBasedLegend() will return true when need to generate data point based legend items.
if ((VisibleSeries.Count == 1 && VisibleSeries[0].IsSingleAccumulationSeries) || HasDataPointBasedLegend())
{
SetLegendItems(legend, index);
}
else if (VisibleSeries.Count == 1 && VisibleSeries[0] is WaterfallSeries)
{
SetWaterfallLegendItems(legend, index);
legend.XAxis = VisibleSeries[0].IsActualTransposed ? (VisibleSeries[0] as ISupportAxes).ActualYAxis : (VisibleSeries[0] as ISupportAxes).ActualXAxis;
legend.YAxis = VisibleSeries[0].IsActualTransposed ? (VisibleSeries[0] as ISupportAxes).ActualXAxis : (VisibleSeries[0] as ISupportAxes).ActualYAxis;
}
else
{
var technicalIndicators = new List <ChartSeriesBase>();
var sfChart = this as SfChart;
if (sfChart != null)
{
foreach (ChartSeries indicator in sfChart.TechnicalIndicators)
{
technicalIndicators.Add(indicator as ChartSeriesBase);
}
}
List <ChartSeriesBase> actualLegendSeries = sfChart != null?ActualSeries.Union(technicalIndicators).ToList() : ActualSeries;
if (AreaType == ChartAreaType.PolarAxes || AreaType == ChartAreaType.CartesianAxes && Legend is ChartLegendCollection)
{
actualLegendSeries = (from actualSeries in actualLegendSeries
where
GetActualRow(legend) == GetActualRow(actualSeries.IsActualTransposed ? actualSeries.ActualXAxis : actualSeries.ActualYAxis) &&
GetActualColumn(legend) == GetActualColumn(actualSeries.IsActualTransposed ? actualSeries.ActualYAxis : actualSeries.ActualXAxis)
select actualSeries).ToList();
}
if (actualLegendSeries.Count > 0 && actualLegendSeries[0] is ISupportAxes)
{
legend.XAxis = actualLegendSeries[0].IsActualTransposed ? (actualLegendSeries[0] as ISupportAxes).ActualYAxis : (actualLegendSeries[0] as ISupportAxes).ActualXAxis;
legend.YAxis = actualLegendSeries[0].IsActualTransposed ? (actualLegendSeries[0] as ISupportAxes).ActualXAxis : (actualLegendSeries[0] as ISupportAxes).ActualYAxis;
}
IEnumerable <ChartSeriesBase> legendSeries;
switch (AreaType)
{
case ChartAreaType.CartesianAxes:
legendSeries = from series in actualLegendSeries
where series is ISupportAxes2D || series is ISupportAxes3D
select series;
break;
case ChartAreaType.PolarAxes:
legendSeries = from series in actualLegendSeries
where series is PolarRadarSeriesBase
select series;
break;
default:
legendSeries = from series in actualLegendSeries
where series is AccumulationSeriesBase || series is CircularSeriesBase3D
select series;
break;
}
var chartSeries = legendSeries as ChartSeries[] ?? legendSeries.ToArray();
foreach (var series in chartSeries)
{
if (series.IsSeriesVisible)
{
if (LegendItems[index].Count > 0 && index < LegendItems[index].Count)//Legend not cleared when bind Series in MVVM view model-WPF-18625
{
LegendItems[index].Clear();
}
}
}
foreach (var item in chartSeries.Where(series => series.VisibilityOnLegend == Visibility.Visible))
{
var containlegenditem = LegendItems[index].Where(it => it.Series == item).ToList();
if (LegendItems.Count == 0 || containlegenditem.Count() == 0)
{
var legenditem = new LegendItem {
Legend = legend, Series = item
};
if (item.IsSingleAccumulationSeries)
{
legenditem.Legend.isSegmentsUpdated = true;
if (item.IsSeriesVisible)
{
legenditem.IsSeriesVisible = true;
}
else
{
legenditem.IsSeriesVisible = false;
}
legenditem.Legend.isSegmentsUpdated = false;
}
LegendItems[index].Add(legenditem);
}
}
foreach (var item in chartSeries)
{
var cartesian = item as CartesianSeries;
if (cartesian != null)
{
foreach (var trend in cartesian.Trendlines.Where(
trendline => trendline.VisibilityOnLegend == Visibility.Visible))
{
var containlegenditem = LegendItems[index].Where(it => it.Trendline == trend).ToList();
if (LegendItems.Count == 0 || containlegenditem.Count() == 0)
{
var trendline = new LegendItem {
Legend = legend, Trendline = trend
};
LegendItems[index].Add(trendline);
trend.UpdateLegendIconTemplate(true);
}
}
}
}
}
}
