Drawing.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.gui.diagram;
 
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.util.LinkedList;
 
import de.lathanda.eos.base.util.GuiToolkit;
 
public class Drawing {
    private static final BufferedImage DUMMY = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
    private static final Graphics2D DUMMY_G = DUMMY.createGraphics();
    private final float scale;
    private final float fontScale2pixel;
    private Font font;
    private Font originalFont;
    private final LinkedList<Translation> transformations = new LinkedList<>();
    private Translation translation = new Translation();
    private Graphics2D g;
 
    public Drawing() {
        this(GuiToolkit.getScreenResolution(), DUMMY_G);
    }
 
    public Drawing(float dpi) {
        this(dpi, DUMMY_G);
    }
 
    public Drawing(float dpi, Graphics2D g) {
        scale = dpi / 25.4f;
        fontScale2pixel = dpi / 72f;
        this.g = g;
        setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 12));
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    }
 
    public void init(Graphics2D g) {
        while (!transformations.isEmpty()) {
            popTransform();
        }
        this.g = g;
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    }
 
    public float stringWidth(String text) {
        return g.getFontMetrics(font).stringWidth(text) / scale;
    }
 
    public float getAscent() {
        return g.getFontMetrics(font).getAscent() / scale;
    }
 
    public float getHeight() {
        return g.getFontMetrics(font).getHeight() / scale;
    }
 
    public void drawLine(float x1, float y1, float x2, float y2) {
        g.drawLine(xp(x1), yp(y1), xp(x2), yp(y2));
    }
 
    public void drawString(String text, float x, float y) {
        g.drawString(text, xp(x), yp(y));
    }
 
    public void setFont(Font font) {
        originalFont = font;
        this.font = font.deriveFont(font.getSize2D() * fontScale2pixel);
        g.setFont(this.font);
    }
 
    public Font getFont() {
        return originalFont;
    }
 
    public void setDrawWidth(float width) {
        g.setStroke(new BasicStroke(width * scale));
    }
 
    public void setColor(Color c) {
        g.setColor(c);
    }
 
    public Color getColor() {
        return g.getColor();
    }
 
    public void drawEllipse(float x, float y, float width, float height) {
        g.drawOval(xp(x), yp(y), wp(x, width), hp(y, height));
    }
 
    public void drawRect(float x, float y, float width, float height) {
        g.drawRect(xp(x), yp(y), wp(x, width), hp(y, height));
    }
 
    public void drawRoundRect(float x, float y, float width, float height, float radius) {
        RoundRectangle2D roundedRectangle = new RoundRectangle2D.Float(xp(x), yp(y), wp(x, width), hp(y, height),
                scale(radius), scale(radius));
        g.draw(roundedRectangle);
    }
 
    public void fillRect(float x, float y, float width, float height) {
        g.fillRect(xp(x), yp(y), wp(x, width), hp(y, height));
    }
 
    public void drawPolygon(float[] x, float[] y, int n) {
        int[] ix = new int[n];
        int[] iy = new int[n];
        for (int i = n; i-- > 0;) {
            ix[i] = xp(x[i]);
            iy[i] = yp(y[i]);
        }
        g.drawPolygon(ix, iy, n);
    }
 
    private int xp(float x) {
        return (int) ((x + translation.x) * scale);
    }
 
    private int yp(float y) {
        return (int) ((y + translation.y) * scale);
    }
 
    private int wp(float x, float w) {
        return xp(x + w) - xp(x);
    }
 
    private int hp(float y, float h) {
        return yp(y + h) - yp(y);
    }
 
    private int scale(float val) {
        return (int) (scale * val);
    }
 
    public void drawArrow(float x1, float y1, float x2, float y2, float size) {
        float dx = x2 - x1;
        float dy = y2 - y1;
        float length = (float) Math.sqrt(dx * dx + dy * dy);
        dx = dx * size / length;
        dy = dy * size / length;
        float xb = x2 - dx;
        float yb = y2 - dy;
        drawLine(x1, y1, x2, y2);
        drawLine(x2, y2, xb - dy * 0.5f, yb + dx * 0.5f);
        drawLine(x2, y2, xb + dy * 0.5f, yb - dx * 0.5f);
    }
 
    public void pushTransform() {
        transformations.push(translation.copy());
    }
 
    public void popTransform() {
        translation = transformations.pop();
    }
 
    public void translate(float dx, float dy) {
        translation.add(dx, dy);
    }
 
    public int convertmm2pixel(float mm) {
        return (int) (mm * scale);
    }
 
    public float convertpixel2mm(int pixel) {
        return pixel / scale;
    }
 
    private static class Translation {
        float x;
        float y;
 
        Translation copy() {
            Translation t = new Translation();
            t.x = this.x;
            t.y = this.y;
            return t;
        }
 
        void add(float dx, float dy) {
            x += dx;
            y += dy;
        }
    }
}