design/designer-base/src/main/java/com/fr/design/cell/CellStylePreviewPane.java

package com.fr.design.cell;

import com.fr.base.BaseUtils;
import com.fr.base.GraphHelper;
import com.fr.base.NameStyle;
import com.fr.base.ScreenResolution;
import com.fr.base.Style;
import com.fr.general.FRFont;
import com.fr.general.IOUtils;
import com.fr.stable.Constants;
import com.fr.stable.unit.PT;

import javax.swing.JPanel;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.util.List;

/**
 * @author Starryi
 * @version 1.0
 * Created by Starryi on 2021/9/3
 */
public class CellStylePreviewPane extends JPanel {

    public static final int MINIMUM_HEIGHT = 40;
    private static final BufferedImage transparentBackgroundImage = IOUtils.readImage("/com/fr/design/images/transparent_background.png");
    private final float transparentBackgroundWidth;
    private final float transparentBackgroundHeight;
    private String paintText = "Report";
    private Style style = Style.DEFAULT_STYLE;

    private final int column;
    private final int row;
    private final int columnSpan;
    private final int rowSpan;

    private final boolean autoClearCanvas;
    private final boolean paintingMosaic;

    public CellStylePreviewPane(int column, int row, int columnSpan, int rowSpan, boolean autoClearCanvas, boolean paintingMosaic) {
        this.column = column;
        this.row = row;
        this.columnSpan = columnSpan;
        this.rowSpan = rowSpan;
        this.autoClearCanvas  = autoClearCanvas;
        this.paintingMosaic = paintingMosaic;
        transparentBackgroundWidth = transparentBackgroundImage.getWidth(null);
        transparentBackgroundHeight = transparentBackgroundImage.getHeight(null);
        setPreferredSize(new Dimension(0, 0));
    }

    public void setPaintText(String paintText) {
        this.paintText = paintText;
        repaint();
    }

    public void setStyle(Style style) {
        this.style = style;
        repaint();
    }

    public void setStyle(NameStyle style) {
        paintText = style.getName();
        setStyle(style.getRealStyle());
    }

    @Override
    public void paint(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;
        if (autoClearCanvas) {
            g2d.clearRect(0, 0, getWidth(), getHeight());
        }
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        if (paintingMosaic) {
            paintTransparentBackground(g2d, style);
        }

        paintCellStyle(g2d, style);

        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
    }

    private void paintTransparentBackground(Graphics2D g2d, Style style) {
        float alpha = computeTransparentBackgroundAlpha(style);

        float scaleWidth = 1.0F * getWidth() / transparentBackgroundWidth;
        float scaleHeight = 1.0F * getHeight() / transparentBackgroundHeight;
        float maxScale = Math.max(scaleWidth, scaleHeight);

        if (maxScale <= 1) {
            scaleWidth = scaleHeight = 1;
        } else {
            scaleHeight = scaleWidth = maxScale;
        }

        Composite oldComposite = g2d.getComposite();
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        g2d.drawImage(transparentBackgroundImage, 0, 0, (int) (transparentBackgroundWidth * scaleWidth), (int) (transparentBackgroundHeight * scaleHeight), null);
        g2d.setComposite(oldComposite);
    }

    private float computeTextColorBrightness(Style style) {
        Color fontColor = style.getFRFont().getForeground();
        return fontColor.getRed() * 0.299F + fontColor.getGreen() * 0.587F + fontColor.getBlue() * 0.114F;
    }

    private float computeTransparentBackgroundAlpha(Style style) {
        float textBrightness = computeTextColorBrightness(style);

        float alpha = 1.0F;
        if (textBrightness < 50) {
            alpha = 0.2F;
        } else if (textBrightness < 160){
            alpha = 0.5F;
        }
        return alpha;
    }

    private void paintCellStyle(Graphics2D g2d, Style style) {
        int resolution = ScreenResolution.getScreenResolution();

        int width = getWidth();
        int height = getHeight();

        if (style == Style.DEFAULT_STYLE) {
            // 如果是默认的style,就只写"Report"上去
            Style.paintContent(g2d, paintText, style, width, height, resolution);
            return;
        }

        Style.paintBackground(g2d, style, width, height);

        Style.paintContent(g2d, paintText, style, width, height, resolution);

        paintCellBorder(g2d, style);
    }

    protected void paintCellBorder(Graphics2D g2d, Style style) {
        float adjustLeft = 0;
        float adjustTop = 0;
        float adjustRight = 0;
        float adjustBottom = 0;
        if (column == 0) {
            adjustLeft = computeHalfSize4StyledBorder(style.getBorderLeft());
        }
        if (row == 0) {
            adjustTop = computeHalfSize4StyledBorder(style.getBorderTop());
        }
        if (column == columnSpan - 1) {
            adjustRight = -computeHalfSize4StyledBorder(style.getBorderRight());
        }
        if (row == rowSpan - 1) {
            adjustBottom = -computeHalfSize4StyledBorder(style.getBorderBottom());
        }

        g2d.translate(adjustLeft, adjustTop);
        Style.paintBorder(g2d, style, getWidth() - adjustLeft + adjustRight, getHeight() - adjustTop + adjustBottom);
        g2d.translate(-adjustLeft, -adjustTop);
    }

    private float computeHalfSize4StyledBorder(int border) {
        float size = GraphHelper.getLineStyleSize(border) / 2.0F;

        if (border == Constants.LINE_DOUBLE) {
            size += GraphHelper.getLineStyleSize(Constants.LINE_THIN) / 2.0F;
        } else if (border == Constants.LINE_DOUBLE_DOT) {
            size += GraphHelper.getLineStyleSize(Constants.LINE_DOT) / 2.0F;
        }

        return size;
    }

    @Override
    public Dimension getPreferredSize() {
        Dimension size = super.getPreferredSize();
        int width = size.width;
        int height = size.height;

        if (height != 0) {
            // 使用者设置了一个高度
            return size;
        } else if (width == 0) {
            // 使用者未设置任何尺寸
            return new Dimension(width, MINIMUM_HEIGHT);
        } else {
            // 使用者设置了宽度，但未设置高度
            return getAutoWrapContentPreferredSize(width, height);
        }
    }

    private Dimension getAutoWrapContentPreferredSize(int width, int height) {
        int resolution = ScreenResolution.getScreenResolution();

        // 计算文本区域高度
        final FRFont frFont = style.getFRFont();
        final Font rfont = frFont.applyResolutionNP(resolution);
        final FontMetrics metrics = GraphHelper.getFontMetrics(rfont);
        final int textLineHeight = metrics.getHeight();
        final double textLineSpacing = PT.pt2pix(style.getLineSpacing(), resolution);

        List<?> textLineList = BaseUtils.getLineTextList(paintText, style, rfont, height, width, resolution);

        double textLinesHeight = textLineList.size() * textLineHeight + Math.max(0, textLineList.size() - 1) * textLineSpacing;

        height = (int) Math.max(MINIMUM_HEIGHT, textLinesHeight);

        return new Dimension(width, height);
    }
}