internal override void UpdateUICore(ChartLayoutContext context) { this.IsRendered = false; base.UpdateUICore(context); this.IsRendered = true; this.UpdateSeriesClip(); }
private void UpdateTicks(ChartLayoutContext context) { int visibleTicks = 0; foreach (AxisTickModel tick in this.model.ticks) { if (!tick.isVisible) { continue; } // the GetVisual method will update the UIElement's Visibility property FrameworkElement visual = this.GetTickVisual(tick, visibleTicks); this.TransformTick(tick, visual); this.ArrangeUIElement(visual, this.GetLayoutSlot(tick, context)); visibleTicks++; } // remove unnecessary ticks while (visibleTicks < this.tickVisuals.Count) { this.tickVisuals[visibleTicks].Visibility = Visibility.Collapsed; visibleTicks++; } }
internal virtual ChartLayoutFlags GetLayoutFlags(ChartLayoutContext context) { // check whether last layout context is valid if (this.lastLayoutContext.AvailableSize == InfinitySize) { return(ChartLayoutFlags.Size); } ChartLayoutFlags flags = ChartLayoutFlags.None; if (this.lastLayoutContext.AvailableSize != context.AvailableSize) { flags |= ChartLayoutFlags.Size; } if (this.lastLayoutContext.Scale != context.Scale) { flags |= ChartLayoutFlags.Zoom; } if (this.lastLayoutContext.PlotOrigin != context.PlotOrigin) { flags |= ChartLayoutFlags.Pan; } return(flags); }
internal virtual void InvalidateCore() { this.lastLayoutContext = ChartLayoutContext.Invalid; // TODO: Check carefully for any performance impact this.isPaletteApplied = false; }
internal override void UpdateAxisLine(ChartLayoutContext context) { double antiAliasOffset = this.model.LineThickness % 2 == 1 ? 0.5 : 0; // update line points if (this.type == AxisType.First) { this.line.X1 = this.model.layoutSlot.X; this.line.X2 = this.model.layoutSlot.Right; if (this.model.VerticalLocation == AxisVerticalLocation.Bottom) { this.line.Y1 = this.line.Y2 = this.model.layoutSlot.Y - antiAliasOffset; } else { this.line.Y1 = this.line.Y2 = this.model.layoutSlot.Bottom - antiAliasOffset; } } else { this.line.Y1 = this.model.layoutSlot.Y; this.line.Y2 = this.model.layoutSlot.Bottom; if (this.model.HorizontalLocation == AxisHorizontalLocation.Left) { this.line.X1 = this.line.X2 = this.model.layoutSlot.Right + antiAliasOffset; } else { this.line.X1 = this.line.X2 = this.model.layoutSlot.X + antiAliasOffset; } } base.UpdateAxisLine(context); }
internal override void OnPlotOriginChanged(ChartLayoutContext context) { base.OnPlotOriginChanged(context); this.UpdateVisuals(); this.UpdateClip(); }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { base.UpdateUICore(context); // update the UI of each presenter foreach (UIElement child in this.renderSurface.Children) { PresenterBase presenter = child as PresenterBase; if (presenter != null) { presenter.UpdateUI(context); } } // position the plot area decoraction RadRect plotAreaSlot = this.PlotAreaDecorationSlot; Canvas.SetLeft(this.plotAreaBackground, plotAreaSlot.X); Canvas.SetTop(this.plotAreaBackground, plotAreaSlot.Y); this.plotAreaBackground.Width = plotAreaSlot.Width; this.plotAreaBackground.Height = plotAreaSlot.Height; this.adornerLayer.IsHitTestVisible = !context.IsEmpty; this.labelLayer.Opacity = context.IsEmpty ? 0 : 1; this.StackedSeriesContext.Clear(); }
private void UpdatePresenters(ChartLayoutContext context) { int index = 0; ChartSeriesModel series = this.Model; if (this.chart.chartArea.IsTreeLoaded && (this.HasPointTemplate || this.SupportsDefaultVisuals)) { foreach (DataPoint point in series.DataPointsInternal) { // point is empty or is laid-out outside the clip area, skip it from visualization. if (point.isEmpty || !context.ClipRect.IntersectsWith(point.layoutSlot)) { continue; } FrameworkElement element = this.GetDataPointVisual(point, index); if (element != null) { this.ArrangeUIElement(element, point.layoutSlot); index++; } } } while (index < this.realizedDataPointPresenters.Count) { var presenter = this.realizedDataPointPresenters[index]; if (presenter.Visibility == Visibility.Visible) { presenter.Visibility = Visibility.Collapsed; } index++; } }
internal virtual void UpdateAxisLine(ChartLayoutContext context) { if (!this.drawWithComposition) { // update stroke thickness this.line.StrokeThickness = this.model.LineThickness; } }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { if (this.renderSurface == null) { return; } base.UpdateUICore(context); this.UpdatePresenters(context); }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { base.UpdateUICore(context); this.majorXLines.Stripes = this.grid.xStripes; this.majorYLines.Stripes = this.grid.yStripes; this.UpdateVisuals(); this.UpdateClip(); }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { base.UpdateUICore(context); if (this.renderSurface != null) { // create and arrange ticks, labels and axis line this.ArrangeVisuals(context); this.UpdateTitle(); } }
internal override void OnPlotOriginChanged(ChartLayoutContext context) { base.OnPlotOriginChanged(context); if (this.chart.chartArea.plotArea.layoutSlot != this.lastPlotAreaRect) { this.UpdateUICore(context); } else { this.UpdateClip(context); } }
internal override void UpdateUICore(ChartLayoutContext context) { base.UpdateUICore(context); this.signalRenderer.Render(this.drawWithComposition); if (this.drawWithComposition && this.signalRenderer.renderPoints.Count > 2) { foreach (DataPointSegment dataSegment in ChartSeriesRenderer.GetDataSegments(this.signalRenderer.renderPoints)) { this.chart.ContainerVisualsFactory.PrepareLineRenderVisual(this.signalRendererVisual, this.signalRenderer.GetPoints(dataSegment), this.SignalStroke, this.StrokeThickness); } } }
private void UpdatePresenters(ChartLayoutContext context) { int index = 0; ChartSeriesModel series = this.Model; if (this.HasPointTemplate || this.SupportsDefaultVisuals) { foreach (DataPoint point in series.DataPointsInternal) { // point is laid-out outside the clip area, skip it from visualization if (!context.ClipRect.IntersectsWith(point.layoutSlot)) { continue; } if (this.drawWithComposition) { var containerVisual = this.GetContainerVisual(index); this.chart.ContainerVisualsFactory.PrepareBarIndicatorVisual(containerVisual, point); index++; } else { FrameworkElement element = this.GetDataPointVisual(point, index); if (element != null) { this.ArrangeUIElement(element, point.layoutSlot); index++; } } } } if (this.drawWithComposition) { while (index < this.realizedVisualDataPoints.Count) { this.realizedVisualDataPoints[index].IsVisible = false; index++; } } else { while (index < this.realizedDataPoints.Count) { this.realizedDataPoints[index].Visibility = Visibility.Collapsed; index++; } } }
private void UpdateLabels(ChartLayoutContext context) { double sineOrCosine = 0; if (this.model.labelFitMode == AxisLabelFitMode.Rotate) { double radiansByModulo = (this.normalizedRotationAngle % 90) * RadMath.DegToRadFactor; if (this.normalizedRotationAngle < 90 || (this.normalizedRotationAngle >= 180 && this.normalizedRotationAngle < 270)) { sineOrCosine = Math.Sin(radiansByModulo); } else { sineOrCosine = Math.Cos(radiansByModulo); } } int visibleLabels = 0; foreach (AxisLabelModel label in this.model.labels) { if (!label.isVisible) { continue; } // the GetVisual method will update the UIelement's Visibility property FrameworkElement visual = this.GetLabelVisual(label, visibleLabels); RadRect layoutSlot = this.GetLayoutSlot(label, context); if (this.model.labelFitMode == AxisLabelFitMode.Rotate) { var margin = visual.Margin; var actualWidth = label.untransformedDesiredSize.Width - (margin.Left + margin.Right); layoutSlot.Y += (int)(sineOrCosine * actualWidth / 2); } this.ArrangeUIElement(visual, layoutSlot, false); visibleLabels++; } // remove unnecessary ticks while (visibleLabels < this.labelVisuals.Count) { this.labelVisuals[visibleLabels].Visibility = Visibility.Collapsed; visibleLabels++; } }
internal virtual void UpdateClip(ChartLayoutContext context) { this.plotOriginTransform.X = context.PlotOrigin.X; this.plotOriginTransform.Y = context.PlotOrigin.Y; if (this.renderSurface != null) { this.chart.ApplyPlotAreaClip(this.renderSurface, this.ClipToPlotArea); } if (this.labelLayer != null) { this.chart.ApplyPlotAreaClip(this.labelLayer, this.ClipToPlotArea); } }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { if (this.renderSurface == null) { return; } RadSize availableSize = new RadSize( this.chart.chartArea.layoutSlot.Width * this.chart.zoomCache.Width, this.chart.chartArea.layoutSlot.Height * this.chart.zoomCache.Height); this.updateContext = this.GetUpdateContext(availableSize); this.UpdateSegments(); base.UpdateUICore(context); }
internal virtual RadRect GetLayoutSlot(Node node, ChartLayoutContext context) { RadRect layoutSlot = node.layoutSlot; if (this.type == AxisType.First) { layoutSlot.X += context.PlotOrigin.X; } else { layoutSlot.Y += context.PlotOrigin.Y; } return(layoutSlot); }
internal override void UpdateAxisLine(ChartLayoutContext context) { PolarChartAreaModel chartArea = this.chart.chartArea as PolarChartAreaModel; double angle = chartArea.NormalizeAngle(0); RadPoint center = chartArea.plotArea.layoutSlot.Center; RadPoint point = RadMath.GetArcPoint(angle, center, chartArea.plotArea.layoutSlot.Width / 2); double antiAliasOffset = this.model.LineThickness % 2 == 1 ? 0.5 : 0; this.line.X1 = center.X; this.line.Y1 = center.Y - antiAliasOffset; this.line.X2 = point.X; this.line.Y2 = point.Y - antiAliasOffset; base.UpdateAxisLine(context); }
private void CallUpdateUI() { if (!this.IsTemplateApplied) { // the template may not be applied if the control is edited in Blend return; } this.UpdateChartArea(); ChartLayoutContext context = new ChartLayoutContext(this.availableSize, this.zoomCache, this.PlotOrigin, this.PlotAreaClip) { IsEmpty = this.UpdateEmptyContent() }; this.UpdateUI(context); }
internal override void UpdateUICore(ChartLayoutContext context) { if (this.Visibility == Visibility.Collapsed) { return; } base.UpdateUICore(context); if (this.model.CombineMode == ChartSeriesCombineMode.Stack || this.model.CombineMode == ChartSeriesCombineMode.Stack100) { // pass our reference to next stacked series this.chart.StackedSeriesContext.PreviousStackedArea = this.areaRenderer.topSurfacePoints; } }
private void UpdateTicks(ChartLayoutContext context) { int visibleTicks = 0; foreach (AxisTickModel tick in this.model.ticks) { if (!tick.isVisible) { continue; } if (this.drawWithComposition) { var containerVisual = this.GetContainerVisual(visibleTicks); this.chart.ContainerVisualsFactory.PrepareTickVisual(containerVisual, this.GetLayoutSlot(tick, context)); visibleTicks++; } else { // the GetVisual method will update the UIElement's Visibility property FrameworkElement visual = this.GetTickVisual(tick, visibleTicks); this.TransformTick(tick, visual); this.ArrangeUIElement(visual, this.GetLayoutSlot(tick, context)); visibleTicks++; } } // remove unnecessary ticks if (this.drawWithComposition) { while (visibleTicks < this.containerVisuals.Count) { this.containerVisuals[visibleTicks].IsVisible = false; visibleTicks++; } } else { while (visibleTicks < this.tickVisuals.Count) { this.tickVisuals[visibleTicks].Visibility = Visibility.Collapsed; visibleTicks++; } } }
/// <summary> /// Updates of all of the chart elements presented by this instance. /// </summary> internal override void UpdateUICore(ChartLayoutContext context) { base.UpdateUICore(context); // hide the series if for some reason the chart is not setup properly this.Opacity = context.IsEmpty ? 0 : 1; if (this.showLabelsCache && this.labelLayer == null) { this.labelLayer = this.chart.AddLabelLayer(this); this.labelLayer.RenderTransform = this.plotOriginTransform; } this.UpdateLabels(context); this.UpdateClip(context); this.lastPlotAreaRect = this.chart.chartArea.plotArea.layoutSlot; }
internal virtual void UpdateClip(ChartLayoutContext context) { if (this.renderSurface == null) { return; } if (this.ClipToPlotArea) { RadRect clipArea = this.chart.chartArea.plotArea.layoutSlot; RectangleGeometry clip = new RectangleGeometry(); clip.Rect = new Rect(clipArea.X, clipArea.Y, clipArea.Width, clipArea.Height); this.renderSurface.Clip = clip; } else { this.renderSurface.Clip = null; } }
internal override void UpdateAxisLine(ChartLayoutContext context) { if (this.drawWithComposition && this.lineContainer != null) { this.chart.ContainerVisualsFactory.PrepareCartesianAxisLineVisual(this, this.lineContainer, this.model.layoutSlot, this.type); } else { double antiAliasOffset = this.model.LineThickness % 2 == 1 ? 0.5 : 0; // update line points if (this.type == AxisType.First) { this.line.X1 = this.model.layoutSlot.X; this.line.X2 = this.model.layoutSlot.Right; if (this.model.VerticalLocation == AxisVerticalLocation.Bottom) { this.line.Y1 = this.line.Y2 = this.model.layoutSlot.Y - antiAliasOffset; } else { this.line.Y1 = this.line.Y2 = this.model.layoutSlot.Bottom - antiAliasOffset; } } else { this.line.Y1 = this.model.layoutSlot.Y; this.line.Y2 = this.model.layoutSlot.Bottom; if (this.model.HorizontalLocation == AxisHorizontalLocation.Left) { this.line.X1 = this.line.X2 = this.model.layoutSlot.Right + antiAliasOffset; } else { this.line.X1 = this.line.X2 = this.model.layoutSlot.X + antiAliasOffset; } } } base.UpdateAxisLine(context); }
internal void Update(ChartLayoutContext context) { if (this.renderSurface == null) { this.isInvalidateRequired = true; return; } this.UpdateVisibility(); if (this.Visibility == Visibility.Collapsed) { return; } if (this.Model.IsUpdated) { this.UpdatePresenters(); } this.UpdateClip(context); }
internal void UpdateUI(ChartLayoutContext context) { context.Flags = this.GetLayoutFlags(context); if ((context.Flags & ChartLayoutFlags.Size) == ChartLayoutFlags.Size || (context.Flags & ChartLayoutFlags.Zoom) == ChartLayoutFlags.Zoom) { this.UpdateUICore(context); } else if ((context.Flags & ChartLayoutFlags.Pan) == ChartLayoutFlags.Pan) { this.OnPlotOriginChanged(context); } // update the palette after UI has been updated this.isPaletteApplied = false; this.ApplyPalette(); this.lastLayoutContext = context; this.OnUIUpdated(); }
private void UpdateLabels(ChartLayoutContext context) { int index = 0; ChartSeriesModel series = this.Model; ChartSeriesLabelUpdateContext labelContext = new ChartSeriesLabelUpdateContext(); labelContext.PlotDirection = this.Model.GetTypedValue <AxisPlotDirection>(AxisModel.PlotDirectionPropertyKey, AxisPlotDirection.Vertical); labelContext.IsPlotInverse = this.Model.GetIsPlotInverse(labelContext.PlotDirection); if (this.showLabelsCache) { foreach (DataPoint point in series.DataPointsInternal) { // point is empty or is laid-out outside the clip area, skip it from visualization. if (point.isEmpty || !context.ClipRect.IntersectsWith(point.layoutSlot)) { continue; } labelContext.Point = point; labelContext.PointVirtualIndex = index; this.ProcessDataPointLabels(labelContext); index++; } } while (index < this.labels.Count) { List <FrameworkElement> pointLabels = this.labels[index].Value; foreach (FrameworkElement label in pointLabels) { label.Visibility = Visibility.Collapsed; } index++; } }
internal override void OnPlotOriginChanged(ChartLayoutContext context) { // TODO: Possible optimizations this.UpdateUICore(context); }