private static List <Point> ScaledPointList(IList <Point> pointList, GeometryScale scaledWidth, GeometryScale scaledHeight) { List <Point> Result = new List <Point>(); foreach (Point Point in pointList) { Result.Add(ScaledPoint(Point, scaledWidth, scaledHeight)); } return(Result); }
private static Point PrescaledPoint(Point point, Rect bounds, GeometryScale widthScale, GeometryScale heightScale) { double X = point.X; double Y = point.Y; if (widthScale != null) { double Width = bounds.Width; X -= bounds.Top; if (X < widthScale.Low) { X = X - widthScale.Low; } else if (X > Width - widthScale.High) { X = X - (Width - widthScale.High) + 1; } else { X = (X - widthScale.Low) / (Width - widthScale.High - widthScale.Low); } } if (heightScale != null) { double Height = bounds.Height; Y -= bounds.Top; if (Y < heightScale.Low) { Y = Y - heightScale.Low; } else if (Y > Height - heightScale.High) { Y = Y - (Height - heightScale.High) + 1; } else { Y = (Y - heightScale.Low) / (Height - heightScale.High - heightScale.Low); } } return(new Point(X, Y)); }
/// <summary> /// Initializes a new instance of the <see cref="ScalableGeometry"/> class. /// </summary> /// <param name="glyphGeometry">The base geometry.</param> /// <param name="bounds">The region to scale within.</param> /// <param name="isWidthScaled">True if the width should be scaled.</param> /// <param name="leftPercent">The fraction of the left side to scale if <paramref name="isWidthScaled"/> is true.</param> /// <param name="rightPercent">The fraction of the right side to scale if <paramref name="isWidthScaled"/> is true.</param> /// <param name="isHeightScaled">True if the height should be scaled.</param> /// <param name="topPercent">The fraction of the top side to scale if <paramref name="isHeightScaled"/> is true.</param> /// <param name="bottomPercent">The fraction of the bottom side to scale if <paramref name="isHeightScaled"/> is true.</param> public ScalableGeometry(Geometry glyphGeometry, Rect bounds, bool isWidthScaled, double leftPercent, double rightPercent, bool isHeightScaled, double topPercent, double bottomPercent) { PathFigure GlyphFigure; if (GeometryToFigure(glyphGeometry, out GlyphFigure)) { Bounds = bounds; if (isWidthScaled) { double GlyphWidth = bounds.Width; WidthScale = new GeometryScale(GlyphWidth * leftPercent, GlyphWidth * rightPercent); } else { WidthScale = null; } if (isHeightScaled) { double GlyphHeight = bounds.Height; HeightScale = new GeometryScale(GlyphHeight * topPercent, GlyphHeight * bottomPercent); } else { HeightScale = null; } if (WidthScale != null || HeightScale != null) { Figure = PrescaledPathFigure(GlyphFigure, bounds, WidthScale, HeightScale); } else { Figure = GlyphFigure; HeightScale = null; } } else { Figure = null; WidthScale = null; HeightScale = null; } }
private static Point ScaledPoint(Point point, GeometryScale scaledWidth, GeometryScale scaledHeight) { double X = point.X; double Y = point.Y; if (scaledWidth != null) { if (X < 0) { X = X + scaledWidth.Low; } else if (X > 1) { X = X + scaledWidth.Scale - scaledWidth.High - 1; } else { X = (X * (scaledWidth.Scale - scaledWidth.Low - scaledWidth.High)) + scaledWidth.Low; } } if (scaledHeight != null) { if (Y < 0) { Y = Y + scaledHeight.Low; } else if (Y > 1) { Y = Y + scaledHeight.Scale - scaledHeight.High - 1; } else { Y = (Y * (scaledHeight.Scale - scaledHeight.Low - scaledHeight.High)) + scaledHeight.Low; } } return(new Point(X, Y)); }
/// <summary> /// Returns the geometry scaled to the provided size. /// </summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> public Geometry Scaled(double width, double height) { StreamGeometry Result = new StreamGeometry(); GeometryScale ScaledWidth = (WidthScale != null) ? new GeometryScale(WidthScale, width) : null; GeometryScale ScaledHeight = (HeightScale != null) ? new GeometryScale(HeightScale, height) : null; using (StreamGeometryContext sgc = Result.Open()) { sgc.BeginFigure(ScaledPoint(Figure.StartPoint, ScaledWidth, ScaledHeight), Figure.IsFilled, Figure.IsClosed); foreach (PathSegment Segment in Figure.Segments) { LineSegment AsLineSegment; PolyLineSegment AsPolyLineSegment; BezierSegment AsBezierSegment; PolyBezierSegment AsPolyBezierSegment; if ((AsLineSegment = Segment as LineSegment) != null) { sgc.LineTo(ScaledPoint(AsLineSegment.Point, ScaledWidth, ScaledHeight), AsLineSegment.IsStroked, AsLineSegment.IsSmoothJoin); } else if ((AsPolyLineSegment = Segment as PolyLineSegment) != null) { sgc.PolyLineTo(ScaledPointList(AsPolyLineSegment.Points, ScaledWidth, ScaledHeight), AsPolyLineSegment.IsStroked, AsPolyLineSegment.IsSmoothJoin); } else if ((AsBezierSegment = Segment as BezierSegment) != null) { sgc.BezierTo(ScaledPoint(AsBezierSegment.Point1, ScaledWidth, ScaledHeight), ScaledPoint(AsBezierSegment.Point2, ScaledWidth, ScaledHeight), ScaledPoint(AsBezierSegment.Point3, ScaledWidth, ScaledHeight), AsBezierSegment.IsStroked, AsBezierSegment.IsSmoothJoin); } else if ((AsPolyBezierSegment = Segment as PolyBezierSegment) != null) { sgc.PolyBezierTo(ScaledPointList(AsPolyBezierSegment.Points, ScaledWidth, ScaledHeight), AsPolyBezierSegment.IsStroked, AsPolyBezierSegment.IsSmoothJoin); } } } return(Result); }
/// <summary> /// Initializes a new instance of the <see cref="ScalableGeometry"/> class. /// </summary> /// <param name="figure">The path figure that constitutes the geometry.</param> /// <param name="bounds">The region to scale within.</param> /// <param name="isWidthScaled">True if the goemetry must be scaled horizontally.</param> /// <param name="isHeightScaled">True if the goemetry must be scaled vertically.</param> public ScalableGeometry(PathFigure figure, Rect bounds, bool isWidthScaled, bool isHeightScaled) { Figure = figure; Bounds = bounds; if (isWidthScaled) { WidthScale = new GeometryScale(bounds.Left < 0 ? -bounds.Left : 0, bounds.Right > 1 ? bounds.Right - 1 : 0); } else { WidthScale = null; } if (isHeightScaled) { HeightScale = new GeometryScale(bounds.Top < 0 ? -bounds.Top : 0, bounds.Bottom > 1 ? bounds.Bottom - 1 : 0); } else { HeightScale = null; } }
private static IList <Point> PrescaledPointList(IList <Point> pointList, Rect bounds, GeometryScale widthScale, GeometryScale heightScale) { List <Point> Result = new List <Point>(); foreach (Point point in pointList) { Result.Add(PrescaledPoint(point, bounds, widthScale, heightScale)); } return(Result); }
private static PathSegment PrescaledPathSegment(PathSegment segment, Rect bounds, GeometryScale widthScale, GeometryScale heightScale) { LineSegment AsLineSegment; PolyLineSegment AsPolyLineSegment; BezierSegment AsBezierSegment; PolyBezierSegment AsPolyBezierSegment; if ((AsLineSegment = segment as LineSegment) != null) { return(new LineSegment(PrescaledPoint(AsLineSegment.Point, bounds, widthScale, heightScale), AsLineSegment.IsStroked)); } else if ((AsPolyLineSegment = segment as PolyLineSegment) != null) { return(new PolyLineSegment(PrescaledPointList(AsPolyLineSegment.Points, bounds, widthScale, heightScale), AsPolyLineSegment.IsStroked)); } else if ((AsBezierSegment = segment as BezierSegment) != null) { return(new BezierSegment(PrescaledPoint(AsBezierSegment.Point1, bounds, widthScale, heightScale), PrescaledPoint(AsBezierSegment.Point2, bounds, widthScale, heightScale), PrescaledPoint(AsBezierSegment.Point3, bounds, widthScale, heightScale), AsBezierSegment.IsStroked)); } else if ((AsPolyBezierSegment = segment as PolyBezierSegment) != null) { return(new PolyBezierSegment(PrescaledPointList(AsPolyBezierSegment.Points, bounds, widthScale, heightScale), AsPolyBezierSegment.IsStroked)); } else { return(segment.Clone()); } }
private static PathFigure PrescaledPathFigure(PathFigure figure, Rect bounds, GeometryScale widthScale, GeometryScale heightScale) { List <PathSegment> SegmentList = new List <PathSegment>(); foreach (PathSegment Item in figure.Segments) { SegmentList.Add(PrescaledPathSegment(Item, bounds, widthScale, heightScale)); } return(new PathFigure(PrescaledPoint(figure.StartPoint, bounds, widthScale, heightScale), SegmentList, figure.IsClosed)); }