Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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: PSGenerator.java 1809627 2017-09-25 13:42:08Z ssteiner $ */
package org.apache.xmlgraphics.ps;
import java.awt.Color;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.DateFormat;
import java.util.Date;
import java.util.Stack;
import javax.xml.transform.Source;
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.xmlgraphics.java2d.color.ColorUtil;
import org.apache.xmlgraphics.java2d.color.ColorWithAlternatives;
import org.apache.xmlgraphics.ps.dsc.ResourceTracker;
import org.apache.xmlgraphics.util.DoubleFormatUtil;
/**
* This class is used to output PostScript code to an OutputStream. This class assumes that
* the {@link PSProcSets#STD_PROCSET} has been added to the PostScript file.
*
* @version $Id: PSGenerator.java 1809627 2017-09-25 13:42:08Z ssteiner $
*/
public class PSGenerator implements PSCommandMap {
/**
* Default postscript language level
*/
public static final int DEFAULT_LANGUAGE_LEVEL = 3;
/**
* Indicator for the PostScript interpreter that the value is provided
* later in the document (mostly in the %%Trailer section).
* @deprecated Please use DSCConstants.ATEND. This constant was in the wrong place.
*/
@Deprecated
public static final Object ATEND = DSCConstants.ATEND;
/** Line feed used by PostScript */
public static final char LF = '\n';
private static final String IDENTITY_H = "Identity-H";
private Log log = LogFactory.getLog(getClass());
private OutputStream out;
private int psLevel = DEFAULT_LANGUAGE_LEVEL;
private boolean acrobatDownsample;
private boolean commentsEnabled = true;
private boolean compactMode = true;
private PSCommandMap commandMap = PSProcSets.STD_COMMAND_MAP;
private Stack graphicsStateStack = new Stack();
private PSState currentState;
private StringBuffer doubleBuffer = new StringBuffer(16);
private StringBuffer tempBuffer = new StringBuffer(256);
private boolean identityHEmbedded;
private PSResource procsetCIDInitResource;
private PSResource identityHCMapResource;
/**
* Creates a new instance.
* @param out the OutputStream to write the generated PostScript code to
*/
public PSGenerator(OutputStream out) {
this.out = out;
resetGraphicsState();
}
/**
* Indicates whether this instance is in compact mode. See {@link #setCompactMode(boolean)}
* for details.
* @return true if compact mode is enabled (the default)
*/
public boolean isCompactMode() {
return this.compactMode;
}
/**
* Controls whether this instance shall produce compact PostScript (omitting comments and
* using short macros). Enabling this mode requires that the standard procset
* ({@link PSProcSets#STD_PROCSET}) is included in the PostScript file. Setting this to
* false produces more verbose PostScript suitable for debugging.
* @param value true to enable compact mode, false for verbose mode
*/
public void setCompactMode(boolean value) {
this.compactMode = value;
}
/**
* Indicates whether this instance allows to write comments. See
* {@link #setCommentsEnabled(boolean)} for details.
* @return true if comments are enabled (the default)
*/
public boolean isCommentsEnabled() {
return this.commentsEnabled;
}
/**
* Controls whether this instance allows to write comments using the {@link #commentln(String)}
* method.
* @param value true to enable comments, false to disable them
*/
public void setCommentsEnabled(boolean value) {
this.commentsEnabled = value;
}
private void resetGraphicsState() {
if (!this.graphicsStateStack.isEmpty()) {
throw new IllegalStateException("Graphics state stack should be empty at this point");
}
this.currentState = new PSState();
}
/**
* Returns the OutputStream the PSGenerator writes to.
* @return the OutputStream
*/
public OutputStream getOutputStream() {
return this.out;
}
/**
* Returns the selected PostScript level.
* @return the PostScript level
*/
public int getPSLevel() {
return this.psLevel;
}
/**
* Sets the PostScript level that is used to generate the current document.
* @param level the PostScript level (currently 1, 2 and 3 are known)
*/
public void setPSLevel(int level) {
this.psLevel = level;
}
public boolean isAcrobatDownsample() {
return acrobatDownsample;
}
public void setAcrobatDownsample(boolean b) {
acrobatDownsample = b;
}
/**
* Attempts to resolve the given URI. PSGenerator should be subclasses to provide more
* sophisticated URI resolution.
* @param uri URI to access
* @return A {@link javax.xml.transform.Source} object, or null if the URI
* cannot be resolved.
*/
public Source resolveURI(String uri) {
return new javax.xml.transform.stream.StreamSource(uri);
}
/**
* Writes a newline character to the OutputStream.
*
* @throws IOException In case of an I/O problem
*/
public final void newLine() throws IOException {
out.write(LF);
}
/**
* Formats a double value for PostScript output.
*
* @param value value to format
* @return the formatted value
*/
public String formatDouble(double value) {
doubleBuffer.setLength(0);
DoubleFormatUtil.formatDouble(value, 3, 3, doubleBuffer);
return doubleBuffer.toString();
}
/**
* Formats a double value for PostScript output (higher resolution).
*
* @param value value to format
* @return the formatted value
*/
public String formatDouble5(double value) {
doubleBuffer.setLength(0);
DoubleFormatUtil.formatDouble(value, 5, 5, doubleBuffer);
return doubleBuffer.toString();
}
/**
* Writes a PostScript command to the stream.
*
* @param cmd The PostScript code to be written.
* @exception IOException In case of an I/O problem
*/
public void write(String cmd) throws IOException {
/* TODO Check disabled until clarification.
if (cmd.length() > 255) {
throw new RuntimeException("PostScript command exceeded limit of 255 characters");
} */
out.write(cmd.getBytes("US-ASCII"));
}
/**
* Writes the given number to the stream in decimal format.
*
* @param n a number
* @throws IOException in case of an I/O problem
*/
public void write(int n) throws IOException {
write(Integer.toString(n));
}
/**
* Writes a PostScript command to the stream and ends the line.
*
* @param cmd The PostScript code to be written.
* @exception IOException In case of an I/O problem
*/
public void writeln(String cmd) throws IOException {
write(cmd);
newLine();
}
/**
* Writes a comment to the stream and ends the line. Output of comments can
* be disabled to reduce the size of the generated file.
*
* @param comment comment to write
* @exception IOException In case of an I/O problem
*/
public void commentln(String comment) throws IOException {
if (isCommentsEnabled()) {
writeln(comment);
}
}
/** {@inheritDoc} */
public String mapCommand(String command) {
if (isCompactMode()) {
return this.commandMap.mapCommand(command);
} else {
return command;
}
}
/**
* Writes encoded data to the PostScript stream.
*
* @param cmd The encoded PostScript code to be written.
* @exception IOException In case of an I/O problem
*/
public void writeByteArr(byte[] cmd) throws IOException {
out.write(cmd);
newLine();
}
/**
* Flushes the OutputStream.
*
* @exception IOException In case of an I/O problem
*/
public void flush() throws IOException {
out.flush();
}
/**
* Escapes a character conforming to the rules established in the PostScript
* Language Reference (Search for "Literal Text Strings").
* @param c character to escape
* @param target target StringBuffer to write the escaped character to
*/
public static final void escapeChar(char c, StringBuffer target) {
switch (c) {
case '\n':
target.append("\\n");
break;
case '\r':
target.append("\\r");
break;
case '\t':
target.append("\\t");
break;
case '\b':
target.append("\\b");
break;
case '\f':
target.append("\\f");
break;
case '\\':
target.append("\\\\");
break;
case '(':
target.append("\\(");
break;
case ')':
target.append("\\)");
break;
default:
if (c > 255) {
//Ignoring non Latin-1 characters
target.append('?');
} else if (c < 32 || c > 127) {
target.append('\\');
target.append((char)('0' + (c >> 6)));
target.append((char)('0' + ((c >> 3) % 8)));
target.append((char)('0' + (c % 8)));
//Integer.toOctalString(i)
} else {
target.append(c);
}
}
}
/**
* Converts text by applying escaping rules established in the DSC specs.
* @param text Text to convert
* @return String The resulting String
*/
public static final String convertStringToDSC(String text) {
return convertStringToDSC(text, false);
}
/**
* Converts a <real> value for use in DSC comments.
* @param value the value to convert
* @return String The resulting String
*/
public static final String convertRealToDSC(float value) {
return Float.toString(value);
}
/**
* Converts text by applying escaping rules established in the DSC specs.
* @param text Text to convert
* @param forceParentheses Force the use of parentheses
* @return String The resulting String
*/
public static final String convertStringToDSC(String text,
boolean forceParentheses) {
if ((text == null) || (text.length() == 0)) {
return "()";
} else {
int initialSize = text.length();
initialSize += initialSize / 2;
StringBuffer sb = new StringBuffer(initialSize);
if ((text.indexOf(' ') >= 0) || forceParentheses) {
sb.append('(');
for (int i = 0; i < text.length(); i++) {
final char c = text.charAt(i);
escapeChar(c, sb);
}
sb.append(')');
return sb.toString();
} else {
for (int i = 0; i < text.length(); i++) {
final char c = text.charAt(i);
escapeChar(c, sb);
}
return sb.toString();
}
}
}
/**
* Writes a DSC comment to the output stream.
* @param name Name of the DSC comment
* @exception IOException In case of an I/O problem
* @see org.apache.xmlgraphics.ps.DSCConstants
*/
public void writeDSCComment(String name) throws IOException {
writeln("%%" + name);
}
/**
* Writes a DSC comment to the output stream. The parameter to the DSC
* comment can be any object. The object is converted to a String as
* necessary.
* @param name Name of the DSC comment
* @param param Single parameter to the DSC comment
* @exception IOException In case of an I/O problem
* @see org.apache.xmlgraphics.ps.DSCConstants
*/
public void writeDSCComment(String name, Object param) throws IOException {
writeDSCComment(name, new Object[] {param});
}
/**
* Writes a DSC comment to the output stream. The parameters to the DSC
* comment can be any object. The objects are converted to Strings as
* necessary. Please see the source code to find out what parameters are
* currently supported.
* @param name Name of the DSC comment
* @param params Array of parameters to the DSC comment
* @exception IOException In case of an I/O problem
* @see org.apache.xmlgraphics.ps.DSCConstants
*/
public void writeDSCComment(String name, Object[] params) throws IOException {
tempBuffer.setLength(0);
tempBuffer.append("%%");
tempBuffer.append(name);
if ((params != null) && (params.length > 0)) {
tempBuffer.append(": ");
for (int i = 0; i < params.length; i++) {
if (i > 0) {
tempBuffer.append(" ");
}
if (params[i] instanceof String) {
tempBuffer.append(convertStringToDSC((String)params[i]));
} else if (params[i] == DSCConstants.ATEND) {
tempBuffer.append(DSCConstants.ATEND);
} else if (params[i] instanceof Double) {
tempBuffer.append(formatDouble((Double) params[i]));
} else if (params[i] instanceof Number) {
tempBuffer.append(params[i].toString());
} else if (params[i] instanceof Date) {
DateFormat datef = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
tempBuffer.append(convertStringToDSC(datef.format((Date)params[i])));
} else if (params[i] instanceof PSResource) {
tempBuffer.append(((PSResource)params[i]).getResourceSpecification());
} else {
throw new IllegalArgumentException("Unsupported parameter type: "
+ params[i].getClass().getName());
}
}
}
writeln(tempBuffer.toString());
}
/**
* Saves the graphics state of the rendering engine.
* @exception IOException In case of an I/O problem
*/
public void saveGraphicsState() throws IOException {
writeln(mapCommand("gsave"));
PSState state = new PSState(this.currentState, false);
this.graphicsStateStack.push(this.currentState);
this.currentState = state;
}
/**
* Restores the last graphics state of the rendering engine.
* @return true if the state was restored, false if there's a stack underflow.
* @exception IOException In case of an I/O problem
*/
public boolean restoreGraphicsState() throws IOException {
if (this.graphicsStateStack.size() > 0) {
writeln(mapCommand("grestore"));
this.currentState = this.graphicsStateStack.pop();
return true;
} else {
return false;
}
}
/**
* Returns the current graphics state.
* @return the current graphics state
*/
public PSState getCurrentState() {
return this.currentState;
}
/**
* Issues the "showpage" command and resets the painting state accordingly.
* @exception IOException In case of an I/O problem
*/
public void showPage() throws IOException {
writeln("showpage");
resetGraphicsState();
}
/**
* Concats the transformation matrix.
* @param a A part
* @param b B part
* @param c C part
* @param d D part
* @param e E part
* @param f F part
* @exception IOException In case of an I/O problem
*/
public void concatMatrix(double a, double b,
double c, double d,
double e, double f) throws IOException {
AffineTransform at = new AffineTransform(a, b, c, d, e, f);
concatMatrix(at);
}
/**
* Concats the transformations matrix.
* @param matrix Matrix to use
* @exception IOException In case of an I/O problem
*/
public void concatMatrix(double[] matrix) throws IOException {
concatMatrix(matrix[0], matrix[1],
matrix[2], matrix[3],
matrix[4], matrix[5]);
}
/**
* Formats a transformation matrix.
* @param at the AffineTransform with the matrix
* @return the formatted transformation matrix (example: "[1 0 0 1 0 0]")
*/
public String formatMatrix(AffineTransform at) {
double[] matrix = new double[6];
at.getMatrix(matrix);
return "[" + formatDouble5(matrix[0]) + " "
+ formatDouble5(matrix[1]) + " "
+ formatDouble5(matrix[2]) + " "
+ formatDouble5(matrix[3]) + " "
+ formatDouble5(matrix[4]) + " "
+ formatDouble5(matrix[5]) + "]";
}
/**
* Concats the transformations matric.
* @param at the AffineTransform whose matrix to use
* @exception IOException In case of an I/O problem
*/
public void concatMatrix(AffineTransform at) throws IOException {
getCurrentState().concatMatrix(at);
writeln(formatMatrix(at) + " " + mapCommand("concat"));
}
/**
* Formats a Rectangle2D to an array.
* @param rect the rectangle
* @return the formatted array
*/
public String formatRectangleToArray(Rectangle2D rect) {
return "[" + formatDouble(rect.getX()) + " "
+ formatDouble(rect.getY()) + " "
+ formatDouble(rect.getWidth()) + " "
+ formatDouble(rect.getHeight()) + "]";
}
/**
* Adds a rectangle to the current path.
* @param x upper left corner
* @param y upper left corner
* @param w width
* @param h height
* @exception IOException In case of an I/O problem
*/
public void defineRect(double x, double y, double w, double h)
throws IOException {
writeln(formatDouble(x)
+ " " + formatDouble(y)
+ " " + formatDouble(w)
+ " " + formatDouble(h)
+ " re");
}
/**
* Establishes the specified line cap style.
* @param linecap the line cap style (0, 1 or 2) as defined by the setlinecap command.
* @exception IOException In case of an I/O problem
*/
public void useLineCap(int linecap) throws IOException {
if (getCurrentState().useLineCap(linecap)) {
writeln(linecap + " " + mapCommand("setlinecap"));
}
}
/**
* Establishes the specified line join style.
* @param linejoin the line join style (0, 1 or 2) as defined by the setlinejoin command.
* @exception IOException In case of an I/O problem
*/
public void useLineJoin(int linejoin) throws IOException {
if (getCurrentState().useLineJoin(linejoin)) {
writeln(linejoin + " " + mapCommand("setlinejoin"));
}
}
/**
* Establishes the specified miter limit.
* @param miterlimit the miter limit as defined by the setmiterlimit command.
* @exception IOException In case of an I/O problem
*/
public void useMiterLimit(float miterlimit) throws IOException {
if (getCurrentState().useMiterLimit(miterlimit)) {
writeln(miterlimit + " " + mapCommand("setmiterlimit"));
}
}
/**
* Establishes the specified line width.
* @param width the line width as defined by the setlinewidth command.
* @exception IOException In case of an I/O problem
*/
public void useLineWidth(double width) throws IOException {
if (getCurrentState().useLineWidth(width)) {
writeln(formatDouble(width) + " " + mapCommand("setlinewidth"));
}
}
/**
* Establishes the specified dash pattern.
* @param pattern the dash pattern as defined by the setdash command.
* @exception IOException In case of an I/O problem
*/
public void useDash(String pattern) throws IOException {
if (pattern == null) {
pattern = PSState.DEFAULT_DASH;
}
if (getCurrentState().useDash(pattern)) {
writeln(pattern + " " + mapCommand("setdash"));
}
}
/**
* Establishes the specified color (RGB).
* @param col the color as defined by the setrgbcolor command.
* @exception IOException In case of an I/O problem
* @deprecated use useColor method instead
*/
@Deprecated
public void useRGBColor(Color col) throws IOException {
useColor(col);
}
/**
* Establishes the specified color.
* @param col the color.
* @exception IOException In case of an I/O problem
*/
public void useColor(Color col) throws IOException {
if (getCurrentState().useColor(col)) {
writeln(convertColorToPS(col));
}
}
private String convertColorToPS(Color color) {
StringBuffer codeBuffer = new StringBuffer();
//Important: Right now, CMYK colors are treated as device colors (DeviceCMYK) irrespective
//of any associated color profile. All other colors are converted to sRGB (if necessary)
//and the resulting RGB components are treated as DeviceRGB colors.
//If all three RGB components are the same, DeviceGray is used.
boolean established = false;
if (color instanceof ColorWithAlternatives) {
ColorWithAlternatives colExt = (ColorWithAlternatives)color;
//Alternative colors have priority
Color[] alt = colExt.getAlternativeColors();
for (Color col : alt) {
established = establishColorFromColor(codeBuffer, col);
if (established) {
break;
}
}
if (log.isDebugEnabled() && alt.length > 0) {
log.debug("None of the alternative colors are supported. Using fallback: "
+ color);
}
}
//Fallback
if (!established) {
established = establishColorFromColor(codeBuffer, color);
}
if (!established) {
establishFallbackRGB(codeBuffer, color);
}
return codeBuffer.toString();
}
private boolean establishColorFromColor(StringBuffer codeBuffer, Color color) {
//Important: see above note about color handling!
float[] comps = color.getColorComponents(null);
if (color.getColorSpace().getType() == ColorSpace.TYPE_CMYK) {
// colorspace is CMYK
writeSetColor(codeBuffer, comps, "setcmykcolor");
return true;
}
return false;
}
private void writeSetColor(StringBuffer codeBuffer, float[] comps, String command) {
for (int i = 0, c = comps.length; i < c; i++) {
if (i > 0) {
codeBuffer.append(" ");
}
codeBuffer.append(formatDouble(comps[i]));
}
codeBuffer.append(" ").append(mapCommand(command));
}
private void establishFallbackRGB(StringBuffer codeBuffer, Color color) {
float[] comps;
if (color.getColorSpace().isCS_sRGB()) {
comps = color.getColorComponents(null);
} else {
if (log.isDebugEnabled()) {
log.debug("Converting color to sRGB as a fallback: " + color);
}
ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB);
comps = color.getColorComponents(sRGB, null);
}
assert comps.length == 3;
boolean gray = ColorUtil.isGray(color);
if (gray) {
comps = new float[] {comps[0]};
}
writeSetColor(codeBuffer, comps, gray ? "setgray" : "setrgbcolor");
}
/**
* Establishes the specified font and size.
* @param name name of the font for the "F" command (see FOP Std Proc Set)
* @param size size of the font
* @exception IOException In case of an I/O problem
*/
public void useFont(String name, float size) throws IOException {
if (getCurrentState().useFont(name, size)) {
writeln(name + " " + formatDouble(size) + " F");
}
}
private ResourceTracker resTracker = new ResourceTracker();
/**
* Resturns the ResourceTracker instance associated with this PSGenerator.
* @return the ResourceTracker instance or null if none is assigned
*/
public ResourceTracker getResourceTracker() {
return this.resTracker;
}
/**
* Sets the ResourceTracker instance to be associated with this PSGenerator.
* @param resTracker the ResourceTracker instance
*/
public void setResourceTracker(ResourceTracker resTracker) {
this.resTracker = resTracker;
}
/**
* Notifies the generator that a new page has been started and that the page resource
* set can be cleared.
* @deprecated Use the notifyStartNewPage() on ResourceTracker instead.
*/
@Deprecated
public void notifyStartNewPage() {
getResourceTracker().notifyStartNewPage();
}
/**
* Notifies the generator about the usage of a resource on the current page.
* @param res the resource being used
* @param needed true if this is a needed resource, false for a supplied resource
* @deprecated Use the notifyResourceUsageOnPage() on ResourceTracker instead
*/
@Deprecated
public void notifyResourceUsage(PSResource res, boolean needed) {
getResourceTracker().notifyResourceUsageOnPage(res);
}
/**
* Writes a DSC comment for the accumulated used resources, either at page level or
* at document level.
* @param pageLevel true if the DSC comment for the page level should be generated,
* false for the document level (in the trailer)
* @exception IOException In case of an I/O problem
* @deprecated Use the writeResources() on ResourceTracker instead.
*/
@Deprecated
public void writeResources(boolean pageLevel) throws IOException {
getResourceTracker().writeResources(pageLevel, this);
}
/**
* Indicates whether a particular resource is supplied, rather than needed.
* @param res the resource
* @return true if the resource is registered as being supplied.
* @deprecated Use the isResourceSupplied() on ResourceTracker instead.
*/
@Deprecated
public boolean isResourceSupplied(PSResource res) {
return getResourceTracker().isResourceSupplied(res);
}
/**
* Embeds the Identity-H CMap file into the output stream, if that has not
* already been done.
*
* @return true if embedding has actually been performed, false otherwise
* (which means that a call to this method had already been made earlier)
* @throws IOException in case of an I/O problem
*/
public boolean embedIdentityH() throws IOException {
if (identityHEmbedded) {
return false;
} else {
resTracker.registerNeededResource(getProcsetCIDInitResource());
writeDSCComment(DSCConstants.BEGIN_DOCUMENT, IDENTITY_H);
InputStream cmap = PSGenerator.class.getResourceAsStream(IDENTITY_H);
try {
IOUtils.copyLarge(cmap, out);
} finally {
IOUtils.closeQuietly(cmap);
}
writeDSCComment(DSCConstants.END_DOCUMENT);
resTracker.registerSuppliedResource(getIdentityHCMapResource());
identityHEmbedded = true;
return true;
}
}
/**
* Returns the PSResource instance corresponding to the Identity-H CMap
* resource.
*
* @return the Identity-H CMap resource.
*/
public PSResource getIdentityHCMapResource() {
if (identityHCMapResource == null) {
identityHCMapResource = new PSResource(PSResource.TYPE_CMAP, IDENTITY_H);
}
return identityHCMapResource;
}
/**
* Returns the PSResource instance corresponding to the CIDInit ProcSet
* resource.
*
* @return the ProcSet CIDInit resource
*/
public PSResource getProcsetCIDInitResource() {
if (procsetCIDInitResource == null) {
procsetCIDInitResource = new PSResource(PSResource.TYPE_PROCSET, "CIDInit");
}
return procsetCIDInitResource;
}
/**
* Adds a PostScript DSC comment to the output stream requiring the
* inclusion of the CIDInit ProcSet resource.
*
* @throws IOException in case of an I/O problem
*/
public void includeProcsetCIDInitResource() throws IOException {
writeDSCComment(DSCConstants.INCLUDE_RESOURCE, getProcsetCIDInitResource());
}
}
