internal virtual void CheckBottomScrollableBounds()
{
double lastItemBottom = this.GetRealizedItemsBottom();
double scrollableContentBottom = this.GetScrollableContentEnd();
bool isLastItemRealized = this.owner.GetItemAfter(this.owner.lastItemCache.associatedDataItem) == null;
if (!RadMath.AreClose(lastItemBottom, scrollableContentBottom) || !isLastItemRealized)
{
if (isLastItemRealized)
{
double offset = lastItemBottom - scrollableContentBottom;
this.CorrectScrollableContentSize(offset);
this.owner.OnBottomEdgeCorrected();
}
else if (scrollableContentBottom < this.scrollableContentHeightAdjustment + this.ViewportLength)
{
// this.CorrectScrollableContentSize(this.scrollableItemsLength - this.ScrollableContentLength);
double amount = this.owner.GetDataItemCount() - Math.Max(this.owner.GetLastItemCacheIndex(), 0);
this.CorrectScrollableContentSize(amount * this.averageItemLength);
}
else
{
this.CheckResizeScrollableContentWhenAllItemsRealized();
}
}
//this.owner.previousScrollOffset = scrollOffset;
}
private static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
RadRating rating = sender as RadRating;
if (rating.settingValuePropertySilently)
{
return;
}
if (!rating.IsTemplateApplied)
{
return;
}
double oldValue = (double)args.OldValue;
double newValue = RadMath.CoerceValue((double)args.NewValue, 0, rating.itemsSource.Count);
if (newValue != rating.Value)
{
rating.SetValuePropertySilently(ValueProperty, newValue);
}
if (newValue != oldValue)
{
rating.HandleValueChange(oldValue, newValue);
}
}
protected override RadRect ArrangeCore(RadRect rect)
{
double radius = rect.Width / 2;
RadPoint center = rect.Center;
NumericalAxisPlotInfo polarPlot = this.firstPlotInfo as NumericalAxisPlotInfo;
double pointRadius = polarPlot.NormalizedValue * radius;
AxisPlotInfo anglePlot = this.secondPlotInfo;
this.angle = 0d;
NumericalAxisPlotInfo numericalAnglePlot = anglePlot as NumericalAxisPlotInfo;
if (numericalAnglePlot != null)
{
this.angle = numericalAnglePlot.ConvertToAngle();
}
else
{
CategoricalAxisPlotInfo categoricalAnglePlot = anglePlot as CategoricalAxisPlotInfo;
if (categoricalAnglePlot != null)
{
this.angle = categoricalAnglePlot.ConvertToAngle(this.GetChartArea <PolarChartAreaModel>());
}
}
RadPoint arcPosition = RadMath.GetArcPoint(this.angle, center, pointRadius);
RadSize desiredSize = this.Measure();
return(new RadRect(arcPosition.X, arcPosition.Y, desiredSize.Width, desiredSize.Height));
}
internal override void SetValueFromAxis(AxisModel axis, object newValue)
{
if (axis is NumericalAxisModel)
{
this.numericalPlot = newValue as NumericalAxisPlotInfo;
if (this.numericalPlot != null)
{
this.isInNumericalRange = true;
this.isPositive = this.numericalPlot.NormalizedValue >= this.numericalPlot.NormalizedOrigin;
//// inverse axis with negative point value is equivalent to regular axis with positive point value
if (this.numericalPlot.Axis.IsInverse && !RadMath.AreClose(this.numericalPlot.NormalizedValue, this.numericalPlot.NormalizedOrigin))
{
this.isPositive ^= true;
}
}
else
{
this.isInNumericalRange = false;
this.isPositive = false;
}
}
else if (axis is CategoricalAxisModel || axis is DateTimeContinuousAxisModel)
{
this.categoricalPlot = newValue as CategoricalAxisPlotInfo;
this.isInCategoricalRange = true;
}
}
public void SnapPointToGridLine(CategoricalDataPoint point)
{
if (point.numericalPlot == null)
{
return;
}
if (point.numericalPlot.SnapTickIndex < 0 ||
point.numericalPlot.SnapTickIndex >= point.numericalPlot.Axis.ticks.Count)
{
return;
}
AxisTickModel tick = point.numericalPlot.Axis.ticks[point.numericalPlot.SnapTickIndex];
if (!RadMath.AreClose(point.numericalPlot.NormalizedValue, (double)tick.normalizedValue))
{
return;
}
if (this.PlotDirection == AxisPlotDirection.Vertical)
{
CategoricalSeriesRoundLayoutContext.SnapToGridLineVertical(point, tick.layoutSlot);
}
else
{
CategoricalSeriesRoundLayoutContext.SnapToGridLineHorizontal(point, tick.layoutSlot);
}
}
private void UpdateLabels(RadSize availableSize)
{
RadRect availableRect = new RadRect(availableSize.Width, availableSize.Height);
RadRect ellipseRect = RadRect.ToSquare(availableRect, false);
ellipseRect = RadRect.CenterRect(ellipseRect, availableRect);
double radius = ellipseRect.Width / 2;
RadPoint center = ellipseRect.Center;
RadPoint arcPosition;
foreach (AxisLabelModel label in this.owner.labels)
{
if (!label.isVisible)
{
continue;
}
double angle = this.owner.IsInverse ? 360 - (double)label.normalizedPosition * 360 : (double)label.normalizedPosition * 360;
arcPosition = RadMath.GetArcPoint(angle, center, radius);
this.UpdateMargins(ellipseRect, label.desiredSize, arcPosition);
}
double offset = this.owner.LineThickness + this.owner.MajorTickLength;
this.margins.Left += offset;
this.margins.Top += offset;
this.margins.Right += offset;
this.margins.Bottom += offset;
}
protected override RadRect ArrangeCore(RadRect rect)
{
double radius = rect.Width / 2;
RadPoint center = rect.Center;
AxisPlotInfo anglePlot = this.plotInfo;
double angle = 0d;
NumericalAxisPlotInfo numericalAnglePlot = anglePlot as NumericalAxisPlotInfo;
if (numericalAnglePlot != null)
{
angle = numericalAnglePlot.ConvertToAngle();
}
else
{
CategoricalAxisPlotInfo categoricalAnglePlot = anglePlot as CategoricalAxisPlotInfo;
if (categoricalAnglePlot != null)
{
angle = categoricalAnglePlot.ConvertToAngle(this.GetChartArea <PolarChartAreaModel>());
}
}
RadPoint arcPoint = RadMath.GetArcPoint(angle, center, radius);
this.radialLine = new RadPolarVector()
{
Point = arcPoint, Angle = angle, Center = center
};
return(new RadRect(center, arcPoint));
}
internal virtual void CheckTopScrollableBounds()
{
double firstItemTop = this.GetRealizedItemsTop();
bool isFirstItemRealized = this.owner.firstItemCache != null && this.owner.GetItemBefore(this.owner.firstItemCache.associatedDataItem) == null;
if (firstItemTop != this.ScrollOffset)
{
if (isFirstItemRealized && !RadMath.AreClose(firstItemTop, 0, 0.01) || (firstItemTop < 0 && this.ScrollOffset < this.ViewportLength / 4))
{
double currentScrollOffset = this.ScrollOffset;
double newOffset = this.ScrollOffset - firstItemTop;
if (!RadMath.AreClose(newOffset, this.ScrollOffset, 0.01))
{
// if (newOffset < 0 || (firstItemTop < 0 && RadMath.AreClose(0, this.ScrollOffset, Epsilon)))
{
this.EnsureCorrectLayout();
}
}
}
else
{
this.CheckResizeScrollableContentWhenAllItemsRealized();
}
}
}
internal override double GetPolarDistance(Point point)
{
var coordinates = RadMath.ToPolarCoordinates(new RadPoint(point.X, point.Y), new RadPoint(this.CenterPoint.X, this.CenterPoint.Y));
var normalizedStartAngle = this.startAngle % 360;
if (this.CenterPoint.X < point.X && this.CenterPoint.Y < point.Y)
{
// IV quadrant
if (this.startAngle + this.sweepAngle > 360)
{
normalizedStartAngle = this.startAngle - 360;
}
}
var pointRadius = coordinates.Item1;
// Outside of bounds.
if (coordinates.Item2 <= normalizedStartAngle || coordinates.Item2 >= normalizedStartAngle + this.sweepAngle)
{
pointRadius = double.PositiveInfinity;
}
return(Math.Max(0, pointRadius - (this.Radius - this.InnerRadius) / 2 + this.InnerRadius));
}
internal override IEnumerable <AxisTickModel> GenerateTicks(ValueRange <decimal> currentVisibleRange)
{
if (this.majorStep <= 0 || this.actualRange.maximum == this.actualRange.minimum)
{
yield break;
}
decimal tickStep = (decimal)this.majorStep;
decimal normalizedTickStep = tickStep / 360;
decimal startTick = 0;
decimal endTick = 1;
decimal currentTick = startTick;
decimal value = 0;
while (currentTick < endTick || RadMath.AreClose((double)currentTick, (double)endTick))
{
AxisTickModel tick = new MajorTickModel();
tick.normalizedValue = this.IsInverse ? 1 - currentTick : currentTick;
tick.value = value;
currentTick += normalizedTickStep;
value += tickStep;
yield return(tick);
}
}
private RadRect InflateCellDecorationVertically(RadRect layoutSlot, Border decoration)
{
if (decoration.BorderBrush == null)
{
return(layoutSlot);
}
if (layoutSlot.Y < this.dayNamesLineSlot.Bottom)
{
layoutSlot.Y -= decoration.BorderThickness.Bottom;
layoutSlot.Height += decoration.BorderThickness.Bottom;
}
else if (RadMath.AreClose(layoutSlot.Bottom, this.Owner.CalendarViewSize.Height))
{
layoutSlot.Y -= decoration.BorderThickness.Top;
layoutSlot.Height += decoration.BorderThickness.Top + decoration.BorderThickness.Bottom;
}
else
{
layoutSlot.Y -= decoration.BorderThickness.Top;
if (this.Owner.HasHorizontalGridLines)
{
layoutSlot.Height += decoration.BorderThickness.Top + decoration.BorderThickness.Bottom;
}
else
{
layoutSlot.Height += decoration.BorderThickness.Top;
}
}
return(layoutSlot);
}
private static void SnapToLowGridLine(OhlcDataPoint point)
{
if (point.numericalPlot.SnapBaseTickIndex == -1 ||
point.numericalPlot.SnapBaseTickIndex >= point.numericalPlot.Axis.ticks.Count)
{
return;
}
var baseTick = point.numericalPlot.Axis.ticks[point.numericalPlot.SnapBaseTickIndex];
if (!RadMath.AreClose(point.numericalPlot.NormalizedLow, (double)baseTick.normalizedValue))
{
return;
}
var tickRect = baseTick.layoutSlot;
double gridLine = tickRect.Y + (int)(tickRect.Height / 2);
double difference = gridLine - point.layoutSlot.Bottom;
point.layoutSlot.Height += difference;
if (point.layoutSlot.Height < 0)
{
point.layoutSlot.Height = 0;
}
}
private static void SnapToHighGridLine(OhlcDataPoint point)
{
if (point.numericalPlot.SnapTickIndex < 0 ||
point.numericalPlot.SnapTickIndex >= point.numericalPlot.Axis.ticks.Count)
{
return;
}
var topTick = point.numericalPlot.Axis.ticks[point.numericalPlot.SnapTickIndex];
if (!RadMath.AreClose(point.numericalPlot.NormalizedHigh, (double)topTick.normalizedValue))
{
return;
}
var tickRect = topTick.layoutSlot;
double gridLine = tickRect.Y + (int)(tickRect.Height / 2);
double difference = point.layoutSlot.Y - gridLine;
point.layoutSlot.Y -= difference;
point.layoutSlot.Height += difference;
if (point.layoutSlot.Height < 0)
{
point.layoutSlot.Height = 0;
}
}
private RadRect InflateCellDecorationHorizontally(RadRect layoutSlot, Border decoration)
{
if (decoration.BorderBrush == null)
{
return(layoutSlot);
}
if (layoutSlot.X < this.weekNumbersLineSlot.Right)
{
layoutSlot.X -= decoration.BorderThickness.Right;
layoutSlot.Width += decoration.BorderThickness.Right;
}
else if (RadMath.AreClose(layoutSlot.Right, this.Owner.CalendarViewSize.Width))
{
layoutSlot.X -= decoration.BorderThickness.Left;
layoutSlot.Width += decoration.BorderThickness.Left + decoration.BorderThickness.Right;
}
else
{
layoutSlot.X -= decoration.BorderThickness.Left;
if (this.Owner.HasVerticalGridLines)
{
layoutSlot.Width += decoration.BorderThickness.Left + decoration.BorderThickness.Right;
}
else
{
layoutSlot.Width += decoration.BorderThickness.Left;
}
}
return(layoutSlot);
}
public void SnapPointToGridLine(RangeDataPoint point)
{
if (point.numericalPlot.SnapTickIndex >= 0 && point.numericalPlot.SnapTickIndex < point.numericalPlot.Axis.ticks.Count)
{
AxisTickModel highTick = point.numericalPlot.Axis.ticks[point.numericalPlot.SnapTickIndex];
if (RadMath.AreClose(point.numericalPlot.NormalizedHigh, (double)highTick.normalizedValue))
{
if (this.PlotDirection == AxisPlotDirection.Vertical)
{
SnapHighToVerticalGridLine(point, highTick.layoutSlot);
}
else
{
SnapHighToHorizontalGridLine(point, highTick.layoutSlot);
}
}
}
if (point.numericalPlot.SnapBaseTickIndex >= 0 && point.numericalPlot.SnapBaseTickIndex < point.numericalPlot.Axis.ticks.Count)
{
AxisTickModel lowTick = point.numericalPlot.Axis.ticks[point.numericalPlot.SnapBaseTickIndex];
if (RadMath.AreClose(point.numericalPlot.NormalizedLow, (double)lowTick.normalizedValue))
{
if (this.PlotDirection == AxisPlotDirection.Vertical)
{
SnapLowToVerticalGridLine(point, lowTick.layoutSlot);
}
else
{
SnapLowToHorizontalGridLine(point, lowTick.layoutSlot);
}
}
}
}
protected override RadRect ArrangeCore(RadRect rect)
{
this.radius = rect.Width / 2;
RadPoint center = rect.Center;
AxisPlotInfo anglePlot1 = this.firstPlotInfo;
double angle1 = 0d;
NumericalAxisPlotInfo numericalAnglePlot1 = anglePlot1 as NumericalAxisPlotInfo;
if (numericalAnglePlot1 != null)
{
angle1 = numericalAnglePlot1.ConvertToAngle();
}
else
{
CategoricalAxisPlotInfo categoricalAnglePlot1 = anglePlot1 as CategoricalAxisPlotInfo;
if (categoricalAnglePlot1 != null)
{
angle1 = categoricalAnglePlot1.ConvertToAngle(this.GetChartArea <PolarChartAreaModel>());
}
}
RadPoint arcPoint1 = RadMath.GetArcPoint(angle1, center, this.radius);
this.polarVector1 = new RadPolarVector()
{
Point = arcPoint1, Angle = angle1, Center = center
};
AxisPlotInfo anglePlot2 = this.secondPlotInfo;
double angle2 = 0d;
NumericalAxisPlotInfo numericalAnglePlot2 = anglePlot2 as NumericalAxisPlotInfo;
if (numericalAnglePlot2 != null)
{
angle2 = numericalAnglePlot2.ConvertToAngle();
}
else
{
CategoricalAxisPlotInfo categoricalAnglePlot2 = anglePlot2 as CategoricalAxisPlotInfo;
if (categoricalAnglePlot2 != null)
{
angle2 = categoricalAnglePlot2.ConvertToAngle(this.GetChartArea <PolarChartAreaModel>());
}
}
RadPoint arcPoint2 = RadMath.GetArcPoint(angle2, center, this.radius);
this.polarVector2 = new RadPolarVector()
{
Point = arcPoint2, Angle = angle2, Center = center
};
return(rect);
}
internal override IEnumerable <AxisTickModel> GenerateTicks(ValueRange <decimal> currentVisibleRange)
{
// use the decimal type for higher accuracy; see the XML comments on the GetVisibleRange method
decimal delta = (decimal)this.actualRange.maximum - (decimal)this.actualRange.minimum;
if (delta <= 0)
{
yield break;
}
double scale = this.layoutStrategy.GetZoom();
double step = this.majorStep;
if (scale != 1d)
{
step = NumericalAxisModel.NormalizeStep(step / scale);
}
decimal tickStep = (decimal)step;
decimal normalizedTickStep = tickStep / delta;
currentVisibleRange.minimum -= currentVisibleRange.minimum % normalizedTickStep;
currentVisibleRange.maximum += normalizedTickStep - (currentVisibleRange.maximum % normalizedTickStep);
decimal startTick, endTick;
if (this.IsInverse)
{
startTick = Math.Max(0, 1 - currentVisibleRange.maximum);
endTick = Math.Min(1, 1 - currentVisibleRange.minimum);
}
else
{
startTick = Math.Max(0, currentVisibleRange.minimum);
endTick = Math.Min(1, currentVisibleRange.maximum);
}
decimal currentTick = startTick;
decimal value = (decimal)this.actualRange.minimum + currentTick * delta;
int virtualIndex = (int)((value - (decimal)this.actualRange.minimum) / tickStep);
while (currentTick < endTick || RadMath.AreClose((double)currentTick, (double)endTick))
{
AxisTickModel tick = new MajorTickModel();
tick.normalizedValue = this.IsInverse ? 1 - currentTick : currentTick;
tick.value = (decimal)this.ReverseTransformValue((double)value);
tick.virtualIndex = virtualIndex;
currentTick += normalizedTickStep;
value += tickStep;
virtualIndex++;
yield return(tick);
}
}
internal override RadRect GetPosition()
{
// TODO: Consider better interpretation of segments in cartesian coordinates.
var centerR = this.Radius / 2;
var centerAng = this.startAngle % 360 + this.SweepAngle / 2;
var point = RadMath.ToCartesianCoordinates(centerR, centerAng);
return(new RadRect(this.CenterPoint.X + point.X, this.CenterPoint.Y + point.Y, 1, 1));
}
internal virtual void CheckTopScrollableBounds()
{
double firstItemTop = this.GetRealizedItemsTop();
double scrollableContentTop = -this.ScrollOffset;
bool isFirstItemRealized = this.owner.GetItemBefore(this.owner.firstItemCache.associatedDataItem) == null;
if (firstItemTop != scrollableContentTop)
{
if (isFirstItemRealized && firstItemTop > scrollableContentTop)
{
double currentScrollOffset = -scrollableContentTop;
double offset = firstItemTop - scrollableContentTop;
double newOffset = currentScrollOffset - offset;
if (!RadMath.AreClose(newOffset, this.ScrollOffset, Epsilon))
{
this.ScrollToOffset(newOffset, null);
}
}
else if (isFirstItemRealized && firstItemTop < scrollableContentTop)
{
double amount = this.GetElementCanvasOffset(this.owner.itemsPanel) + (scrollableContentTop - firstItemTop);
this.SetElementCanvasOffset(this.owner.itemsPanel, amount);
double newScrollOffset = this.ScrollOffset + (scrollableContentTop - firstItemTop);
double heightCorrection = Math.Max(0, newScrollOffset - this.ScrollableLength);
if (heightCorrection > 0)
{
this.CorrectScrollableContentSize(heightCorrection);
}
// this.ScrollToOffset(Math.Min(newScrollOffset, this.ScrollableLength), null);
}
else if (scrollableContentTop > -this.scrollableContentHeightAdjustment)
{
double currentScrollOffset = -scrollableContentTop;
double adjustment = Math.Max(this.owner.GetFirstItemCacheIndex(), 1) * this.averageItemLength;
double newOffset = currentScrollOffset + adjustment;
double heightCorrection = Math.Max(0, newOffset - this.ScrollableLength);
if (heightCorrection > 0)
{
this.CorrectScrollableContentSize(heightCorrection);
}
newOffset = Math.Min(newOffset, this.ScrollableLength);
//this.ScrollToOffset(newOffset, () =>
//{
// double correction = newOffset - this.ScrollOffset;
// double amount = this.GetElementCanvasOffset(this.owner.itemsPanel) + adjustment - correction;
// this.SetElementCanvasOffset(this.owner.itemsPanel, amount);
//});
}
else
{
this.CheckResizeScrollableContentWhenAllItemsRealized();
}
}
}
/// <summary>
/// Clips the <paramref name="rect"/> to the <paramref name="container"/>.
/// </summary>
/// <param name="rect">The <see cref="RadRect"/> to be clipped.</param>
/// <param name="container">The container.</param>
/// <param name="borderOverflow">The border (stroke thickness) of the <paramref name="rect"/>.</param>
/// <param name="dashPatternLength">The length of the dash pattern of the <see cref="RadRect"/> stroke.</param>
/// <returns>The clipped rectangle.</returns>
internal static RadRect ClipRectangle(RadRect rect, RadRect container, double borderOverflow, double dashPatternLength)
{
// extend the container with the element border
container.X -= borderOverflow;
container.Y -= borderOverflow;
container.Width += 2 * borderOverflow;
container.Height += 2 * borderOverflow;
if (!rect.IntersectsWith(container))
{
return(RadRect.Empty);
}
// calculate the clipped rectangle, extended with the element border
double xFrom = RadMath.CoerceValue(rect.X, container.X, container.Right);
double yFrom = RadMath.CoerceValue(rect.Y, container.Y, container.Bottom);
double xTo = RadMath.CoerceValue(rect.Right, container.X, container.Right);
double yTo = RadMath.CoerceValue(rect.Bottom, container.Y, container.Bottom);
if (dashPatternLength == 0 || double.IsNaN(dashPatternLength) || double.IsInfinity(dashPatternLength))
{
dashPatternLength = 1;
}
// first check if "To" values are clipped, and if so, add the additional space needed by the dash array to be rendered correctly
if (rect.Right != xTo)
{
xTo += (rect.Right - xTo) % dashPatternLength;
}
if (rect.Bottom != yTo)
{
yTo += (rect.Bottom - yTo) % dashPatternLength;
}
// check if "From" values are clipped, and if so, add the additional space needed by the dash array to be rendered correctly and change the rect coordinates
if (rect.X != xFrom)
{
xFrom -= (xFrom - rect.X) % dashPatternLength;
rect.X = xFrom;
}
if (rect.Y != yFrom)
{
yFrom -= (yFrom - rect.Y) % dashPatternLength;
rect.Y = yFrom;
}
rect.Width = xTo - xFrom;
rect.Height = yTo - yFrom;
return(rect);
}
public static Geometry RenderArc(DoughnutSegmentData context)
{
PathFigure figure = new PathFigure();
figure.IsClosed = true;
figure.IsFilled = true;
RadPoint startPoint = RadMath.GetArcPoint(context.StartAngle, context.Center, context.Radius1);
figure.StartPoint = startPoint.ToPoint();
ArcSegment firstArc = new ArcSegment();
firstArc.Size = new Size(context.Radius1, context.Radius1);
firstArc.IsLargeArc = context.SweepAngle > 180 || context.SweepAngle < -180;
var angle = context.StartAngle;
if (context.SweepDirection == SweepDirection.Clockwise)
{
angle += context.SweepAngle;
}
else
{
angle -= context.SweepAngle;
}
firstArc.SweepDirection = context.SweepAngle > 0 ? context.SweepDirection : context.SweepDirection ^ SweepDirection.Clockwise;
firstArc.Point = RadMath.GetArcPoint(angle, context.Center, context.Radius1).ToPoint();
figure.Segments.Add(firstArc);
LineSegment firstLine = new LineSegment();
firstLine.Point = RadMath.GetArcPoint(angle, context.Center, context.Radius2).ToPoint();
figure.Segments.Add(firstLine);
ArcSegment secondArc = new ArcSegment();
secondArc.Size = new Size(context.Radius2, context.Radius2);
secondArc.IsLargeArc = context.SweepAngle > 180 || context.SweepAngle < -180;
secondArc.SweepDirection = context.SweepAngle > 0 ? context.SweepDirection ^ SweepDirection.Clockwise : context.SweepDirection;
secondArc.Point = RadMath.GetArcPoint(context.StartAngle, context.Center, context.Radius2).ToPoint();
figure.Segments.Add(secondArc);
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(figure);
return(geometry);
}
/// <inheritdoc/>
protected override bool ApplyTemplateCore()
{
this.ratingPanel = this.GetTemplateChild("Part_RatingPanel") as StackPanel;
if (this.ratingPanel == null)
{
throw new MissingTemplatePartException("Part_RatingPanel", typeof(StackPanel));
}
if (this.itemsSource.Count != 0)
{
if (!this.IsItemsSourceManual)
{
throw new InvalidOperationException(AutoGeneratedItemsCountExceptionMessage);
}
this.SetValue(AutoGeneratedItemsCountProperty, 0);
}
else
{
if (this.AutoGeneratedItemsCount == (int)AutoGeneratedItemsCountProperty.GetMetadata(typeof(int)).DefaultValue)
{
this.SetValue(AutoGeneratedItemsCountProperty, (int)AutoGeneratedItemsCountProperty.GetMetadata(typeof(int)).DefaultValue);
}
this.GenerateRatingItems();
}
this.PopulateRatingPanel();
double coercedValue = RadMath.CoerceValue(this.Value, 0, this.itemsSource.Count);
if (this.Value != coercedValue)
{
this.SetValuePropertySilently(ValueProperty, coercedValue);
}
double defaultValue = (double)ValueProperty.GetMetadata(typeof(double)).DefaultValue;
if (this.Value != defaultValue)
{
this.HandleValueChange(defaultValue, this.Value);
}
this.UpdateDisplayValue();
this.UpdateFillRatio();
this.UpdateVisualState(false);
return(base.ApplyTemplateCore());
}
private bool TryTranslateItemsPanelWithPullToRefreshHeight()
{
var currentOffset = this.virtualizationStrategy.GetElementCanvasOffset(this.itemsPanel);
if (RadMath.AreClose(currentOffset, 0))
{
var length = this.virtualizationStrategy.LayoutOrientation == Orientation.Vertical ? this.pullToRefreshIndicator.DesiredSize.Height : this.pullToRefreshIndicator.DesiredSize.Width;
this.TranslateItemsPanel(length);
return(true);
}
return(false);
}
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 ArrangeMenuItemControl(RadialSegment segmentModel)
{
var centerPointPolar = CoordinatesUtils.GetCenterPosition(segmentModel.LayoutSlot);
var centerPoint = RadMath.ToCartesianCoordinates(centerPointPolar.Radius, centerPointPolar.Angle);
var tranformedCenterPoint = new Point(centerPoint.X + this.Model.OuterRadius, this.Model.OuterRadius - centerPoint.Y);
var element = segmentModel.Visual as RadialMenuItemControl;
element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
var arrangeSlot = new Rect(tranformedCenterPoint.X - element.DesiredSize.Width / 2.0, tranformedCenterPoint.Y - element.DesiredSize.Height / 2.0, element.DesiredSize.Width, element.DesiredSize.Height);
element.Arrange(arrangeSlot);
Canvas.SetLeft(element, arrangeSlot.X);
Canvas.SetTop(element, arrangeSlot.Y);
}
internal virtual void CheckBottomScrollableBounds()
{
if (this.owner.RealizedItems.Length == 0)
{
return;
}
double lastItemBottom = this.GetRealizedItemsBottom();
double scrollableContentBottom = this.GetScrollableContentEnd();
bool isFirstItemRealized = this.owner.GetItemBefore(this.owner.firstItemCache.associatedDataItem) == null;
bool isLastItemRealized = this.owner.GetItemAfter(this.owner.lastItemCache.associatedDataItem) == null;
if (!RadMath.AreClose(lastItemBottom, scrollableContentBottom) || !isLastItemRealized)
{
if (isLastItemRealized)
{
double offsetChange = lastItemBottom - scrollableContentBottom;
var lastItemEnd = lastItemBottom;
var lastItemStart = this.owner.lastItemCache.CurrentOffset;
if (lastItemEnd < this.ScrollOffset + this.ViewportLength && offsetChange < 0 || lastItemStart < this.ScrollOffset + this.ViewportLength || this.ScrollOffset + this.ViewportLength > this.ScrollableLength)
{
if (!RadMath.AreClose(offsetChange, 0, 0.1))
{
this.CorrectScrollableContentSize(offsetChange);
this.owner.OnBottomEdgeCorrected();
}
}
}
else if (!RadMath.AreClose(lastItemBottom, scrollableContentBottom) && !(isFirstItemRealized && isLastItemRealized))
{
var estimatedLength = this.scrollableItemsLength;
var change = estimatedLength - scrollableContentBottom;
if (Math.Abs(change) > 0.01)
{
this.CorrectScrollableContentSize(change);
}
}
else if (isFirstItemRealized && isLastItemRealized)
{
this.CheckResizeScrollableContentWhenAllItemsRealized();
}
}
}
internal override IEnumerable <AxisTickModel> GenerateTicks(ValueRange <decimal> currentVisibleRange)
{
int categoryCount = this.categories.Count;
if (categoryCount == 0)
{
yield break;
}
int tickInterval = this.GetMajorTickInterval();
int emptyTickCount = 0;
int tickCount = categoryCount;
decimal tickStep = tickCount == 1 ? 1 : 1m / tickCount;
decimal normalizedTickStep = tickStep * 360;
decimal startTick = 0;
decimal endTick = 1 - tickStep;
decimal currentTick = startTick;
decimal value = 0;
int virtualIndex = (int)(startTick / tickStep);
while (currentTick < endTick || RadMath.AreClose((double)currentTick, (double)endTick))
{
if (emptyTickCount == 0)
{
AxisTickModel tick = new MajorTickModel();
tick.normalizedValue = this.IsInverse ? 1 - currentTick : currentTick;
tick.value = value;
tick.virtualIndex = virtualIndex;
emptyTickCount = tickInterval - 1;
yield return(tick);
}
else
{
emptyTickCount--;
}
currentTick += tickStep;
value += normalizedTickStep;
virtualIndex++;
}
}
private PathGeometry BuildPolarStripe(RadPolarVector vector, RadPolarVector nextVector, bool isLargeArc)
{
RadPoint center = this.model.layoutSlot.Center;
double radius = this.model.layoutSlot.Width / 2;
double endAngle = nextVector.Angle;
if (endAngle == 360)
{
endAngle = 0;
}
RadPoint arcEndPoint = RadMath.GetArcPoint(endAngle, center, radius);
PathGeometry geometry = new PathGeometry();
PathFigure figure = new PathFigure();
figure.IsClosed = true;
figure.IsFilled = true;
figure.StartPoint = new Point(vector.Center.X, vector.Center.Y);
// first line
figure.Segments.Add(new LineSegment()
{
Point = new Point(vector.Point.X, vector.Point.Y)
});
// arc
ArcSegment arc = new ArcSegment();
arc.SweepDirection = (this.Chart as RadPolarChart).RadialAxis.SweepDirection;
arc.Size = new Size(radius, radius);
arc.IsLargeArc = isLargeArc;
arc.Point = new Point(arcEndPoint.X, arcEndPoint.Y);
figure.Segments.Add(arc);
// second line
figure.Segments.Add(new LineSegment()
{
Point = new Point(nextVector.Point.X, nextVector.Point.Y)
});
geometry.Figures.Add(figure);
return(geometry);
}
/// <summary>
/// Clips the <paramref name="line"/> to the <paramref name="container"/>.
/// </summary>
/// <param name="line">The line to be clipped.</param>
/// <param name="container">The container.</param>
/// <param name="borderOverflow">The border (stroke thickness) of the <paramref name="line"/>.</param>
/// <param name="dashPatternLength">The length of the dash pattern of the line stroke.</param>
/// <returns>The clipped line.</returns>
internal static RadLine ClipLine(RadLine line, RadRect container, double borderOverflow, double dashPatternLength)
{
// extend the container with the element border
container.X -= borderOverflow;
container.Y -= borderOverflow;
container.Width += 2 * borderOverflow;
container.Height += 2 * borderOverflow;
bool firstPointInside = container.Contains(line.X1, line.Y1);
bool secondPointInside = container.Contains(line.X2, line.Y2);
if (firstPointInside && secondPointInside)
{
return(line);
}
if (dashPatternLength == 0 || double.IsNaN(dashPatternLength) || double.IsInfinity(dashPatternLength))
{
dashPatternLength = 1;
}
// find intersectionns of the line with the sides of the container
double topIntersectionX = RadMath.CalculateIntersectionX(line.X1, line.Y1, line.X2, line.Y2, container.Y);
double bottomIntersectionX = RadMath.CalculateIntersectionX(line.X1, line.Y1, line.X2, line.Y2, container.Bottom);
double leftIntersectionY = RadMath.CalculateIntersectionY(line.X1, line.Y1, line.X2, line.Y2, container.X);
double rightIntersectionY = RadMath.CalculateIntersectionY(line.X1, line.Y1, line.X2, line.Y2, container.Right);
// slope of the line: angle between the line ant the horizon (-pi/2, pi/2)
var angle = Math.Atan((line.Y1 - line.Y2) / (line.X2 - line.X1));
bool intersectsWithRect = false;
// clip to container sides
intersectsWithRect |= AnnotationHelper.TryClipToContainerTop(ref line, container, topIntersectionX, dashPatternLength, angle > 0 ? angle : Math.PI + angle);
intersectsWithRect |= AnnotationHelper.TryClipToContainerBottom(ref line, container, bottomIntersectionX, dashPatternLength, angle > 0 ? angle : Math.PI + angle);
intersectsWithRect |= AnnotationHelper.TryClipToContainerLeft(ref line, container, leftIntersectionY, dashPatternLength, angle);
intersectsWithRect |= AnnotationHelper.TryClipToContainerRight(ref line, container, rightIntersectionY, dashPatternLength, angle);
if (!intersectsWithRect)
{
line = new RadLine();
}
return(line);
}
private void ArrangePolarLines()
{
// update polar (radius) lines
int polarLinesIndex = 0;
if ((this.linesVisibility & PolarGridLineVisibility.Polar) == PolarGridLineVisibility.Polar)
{
double antiAliasOffset = -1;
foreach (RadPolarVector vector in this.model.polarLines)
{
Line line = this.GetLineVisual(polarLinesIndex);
line.X1 = vector.Center.X;
line.Y1 = vector.Center.Y;
line.X2 = vector.Point.X;
line.Y2 = vector.Point.Y;
if (antiAliasOffset == -1)
{
antiAliasOffset = line.StrokeThickness % 2 == 1 ? 0.5 : 0;
}
if (RadMath.AreClose(line.Y1, line.Y2))
{
line.Y1 -= antiAliasOffset;
line.Y2 -= antiAliasOffset;
}
else if (RadMath.AreClose(line.X1, line.X2))
{
line.X1 += antiAliasOffset;
line.X2 += antiAliasOffset;
}
polarLinesIndex++;
}
}
// hide not used lines
while (polarLinesIndex < this.polarLines.Count)
{
this.polarLines[polarLinesIndex].Visibility = Visibility.Collapsed;
polarLinesIndex++;
}
}