com.dua3.utility.swing.StyledDocumentConverter Maven / Gradle / Ivy

Go to download
// Copyright (c) 2019 Axel Howind
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT

package com.dua3.utility.swing;

import com.dua3.utility.data.Pair;
import com.dua3.utility.text.AttributeBasedConverter;
import com.dua3.utility.text.Font;
import com.dua3.utility.text.RichText;
import com.dua3.utility.text.TextAttributes;

import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

/**
 * A {@link AttributeBasedConverter} implementation for translating
 * {@code RichText} to StyledDocument.
 *
 * @author Axel Howind ([email protected])
 */
public final class StyledDocumentConverter extends AttributeBasedConverter {

    private static final Font DEFAULT_FONT = new Font();
    private final SimpleAttributeSet defaultStyledAttributes = new SimpleAttributeSet();
    // some settings controlling the conversion
    private Font defaultFont = DEFAULT_FONT;
    private Map defaultAttributes = new HashMap<>();
    private double scale = 1.0;
    // -- define a dictionary to map StyleConstants attribute keys to calls to Font getters
    @SuppressWarnings("NumericCastThatLosesPrecision")
    private final Map> dictionary = Map.of(
            StyleConstants.Family, Font::getFamily,
            StyleConstants.Size, f -> (int) Math.round(scale * f.getSizeInPoints()),
            StyleConstants.Bold, Font::isBold,
            StyleConstants.Italic, Font::isItalic,
            StyleConstants.Underline, Font::isUnderline,
            StyleConstants.StrikeThrough, Font::isStrikeThrough,
            StyleConstants.Foreground, f -> SwingUtil.toAwtColor(f.getColor())
    );

    private StyledDocumentConverter() {
    }

    /**
     * Create a new converter instance.
     *
     * @param options the options to use
     * @return new converter instance
     */
    public static StyledDocumentConverter create(StyledDocumentConversionOption... options) {
        return create(List.of(options));
    }

    /**
     * Create a new converter instance.
     *
     * @param options the options to use
     * @return new converter instance
     */
    public static StyledDocumentConverter create(Collection options) {
        StyledDocumentConverter instance = new StyledDocumentConverter();
        options.forEach(o -> o.apply(instance));
        return instance;
    }

    /**
     * Set default attributes.
     *
     * @param attributes attributes for new StyledDocuments
     * @return the option to use
     */
    public static StyledDocumentConversionOption addStyledAttributes(Map attributes) {
        return addStyledAttributes(attributes.entrySet());
    }

    /**
     * Set default attributes.
     *
     * @param attributes attributes for new StyledDocuments
     * @return the option to use
     */
    public static StyledDocumentConversionOption addStyledAttributes(Iterable> attributes) {
        return new StyledDocumentConversionOption(c -> attributes.forEach(p -> c.defaultStyledAttributes.addAttribute(p.getKey(), p.getValue())));
    }

    /**
     * Set default attributes.
     *
     * @param attributes attributes for new StyledDocuments
     * @return the option to use
     */
    public static StyledDocumentConversionOption addStyledAttributes(AttributeSet attributes) {
        return new StyledDocumentConversionOption(c -> c.defaultStyledAttributes.addAttributes(attributes));
    }

    /**
     * Set default attributes.
     *
     * @param attributes the default Attributes
     * @return the option to use
     */
    public static StyledDocumentConversionOption defaultAttributes(Map attributes) {
        return new StyledDocumentConversionOption(c -> c.defaultAttributes = attributes);
    }

    /**
     * Set default font.
     *
     * @param font the default font
     * @return the option to use
     */
    public static StyledDocumentConversionOption defaultFont(Font font) {
        return new StyledDocumentConversionOption(c -> c.defaultFont = font);
    }

    /**
     * Set font scaling factor.
     *
     * @param scale the font scaling factor
     * @return the option to use
     */
    public static StyledDocumentConversionOption scale(double scale) {
        return new StyledDocumentConversionOption(c -> c.setScale(scale));
    }

    @Override
    protected AttributeBasedConverterImpl createConverter(RichText text) {
        return new StyledDocumentConverterImpl();
    }

    /**
     * Set the scale to use in conversion. This scale will be applied to all font sizes during conversion.
     *
     * @param scale the scale
     */
    public void setScale(double scale) {
        this.scale = scale;
    }

    class StyledDocumentConverterImpl extends AttributeBasedConverterImpl {

        private final StyledDocument buffer;
        private AttributeSet currentAttributes;
        private Font currentFont;

        StyledDocumentConverterImpl() {
            super(defaultAttributes);
            buffer = new DefaultStyledDocument();
            currentAttributes = defaultStyledAttributes;
            currentFont = defaultFont;
        }

        @Override
        protected StyledDocument get() {
            return buffer;
        }

        @Override
        protected void apply(Map> changedAttributes) {
            Map attributes = new HashMap<>();
            changedAttributes.forEach((attribute, values) -> attributes.put(attribute, values.second()));
            // apply the default font styles 
            currentFont = currentFont.deriveFont(TextAttributes.getFontDef(attributes));
            currentAttributes = createAttributeSet(currentFont);
        }

        @Override
        protected void appendChars(CharSequence s) {
            try {
                int pos = buffer.getLength();
                int length = s.length();
                buffer.insertString(pos, s.toString(), currentAttributes);
                buffer.setCharacterAttributes(pos, length, currentAttributes, true);
                buffer.setParagraphAttributes(pos, length, currentAttributes, true);
            } catch (BadLocationException e) {
                // this should never happen
                throw new IllegalStateException(e);
            }
        }

        /**
         * Create AttributeSet for a Font instance
         *
         * @param font the font
         * @return the AttributeSet
         */
        private AttributeSet createAttributeSet(Font font) {
            SimpleAttributeSet attrs = new SimpleAttributeSet();
            attrs.addAttributes(defaultStyledAttributes);
            dictionary.forEach((key, getter) -> attrs.addAttribute(key, getter.apply(font)));
            return attrs;
        }

    }
}