/// <summary>
/// Retrieves the template parts of the control.
/// </summary>
protected override bool ApplyTemplateCore()
{
base.ApplyTemplateCore();
this.qualitativeBarPart = this.GetTemplatePartField <SegmentedLinearGaugeIndicator>(QualitativeBarPartName);
bool applied = this.qualitativeBarPart != null;
if (applied)
{
foreach (BarIndicatorSegment segment in this.QualitativeRanges)
{
this.qualitativeBarPart.Segments.Add(segment);
}
this.QualitativeRanges.Clear();
this.QualitativeRanges = this.qualitativeBarPart.Segments;
}
this.comparativeMeasurePart = this.GetTemplatePartField <MarkerGaugeIndicator>(ComparativeMeasurePartName);
applied = applied && this.comparativeMeasurePart != null;
this.scalePart = this.GetTemplatePartField <RadLinearGauge>(ScalePartName);
applied = applied && this.scalePart != null;
if (applied)
{
foreach (BulletGraphComparativeMeasure measure in this.AdditionalComparativeMeasures)
{
this.scalePart.Indicators.Add(measure.Visual);
this.SyncComparativeMeasureTemplate(measure);
}
}
return(applied);
}
/// <summary>
/// This is a virtual method that resets the state of the indicator.
/// The parent range is responsible to (indirectly) call this method when
/// a property of importance changes.
/// </summary>
/// <param name="availableSize">A size which can be used by the update logic.</param>
/// <remarks>
/// The linear range for example triggers the UpdateOverride() method
/// of its indicators when its Orientation property changes.
/// </remarks>
internal override void UpdateOverride(Size availableSize)
{
this.isHorizontal = RadLinearGauge.GetOrientation(this) == Orientation.Horizontal;
this.minValue = this.Owner.OwnerGauge.MinValue;
base.UpdateOverride(availableSize);
}
private Point ArrangeRectangle(double value, Size finalSize)
{
Point result = new Point();
double finalValue = Math.Abs(value - this.StartValue);
double extent = RadGauge.MapLogicalToPhysicalValue(finalValue, this.isHorizontal ? finalSize.Width : finalSize.Height, this.MinMaxValueDifference);
bool flip = this.Value < this.StartValue;
double barLength = extent;
if (this.isHorizontal)
{
this.bar.Width = barLength;
this.bar.Height = this.Thickness;
result.X = flip ? this.barLocation - extent : this.barLocation;
result.Y = ((finalSize.Height / 2) - (this.bar.Height / 2)) + RadLinearGauge.GetIndicatorOffset(this);
}
else
{
this.bar.Height = barLength;
this.bar.Width = this.Thickness;
result.X = ((finalSize.Width / 2) - (this.bar.Width / 2)) + RadLinearGauge.GetIndicatorOffset(this);
result.Y = flip ? this.barLocation : this.barLocation - extent;
}
return(result);
}
/// <summary>
/// This is a virtual method that resets the state of the indicator.
/// The parent range is responsible to (indirectly) call this method when
/// a property of importance changes.
/// </summary>
/// <param name="availableSize">A size which can be used by the update logic.</param>
/// <remarks>
/// The linear range for example triggers the UpdateOverride() method
/// of its indicators when its Orientation property changes.
/// </remarks>
internal override void UpdateOverride(Size availableSize)
{
base.UpdateOverride(availableSize);
this.isHorizontal = RadLinearGauge.GetOrientation(this) == Orientation.Horizontal;
this.UpdateBarLocation(this.StartValue);
}
/// <summary>
/// A virtual method that is called when the Owner of this indicator changes.
/// </summary>
/// <param name="newOwner">The new Owner.</param>
/// <param name="oldOwner">The old Owner.</param>
internal override void OnOwnerChanged(GaugePanel newOwner, GaugePanel oldOwner)
{
base.OnOwnerChanged(newOwner, oldOwner);
Orientation orientation = RadLinearGauge.GetOrientation(newOwner);
this.isHorizontal = orientation == Orientation.Horizontal;
RadLinearGauge.SetOrientation(this, orientation);
}
private Point CreateStartPoint(Size rangeSize)
{
double halfVisualElementWidth = this.visualElement.DesiredSize.Width / 2;
double halfVisualElementHeight = this.visualElement.DesiredSize.Height / 2;
if (this.isHorizontal)
{
return(new Point(-halfVisualElementWidth, ((rangeSize.Height / 2) - halfVisualElementHeight) + RadLinearGauge.GetIndicatorOffset(this)));
}
return(new Point(((rangeSize.Width / 2) - halfVisualElementWidth) + RadLinearGauge.GetIndicatorOffset(this), rangeSize.Height - halfVisualElementHeight));
}
private void PrivateUpdate()
{
if (this.Owner != null && this.Owner.OwnerGauge is RadRadialGauge)
{
var gauge = (RadRadialGauge)this.Owner.OwnerGauge;
this.maxAngle = gauge.MaxAngle;
this.minAngle = gauge.MinAngle;
}
this.isHorizontal = RadLinearGauge.GetOrientation(this.Owner) == Orientation.Horizontal;
this.minValue = this.Owner.OwnerGauge.MinValue;
}
/// <summary>
/// Called in the arrange pass of the layout system.
/// </summary>
/// <param name="finalSize">The final size that was given by the layout system.</param>
/// <returns>The final size of the panel.</returns>
protected override Size ArrangeOverride(Size finalSize)
{
this.isHorizontal = RadLinearGauge.GetOrientation(this.OwnerGauge) == Orientation.Horizontal;
this.availableExtent = this.isHorizontal ? finalSize.Width : finalSize.Height;
this.halfAvailableExtent = this.availableExtent / 2;
this.halfAvailableWidth = finalSize.Width / 2;
this.halfAvailableHeight = finalSize.Height / 2;
return(base.ArrangeOverride(finalSize));
}
/// <summary>
/// This method is called whenever the segments
/// need to recreate their visual representation.
/// </summary>
/// <param name="availableSize">The available size which the visual parts can occupy.</param>
internal override void ResetSegments(Size availableSize)
{
this.SegmentInfos.Clear();
this.extent = this.isHorizontal ? availableSize.Width : availableSize.Height;
double logicalRange = this.MinMaxValueDifference;
double physicalStart = RadGauge.MapLogicalToPhysicalValue(this.StartValue - this.minValue, this.extent, logicalRange);
double indicatorExtent = RadGauge.MapLogicalToPhysicalValue(this.ActualValue - this.minValue, this.extent, logicalRange) - physicalStart;
double startPosition = this.isHorizontal ? physicalStart : (this.extent - physicalStart);
double halfAvailableWidth = availableSize.Width / 2;
double halfAvailableHeight = availableSize.Height / 2;
double offset = RadLinearGauge.GetIndicatorOffset(this);
foreach (BarIndicatorSegment segment in this.Segments)
{
if (segment.Path == null)
{
Debug.Assert(false, "Missing segment path.");
continue;
}
double lengthRatio = segment.Length / this.TotalSegmentLength;
double lineLength = indicatorExtent * lengthRatio;
SegmentInfo info = new SegmentInfo();
info.Start = startPosition;
info.End = startPosition + (this.isHorizontal ? lineLength : -lineLength);
this.SegmentInfos.Add(info);
LineSegment line = new LineSegment();
line.Point = this.isHorizontal ? new Point(info.End, halfAvailableHeight + offset) : new Point(halfAvailableWidth + offset, info.End);
info.PathSegment = line;
PathFigure figure = new PathFigure();
figure.StartPoint = this.isHorizontal ? new Point(info.Start, halfAvailableHeight + offset) : new Point(halfAvailableWidth + offset, info.Start);
figure.Segments.Add(line);
PathGeometry geom = new PathGeometry();
geom.Figures.Add(figure);
Path path = segment.Path;
path.Stroke = segment.Stroke;
path.StrokeThickness = segment.Thickness;
path.Data = geom;
startPosition = info.End;
}
}
/// <summary>
/// A virtual method that is called when the Orientation property changes.
/// </summary>
/// <param name="newOrientation">The new Orientation.</param>
/// <param name="oldOrientation">The old Orientation.</param>
internal virtual void OnOrientationChanged(Orientation newOrientation, Orientation oldOrientation)
{
this.isHorizontal = newOrientation == Orientation.Horizontal;
foreach (UIElement element in this.Indicators)
{
GaugeIndicator indicator = element as GaugeIndicator;
if (indicator == null)
{
continue;
}
RadLinearGauge.SetOrientation(indicator, newOrientation);
}
this.InvalidateMeasure();
}
/// <summary>
/// Initializes a new instance of the BulletGraphMeasureBase class.
/// </summary>
protected BulletGraphMeasureBase()
{
this.Visual = this.CreateVisual();
RadLinearGauge.SetIndicatorOffset(this.Visual, -20);
}