| /* |
| * 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.render.ps; |
| |
| import java.awt.Color; |
| import java.awt.Graphics2D; |
| import java.awt.Paint; |
| import java.awt.Shape; |
| import java.awt.Stroke; |
| import java.awt.geom.AffineTransform; |
| import java.awt.geom.PathIterator; |
| import java.awt.geom.Point2D; |
| import java.awt.geom.Point2D.Double; |
| import java.io.IOException; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.apache.batik.gvt.text.TextPaintInfo; |
| |
| import org.apache.xmlgraphics.java2d.ps.PSGraphics2D; |
| import org.apache.xmlgraphics.ps.PSGenerator; |
| |
| import org.apache.fop.fonts.Font; |
| import org.apache.fop.fonts.FontInfo; |
| import org.apache.fop.fonts.FontMetrics; |
| import org.apache.fop.fonts.LazyFont; |
| import org.apache.fop.fonts.MultiByteFont; |
| import org.apache.fop.svg.NativeTextPainter; |
| import org.apache.fop.util.HexEncoder; |
| |
| /** |
| * Renders the attributed character iterator of a {@link org.apache.batik.bridge.TextNode TextNode}. |
| * This class draws the text directly using PostScript text operators so |
| * the text is not drawn using shapes which makes the PS files larger. |
| * <p> |
| * The text runs are split into smaller text runs that can be bundles in single |
| * calls of the xshow, yshow or xyshow operators. For outline text, the charpath |
| * operator is used. |
| */ |
| public class PSTextPainter extends NativeTextPainter { |
| |
| private FontResourceCache fontResources; |
| |
| private PSGraphics2D ps; |
| |
| private PSGenerator gen; |
| |
| private TextUtil textUtil; |
| |
| private boolean flushCurrentRun; |
| |
| private PSTextRun psRun; |
| |
| private Double relPos; |
| |
| private static final AffineTransform IDENTITY_TRANSFORM = new AffineTransform(); |
| |
| /** |
| * Create a new PS text painter with the given font information. |
| * @param fontInfo the font collection |
| */ |
| public PSTextPainter(FontInfo fontInfo) { |
| super(fontInfo); |
| this.fontResources = new FontResourceCache(fontInfo); |
| } |
| |
| /** {@inheritDoc} */ |
| protected boolean isSupported(Graphics2D g2d) { |
| return g2d instanceof PSGraphics2D; |
| } |
| |
| @Override |
| protected void preparePainting(Graphics2D g2d) { |
| ps = (PSGraphics2D) g2d; |
| gen = ps.getPSGenerator(); |
| ps.preparePainting(); |
| } |
| |
| @Override |
| protected void saveGraphicsState() throws IOException { |
| gen.saveGraphicsState(); |
| } |
| |
| @Override |
| protected void restoreGraphicsState() throws IOException { |
| gen.restoreGraphicsState(); |
| } |
| |
| @Override |
| protected void setInitialTransform(AffineTransform transform) throws IOException { |
| gen.concatMatrix(transform); |
| } |
| |
| private PSFontResource getResourceForFont(Font f, String postfix) { |
| String key = (postfix != null ? f.getFontName() + '_' + postfix : f.getFontName()); |
| return this.fontResources.getFontResourceForFontKey(key); |
| } |
| |
| @Override |
| protected void clip(Shape shape) throws IOException { |
| if (shape == null) { |
| return; |
| } |
| ps.getPSGenerator().writeln("newpath"); |
| PathIterator iter = shape.getPathIterator(IDENTITY_TRANSFORM); |
| ps.processPathIterator(iter); |
| ps.getPSGenerator().writeln("clip"); |
| } |
| |
| @Override |
| protected void beginTextObject() throws IOException { |
| gen.writeln("BT"); |
| textUtil = new TextUtil(); |
| psRun = new PSTextRun(); //Used to split a text run into smaller runs |
| } |
| |
| @Override |
| protected void endTextObject() throws IOException { |
| psRun.paint(ps, textUtil, tpi); |
| gen.writeln("ET"); |
| } |
| |
| @Override |
| protected void positionGlyph(Point2D prevPos, Point2D glyphPos, boolean reposition) { |
| flushCurrentRun = false; |
| //Try to optimize by combining characters using the same font and on the same line. |
| if (reposition) { |
| //Happens for text-on-a-path |
| flushCurrentRun = true; |
| } |
| if (psRun.getRunLength() >= 128) { |
| //Don't let a run get too long |
| flushCurrentRun = true; |
| } |
| |
| //Note the position of the glyph relative to the previous one |
| if (prevPos == null) { |
| relPos = new Point2D.Double(0, 0); |
| } else { |
| relPos = new Point2D.Double( |
| glyphPos.getX() - prevPos.getX(), |
| glyphPos.getY() - prevPos.getY()); |
| } |
| if (psRun.vertChanges == 0 |
| && psRun.getHorizRunLength() > 2 |
| && relPos.getY() != 0) { |
| //new line |
| flushCurrentRun = true; |
| } |
| } |
| |
| @Override |
| protected void writeGlyph(char glyph, AffineTransform localTransform) throws IOException { |
| boolean fontChanging = textUtil.isFontChanging(font, glyph); |
| if (fontChanging) { |
| flushCurrentRun = true; |
| } |
| |
| if (flushCurrentRun) { |
| //Paint the current run and reset for the next run |
| psRun.paint(ps, textUtil, tpi); |
| psRun.reset(); |
| } |
| |
| //Track current run |
| psRun.addGlyph(glyph, relPos); |
| psRun.noteStartingTransformation(localTransform); |
| |
| //Change font if necessary |
| if (fontChanging) { |
| textUtil.setCurrentFont(font, glyph); |
| } |
| } |
| |
| private class TextUtil { |
| |
| private Font currentFont; |
| private int currentEncoding = -1; |
| |
| public boolean isMultiByte(Font f) { |
| FontMetrics metrics = f.getFontMetrics(); |
| boolean multiByte = metrics instanceof MultiByteFont || metrics instanceof LazyFont |
| && ((LazyFont) metrics).getRealFont() instanceof MultiByteFont; |
| return multiByte; |
| } |
| |
| public void writeTextMatrix(AffineTransform transform) throws IOException { |
| double[] matrix = new double[6]; |
| transform.getMatrix(matrix); |
| gen.writeln(gen.formatDouble5(matrix[0]) + " " |
| + gen.formatDouble5(matrix[1]) + " " |
| + gen.formatDouble5(matrix[2]) + " " |
| + gen.formatDouble5(matrix[3]) + " " |
| + gen.formatDouble5(matrix[4]) + " " |
| + gen.formatDouble5(matrix[5]) + " Tm"); |
| } |
| |
| public boolean isFontChanging(Font f, char mapped) { |
| // this is only applicable for single byte fonts |
| if (!isMultiByte(f)) { |
| if (f != getCurrentFont()) { |
| return true; |
| } |
| if (mapped / 256 != getCurrentFontEncoding()) { |
| return true; |
| } |
| } |
| return false; //Font is the same |
| } |
| |
| public void selectFont(Font f, char mapped) throws IOException { |
| int encoding = mapped / 256; |
| String postfix = (!isMultiByte(f) && encoding > 0 ? Integer.toString(encoding) : null); |
| PSFontResource res = getResourceForFont(f, postfix); |
| gen.useFont("/" + res.getName(), f.getFontSize() / 1000f); |
| res.notifyResourceUsageOnPage(gen.getResourceTracker()); |
| } |
| |
| public Font getCurrentFont() { |
| return this.currentFont; |
| } |
| |
| public int getCurrentFontEncoding() { |
| return this.currentEncoding; |
| } |
| |
| public void setCurrentFont(Font font, int encoding) { |
| this.currentFont = font; |
| this.currentEncoding = encoding; |
| } |
| |
| public void setCurrentFont(Font font, char mapped) { |
| int encoding = mapped / 256; |
| setCurrentFont(font, encoding); |
| } |
| |
| } |
| |
| private class PSTextRun { |
| |
| private AffineTransform textTransform; |
| private List<Point2D> relativePositions = new LinkedList<Point2D>(); |
| private StringBuffer currentGlyphs = new StringBuffer(); |
| private int horizChanges; |
| private int vertChanges; |
| |
| public void reset() { |
| textTransform = null; |
| currentGlyphs.setLength(0); |
| horizChanges = 0; |
| vertChanges = 0; |
| relativePositions.clear(); |
| } |
| |
| public int getHorizRunLength() { |
| if (this.vertChanges == 0 |
| && getRunLength() > 0) { |
| return getRunLength(); |
| } |
| return 0; |
| } |
| |
| public void addGlyph(char glyph, Point2D relPos) { |
| addRelativePosition(relPos); |
| currentGlyphs.append(glyph); |
| } |
| |
| private void addRelativePosition(Point2D relPos) { |
| if (getRunLength() > 0) { |
| if (relPos.getX() != 0) { |
| horizChanges++; |
| } |
| if (relPos.getY() != 0) { |
| vertChanges++; |
| } |
| } |
| relativePositions.add(relPos); |
| } |
| |
| public void noteStartingTransformation(AffineTransform transform) { |
| if (textTransform == null) { |
| this.textTransform = new AffineTransform(transform); |
| } |
| } |
| |
| public int getRunLength() { |
| return currentGlyphs.length(); |
| } |
| |
| private boolean isXShow() { |
| return vertChanges == 0; |
| } |
| |
| private boolean isYShow() { |
| return horizChanges == 0; |
| } |
| |
| public void paint(PSGraphics2D g2d, TextUtil textUtil, TextPaintInfo tpi) |
| throws IOException { |
| if (getRunLength() > 0) { |
| textUtil.writeTextMatrix(this.textTransform); |
| if (isXShow()) { |
| log.debug("Horizontal text: xshow"); |
| paintXYShow(g2d, textUtil, tpi.fillPaint, true, false); |
| } else if (isYShow()) { |
| log.debug("Vertical text: yshow"); |
| paintXYShow(g2d, textUtil, tpi.fillPaint, false, true); |
| } else { |
| log.debug("Arbitrary text: xyshow"); |
| paintXYShow(g2d, textUtil, tpi.fillPaint, true, true); |
| } |
| boolean stroke = (tpi.strokePaint != null) && (tpi.strokeStroke != null); |
| if (stroke) { |
| log.debug("Stroked glyph outlines"); |
| paintStrokedGlyphs(g2d, textUtil, tpi.strokePaint, tpi.strokeStroke); |
| } |
| } |
| } |
| |
| private void paintXYShow(PSGraphics2D g2d, TextUtil textUtil, Paint paint, |
| boolean x, boolean y) throws IOException { |
| char glyph = currentGlyphs.charAt(0); |
| textUtil.selectFont(font, glyph); |
| textUtil.setCurrentFont(font, glyph); |
| applyColor(paint); |
| |
| boolean multiByte = textUtil.isMultiByte(font); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(multiByte ? '<' : '('); |
| for (int i = 0, c = this.currentGlyphs.length(); i < c; i++) { |
| glyph = this.currentGlyphs.charAt(i); |
| if (multiByte) { |
| sb.append(HexEncoder.encode(glyph)); |
| } else { |
| char codepoint = (char) (glyph % 256); |
| PSGenerator.escapeChar(codepoint, sb); |
| } |
| } |
| sb.append(multiByte ? '>' : ')'); |
| if (x || y) { |
| sb.append("\n["); |
| int idx = 0; |
| for (Point2D pt : this.relativePositions) { |
| if (idx > 0) { |
| if (x) { |
| sb.append(format(gen, pt.getX())); |
| } |
| if (y) { |
| if (x) { |
| sb.append(' '); |
| } |
| sb.append(format(gen, -pt.getY())); |
| } |
| if (idx % 8 == 0) { |
| sb.append('\n'); |
| } else { |
| sb.append(' '); |
| } |
| } |
| idx++; |
| } |
| if (x) { |
| sb.append('0'); |
| } |
| if (y) { |
| if (x) { |
| sb.append(' '); |
| } |
| sb.append('0'); |
| } |
| sb.append(']'); |
| } |
| sb.append(' '); |
| if (x) { |
| sb.append('x'); |
| } |
| if (y) { |
| sb.append('y'); |
| } |
| sb.append("show"); // --> xshow, yshow or xyshow |
| gen.writeln(sb.toString()); |
| } |
| |
| private void applyColor(Paint paint) throws IOException { |
| if (paint == null) { |
| return; |
| } else if (paint instanceof Color) { |
| Color col = (Color) paint; |
| gen.useColor(col); |
| } else { |
| log.warn("Paint not supported: " + paint.toString()); |
| } |
| } |
| |
| private String format(PSGenerator gen, double coord) { |
| if (Math.abs(coord) < 0.00001) { |
| return "0"; |
| } else { |
| return gen.formatDouble5(coord); |
| } |
| } |
| |
| private void paintStrokedGlyphs(PSGraphics2D g2d, TextUtil textUtil, |
| Paint strokePaint, Stroke stroke) throws IOException { |
| if (currentGlyphs.toString().trim().isEmpty()) { |
| return; |
| } |
| applyColor(strokePaint); |
| PSGraphics2D.applyStroke(stroke, gen); |
| |
| Iterator<Point2D> iter = this.relativePositions.iterator(); |
| iter.next(); |
| Point2D pos = new Point2D.Double(0, 0); |
| gen.writeln("0 0 M"); |
| for (int i = 0, c = this.currentGlyphs.length(); i < c; i++) { |
| char mapped = this.currentGlyphs.charAt(i); |
| if (i == 0) { |
| textUtil.selectFont(font, mapped); |
| textUtil.setCurrentFont(font, mapped); |
| } |
| //add glyph outlines to current path |
| FontMetrics metrics = font.getFontMetrics(); |
| boolean multiByte = metrics instanceof MultiByteFont |
| || metrics instanceof LazyFont |
| && ((LazyFont) metrics).getRealFont() instanceof MultiByteFont; |
| if (multiByte) { |
| gen.write("<"); |
| gen.write(HexEncoder.encode(mapped)); |
| gen.write(">"); |
| } else { |
| char codepoint = (char) (mapped % 256); |
| gen.write("(" + codepoint + ")"); |
| } |
| gen.writeln(" false charpath"); |
| |
| if (iter.hasNext()) { |
| //Position for the next character |
| Point2D pt = iter.next(); |
| pos.setLocation(pos.getX() + pt.getX(), pos.getY() - pt.getY()); |
| gen.writeln(gen.formatDouble5(pos.getX()) + " " |
| + gen.formatDouble5(pos.getY()) + " M"); |
| } |
| } |
| gen.writeln("stroke"); //paints all accumulated glyph outlines |
| } |
| |
| } |
| |
| } |
| |
| |
