Ejemplo n.º 1
0
        public void DrawClosedCurve(AbstractPen pen, AbstractBrush brush, PointF[] points, float tension)
        {
            var e = Append(new Element(ElementNames.PATH));

            e.Set("d", ToSVG(points, tension, true));
            e.Apply(pen, brush);
        }
Ejemplo n.º 2
0
        public void DrawPath(AbstractPen pen, AbstractBrush brush, AbstractPath path)
        {
            var e = Append(new Element(ElementNames.PATH));

            e.Set("d", ToSVG(path));
            e.Apply(pen, brush);
        }
Ejemplo n.º 3
0
        // String is positioned relative to x,y according to TextFormat.
        // TextFormat also controls text alignment (left, center, right).
        // Handles embedded newlines.
        public static void DrawString(AbstractGraphics g, string text, Font font, AbstractBrush brush, float x, float y, TextFormat format = TextFormat.Center)
        {
            if (string.IsNullOrWhiteSpace(text))
            {
                return;
            }

            var lines = text.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None).ToList();
            var sizes = lines.Select(s => g.MeasureString(s, font)).ToList();

            float fontUnitsToWorldUnits = font.Size / font.FontFamily.GetEmHeight(font.Style);
            float lineSpacing           = font.FontFamily.GetLineSpacing(font.Style) * fontUnitsToWorldUnits;
            float ascent = font.FontFamily.GetCellAscent(font.Style) * fontUnitsToWorldUnits;
            //float descent = font.FontFamily.GetCellDescent(font.Style) * fontUnitsToWorldUnits;

            SizeF boundingSize = new SizeF(sizes.Max(s => s.Width), lineSpacing * sizes.Count());

            // Offset from baseline to top-left.
            y += lineSpacing / 2;

            float widthFactor = 0;

            switch (format)
            {
            case TextFormat.MiddleLeft:
            case TextFormat.Center:
            case TextFormat.MiddleRight:
                y -= boundingSize.Height / 2;
                break;

            case TextFormat.BottomLeft:
            case TextFormat.BottomCenter:
            case TextFormat.BottomRight:
                y -= boundingSize.Height;
                break;
            }

            switch (format)
            {
            case TextFormat.TopCenter:
            case TextFormat.Center:
            case TextFormat.BottomCenter:
                widthFactor = -0.5f;
                break;

            case TextFormat.TopRight:
            case TextFormat.MiddleRight:
            case TextFormat.BottomRight:
                widthFactor = -1;
                break;
            }

            lines.ForEachZip(sizes, (line, sz) =>
            {
                g.DrawString(line, font, brush, x + widthFactor * sz.Width + sz.Width / 2, y, Graphics.StringAlignment.Centered);
                y += lineSpacing;
            });
        }
Ejemplo n.º 4
0
        public void DrawRectangle(AbstractPen pen, AbstractBrush brush, float x, float y, float width, float height)
        {
            var e = Append(new Element(ElementNames.RECT));

            e.Set("x", x);
            e.Set("y", y);
            e.Set("width", width);
            e.Set("height", height);
            e.Apply(pen, brush);
        }
Ejemplo n.º 5
0
 public void DrawString(string s, Font font, AbstractBrush brush, float x, float y, StringAlignment format)
 {
     Apply(brush);
     if (format == StringAlignment.Baseline)
     {
         float fontUnitsToWorldUnits = font.Size / font.FontFamily.GetEmHeight(font.Style);
         float ascent = font.FontFamily.GetCellAscent(font.Style) * fontUnitsToWorldUnits;
         g.DrawString(s, font, this.brush, x, y - ascent);
     }
     else
     {
         g.DrawString(s, font, this.brush, x, y, Format(format));
     }
 }
Ejemplo n.º 6
0
        public void DrawString(string s, Font font, AbstractBrush brush, float x, float y, StringAlignment alignment)
        {
            var e = Append(new Element(ElementNames.TEXT));

            e.content = s;

            e.Set("font-family", font.Name);
            e.Set("font-size", font.Size);
            if (font.Italic)
            {
                e.Set("font-style", "italic");
            }
            if (font.Bold)
            {
                e.Set("font-weight", "bold");
            }
            if (font.Underline)
            {
                e.Set("text-decoration", "underline");
            }
            else if (font.Strikeout)
            {
                e.Set("text-decoration", "line-through");
            }

            switch (alignment)
            {
            case StringAlignment.Centered: y += (font.Size * 0.85f) / 2; e.Set("text-anchor", "middle"); break;

            case StringAlignment.TopLeft: y += font.Size * 0.85f; break;

            case StringAlignment.TopCenter: y += font.Size * 0.85f; e.Set("text-anchor", "middle"); break;

            case StringAlignment.TopRight: y += font.Size * 0.85f; e.Set("text-anchor", "end"); break;

            case StringAlignment.CenterLeft: y += (font.Size * 0.85f) / 2; break;

            case StringAlignment.Baseline: break;

            default: throw new ApplicationException("Unhandled string alignment");
            }

            e.Set("x", x);
            e.Set("y", y);
            e.Apply(brush);
        }
