Question

I am trying to create a custom shape class, that is basically a hexagon, but with few extra properties and methods.

I tried inheriting it from the Polygon class, but it would not allow it, as the Polygon class is sealed, so I inherited it from the abstract Shape class, but don’t know what to do next. So far my code looks like this

public class Cell : Shape
{
    private Polygon poly;
    private Point[] points = new Point[6];
    public PointCollection Points { get; set; }
    public double Radius { get; set; }
    public Point Center { get; set; }
    public Cell()
    {
        points[0] = new Point(Center.X - 1 / 2 * Radius, Center.Y - Radius * 0.866);
        points[1] = new Point(Center.X + 1 / 2 * Radius, Center.Y - Radius * 0.866);
        points[2] = new Point(Center.X + Radius, Center.Y);
        points[3] = new Point(Center.X + 1 / 2 * Radius, Center.Y + Radius * 0.866);
        points[4] = new Point(Center.X - 1 / 2 * Radius, Center.Y + Radius * 0.866);
        points[5] = new Point(Center.X - Radius, Center.Y);

        Points = new PointCollection();
        foreach (Point p in points)
            Points.Add(p);
        poly = new Polygon();
        poly.Points = this.Points;
    }
}

Now, I want to be able to declare it in XAML as such:

<local:Cell Center="20,20" Radius="10" Stroke="Blue" Fill="White"/>

And I also want it to be visible in the constructor.

What else do I need to add to my class to be able to do that? Is there a certain interface I need to implement or method that I need to override?

Answer 1

I did something similar to produce a semicircle shape. You need to inherit from Shape and override DefiningGeometry and MeasureOverride. In DefiningGeometry you will do the actual drawing and return the geometry.

For you properties to be visible in XAML you just need to add properties to your class. Plain .NET properties will show up, but you’ll probably want to add dependency properties and set the AffectsRender FrameworkPropertyMetadataOptions so that it will force a redraw when you change the properties.

Here’s what my class looked like:

public class SemiCircle : Shape
{
    /// <summary>
    /// Gets or set the alignment of the semicircle. I.e. where should the flat part point.
    /// </summary>
    public SemiCircleAlignment Alignment
    {
        get { return (SemiCircleAlignment)GetValue(AlignmentProperty); }
        set { SetValue(AlignmentProperty, value); }
    }

    // Using a DependencyProperty as the backing store for alignment.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty AlignmentProperty =
        DependencyProperty.Register("Alignment", typeof(SemiCircleAlignment), typeof(SemiCircle), 
        new FrameworkPropertyMetadata(SemiCircleAlignment.Top,FrameworkPropertyMetadataOptions.AffectsRender));

    protected override System.Windows.Media.Geometry DefiningGeometry
    {
        get 
        {
            StreamGeometry geometry = new StreamGeometry();
            using (StreamGeometryContext context = geometry.Open())
            {
                DrawSemiCircle(context);
            }
            geometry.Freeze();
            return geometry;
        }
    }

    protected override Size MeasureOverride(Size constraint)
    {
        if (constraint.Height == double.PositiveInfinity || constraint.Width == double.PositiveInfinity)
        {
            if (double.IsNaN(Width) || double.IsNaN(Height))
            {
                return new Size(0, 0);
            }
            return new Size(Width, Height);
        }
        return constraint;
    }

    private void DrawSemiCircle(StreamGeometryContext context)
    {
        double tOff = StrokeThickness / 2.0;                // an offset to account for stroke thickness
        Point startPt = new Point(tOff, tOff);                                   // upper left corner
        if (Alignment == SemiCircleAlignment.Bottom || Alignment == SemiCircleAlignment.Right)
        {
            startPt = new Point(ActualWidth - tOff, ActualHeight - tOff);        // or lower right corner
        }
        Point endPt = new Point(ActualWidth - tOff,tOff);                         // upper right corner
        if (Alignment == SemiCircleAlignment.Left || Alignment == SemiCircleAlignment.Bottom)
        {
            endPt = new Point(tOff, ActualHeight - tOff);                         // or lower left corner
        }
        Size s = new Size(Math.Max(0.0,(ActualWidth / 2) - tOff), 
            Math.Max(0,ActualHeight - StrokeThickness));    // half width is radius
        SweepDirection sweep = SweepDirection.Counterclockwise;    
        if (Alignment == SemiCircleAlignment.Left || Alignment == SemiCircleAlignment.Right)
        {
            s = new Size(Math.Max(0,ActualWidth - StrokeThickness),
                Math.Max(0.0,(ActualHeight / 2) - tOff));     // or half height is radius
            sweep = SweepDirection.Clockwise;
        }

        context.BeginFigure(startPt, true, true);
        context.ArcTo(endPt, s, 0, false, sweep, true, false);
    }
}

public enum SemiCircleAlignment { Left, Top, Right, Bottom };