|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
//
// Description:
// Implementation of Ellipse shape element.
//
using System.Windows.Media;
namespace System.Windows.Shapes
{
/// <summary>
/// The ellipse shape element
/// This element (like all shapes) belongs under a Canvas,
/// and will be presented by the parent canvas.
/// </summary>
/// <ExternalAPI/>
public sealed class Ellipse : Shape
{
#region Constructors
/// <summary>
/// Instantiates a new instance of a Ellipse.
/// </summary>
/// <ExternalAPI/>
public Ellipse()
{
}
// The default stretch mode of Ellipse is Fill
static Ellipse()
{
StretchProperty.OverrideMetadata(typeof(Ellipse), new FrameworkPropertyMetadata(Stretch.Fill));
}
#endregion Constructors
#region Dynamic Properties
// For an Ellipse, RenderedGeometry = defining geometry and GeometryTransform = Identity
/// <summary>
/// The RenderedGeometry property returns the final rendered geometry
/// </summary>
public override Geometry RenderedGeometry
{
get
{
// RenderedGeometry = defining geometry
return DefiningGeometry;
}
}
/// <summary>
/// Return the transformation applied to the geometry before rendering
/// </summary>
public override Transform GeometryTransform
{
get
{
return Transform.Identity;
}
}
#endregion Dynamic Properties
#region Protected
/// <summary>
/// Updates DesiredSize of the Ellipse. Called by parent UIElement. This is the first pass of layout.
/// </summary>
/// <param name="constraint">Constraint size is an "upper limit" that Ellipse should not exceed.</param>
/// <returns>Ellipse's desired size.</returns>
protected override Size MeasureOverride(Size constraint)
{
if (Stretch == Stretch.UniformToFill)
{
double width = constraint.Width;
double height = constraint.Height;
if (Double.IsInfinity(width) && Double.IsInfinity(height))
{
return GetNaturalSize();
}
else if (Double.IsInfinity(width) || Double.IsInfinity(height))
{
width = Math.Min(width, height);
}
else
{
width = Math.Max(width, height);
}
return new Size(width, width);
}
return GetNaturalSize();
}
/// <summary>
/// Returns the final size of the shape and caches the bounds.
/// </summary>
protected override Size ArrangeOverride(Size finalSize)
{
// We construct the rectangle to fit finalSize with the appropriate Stretch mode. The rendering
// transformation will thus be the identity.
double penThickness = GetStrokeThickness();
double margin = penThickness / 2;
_rect = new Rect(
margin, // X
margin, // Y
Math.Max(0, finalSize.Width - penThickness), // Width
Math.Max(0, finalSize.Height - penThickness)); // Height
switch (Stretch)
{
case Stretch.None:
// A 0 Rect.Width and Rect.Height rectangle
_rect.Width = _rect.Height = 0;
break;
case Stretch.Fill:
// The most common case: a rectangle that fills the box.
// _rect has already been initialized for that.
break;
case Stretch.Uniform:
// The maximal square that fits in the final box
if (_rect.Width > _rect.Height)
{
_rect.Width = _rect.Height;
}
else // _rect.Width <= _rect.Height
{
_rect.Height = _rect.Width;
}
break;
case Stretch.UniformToFill:
// The minimal square that fills the final box
if (_rect.Width < _rect.Height)
{
_rect.Width = _rect.Height;
}
else // _rect.Width >= _rect.Height
{
_rect.Height = _rect.Width;
}
break;
}
ResetRenderedGeometry();
return finalSize;
}
/// <summary>
/// Get the ellipse that defines this shape
/// </summary>
protected override Geometry DefiningGeometry
{
get
{
if (_rect.IsEmpty)
{
return Geometry.Empty;
}
return new EllipseGeometry(_rect);
}
}
/// <summary>
/// Render callback.
/// </summary>
protected override void OnRender(DrawingContext drawingContext)
{
if (!_rect.IsEmpty)
{
Pen pen = GetPen();
drawingContext.DrawGeometry(Fill, pen, new EllipseGeometry(_rect));
}
}
#endregion Protected
#region Internal Methods
internal override void CacheDefiningGeometry()
{
double margin = GetStrokeThickness() / 2;
_rect = new Rect(margin, margin, 0, 0);
}
/// <summary>
/// Get the natural size of the geometry that defines this shape
/// </summary>
internal override Size GetNaturalSize()
{
double strokeThickness = GetStrokeThickness();
return new Size(strokeThickness, strokeThickness);
}
/// <summary>
/// Get the bonds of the rectangle that defines this shape
/// </summary>
internal override Rect GetDefiningGeometryBounds()
{
return _rect;
}
//
// This property
// 1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject
// 2. This is a performance optimization
//
internal override int EffectiveValuesInitialSize
{
get { return 13; }
}
#endregion Internal Methods
#region Private Fields
private Rect _rect = Rect.Empty;
#endregion Private Fields
}
}
|