Ejemplo n.º 7
0
        public void DrawEllipse(AbstractPen pen, AbstractBrush brush, float x, float y, float width, float height)
        {
            Element e;

            if (width == height)
            {
                e = Append(new Element(ElementNames.CIRCLE));
                e.Set("r", width / 2);
            }
            else
            {
                e = Append(new Element(ElementNames.ELLIPSE));
                e.Set("rx", width / 2);
                e.Set("ry", height / 2);
            }
            e.Set("cx", x + width / 2);
            e.Set("cy", y + height / 2);
            e.Apply(pen, brush);
        }
Ejemplo n.º 8
0
        internal void Paint(AbstractGraphics graphics, Color dotColor, AbstractBrush labelBrush, AbstractFont labelFont)
        {
            if (graphics == null)
            {
                throw new ArgumentNullException(nameof(graphics));
            }

            Point pt = Astrometrics.LocationToCoordinates(Location);

            using (graphics.Save())
            {
                graphics.TranslateTransform(pt.X, pt.Y);
                graphics.ScaleTransform(1.0f / Astrometrics.ParsecScaleX, 1.0f / Astrometrics.ParsecScaleY);

                const float radius = 3;

                AbstractBrush brush = new AbstractBrush(dotColor);
                AbstractPen   pen   = new AbstractPen(dotColor);
                graphics.SmoothingMode = SmoothingMode.HighQuality;
                graphics.DrawEllipse(pen, brush, -radius / 2, -radius / 2, radius, radius);

                RenderUtil.TextFormat format;
                if (LabelBiasX > 0)
                {
                    format = LabelBiasY < 0 ? RenderUtil.TextFormat.BottomLeft : LabelBiasY > 0 ? RenderUtil.TextFormat.TopLeft : RenderUtil.TextFormat.MiddleLeft;
                }
                else if (LabelBiasX < 0)
                {
                    format = LabelBiasY < 0 ? RenderUtil.TextFormat.BottomRight : LabelBiasY > 0 ? RenderUtil.TextFormat.TopRight : RenderUtil.TextFormat.MiddleRight;
                }
                else
                {
                    format = LabelBiasY < 0 ? RenderUtil.TextFormat.BottomCenter : LabelBiasY > 0 ? RenderUtil.TextFormat.TopCenter : RenderUtil.TextFormat.Center;
                }

                float y = (LabelBiasY * radius / 2);
                float x = (LabelBiasX * radius / 2);

                RenderUtil.DrawString(graphics, Name, labelFont, labelBrush, x, y, format);
            }
        }
Ejemplo n.º 9
0
        internal void Fill(AbstractGraphics graphics, RectangleF rect, AbstractBrush fillBrush)
        {
            if (graphics == null)
            {
                throw new ArgumentNullException("graphics");
            }

            RectangleF bounds = TransformedBounds;

            if (bounds.IntersectsWith(rect))
            {
                var path = Path;

                using (graphics.Save())
                {
                    XMatrix matrix = new XMatrix();
                    matrix.ScalePrepend(ScaleX, ScaleY);
                    matrix.TranslatePrepend(-OriginX, -OriginY);
                    graphics.MultiplyTransform(matrix);
                    graphics.DrawPath(fillBrush, path);
                }
            }
        }
Ejemplo n.º 10
0
 public void DrawPath(AbstractBrush brush, AbstractPath path)
 {
     DrawPath(null, brush, path);
 }
Ejemplo n.º 11
0
 public void DrawEllipse(AbstractBrush brush, float x, float y, float width, float height)
 {
     Apply(brush); g.DrawEllipse(this.brush, x, y, width, height);
 }
Ejemplo n.º 12
0
 public void DrawString(string s, Font font, AbstractBrush brush, float x, float y, StringAlignment format)
 {
     Apply(brush);
     g.DrawString(s, Convert(font), this.brush, x, y, Format(format));
 }
Ejemplo n.º 13
0
 public void DrawPath(AbstractBrush brush, AbstractPath path)
 {
     Apply(brush); g.FillPath(this.brush, new GraphicsPath(path.Points, path.Types, FillMode.Winding));
 }
Ejemplo n.º 14
0
 public void DrawClosedCurve(AbstractBrush brush, PointF[] points, float tension)
 {
     Apply(brush); g.FillClosedCurve(this.brush, points, FillMode.Winding, tension);
 }
Ejemplo n.º 15
0
 private void Apply(AbstractBrush brush)
 {
     this.brush.Color = brush.Color;
 }
Ejemplo n.º 16
0
 public void DrawClosedCurve(AbstractBrush brush, PointF[] points, float tension)
 {
     DrawClosedCurve(null, brush, points, tension);
 }
