/*
* 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: AbstractFOPTextPainter.java 1664570 2015-03-06 09:41:07Z lbernardo $ */
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 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. /**
* 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 /** 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.
/**
* 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.
Params: - nativeTextHandler – the NativeTextHandler instance used for text painting
/**
* 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.
Params: - node – the TextNode to paint
- g2d – the Graphics2D to use
/**
* 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.
Params: - g2d – the Graphics2D instance to check
Returns: true if the Graphics2D is supported
/**
* 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.
Params: - aci – ACI to inspect
Returns: the extracted text
/**
* 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.
Params: - node – the text node
Returns: the outline shape of the text characters
/**
* 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.
Params: - node – the text node
Returns: the bounds of the text
/**
* 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.
Params: - node – the text node
Returns: the bounds of the text
/**
* 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.
Params: - node – the text node
- pos – the position
- all – select all
Returns: null
/**
* 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.
Params: - x – the x position
- y – the y position
- node – the text node
Returns: 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.
Params: - x – the x position
- y – the y position
- beginMark – the start mark
Returns: 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.
Params: - node – the text node
Returns: 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.
Params: - node – the text node
Returns: 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.
Params: - start – the start mark
- finish – the finish mark
Returns: 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.
Params: - beginMark – the start mark
- endMark – the end mark
Returns: 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;
}
}