path: root/src/java/org/apache/fop/svg/AbstractFOPTextPainter.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */

package org.apache.fop.svg;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.text.AttributedCharacterIterator;
import java.text.CharacterIterator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.batik.bridge.Mark;
import org.apache.batik.bridge.StrokingTextPainter;
import org.apache.batik.bridge.TextNode;
import org.apache.batik.bridge.TextPainter;
import org.apache.batik.gvt.text.GVTAttributedCharacterIterator;
import org.apache.batik.gvt.text.TextPaintInfo;

import org.apache.fop.afp.AFPGraphics2D;
import org.apache.fop.fonts.Font;

/**
 * Renders the attributed character iterator of a {@link TextNode}.
 * This class draws the text directly into the Graphics2D so that
 * the text is not drawn using shapes.
 * If the text is simple enough to draw then it sets the font and calls
 * drawString. If the text is complex or the cannot be translated
 * into a simple drawString the StrokingTextPainter is used instead.
 */
public abstract class AbstractFOPTextPainter implements TextPainter {

    /** the logger for this class */
    protected Log log = LogFactory.getLog(AbstractFOPTextPainter.class);

    private final FOPTextHandler nativeTextHandler;

    /**
     * Use the stroking text painter to get the bounds and shape.
     * Also used as a fallback to draw the string with strokes.
     */
    private final TextPainter proxyTextPainter;

    /**
     * Create a new PS text painter with the given font information.
     * @param nativeTextHandler the NativeTextHandler instance used for text painting
     */
    public AbstractFOPTextPainter(FOPTextHandler nativeTextHandler, TextPainter proxyTextPainter) {
        this.nativeTextHandler = nativeTextHandler;
        this.proxyTextPainter = proxyTextPainter;
    }

    /**
     * Paints the specified attributed character iterator using the
     * specified Graphics2D and context and font context.
     *
     * @param node the TextNode to paint
     * @param g2d the Graphics2D to use
     */
    public void paint(TextNode node, Graphics2D g2d) {
        if (isSupportedGraphics2D(g2d)) {
            new TextRunPainter().paintTextRuns(node.getTextRuns(), g2d, node.getLocation());
        }
        proxyTextPainter.paint(node, g2d);
    }

    /**
     * Checks whether the Graphics2D is compatible with this text painter. Batik may
     * pass in a Graphics2D instance that paints on a special buffer image, for example
     * for filtering operations. In that case, the text painter should be bypassed.
     * @param g2d the Graphics2D instance to check
     * @return true if the Graphics2D is supported
     */
    protected abstract boolean isSupportedGraphics2D(Graphics2D g2d);

    private class TextRunPainter {

        private Point2D currentLocation;

        public void paintTextRuns(Iterable<StrokingTextPainter.TextRun> textRuns, Graphics2D g2d,
                Point2D nodeLocation) {
            currentLocation = new Point2D.Double(nodeLocation.getX(), nodeLocation.getY());
            for (StrokingTextPainter.TextRun run : textRuns) {
                paintTextRun(run, g2d);
            }
        }