Ejemplo n.º 17
0
 public void Apply(AbstractBrush brush)
 {
     Set("fill", brush?.Color ?? Color.Empty);
 }
Ejemplo n.º 18
0
 public void DrawClosedCurve(AbstractBrush brush, PointF[] points, float tension)
 {
     Apply(brush); g.DrawClosedCurve(this.brush, points, XFillMode.Alternate, tension);
 }
Ejemplo n.º 19
0
        public static void DrawLabel(AbstractGraphics g, string text, PointF center, AbstractFont font, AbstractBrush brush, LabelStyle labelStyle)
        {
            using (g.Save())
            {
                if (labelStyle.Uppercase)
                {
                    text = text.ToUpper();
                }
                if (labelStyle.Wrap)
                {
                    text = text.Replace(' ', '\n');
                }

                g.TranslateTransform(center.X, center.Y);
                g.ScaleTransform(1.0f / Astrometrics.ParsecScaleX, 1.0f / Astrometrics.ParsecScaleY);

                g.TranslateTransform(labelStyle.Translation.X, labelStyle.Translation.Y);
                g.RotateTransform(labelStyle.Rotation);
                g.ScaleTransform(labelStyle.Scale.Width, labelStyle.Scale.Height);

                if (labelStyle.Rotation != 0 && g.Graphics != null)
                {
                    g.Graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
                }

                DrawString(g, text, font, brush, 0, 0);
            }
        }
Ejemplo n.º 20
0
 private void Apply(AbstractPen pen, AbstractBrush brush)
 {
     Apply(pen); Apply(brush);
 }
Ejemplo n.º 21
0
 public void DrawRectangle(AbstractBrush brush, RectangleF rect)
 {
     Apply(brush); g.FillRectangle(this.brush, rect);
 }
Ejemplo n.º 22
0
 public void DrawRectangle(AbstractBrush brush, RectangleF rect)
 {
     DrawRectangle(null, brush, rect.X, rect.Y, rect.Width, rect.Height);
 }
Ejemplo n.º 23
0
 public void Apply(AbstractPen pen, AbstractBrush brush)
 {
     Apply(pen);
     Apply(brush);
 }
Ejemplo n.º 24
0
 public void DrawEllipse(AbstractBrush brush, float x, float y, float width, float height)
 {
     DrawEllipse(null, brush, x, y, width, height);
 }
Ejemplo n.º 25
0
 public void DrawRectangle(AbstractBrush brush, float x, float y, float width, float height)
 {
     Apply(brush); g.FillRectangle(this.brush, x, y, width, height);
 }
Ejemplo n.º 26
0
        internal void DrawName(AbstractGraphics graphics, RectangleF rect, AbstractFont font, AbstractBrush textBrush, LabelStyle labelStyle)
        {
            if (graphics == null)
            {
                throw new ArgumentNullException(nameof(graphics));
            }

            RectangleF bounds = TransformedBounds;

            if (bounds.IntersectsWith(rect))
            {
                if (Name != null)
                {
                    string str = Name;
                    if (labelStyle.Uppercase)
                    {
                        str = str.ToUpperInvariant();
                    }

                    PointF pos = NamePosition;// PointF( bounds.Left + bounds.Width / 2, bounds.Top + bounds.Height / 2 );

                    using (graphics.Save())
                    {
                        graphics.TranslateTransform(pos.X, pos.Y);
                        graphics.ScaleTransform(1.0f / Astrometrics.ParsecScaleX, 1.0f / Astrometrics.ParsecScaleY);
                        graphics.RotateTransform(-labelStyle.Rotation); // Rotate it

                        RenderUtil.DrawString(graphics, str, font, textBrush, 0, 0);
                    }
                }
            }
        }
Ejemplo n.º 27
0
 public void DrawEllipse(AbstractPen pen, AbstractBrush brush, float x, float y, float width, float height)
 {
     Apply(pen, brush); g.FillEllipse(this.brush, x, y, width, height); g.DrawEllipse(this.pen, x, y, width, height);
 }
Ejemplo n.º 28
0
        public static void DrawGlyph(AbstractGraphics g, Glyph glyph, FontCache styleRes, AbstractBrush brush, PointF pt)
        {
            AbstractFont font;
            string       s = glyph.Characters;

            if (g.SupportsWingdings && s.All(c => DING_MAP.ContainsKey(c)))
            {
                s    = string.Join("", s.Select(c => DING_MAP[c]));
                font = styleRes.WingdingFont;
            }
            else
            {
                font = styleRes.GlyphFont;
            }

            g.DrawString(s, font, brush, pt.X, pt.Y, Maps.Graphics.StringAlignment.Centered);
        }
Ejemplo n.º 29
0
 public void Apply(AbstractBrush brush)
 {
     Set("fill", brush == null ? Color.Empty : brush.Color);
 }