mirror of git://gcc.gnu.org/git/gcc.git
1350 lines
38 KiB
Java
1350 lines
38 KiB
Java
/* PostScriptGraphics2D.java -- AWT printer rendering class.
|
|
Copyright (C) 2006 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.java.awt.print;
|
|
|
|
import java.awt.BasicStroke;
|
|
import java.awt.Color;
|
|
import java.awt.Composite;
|
|
import java.awt.Paint;
|
|
import java.awt.Font;
|
|
import java.awt.FontMetrics;
|
|
import java.awt.GradientPaint;
|
|
import java.awt.Graphics;
|
|
import java.awt.GraphicsConfiguration;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.Image;
|
|
import java.awt.Polygon;
|
|
import java.awt.Rectangle;
|
|
import java.awt.RenderingHints;
|
|
import java.awt.Shape;
|
|
import java.awt.Stroke;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.geom.Arc2D;
|
|
import java.awt.geom.Ellipse2D;
|
|
import java.awt.geom.RoundRectangle2D;
|
|
import java.awt.geom.PathIterator;
|
|
import java.awt.geom.Point2D;
|
|
import java.awt.geom.Rectangle2D;
|
|
import java.awt.font.FontRenderContext;
|
|
import java.awt.font.GlyphVector;
|
|
import java.awt.font.TextLayout;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.BufferedImageOp;
|
|
import java.awt.image.renderable.RenderableImage;
|
|
import java.awt.image.RenderedImage;
|
|
import java.awt.image.ImageObserver;
|
|
import java.awt.image.PixelGrabber;
|
|
import java.awt.print.PageFormat;
|
|
import java.awt.print.Pageable;
|
|
import java.awt.print.Paper;
|
|
import java.awt.print.Printable;
|
|
import java.awt.print.PrinterException;
|
|
import java.awt.print.PrinterJob;
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStreamWriter;
|
|
import java.io.PrintWriter;
|
|
import java.text.AttributedCharacterIterator;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Class PostScriptGraphics2D - Class that implements the Graphics2D object,
|
|
* writing the output to a PostScript or EPS file
|
|
*
|
|
* @author Sven de Marothy
|
|
*
|
|
*/
|
|
class PostScriptGraphics2D extends Graphics2D
|
|
{
|
|
/**
|
|
* The associated printer job.
|
|
*/
|
|
private PrinterJob printerJob;
|
|
|
|
/**
|
|
* Output file.
|
|
*/
|
|
private PrintWriter out;
|
|
|
|
// Graphics data
|
|
private AffineTransform currentTransform = new AffineTransform();
|
|
private AffineTransform pageTransform;
|
|
private RenderingHints renderingHints;
|
|
private Paint currentPaint = null;
|
|
private Shape clipShape = null;
|
|
private Font currentFont = null;
|
|
private Color currentColor = Color.black;
|
|
private Color backgroundColor = Color.white;
|
|
private Stroke currentStroke = null;
|
|
private static Stroke ordinaryStroke = new BasicStroke(0.0f,
|
|
BasicStroke.CAP_BUTT,
|
|
BasicStroke.JOIN_MITER);
|
|
private float cx; // current drawing position
|
|
private float cy; // current drawing position
|
|
private boolean currentFontIsPS; // set if currentFont is one of the above
|
|
|
|
// settings
|
|
private double pageX = 595;
|
|
private double pageY = 842;
|
|
private double Y = pageY;
|
|
private boolean gradientOn = false;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
*/
|
|
public PostScriptGraphics2D( PrinterJob pg )
|
|
{
|
|
printerJob = pg;
|
|
// create transform objects
|
|
pageTransform = new AffineTransform();
|
|
currentTransform = new AffineTransform();
|
|
|
|
/*
|
|
Create Rendering hints
|
|
No text aliasing
|
|
Quality color and rendering
|
|
Bicubic interpolation
|
|
Fractional metrics supported
|
|
*/
|
|
renderingHints = new RenderingHints(null);
|
|
renderingHints.put(RenderingHints.KEY_RENDERING,
|
|
RenderingHints.VALUE_RENDER_QUALITY);
|
|
renderingHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
|
|
RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
|
|
renderingHints.put(RenderingHints.KEY_INTERPOLATION,
|
|
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
|
|
renderingHints.put(RenderingHints.KEY_FRACTIONALMETRICS,
|
|
RenderingHints.VALUE_FRACTIONALMETRICS_ON);
|
|
renderingHints.put(RenderingHints.KEY_COLOR_RENDERING,
|
|
RenderingHints.VALUE_COLOR_RENDER_QUALITY);
|
|
}
|
|
|
|
/**
|
|
* Spool a document to PostScript.
|
|
* If Pageable is non-null, it will print that, otherwise it will use
|
|
* the supplied printable and pageFormat.
|
|
*/
|
|
public SpooledDocument spoolPostScript(Printable printable,
|
|
PageFormat pageFormat,
|
|
Pageable pageable)
|
|
throws PrinterException
|
|
{
|
|
try
|
|
{
|
|
// spool to a temporary file
|
|
File temp = File.createTempFile("cpspool", ".ps");
|
|
temp.deleteOnExit();
|
|
|
|
out = new PrintWriter(new BufferedWriter
|
|
(new OutputStreamWriter
|
|
(new FileOutputStream(temp),
|
|
"ISO8859_1"), 1000000));
|
|
|
|
writePSHeader();
|
|
|
|
if(pageable != null)
|
|
{
|
|
for(int index = 0; index < pageable.getNumberOfPages(); index++)
|
|
spoolPage(out, pageable.getPrintable(index),
|
|
pageable.getPageFormat(index), index);
|
|
}
|
|
else
|
|
{
|
|
int index = 0;
|
|
while(spoolPage(out, printable, pageFormat, index++) ==
|
|
Printable.PAGE_EXISTS)
|
|
;
|
|
}
|
|
out.println("%%Trailer");
|
|
out.println("%%EOF");
|
|
out.close();
|
|
return new SpooledDocument( temp );
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
PrinterException pe = new PrinterException();
|
|
pe.initCause(e);
|
|
throw pe;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Write the postscript file header,
|
|
* setup the page format and transforms.
|
|
*/
|
|
private void writePSHeader()
|
|
{
|
|
out.println("%!PS-Adobe-3.0");
|
|
out.println("%%Title: "+printerJob.getJobName());
|
|
out.println("%%Creator: GNU Classpath ");
|
|
out.println("%%DocumentData: Clean8Bit");
|
|
|
|
out.println("%%DocumentNeededResources: font Times-Roman Helvetica Courier");
|
|
out.println("%%EndComments");
|
|
|
|
out.println("%%BeginProlog");
|
|
out.println("%%EndProlog");
|
|
out.println("%%BeginSetup");
|
|
|
|
out.println("%%EndFeature");
|
|
setupFonts();
|
|
out.println("%%EndSetup");
|
|
|
|
// set default fonts and colors
|
|
setFont( new Font("Dialog", Font.PLAIN, 12) );
|
|
currentColor = Color.white;
|
|
currentStroke = new BasicStroke();
|
|
setPaint(currentColor);
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
/**
|
|
* setupFonts - set up the font dictionaries for
|
|
* helvetica, times and courier
|
|
*/
|
|
private void setupFonts()
|
|
{
|
|
out.println("/helveticaISO");
|
|
out.println("/Helvetica findfont dup length dict begin");
|
|
out.println("{ 1 index /FID eq { pop pop } { def } ifelse } forall");
|
|
out.println("/Encoding ISOLatin1Encoding def");
|
|
out.println("currentdict end definefont pop");
|
|
|
|
out.println("/timesISO");
|
|
out.println("/Times-Roman findfont dup length dict begin");
|
|
out.println("{ 1 index /FID eq { pop pop } { def } ifelse } forall");
|
|
out.println("/Encoding ISOLatin1Encoding def");
|
|
out.println("currentdict end definefont pop");
|
|
|
|
out.println("/courierISO");
|
|
out.println("/Courier findfont dup length dict begin");
|
|
out.println("{ 1 index /FID eq { pop pop } { def } ifelse } forall");
|
|
out.println("/Encoding ISOLatin1Encoding def");
|
|
out.println("currentdict end definefont pop");
|
|
}
|
|
|
|
/**
|
|
* Spools a single page, returns NO_SUCH_PAGE unsuccessful,
|
|
* PAGE_EXISTS if it was.
|
|
*/
|
|
public int spoolPage(PrintWriter out,
|
|
Printable printable,
|
|
PageFormat pageFormat,
|
|
int index) throws IOException, PrinterException
|
|
{
|
|
out.println("%%BeginPageSetup");
|
|
|
|
Paper p = pageFormat.getPaper();
|
|
pageX = p.getWidth();
|
|
pageY = p.getHeight();
|
|
|
|
if( pageFormat.getOrientation() == PageFormat.PORTRAIT )
|
|
out.println( "%%Orientation: Portrait" );
|
|
else
|
|
{
|
|
out.println( "%%Orientation: Landscape" );
|
|
double t = pageX;
|
|
pageX = pageY;
|
|
pageY = t;
|
|
}
|
|
|
|
setClip(0, 0, (int)pageX, (int)pageY);
|
|
|
|
out.println("gsave % first save");
|
|
|
|
// 595x842; 612x792 respectively
|
|
out.println("<< /PageSize [" +pageX + " "+pageY+ "] >> setpagedevice");
|
|
|
|
if( pageFormat.getOrientation() != PageFormat.LANDSCAPE )
|
|
{
|
|
pageTransform.translate(pageX, 0);
|
|
pageTransform.scale(-1.0, 1.0);
|
|
}
|
|
|
|
// save the original CTM
|
|
pushCTM();
|
|
concatCTM(pageTransform);
|
|
setTransform(new AffineTransform());
|
|
|
|
out.println("%%EndPageSetup");
|
|
|
|
out.println("gsave");
|
|
|
|
if( printable.print(this, pageFormat, index) == Printable.NO_SUCH_PAGE )
|
|
return Printable.NO_SUCH_PAGE;
|
|
|
|
out.println("grestore");
|
|
out.println("showpage");
|
|
|
|
return Printable.PAGE_EXISTS;
|
|
}
|
|
|
|
/** push the Current Transformation Matrix onto the PS stack */
|
|
private void pushCTM()
|
|
{
|
|
out.println("matrix currentmatrix % pushCTM()");
|
|
}
|
|
|
|
/** pop the Current Transformation Matrix from the PS stack */
|
|
private void popCTM()
|
|
{
|
|
out.println("setmatrix % restore CTM");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
public Graphics create()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public void drawOval(int x, int y, int width, int height)
|
|
{
|
|
out.println("% drawOval()");
|
|
setStroke(ordinaryStroke);
|
|
draw(new Ellipse2D.Double(x, y, width, height));
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
|
|
{
|
|
if (nPoints <= 0 || xPoints.length < nPoints || yPoints.length < nPoints)
|
|
return;
|
|
out.println("newpath % drawPolyLine()");
|
|
out.println(xPoints[0] + " " + yPoints[0] + " moveto");
|
|
for (int i = 1; i < nPoints; i++)
|
|
out.println(xPoints[i] + " " + yPoints[i] + " lineto");
|
|
out.println("closepath");
|
|
out.println("stroke");
|
|
}
|
|
|
|
public void drawRoundRect(int x, int y, int width, int height, int arcWidth,
|
|
int arcHeight)
|
|
{
|
|
out.println("% drawRoundRect()");
|
|
RoundRectangle2D.Double rr = new RoundRectangle2D.Double(x, y, width,
|
|
height, arcWidth,
|
|
arcHeight);
|
|
setStroke(ordinaryStroke);
|
|
draw(rr);
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
public void fillRoundRect(int x, int y, int width, int height, int arcWidth,
|
|
int arcHeight)
|
|
{
|
|
out.println("% fillRoundRect()");
|
|
RoundRectangle2D.Double rr = new RoundRectangle2D.Double(x, y, width,
|
|
height, arcWidth,
|
|
arcHeight);
|
|
fill(rr);
|
|
}
|
|
|
|
public void drawArc(int x, int y, int width, int height, int startAngle,
|
|
int arcAngle)
|
|
{
|
|
setStroke(ordinaryStroke);
|
|
draw(new Arc2D.Double(x, y, width, height, startAngle, arcAngle, Arc2D.OPEN));
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
public void fillArc(int x, int y, int width, int height, int startAngle,
|
|
int arcAngle)
|
|
{
|
|
fill(new Arc2D.Double(x, y, width, height, startAngle, arcAngle, Arc2D.PIE));
|
|
}
|
|
|
|
public void fillOval(int x, int y, int width, int height)
|
|
{
|
|
out.println("% fillOval()");
|
|
fill( new Ellipse2D.Double(x, y, width, height) );
|
|
}
|
|
|
|
public void fillPolygon(int[] x, int[] y, int nPoints)
|
|
{
|
|
out.println("% fillPolygon()");
|
|
fill( new Polygon(x, y, nPoints) );
|
|
}
|
|
|
|
public void drawLine(int x1, int y1, int x2, int y2)
|
|
{
|
|
out.println("% drawLine()");
|
|
setStroke(ordinaryStroke);
|
|
out.println("newpath");
|
|
out.println(x1 + " " + (y1) + " moveto");
|
|
out.println(x2 + " " + (y2) + " lineto");
|
|
out.println("stroke");
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
//--------------- Image drawing ------------------------------------------
|
|
public boolean drawImage(Image img, int x, int y, Color bgcolor,
|
|
ImageObserver observer)
|
|
{
|
|
int w = img.getWidth(null);
|
|
int h = img.getHeight(null);
|
|
|
|
return drawImage(img, x, y, x + w, y + h, 0, 0, w - 1, h - 1, bgcolor,
|
|
observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2,
|
|
int sx1, int sy1, int sx2, int sy2, Color bgcolor,
|
|
ImageObserver observer)
|
|
{
|
|
int n = 0;
|
|
boolean flipx = false;
|
|
boolean flipy = false;
|
|
|
|
// swap X and Y's
|
|
if (sx1 > sx2)
|
|
{
|
|
n = sx1;
|
|
sx1 = sx2;
|
|
sx2 = n;
|
|
flipx = ! flipx;
|
|
}
|
|
if (sy1 > sy2)
|
|
{
|
|
n = sy1;
|
|
sy1 = sy2;
|
|
sy2 = n;
|
|
flipy = ! flipy;
|
|
}
|
|
if (dx1 > dx2)
|
|
{
|
|
n = dx1;
|
|
dx1 = dx2;
|
|
dx2 = n;
|
|
flipx = ! flipx;
|
|
}
|
|
if (dy1 > dy2)
|
|
{
|
|
n = dy1;
|
|
dy1 = dy2;
|
|
dy2 = n;
|
|
flipy = ! flipy;
|
|
}
|
|
n = 0;
|
|
int sw = sx2 - sx1; // source width
|
|
int sh = sy2 - sy1; // source height
|
|
int[] pixels = new int[sw * sh]; // pixel buffer
|
|
int dw = dx2 - dx1; // destination width
|
|
int dh = dy2 - dy1; // destination height
|
|
double x_scale = ((double) dw) / ((double) sw);
|
|
double y_scale = ((double) dh) / ((double) sh);
|
|
|
|
out.println("% drawImage() 2");
|
|
out.println("gsave");
|
|
out.println(dx1 + " " + dy1 + " translate");
|
|
out.println(dw + " " + dh + " scale");
|
|
out.println(sw + " " + sh + " 8 [" + (flipx ? -sw : sw) + " 0 0 "
|
|
+ (flipy ? -sh : sh) + " " + (flipx ? sw : 0) + " "
|
|
+ (flipy ? sh : 0) + " ]");
|
|
out.println("{currentfile 3 string readhexstring pop} bind");
|
|
out.println("false 3 colorimage");
|
|
|
|
PixelGrabber pg = new PixelGrabber(img, sx1, sy1, sw, sh, pixels, 0, sw);
|
|
try
|
|
{
|
|
pg.grabPixels();
|
|
}
|
|
catch (InterruptedException e)
|
|
{
|
|
System.err.println("interrupted waiting for pixels!");
|
|
return (false);
|
|
}
|
|
|
|
if ((pg.getStatus() & ImageObserver.ABORT) != 0)
|
|
{
|
|
System.err.println("image fetch aborted or errored");
|
|
return (false);
|
|
}
|
|
|
|
for (int j = 0; j < sh; j++)
|
|
{
|
|
for (int i = 0; i < sw; i++)
|
|
{
|
|
out.print(colorTripleHex(new Color(pixels[j * sw + i])));
|
|
if (((++n) % 11) == 0)
|
|
out.println();
|
|
}
|
|
}
|
|
|
|
out.println();
|
|
out.println("%%EOF");
|
|
out.println("grestore");
|
|
return true;
|
|
}
|
|
|
|
public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2,
|
|
int sx1, int sy1, int sx2, int sy2,
|
|
ImageObserver observer)
|
|
{
|
|
return drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
|
|
observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, ImageObserver observer)
|
|
{
|
|
return drawImage(img, x, y, null, observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, int width, int height,
|
|
Color bgcolor, ImageObserver observer)
|
|
{
|
|
int sw = img.getWidth(null);
|
|
int sh = img.getHeight(null);
|
|
return drawImage(img, x, y, x + width, y + height, /* destination */
|
|
0, 0, sw - 1, sh - 1, /* source */
|
|
bgcolor, observer);
|
|
// correct?
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, int width, int height,
|
|
ImageObserver observer)
|
|
{
|
|
return drawImage(img, x, y, width, height, null, observer);
|
|
}
|
|
|
|
/** Renders a BufferedImage that is filtered with a BufferedImageOp. */
|
|
public void drawImage(BufferedImage img, BufferedImageOp op, int x, int y)
|
|
{
|
|
BufferedImage result = op.filter(img, null);
|
|
drawImage(result, x, y, null);
|
|
}
|
|
|
|
/** Renders an image, applying a transform from image space
|
|
into user space before drawing. */
|
|
public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs)
|
|
{
|
|
AffineTransform oldTransform = new AffineTransform(currentTransform);
|
|
boolean ret;
|
|
|
|
transform(xform);
|
|
ret = drawImage(img, 0, 0, null, obs);
|
|
setTransform(oldTransform);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/** Renders a RenderableImage, applying a transform from image
|
|
space into user space before drawing. */
|
|
public void drawRenderableImage(RenderableImage img, AffineTransform xform)
|
|
{
|
|
// FIXME
|
|
}
|
|
|
|
/** Renders a RenderedImage, applying a transform from
|
|
image space into user space before drawing. */
|
|
public void drawRenderedImage(RenderedImage img, AffineTransform xform)
|
|
{
|
|
// FIXME
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
|
|
{
|
|
setStroke(ordinaryStroke);
|
|
draw(new Polygon(xPoints, yPoints, nPoints));
|
|
setStroke(currentStroke);
|
|
}
|
|
|
|
public void drawString(String str, int x, int y)
|
|
{
|
|
drawString(str, (float) x, (float) y);
|
|
}
|
|
|
|
public void drawString(String str, float x, float y)
|
|
{
|
|
if( str.trim().equals("") )
|
|
return; // don't draw whitespace, silly!
|
|
|
|
if( currentFontIsPS )
|
|
{
|
|
drawStringPSFont(str, x, y);
|
|
return;
|
|
}
|
|
|
|
TextLayout text = new TextLayout(str, currentFont, getFontRenderContext());
|
|
Shape s = text.getOutline(AffineTransform.getTranslateInstance(x, y));
|
|
drawStringShape(s);
|
|
}
|
|
|
|
private void drawStringPSFont(String str, float x, float y)
|
|
{
|
|
out.println("% drawString PS font");
|
|
out.println(x + " " + y + " moveto");
|
|
saveAndInvertAxis();
|
|
out.println("(" + str + ") show");
|
|
restoreAxis();
|
|
}
|
|
|
|
private void saveAndInvertAxis()
|
|
{
|
|
// Invert the Y axis of the CTM.
|
|
popCTM();
|
|
pushCTM();
|
|
|
|
double[] test =
|
|
{
|
|
pageTransform.getScaleX(), pageTransform.getShearY(),
|
|
pageTransform.getShearX(), pageTransform.getScaleY(),
|
|
pageTransform.getTranslateX(),
|
|
-pageTransform.getTranslateY() + pageY
|
|
};
|
|
|
|
double[] test2 =
|
|
{
|
|
currentTransform.getScaleX(),
|
|
currentTransform.getShearY(),
|
|
-currentTransform.getShearX(),
|
|
-currentTransform.getScaleY(),
|
|
currentTransform.getTranslateX(),
|
|
currentTransform.getTranslateY()
|
|
};
|
|
|
|
AffineTransform total = new AffineTransform(test);
|
|
total.concatenate(new AffineTransform(test2));
|
|
concatCTM(total);
|
|
}
|
|
|
|
private void restoreAxis()
|
|
{
|
|
// reset the CTM
|
|
popCTM();
|
|
pushCTM();
|
|
AffineTransform total = new AffineTransform(pageTransform);
|
|
total.concatenate(currentTransform);
|
|
concatCTM(total);
|
|
}
|
|
|
|
/**
|
|
* special drawing routine for string shapes,
|
|
* which need to be drawn with the Y axis uninverted.
|
|
*/
|
|
private void drawStringShape(Shape s)
|
|
{
|
|
saveAndInvertAxis();
|
|
|
|
// draw the shape s with an inverted Y axis.
|
|
PathIterator pi = s.getPathIterator(null);
|
|
float[] coords = new float[6];
|
|
|
|
while (! pi.isDone())
|
|
{
|
|
switch (pi.currentSegment(coords))
|
|
{
|
|
case PathIterator.SEG_MOVETO:
|
|
out.println((coords[0]) + " " + (Y - coords[1]) + " moveto");
|
|
cx = coords[0];
|
|
cy = coords[1];
|
|
break;
|
|
case PathIterator.SEG_LINETO:
|
|
out.println((coords[0]) + " " + (Y - coords[1]) + " lineto");
|
|
cx = coords[0];
|
|
cy = coords[1];
|
|
break;
|
|
case PathIterator.SEG_QUADTO:
|
|
// convert to cubic bezier points
|
|
float x1 = (cx + 2 * coords[0]) / 3;
|
|
float y1 = (cy + 2 * coords[1]) / 3;
|
|
float x2 = (2 * coords[2] + coords[0]) / 3;
|
|
float y2 = (2 * coords[3] + coords[1]) / 3;
|
|
|
|
out.print((x1) + " " + (Y - y1) + " ");
|
|
out.print((x2) + " " + (Y - y2) + " ");
|
|
out.println((coords[2]) + " " + (Y - coords[3]) + " curveto");
|
|
cx = coords[2];
|
|
cy = coords[3];
|
|
break;
|
|
case PathIterator.SEG_CUBICTO:
|
|
out.print((coords[0]) + " " + (Y - coords[1]) + " ");
|
|
out.print((coords[2]) + " " + (Y - coords[3]) + " ");
|
|
out.println((coords[4]) + " " + (Y - coords[5]) + " curveto");
|
|
cx = coords[4];
|
|
cy = coords[5];
|
|
break;
|
|
case PathIterator.SEG_CLOSE:
|
|
out.println("closepath");
|
|
break;
|
|
}
|
|
pi.next();
|
|
}
|
|
out.println("fill");
|
|
|
|
restoreAxis();
|
|
}
|
|
|
|
public void setColor(Color c)
|
|
{
|
|
/* don't set the color if it's already set */
|
|
if (c.equals(currentColor))
|
|
return;
|
|
gradientOn = false;
|
|
currentColor = c;
|
|
currentPaint = c; // Graphics2D extends colors to paint
|
|
|
|
out.println(colorTriple(c) + " setrgbcolor");
|
|
}
|
|
|
|
public void clearRect(int x, int y, int width, int height)
|
|
{
|
|
out.println("% clearRect");
|
|
Color c = currentColor;
|
|
setColor(backgroundColor);
|
|
fill(new Rectangle2D.Double(x, y, width, height));
|
|
setColor(c);
|
|
}
|
|
|
|
public void clipRect(int x, int y, int width, int height)
|
|
{
|
|
clip(new Rectangle2D.Double(x, y, width, height));
|
|
}
|
|
|
|
public void copyArea(int x, int y, int width, int height, int dx, int dy)
|
|
{
|
|
// FIXME
|
|
}
|
|
|
|
public void fillRect(int x, int y, int width, int height)
|
|
{
|
|
fill(new Rectangle2D.Double(x, y, width, height));
|
|
}
|
|
|
|
public void dispose()
|
|
{
|
|
}
|
|
|
|
public void setClip(int x, int y, int width, int height)
|
|
{
|
|
out.println("% setClip()");
|
|
setClip(new Rectangle2D.Double(x, y, width, height));
|
|
}
|
|
|
|
public void setClip(Shape s)
|
|
{
|
|
clip(s);
|
|
}
|
|
|
|
public Shape getClip()
|
|
{
|
|
return clipShape;
|
|
}
|
|
|
|
public Rectangle getClipBounds()
|
|
{
|
|
return clipShape.getBounds();
|
|
}
|
|
|
|
public Color getColor()
|
|
{
|
|
return currentColor;
|
|
}
|
|
|
|
public Font getFont()
|
|
{
|
|
return currentFont;
|
|
}
|
|
|
|
public FontMetrics getFontMetrics()
|
|
{
|
|
return getFontMetrics(currentFont);
|
|
}
|
|
|
|
public FontMetrics getFontMetrics(Font f)
|
|
{
|
|
// FIXME
|
|
return null;
|
|
}
|
|
|
|
public void setFont(Font font)
|
|
{
|
|
out.println("% setfont()");
|
|
if (font == null)
|
|
// use the default font
|
|
font = new Font("Dialog", Font.PLAIN, 12);
|
|
currentFont = font;
|
|
setPSFont(); // set up the PostScript fonts
|
|
}
|
|
|
|
/**
|
|
* Setup the postscript font if the current font is one
|
|
*/
|
|
private void setPSFont()
|
|
{
|
|
currentFontIsPS = false;
|
|
|
|
String s = currentFont.getName();
|
|
out.println("% setPSFont: Fontname: " + s);
|
|
if (s.equalsIgnoreCase("Helvetica") || s.equalsIgnoreCase("SansSerif"))
|
|
out.print("/helveticaISO findfont ");
|
|
else if (s.equalsIgnoreCase("Times New Roman"))
|
|
out.print("/timesISO findfont ");
|
|
else if (s.equalsIgnoreCase("Courier"))
|
|
out.print("/courierISO findfont ");
|
|
else
|
|
return;
|
|
|
|
currentFontIsPS = true;
|
|
|
|
out.print(currentFont.getSize() + " scalefont ");
|
|
out.println("setfont");
|
|
}
|
|
|
|
/** XOR mode is not supported */
|
|
public void setPaintMode()
|
|
{
|
|
}
|
|
|
|
/** XOR mode is not supported */
|
|
public void setXORMode(Color c1)
|
|
{
|
|
}
|
|
|
|
public void close()
|
|
{
|
|
out.println("showpage");
|
|
out.println("%%Trailer");
|
|
out.println("grestore % restore original stuff");
|
|
out.println("%%EOF");
|
|
|
|
try
|
|
{
|
|
out.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
}
|
|
out = null;
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
// Graphics2D stuff ----------------------------------------------
|
|
|
|
/** Sets the values of an arbitrary number of
|
|
preferences for the rendering algorithms. */
|
|
public void addRenderingHints(Map hints)
|
|
{
|
|
/* rendering hint changes are disallowed */
|
|
}
|
|
|
|
/** write a shape to the file */
|
|
private void writeShape(Shape s)
|
|
{
|
|
PathIterator pi = s.getPathIterator(null);
|
|
float[] coords = new float[6];
|
|
|
|
while (! pi.isDone())
|
|
{
|
|
switch (pi.currentSegment(coords))
|
|
{
|
|
case PathIterator.SEG_MOVETO:
|
|
out.println(coords[0] + " " + (coords[1]) + " moveto");
|
|
cx = coords[0];
|
|
cy = coords[1];
|
|
break;
|
|
case PathIterator.SEG_LINETO:
|
|
out.println(coords[0] + " " + (coords[1]) + " lineto");
|
|
cx = coords[0];
|
|
cy = coords[1];
|
|
break;
|
|
case PathIterator.SEG_QUADTO:
|
|
// convert to cubic bezier points
|
|
float x1 = (cx + 2 * coords[0]) / 3;
|
|
float y1 = (cy + 2 * coords[1]) / 3;
|
|
float x2 = (2 * coords[2] + coords[0]) / 3;
|
|
float y2 = (2 * coords[3] + coords[1]) / 3;
|
|
|
|
out.print(x1 + " " + (Y - y1) + " ");
|
|
out.print(x2 + " " + (Y - y2) + " ");
|
|
out.println(coords[2] + " " + (Y - coords[3]) + " curveto");
|
|
cx = coords[2];
|
|
cy = coords[3];
|
|
break;
|
|
case PathIterator.SEG_CUBICTO:
|
|
out.print(coords[0] + " " + coords[1] + " ");
|
|
out.print(coords[2] + " " + coords[3] + " ");
|
|
out.println(coords[4] + " " + coords[5] + " curveto");
|
|
cx = coords[4];
|
|
cy = coords[5];
|
|
break;
|
|
case PathIterator.SEG_CLOSE:
|
|
out.println("closepath");
|
|
break;
|
|
}
|
|
pi.next();
|
|
}
|
|
}
|
|
|
|
/** Intersects the current Clip with the interior of
|
|
the specified Shape and sets the Clip to the resulting intersection. */
|
|
public void clip(Shape s)
|
|
{
|
|
clipShape = s;
|
|
out.println("% clip INACTIVE");
|
|
// writeShape(s);
|
|
// out.println("clip");
|
|
}
|
|
|
|
/** Strokes the outline of a Shape using the
|
|
settings of the current Graphics2D context.*/
|
|
public void draw(Shape s)
|
|
{
|
|
if(!(currentStroke instanceof BasicStroke))
|
|
fill(currentStroke.createStrokedShape(s));
|
|
|
|
out.println("% draw");
|
|
writeShape(s);
|
|
out.println("stroke");
|
|
}
|
|
|
|
/** Renders the text of the specified GlyphVector using the
|
|
Graphics2D context's rendering attributes. */
|
|
public void drawGlyphVector(GlyphVector gv, float x, float y)
|
|
{
|
|
out.println("% drawGlyphVector");
|
|
Shape s = gv.getOutline();
|
|
drawStringShape(AffineTransform.getTranslateInstance(x, y)
|
|
.createTransformedShape(s));
|
|
}
|
|
|
|
/** Renders the text of the specified iterator,
|
|
using the Graphics2D context's current Paint.*/
|
|
public void drawString(AttributedCharacterIterator iterator, float x, float y)
|
|
{
|
|
TextLayout text = new TextLayout(iterator, getFontRenderContext());
|
|
Shape s = text.getOutline(AffineTransform.getTranslateInstance(x, y));
|
|
drawStringShape(s);
|
|
}
|
|
|
|
/** Renders the text of the specified iterator,
|
|
using the Graphics2D context's current Paint. */
|
|
public void drawString(AttributedCharacterIterator iterator, int x, int y)
|
|
{
|
|
drawString(iterator, (float) x, (float) y);
|
|
}
|
|
|
|
/** Fills the interior of a Shape using the settings of the Graphics2D context. */
|
|
public void fill(Shape s)
|
|
{
|
|
out.println("% fill");
|
|
if (! gradientOn)
|
|
{
|
|
writeShape(s);
|
|
out.println("fill");
|
|
}
|
|
else
|
|
{
|
|
out.println("gsave");
|
|
writeShape(s);
|
|
out.println("clip");
|
|
writeGradient();
|
|
out.println("shfill");
|
|
out.println("grestore");
|
|
}
|
|
}
|
|
|
|
/** Returns the background color used for clearing a region. */
|
|
public Color getBackground()
|
|
{
|
|
return backgroundColor;
|
|
}
|
|
|
|
/** Returns the current Composite in the Graphics2D context. */
|
|
public Composite getComposite()
|
|
{
|
|
// FIXME
|
|
return null;
|
|
}
|
|
|
|
/** Returns the device configuration associated with this Graphics2D. */
|
|
public GraphicsConfiguration getDeviceConfiguration()
|
|
{
|
|
// FIXME
|
|
out.println("% getDeviceConfiguration()");
|
|
return null;
|
|
}
|
|
|
|
/** Get the rendering context of the Font within this Graphics2D context. */
|
|
public FontRenderContext getFontRenderContext()
|
|
{
|
|
out.println("% getFontRenderContext()");
|
|
|
|
double[] scaling =
|
|
{
|
|
pageTransform.getScaleX(), 0, 0,
|
|
-pageTransform.getScaleY(), 0, 0
|
|
};
|
|
|
|
return (new FontRenderContext(new AffineTransform(scaling), false, true));
|
|
}
|
|
|
|
/** Returns the current Paint of the Graphics2D context. */
|
|
public Paint getPaint()
|
|
{
|
|
return currentPaint;
|
|
}
|
|
|
|
/** Returns the value of a single preference for the rendering algorithms. */
|
|
public Object getRenderingHint(RenderingHints.Key hintKey)
|
|
{
|
|
return renderingHints.get(hintKey);
|
|
}
|
|
|
|
/** Gets the preferences for the rendering algorithms. */
|
|
public RenderingHints getRenderingHints()
|
|
{
|
|
return renderingHints;
|
|
}
|
|
|
|
/** Returns the current Stroke in the Graphics2D context. */
|
|
public Stroke getStroke()
|
|
{
|
|
return currentStroke;
|
|
}
|
|
|
|
/** Returns a copy of the current Transform in the Graphics2D context. */
|
|
public AffineTransform getTransform()
|
|
{
|
|
return currentTransform;
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the specified Shape intersects
|
|
* the specified Rectangle, which is in device space.
|
|
*/
|
|
public boolean hit(Rectangle rect, Shape s, boolean onStroke)
|
|
{
|
|
Rectangle2D.Double r = new Rectangle2D.Double(rect.getX(), rect.getY(),
|
|
rect.getWidth(),
|
|
rect.getHeight());
|
|
return s.intersects(r);
|
|
}
|
|
|
|
/** Sets the background color for the Graphics2D context.*/
|
|
public void setBackground(Color color)
|
|
{
|
|
out.println("% setBackground(" + color + ")");
|
|
backgroundColor = color;
|
|
}
|
|
|
|
/** Sets the Composite for the Graphics2D context.
|
|
Not supported. */
|
|
public void setComposite(Composite comp)
|
|
{
|
|
}
|
|
|
|
/** Sets the Paint attribute for the Graphics2D context.*/
|
|
public void setPaint(Paint paint)
|
|
{
|
|
currentPaint = paint;
|
|
gradientOn = false;
|
|
if (paint instanceof Color)
|
|
{
|
|
setColor((Color) paint);
|
|
return;
|
|
}
|
|
if (paint instanceof GradientPaint)
|
|
{
|
|
gradientOn = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* get a space seperated 0.0 - 1.0 color RGB triple */
|
|
private String colorTriple(Color c)
|
|
{
|
|
return (((double) c.getRed() / 255.0) + " "
|
|
+ ((double) c.getGreen() / 255.0) + " "
|
|
+ ((double) c.getBlue() / 255.0));
|
|
}
|
|
|
|
/**
|
|
* Get a nonsperated hex RGB triple, eg FFFFFF = white
|
|
* used by writeGradient and drawImage
|
|
*/
|
|
private String colorTripleHex(Color c)
|
|
{
|
|
String r = "00" + Integer.toHexString(c.getRed());
|
|
r = r.substring(r.length() - 2);
|
|
String g = "00" + Integer.toHexString(c.getGreen());
|
|
g = g.substring(g.length() - 2);
|
|
String b = "00" + Integer.toHexString(c.getBlue());
|
|
b = b.substring(b.length() - 2);
|
|
return r + g + b;
|
|
}
|
|
|
|
/* write the current gradient fill */
|
|
private void writeGradient()
|
|
{
|
|
GradientPaint paint = (GradientPaint) currentPaint;
|
|
out.println("% writeGradient()");
|
|
|
|
int n = 1;
|
|
double x;
|
|
double y;
|
|
double dx;
|
|
double dy;
|
|
Point2D p1 = currentTransform.transform(paint.getPoint1(), null);
|
|
Point2D p2 = currentTransform.transform(paint.getPoint2(), null);
|
|
x = p1.getX();
|
|
y = p1.getY();
|
|
dx = p2.getX() - x;
|
|
dy = p2.getY() - y;
|
|
|
|
// get number of repetitions
|
|
while (x + n * dx < pageY && y + n * dy < pageX && x + n * dx > 0
|
|
&& y + n * dy > 0)
|
|
n++;
|
|
|
|
out.println("<<"); // start
|
|
out.println("/ShadingType 2"); // gradient fill
|
|
out.println("/ColorSpace [ /DeviceRGB ]"); // RGB colors
|
|
out.print("/Coords [");
|
|
out.print(x + " " + y + " " + (x + n * dx) + " " + (y + n * dy) + " ");
|
|
out.println("]"); // coordinates defining the axis
|
|
out.println("/Function <<");
|
|
out.println("/FunctionType 0");
|
|
out.println("/Order 1");
|
|
out.println("/Domain [ 0 1 ]");
|
|
out.println("/Range [ 0 1 0 1 0 1 ]");
|
|
out.println("/BitsPerSample 8");
|
|
out.println("/Size [ " + (1 + n) + " ]");
|
|
out.print("/DataSource < " + colorTripleHex(paint.getColor1()) + " "
|
|
+ colorTripleHex(paint.getColor2()) + " ");
|
|
for (; n > 1; n--)
|
|
if (paint.isCyclic())
|
|
{
|
|
if ((n % 2) == 1)
|
|
out.print(colorTripleHex(paint.getColor1()) + " ");
|
|
else
|
|
out.print(colorTripleHex(paint.getColor2()) + " ");
|
|
}
|
|
else
|
|
out.print(colorTripleHex(paint.getColor2()) + " ");
|
|
out.println(">");
|
|
out.println(">>");
|
|
out.println(">>");
|
|
}
|
|
|
|
/** Sets the value of a single preference for the rendering algorithms. */
|
|
public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue)
|
|
{
|
|
/* we don't allow the changing of rendering hints. */
|
|
}
|
|
|
|
/** Replaces the values of all preferences for the rendering algorithms
|
|
with the specified hints. */
|
|
public void setRenderingHints(Map hints)
|
|
{
|
|
/* we don't allow the changing of rendering hints. */
|
|
}
|
|
|
|
/**
|
|
* Sets the Stroke for the Graphics2D context. BasicStroke fully implemented.
|
|
*/
|
|
public void setStroke(Stroke s)
|
|
{
|
|
currentStroke = s;
|
|
|
|
if (! (s instanceof BasicStroke))
|
|
return;
|
|
|
|
BasicStroke bs = (BasicStroke) s;
|
|
out.println("% setStroke()");
|
|
try
|
|
{
|
|
// set the line width
|
|
out.println(bs.getLineWidth() + " setlinewidth");
|
|
|
|
// set the line dash
|
|
float[] dashArray = bs.getDashArray();
|
|
if (dashArray != null)
|
|
{
|
|
out.print("[ ");
|
|
for (int i = 0; i < dashArray.length; i++)
|
|
out.print(dashArray[i] + " ");
|
|
out.println("] " + bs.getDashPhase() + " setdash");
|
|
}
|
|
else
|
|
out.println("[] 0 setdash"); // set solid
|
|
|
|
// set the line cap
|
|
switch (bs.getEndCap())
|
|
{
|
|
case BasicStroke.CAP_BUTT:
|
|
out.println("0 setlinecap");
|
|
break;
|
|
case BasicStroke.CAP_ROUND:
|
|
out.println("1 setlinecap");
|
|
break;
|
|
case BasicStroke.CAP_SQUARE:
|
|
out.println("2 setlinecap");
|
|
break;
|
|
}
|
|
|
|
// set the line join
|
|
switch (bs.getLineJoin())
|
|
{
|
|
case BasicStroke.JOIN_BEVEL:
|
|
out.println("2 setlinejoin");
|
|
break;
|
|
case BasicStroke.JOIN_MITER:
|
|
out.println("0 setlinejoin");
|
|
out.println(bs.getMiterLimit() + " setmiterlimit");
|
|
break;
|
|
case BasicStroke.JOIN_ROUND:
|
|
out.println("1 setlinejoin");
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
out.println("% Exception in setStroke()");
|
|
}
|
|
}
|
|
|
|
//////////////////// TRANSFORM SETTING /////////////////////////////////////
|
|
private void concatCTM(AffineTransform Tx)
|
|
{
|
|
double[] matrixElements = new double[6];
|
|
Tx.getMatrix(matrixElements);
|
|
|
|
out.print("[ ");
|
|
for (int i = 0; i < 6; i++)
|
|
out.print(matrixElements[i] + " ");
|
|
out.println("] concat");
|
|
}
|
|
|
|
/** Sets the Transform in the Graphics2D context. */
|
|
public void setTransform(AffineTransform Tx)
|
|
{
|
|
// set the transformation matrix;
|
|
currentTransform = Tx;
|
|
|
|
// concatenate the current transform and the page transform
|
|
AffineTransform totalTransform = new AffineTransform(pageTransform);
|
|
totalTransform.concatenate(currentTransform);
|
|
out.println("% setTransform()");
|
|
out.println("% pageTransform:" + pageTransform);
|
|
out.println("% currentTransform:" + currentTransform);
|
|
out.println("% totalTransform:" + totalTransform);
|
|
|
|
popCTM();
|
|
pushCTM(); // set the CTM to it's original state
|
|
concatCTM(totalTransform); // apply our transforms
|
|
}
|
|
|
|
/** Composes an AffineTransform object with the Transform
|
|
in this Graphics2D according to the rule last-specified-first-applied. */
|
|
public void transform(AffineTransform Tx)
|
|
{
|
|
// concatenate the current transform
|
|
currentTransform.concatenate(Tx);
|
|
// and the PS CTM
|
|
concatCTM(Tx);
|
|
}
|
|
|
|
////////////////////////// TRANSFORMS //////////////////////////////////////
|
|
|
|
/** shear transform */
|
|
public void shear(double shx, double shy)
|
|
{
|
|
out.println("% shear()");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.shear(shx, shy);
|
|
transform(Tx);
|
|
}
|
|
|
|
/** Translates the origin of the Graphics2D context
|
|
to the point (x, y) in the current coordinate system. */
|
|
public void translate(int x, int y)
|
|
{
|
|
out.println("% translate()");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.translate(x, y);
|
|
transform(Tx);
|
|
}
|
|
|
|
/** Translates the origin of the Graphics2D context
|
|
to the point (x, y) in the current coordinate system. */
|
|
public void translate(double x, double y)
|
|
{
|
|
out.println("% translate(" + x + ", " + y + ")");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.translate(x, y);
|
|
transform(Tx);
|
|
}
|
|
|
|
/** Concatenates the current Graphics2D Transform with a rotation transform.*/
|
|
public void rotate(double theta)
|
|
{
|
|
out.println("% rotate(" + theta + ")");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.rotate(theta);
|
|
transform(Tx);
|
|
}
|
|
|
|
/** Concatenates the current Graphics2D Transform with
|
|
a translated rotation transform.*/
|
|
public void rotate(double theta, double x, double y)
|
|
{
|
|
out.println("% rotate()");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.rotate(theta, x, y);
|
|
transform(Tx);
|
|
}
|
|
|
|
/** Concatenates the current Graphics2D Transform with a scaling
|
|
transformation Subsequent rendering is resized according to the
|
|
specified scaling factors relative to the previous scaling.*/
|
|
public void scale(double sx, double sy)
|
|
{
|
|
out.println("% scale(" + sx + ", " + sy + ")");
|
|
AffineTransform Tx = new AffineTransform();
|
|
Tx.scale(sx, sy);
|
|
transform(Tx);
|
|
}
|
|
}
|