| /* JavaPrinterGraphics.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 gnu.java.awt.peer.gtk.CairoSurface; | |
| import java.awt.Color; | |
| import java.awt.Font; | |
| import java.awt.FontMetrics; | |
| import java.awt.Graphics; | |
| import java.awt.Image; | |
| import java.awt.Rectangle; | |
| import java.awt.Shape; | |
| import java.awt.geom.AffineTransform; | |
| 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.PrinterGraphics; | |
| 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; | |
| /** | |
| * Graphics context to draw to PostScript. | |
| * | |
| * @author Sven de Marothy | |
| */ | |
| public class JavaPrinterGraphics extends Graphics implements PrinterGraphics | |
| { | |
| /** | |
| * The used graphics context. | |
| */ | |
| private Graphics g; | |
| /** | |
| * The associated printer job. | |
| */ | |
| private PrinterJob printerJob; | |
| /** | |
| * Rendering resolution | |
| */ | |
| private static final double DPI = 72.0; | |
| /** | |
| * Rendered image size. | |
| */ | |
| private int xSize, ySize; | |
| /** | |
| * The image to render to. | |
| */ | |
| private Image image; | |
| public JavaPrinterGraphics( PrinterJob printerJob ) | |
| { | |
| this.printerJob = printerJob; | |
| } | |
| /** | |
| * 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(); | |
| PrintWriter out = new PrintWriter | |
| (new BufferedWriter | |
| (new OutputStreamWriter | |
| (new FileOutputStream(temp), "ISO8859_1"), 1000000)); | |
| writePSHeader(out); | |
| 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; | |
| } | |
| } | |
| /** | |
| * 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 | |
| { | |
| initImage( pageFormat ); | |
| if(printable.print(this, pageFormat, index) == Printable.NO_SUCH_PAGE) | |
| return Printable.NO_SUCH_PAGE; | |
| g.dispose(); | |
| g = null; | |
| writePage( out, pageFormat ); | |
| return Printable.PAGE_EXISTS; | |
| } | |
| private void initImage(PageFormat pageFormat) | |
| { | |
| // Create a really big image and draw to that. | |
| xSize = (int)(DPI*pageFormat.getWidth()/72.0); | |
| ySize = (int)(DPI*pageFormat.getHeight()/72.0); | |
| // Swap X and Y sizes if it's a Landscape page. | |
| if( pageFormat.getOrientation() != PageFormat.PORTRAIT ) | |
| { | |
| int t = xSize; | |
| xSize = ySize; | |
| ySize = t; | |
| } | |
| // FIXME: This should at least be BufferedImage. | |
| // Fix once we have a working B.I. | |
| // Graphics2D should also be supported of course. | |
| image = CairoSurface.getBufferedImage(xSize, ySize); | |
| g = image.getGraphics(); | |
| setColor(Color.white); | |
| fillRect(0, 0, xSize, ySize); | |
| setColor(Color.black); | |
| } | |
| private void writePSHeader(PrintWriter out) | |
| { | |
| 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("%%Pages: "+); // FIXME # pages. | |
| out.println("%%EndComments"); | |
| out.println("%%BeginProlog"); | |
| out.println("%%EndProlog"); | |
| out.println("%%BeginSetup"); | |
| // FIXME: Paper name | |
| // E.g. "A4" "Letter" | |
| // out.println("%%BeginFeature: *PageSize A4"); | |
| out.println("%%EndFeature"); | |
| out.println("%%EndSetup"); | |
| // out.println("%%Page: 1 1"); | |
| } | |
| private void writePage(PrintWriter out, PageFormat pageFormat) | |
| { | |
| out.println("%%BeginPageSetup"); | |
| Paper p = pageFormat.getPaper(); | |
| double pWidth = p.getWidth(); | |
| double pHeight = p.getHeight(); | |
| if( pageFormat.getOrientation() == PageFormat.PORTRAIT ) | |
| out.println( "%%Orientation: Portrait" ); | |
| else | |
| { | |
| out.println( "%%Orientation: Landscape" ); | |
| double t = pWidth; | |
| pWidth = pHeight; | |
| pHeight = t; | |
| } | |
| out.println("gsave % first save"); | |
| // 595x842; 612x792 respectively | |
| out.println("<< /PageSize [" +pWidth + " "+pHeight+ "] >> setpagedevice"); | |
| // invert the Y axis so that we get screen-like coordinates instead. | |
| AffineTransform pageTransform = new AffineTransform(); | |
| if( pageFormat.getOrientation() == PageFormat.REVERSE_LANDSCAPE ) | |
| { | |
| pageTransform.translate(pWidth, pHeight); | |
| pageTransform.scale(-1.0, -1.0); | |
| } | |
| concatCTM(out, pageTransform); | |
| out.println("%%EndPageSetup"); | |
| out.println("gsave"); | |
| // Draw the image | |
| out.println(xSize+" "+ySize+" 8 [1 0 0 -1 0 "+ySize+" ]"); | |
| out.println("{currentfile 3 string readhexstring pop} bind"); | |
| out.println("false 3 colorimage"); | |
| int[] pixels = new int[xSize * ySize]; | |
| PixelGrabber pg = new PixelGrabber(image, 0, 0, xSize, ySize, pixels, 0, xSize); | |
| try { | |
| pg.grabPixels(); | |
| } catch (InterruptedException e) { | |
| out.println("% Bug getting pixels!"); | |
| } | |
| int n = 0; | |
| for (int j = 0; j < ySize; j++) { | |
| for (int i = 0; i < xSize; i++) { | |
| out.print( colorTripleHex(pixels[j * xSize + i]) ); | |
| if(((++n)%11) == 0) out.println(); | |
| } | |
| } | |
| out.println(); | |
| out.println("%%EOF"); | |
| out.println("grestore"); | |
| out.println("showpage"); | |
| } | |
| /** | |
| * Get a nonsperated hex RGB triple, e.g. FFFFFF = white | |
| */ | |
| private String colorTripleHex(int num){ | |
| String s = ""; | |
| try { | |
| s = Integer.toHexString( ( num & 0x00FFFFFF ) ); | |
| if( s.length() < 6 ) | |
| { | |
| s = "000000"+s; | |
| return s.substring(s.length()-6); | |
| } | |
| } catch (Exception e){ | |
| s = "FFFFFF"; | |
| } | |
| return s; | |
| } | |
| private void concatCTM(PrintWriter out, 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"); | |
| } | |
| //----------------------------------------------------------------------------- | |
| /** | |
| * PrinterGraphics method - Returns the printer job associated with this object. | |
| */ | |
| public PrinterJob getPrinterJob() | |
| { | |
| return printerJob; | |
| } | |
| /** | |
| * The rest of the methods here are just pass-throughs to g. | |
| */ | |
| public void clearRect(int x, int y, int width, int height) | |
| { | |
| g.clearRect(x, y, width, height); | |
| } | |
| public void clipRect(int x, int y, int width, int height) | |
| { | |
| g.clipRect(x, y, width, height); | |
| } | |
| public void copyArea(int x, int y, int width, int height, int dx, int dy) | |
| { | |
| g.copyArea(x, y, width, height, dx, dy); | |
| } | |
| public Graphics create() | |
| { | |
| return g.create(); | |
| } | |
| public void dispose() | |
| { | |
| } | |
| public void drawArc(int x, int y, int width, int height, int startAngle, | |
| int arcAngle) | |
| { | |
| g.drawArc(x, y, width, height, startAngle, arcAngle); | |
| } | |
| public boolean drawImage(Image img, int x, int y, Color bgcolor, | |
| ImageObserver observer) | |
| { | |
| return g.drawImage(img, x, y, bgcolor, observer); | |
| } | |
| public boolean drawImage(Image img, int x, int y, ImageObserver observer) | |
| { | |
| return g.drawImage(img, x, y, observer); | |
| } | |
| public boolean drawImage(Image img, int x, int y, int width, int height, | |
| Color bgcolor, ImageObserver observer) | |
| { | |
| return g.drawImage(img, x, y, width, height, bgcolor, observer); | |
| } | |
| public boolean drawImage(Image img, int x, int y, int width, int height, | |
| ImageObserver observer) | |
| { | |
| return g.drawImage(img, x, y, width, height, 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) | |
| { | |
| return g.drawImage(img, dx1, dy1, dx2, dy2, | |
| sx1, sy1, sx2, sy2, bgcolor, observer); | |
| } | |
| public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, | |
| int sx1, int sy1, int sx2, int sy2, ImageObserver observer) | |
| { | |
| return g.drawImage(img, dx1, dy1, dx2, dy2, | |
| sx1, sy1, sx2, sy2, observer); | |
| } | |
| public void drawLine(int x1, int y1, int x2, int y2) | |
| { | |
| g.drawLine(x1, y1, x2, y2); | |
| } | |
| public void drawOval(int x, int y, int width, int height) | |
| { | |
| g.drawOval(x, y, width, height); | |
| } | |
| public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) | |
| { | |
| g.drawPolygon(xPoints, yPoints, nPoints); | |
| } | |
| public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) | |
| { | |
| g.drawPolyline(xPoints, yPoints, nPoints); | |
| } | |
| public void drawRoundRect(int x, int y, int width, int height, | |
| int arcWidth, int arcHeight) | |
| { | |
| g.drawRoundRect(x, y, width, height, arcWidth, arcHeight); | |
| } | |
| public void drawString(AttributedCharacterIterator iterator, int x, int y) | |
| { | |
| g.drawString(iterator, x, y); | |
| } | |
| public void drawString(String str, int x, int y) | |
| { | |
| g.drawString(str, x, y); | |
| } | |
| public void fillArc(int x, int y, int width, int height, | |
| int startAngle, int arcAngle) | |
| { | |
| g.fillArc(x, y, width, height, startAngle, arcAngle); | |
| } | |
| public void fillOval(int x, int y, int width, int height) | |
| { | |
| g.fillOval(x, y, width, height); | |
| } | |
| public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) | |
| { | |
| g.fillPolygon(xPoints, yPoints, nPoints); | |
| } | |
| public void fillRect(int x, int y, int width, int height) | |
| { | |
| g.fillRect(x, y, width, height); | |
| } | |
| public void fillRoundRect(int x, int y, int width, int height, | |
| int arcWidth, int arcHeight) | |
| { | |
| g.fillRoundRect(x, y, width, height, arcWidth, arcHeight); | |
| } | |
| public Shape getClip() | |
| { | |
| return g.getClip(); | |
| } | |
| public Rectangle getClipBounds() | |
| { | |
| return g.getClipBounds(); | |
| } | |
| public Color getColor() | |
| { | |
| return g.getColor(); | |
| } | |
| public Font getFont() | |
| { | |
| return g.getFont(); | |
| } | |
| public FontMetrics getFontMetrics(Font f) | |
| { | |
| return g.getFontMetrics(f); | |
| } | |
| public void setClip(int x, int y, int width, int height) | |
| { | |
| g.setClip(x, y, width, height); | |
| } | |
| public void setClip(Shape clip) | |
| { | |
| g.setClip(clip); | |
| } | |
| public void setColor(Color c) | |
| { | |
| g.setColor(c); | |
| } | |
| public void setFont(Font font) | |
| { | |
| g.setFont(font); | |
| } | |
| public void setPaintMode() | |
| { | |
| g.setPaintMode(); | |
| } | |
| public void setXORMode(Color c1) | |
| { | |
| g.setXORMode(c1); | |
| } | |
| public void translate(int x, int y) | |
| { | |
| g.translate(x, y); | |
| } | |
| } | |