        private void paintTextRun(StrokingTextPainter.TextRun run, Graphics2D g2d) {
            AttributedCharacterIterator aci = run.getACI();
            aci.first();
            updateLocationFromACI(aci, currentLocation);
            // font
            Font font = getFont(aci);
            if (font != null) {
                nativeTextHandler.setOverrideFont(font);
            }
            // color
            TextPaintInfo tpi = (TextPaintInfo) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.PAINT_INFO);
            if (tpi == null) {
                return;
            }
            Paint foreground = tpi.fillPaint;
            if (foreground instanceof Color) {
                Color col = (Color) foreground;
                g2d.setColor(col);
            }
            g2d.setPaint(foreground);
            // text anchor
            TextNode.Anchor anchor = (TextNode.Anchor) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.ANCHOR_TYPE);
            // text
            String txt = getText(aci);
            double advance = font == null ? run.getLayout().getAdvance2D().getX() : getStringWidth(txt, font);
            double tx = 0;
            if (anchor != null) {
                switch (anchor.getType()) {
                case TextNode.Anchor.ANCHOR_MIDDLE:
                    tx = -advance / 2;
                    break;
                case TextNode.Anchor.ANCHOR_END:
                    tx = -advance;
                    break;
                default: //nop
                }
            }
            // draw string
            Point2D outputLocation = g2d.getTransform().transform(currentLocation, null);
            double x = outputLocation.getX();
            double y = outputLocation.getY();
            try {
                try {
                    AFPGraphics2D afpg2d = (AFPGraphics2D)g2d;
                    int fontSize = 0;
                    if (font != null) {
                        fontSize = (int) Math.round(afpg2d.convertToAbsoluteLength(font.getFontSize()));
                    }
                    if (fontSize < 6000) {
                        nativeTextHandler.drawString(g2d, txt, (float) (x + tx), (float) y);
                    } else {
                        double scaleX = g2d.getTransform().getScaleX();
                        for (int i = 0; i < txt.length(); i++) {
                            double ad = run.getLayout().getGlyphAdvances()[i] * scaleX;
                            nativeTextHandler.drawString(g2d, txt.charAt(i) + "", (float) (x + tx + ad), (float) y);
                        }
                    }
                    //TODO draw underline and overline if set
                    //TODO draw strikethrough if set
                } catch (IOException ioe) {
                    if (g2d instanceof AFPGraphics2D) {
                        ((AFPGraphics2D) g2d).handleIOException(ioe);
                    }
                }
            } finally {
                nativeTextHandler.setOverrideFont(null);
            }
            currentLocation.setLocation(currentLocation.getX() + advance, currentLocation.getY());
        }
        private void updateLocationFromACI(AttributedCharacterIterator aci, Point2D loc) {
            //Adjust position of span
            Float xpos = (Float) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.X);
            Float ypos = (Float) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.Y);
            Float dxpos = (Float) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.DX);
            Float dypos = (Float) aci.getAttribute(
                    GVTAttributedCharacterIterator.TextAttribute.DY);
            if (xpos != null) {
                loc.setLocation(xpos.doubleValue(), loc.getY());
            }
            if (ypos != null) {
                loc.setLocation(loc.getX(), ypos.doubleValue());
            }
            if (dxpos != null) {
                loc.setLocation(loc.getX() + dxpos.doubleValue(), loc.getY());
            }
            if (dypos != null) {
                loc.setLocation(loc.getX(), loc.getY() + dypos.doubleValue());
            }
        }
    }

    /**
     * Extract the raw text from an ACI.
     * @param aci ACI to inspect
     * @return the extracted text
     */
    protected String getText(AttributedCharacterIterator aci) {
        StringBuffer sb = new StringBuffer(aci.getEndIndex() - aci.getBeginIndex());
        for (char c = aci.first(); c != CharacterIterator.DONE; c = aci.next()) {
            sb.append(c);
        }
        return sb.toString();
    }

    private Font getFont(AttributedCharacterIterator aci) {
        Font[] fonts = ACIUtils.findFontsForBatikACI(aci, nativeTextHandler.getFontInfo());
        return fonts == null ? null : fonts[0];
    }

    private float getStringWidth(String str, Font font) {
        float wordWidth = 0;
        float whitespaceWidth = font.getWidth(font.mapChar(' '));

        for (int i = 0; i < str.length(); i++) {
            float charWidth;
            char c = str.charAt(i);
            if (!((c == ' ') || (c == '\n') || (c == '\r') || (c == '\t'))) {
                charWidth = font.getWidth(font.mapChar(c));
                if (charWidth <= 0) {
                    charWidth = whitespaceWidth;
                }
            } else {
                charWidth = whitespaceWidth;
            }
            wordWidth += charWidth;
        }
        return wordWidth / 1000f;
    }

    /**
     * Get the outline shape of the text characters.
     * This uses the StrokingTextPainter to get the outline
     * shape since in theory it should be the same.
     *
     * @param node the text node
     * @return the outline shape of the text characters
     */
    public Shape getOutline(TextNode node) {
        return proxyTextPainter.getOutline(node);
    }

    /**
     * Get the bounds.
     * This uses the StrokingTextPainter to get the bounds
     * since in theory it should be the same.
     *
     * @param node the text node
     * @return the bounds of the text
     */
    public Rectangle2D getBounds2D(TextNode node) {
        /* (todo) getBounds2D() is too slow
         * because it uses the StrokingTextPainter. We should implement this
         * method ourselves. */
        return proxyTextPainter.getBounds2D(node);
    }

    /**
     * Get the geometry bounds.
     * This uses the StrokingTextPainter to get the bounds
     * since in theory it should be the same.
     *
     * @param node the text node
     * @return the bounds of the text
     */
    public Rectangle2D getGeometryBounds(TextNode node) {
        return proxyTextPainter.getGeometryBounds(node);
    }

    // Methods that have no purpose for PS

    /**
     * Get the mark.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param node the text node
     * @param pos the position
     * @param all select all
     * @return null
     */
    public Mark getMark(TextNode node, int pos, boolean all) {
        return null;
    }

    /**
     * Select at.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param x the x position
     * @param y the y position
     * @param node the text node
     * @return null
     */
    public Mark selectAt(double x, double y, TextNode node) {
        return null;
    }

    /**
     * Select to.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param x the x position
     * @param y the y position
     * @param beginMark the start mark
     * @return null
     */
    public Mark selectTo(double x, double y, Mark beginMark) {
        return null;
    }

    /**
     * Selec first.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param node the text node
     * @return null
     */
    public Mark selectFirst(TextNode node) {
        return null;
    }

    /**
     * Select last.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param node the text node
     * @return null
     */
    public Mark selectLast(TextNode node) {
        return null;
    }

    /**
     * Get selected.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param start the start mark
     * @param finish the finish mark
     * @return null
     */
    public int[] getSelected(Mark start, Mark finish) {
        return null;
    }

    /**
     * Get the highlighted shape.
     * This does nothing since the output is AFP and not interactive.
     *
     * @param beginMark the start mark
     * @param endMark the end mark
     * @return null
     */
    public Shape getHighlightShape(Mark beginMark, Mark endMark) {
        return null;
    }

}