fop/fop-core/src/main/java/org/apache/fop/render/pcl/PCLDocumentHandler.java

/*
 * 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.pcl;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.util.Map;

import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.xmlgraphics.io.TempResourceURIGenerator;
import org.apache.xmlgraphics.util.UnitConv;

import org.apache.fop.apps.FopFactoryConfig;
import org.apache.fop.apps.MimeConstants;
import org.apache.fop.fonts.FontInfo;
import org.apache.fop.fonts.Typeface;
import org.apache.fop.render.intermediate.AbstractBinaryWritingIFDocumentHandler;
import org.apache.fop.render.intermediate.IFContext;
import org.apache.fop.render.intermediate.IFDocumentHandlerConfigurator;
import org.apache.fop.render.intermediate.IFException;
import org.apache.fop.render.intermediate.IFPainter;
import org.apache.fop.render.java2d.Java2DPainter;
import org.apache.fop.render.java2d.Java2DUtil;
import org.apache.fop.render.pcl.PCLRendererConfig.PCLRendererConfigParser;
import org.apache.fop.render.pcl.extensions.PCLElementMapping;
import org.apache.fop.render.pcl.fonts.PCLSoftFontManager;

/**
 * {@link org.apache.fop.render.intermediate.IFDocumentHandler} implementation
 * that produces PCL 5.
 */
public class PCLDocumentHandler extends AbstractBinaryWritingIFDocumentHandler
            implements PCLConstants {

    /** logging instance */
    private static Log log = LogFactory.getLog(PCLDocumentHandler.class);

    /** the temporary file in case of two-pass processing */
    private URI tempURI;
    private static final TempResourceURIGenerator TEMP_URI_GENERATOR = new TempResourceURIGenerator("pcl-optimize");

    /** Utility class for handling all sorts of peripheral tasks around PCL generation. */
    protected PCLRenderingUtil pclUtil;

    /** The PCL generator */
    private PCLGenerator gen;

    private PCLPageDefinition currentPageDefinition;

    /** contains the pageWith of the last printed page */
    private long pageWidth;
    /** contains the pageHeight of the last printed page */
    private long pageHeight;

    /** the current page image (only set when all-bitmap painting is activated) */
    private BufferedImage currentImage;


    /**
     * Default constructor.
     */
    public PCLDocumentHandler(IFContext context) {
        super(context);
        this.pclUtil = new PCLRenderingUtil(context.getUserAgent());
    }

    /** {@inheritDoc} */
    public boolean supportsPagesOutOfOrder() {
        return false;
    }

    /** {@inheritDoc} */
    public String getMimeType() {
        return MimeConstants.MIME_PCL;
    }

    /** {@inheritDoc} */
    public IFDocumentHandlerConfigurator getConfigurator() {
        return new PCLRendererConfigurator(getUserAgent(), new PCLRendererConfigParser());
    }

    /** {@inheritDoc} */
    @Override
    public void setDefaultFontInfo(FontInfo fontInfo) {
        FontInfo fi = Java2DUtil.buildDefaultJava2DBasedFontInfo(fontInfo, getUserAgent());
        setFontInfo(fi);
    }

    PCLRenderingUtil getPCLUtil() {
        return this.pclUtil;
    }

    PCLGenerator getPCLGenerator() {
        return this.gen;
    }

    /** @return the target resolution */
    protected int getResolution() {
        int resolution = Math.round(getUserAgent().getTargetResolution());
        if (resolution <= 300) {
            return 300;
        } else {
            return 600;
        }
    }

    //----------------------------------------------------------------------------------------------

    /** {@inheritDoc} */
    @Override
    public void startDocument() throws IFException {
        super.startDocument();
        try {
            final OutputStream out;
            if (pclUtil.isOptimizeResources()) {
                tempURI = TEMP_URI_GENERATOR.generate();
                out = new BufferedOutputStream(getUserAgent().getResourceResolver().getOutputStream(tempURI));
            } else {
                out = this.outputStream;
            }

            this.gen = new PCLGenerator(out, getResolution());
            this.gen.setDitheringQuality(pclUtil.getDitheringQuality());

            if (!pclUtil.isPJLDisabled()) {
                gen.universalEndOfLanguage();
                gen.writeText("@PJL COMMENT Produced by " + getUserAgent().getProducer() + "\n");
                if (getUserAgent().getTitle() != null) {
                    gen.writeText("@PJL JOB NAME = \"" + getUserAgent().getTitle() + "\"\n");
                }
                gen.writeText("@PJL SET RESOLUTION = " + getResolution() + "\n");
                gen.writeText("@PJL ENTER LANGUAGE = PCL\n");
            }
            gen.resetPrinter();
            gen.setUnitOfMeasure(getResolution());
            gen.setRasterGraphicsResolution(getResolution());
        } catch (IOException e) {
            throw new IFException("I/O error in startDocument()", e);
        }
    }

    /** {@inheritDoc} */
    @Override
    public void endDocumentHeader() throws IFException {
    }

    /** {@inheritDoc} */
    @Override
    public void endDocument() throws IFException {
        try {
            gen.separateJobs();
            gen.resetPrinter();
            if (!pclUtil.isPJLDisabled()) {
                gen.universalEndOfLanguage();
            }

            if (pclUtil.isOptimizeResources()) {
                IOUtils.closeQuietly(gen.getOutputStream());
                rewritePCLFile();
            }
        } catch (IOException ioe) {
            throw new IFException("I/O error in endDocument()", ioe);
        }
        super.endDocument();
    }

    private void rewritePCLFile() throws IOException {
        InputStream in = new BufferedInputStream(getUserAgent().getResourceResolver().getResource(tempURI));
        long offset = 0;
        for (Map.Entry<PCLSoftFontManager, Map<Typeface, Long>> fontManagerMapEntry : gen.fontManagerMap.entrySet()) {
            PCLSoftFontManager softFontManager = fontManagerMapEntry.getKey();
            for (Map.Entry<Typeface, Long> fontEntry : fontManagerMapEntry.getValue().entrySet()) {
                ByteArrayOutputStream fontData = softFontManager.makeSoftFont(fontEntry.getKey(), null);
                long pos = fontEntry.getValue();
                copy(in, pos - offset);
                outputStream.write(fontData.toByteArray());
                offset = pos;
            }
        }
        copy(in, Long.MAX_VALUE);
        this.outputStream.flush();
        IOUtils.closeQuietly(in);
    }

    private void copy(InputStream is, long len) throws IOException {
        while (len > 0) {
            int bufsize = (int) Math.min(1024, len);
            byte[] buf = new byte[bufsize];
            if (is.read(buf) == -1) {
                return;
            }
            outputStream.write(buf);
            len -= bufsize;
        }
    }

    /** {@inheritDoc} */
    public void startPageSequence(String id) throws IFException {
        //nop
    }

    /** {@inheritDoc} */
    public void endPageSequence() throws IFException {
        //nop
    }

    /** {@inheritDoc} */
    public void startPage(int index, String name, String pageMasterName, Dimension size)
            throws IFException {

        try {
            //Paper source
            Object paperSource = getContext().getForeignAttribute(
                    PCLElementMapping.PCL_PAPER_SOURCE);
            if (paperSource != null) {
                gen.selectPaperSource(Integer.parseInt(paperSource.toString()));
            }

            //Output bin
            Object outputBin = getContext().getForeignAttribute(
                    PCLElementMapping.PCL_OUTPUT_BIN);
            if (outputBin != null) {
                gen.selectOutputBin(Integer.parseInt(outputBin.toString()));
            }

            // Is Page duplex?
            Object pageDuplex = getContext().getForeignAttribute(
                    PCLElementMapping.PCL_DUPLEX_MODE);
            if (pageDuplex != null) {
                gen.selectDuplexMode(Integer.parseInt(pageDuplex.toString()));
            }

            //Page size
            final long pagewidth = size.width;
            final long pageheight = size.height;
            selectPageFormat(pagewidth, pageheight);
        } catch (IOException ioe) {
            throw new IFException("I/O error in startPage()", ioe);
        }
    }

    /** {@inheritDoc} */
    public IFPainter startPageContent() throws IFException {
        if (pclUtil.getRenderingMode() == PCLRenderingMode.BITMAP) {
            return createAllBitmapPainter();
        } else {
            return new PCLPainter(this, this.currentPageDefinition);
        }
    }

    private IFPainter createAllBitmapPainter() {
        double scale = gen.getMaximumBitmapResolution()
                / FopFactoryConfig.DEFAULT_TARGET_RESOLUTION;
        Rectangle printArea = this.currentPageDefinition.getLogicalPageRect();
        int bitmapWidth = (int)Math.ceil(
                UnitConv.mpt2px(printArea.width, gen.getMaximumBitmapResolution()));
        int bitmapHeight = (int)Math.ceil(
                UnitConv.mpt2px(printArea.height, gen.getMaximumBitmapResolution()));
        this.currentImage = createBufferedImage(bitmapWidth, bitmapHeight);
        Graphics2D graphics2D = this.currentImage.createGraphics();

        if (!PCLGenerator.isJAIAvailable()) {
            RenderingHints hints = new RenderingHints(null);
            //These hints don't seem to make a difference :-( Not seeing any dithering on Sun Java.
            hints.put(RenderingHints.KEY_DITHERING,
                    RenderingHints.VALUE_DITHER_ENABLE);
            graphics2D.addRenderingHints(hints);
        }

        //Ensure white page background
        graphics2D.setBackground(Color.WHITE);
        graphics2D.clearRect(0, 0, bitmapWidth, bitmapHeight);

        graphics2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                RenderingHints.VALUE_FRACTIONALMETRICS_ON);
        graphics2D.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
                RenderingHints.VALUE_STROKE_PURE);
        graphics2D.scale(scale / 1000f, scale / 1000f);
        graphics2D.translate(-printArea.x, -printArea.y);

        return new Java2DPainter(graphics2D, getContext(), getFontInfo(), this);
    }

    private BufferedImage createBufferedImage(int bitmapWidth, int bitmapHeight) {
        int bitmapType;
        if (PCLGenerator.isJAIAvailable()) {
            //TYPE_BYTE_GRAY was used to work around the lack of dithering when using
            //TYPE_BYTE_BINARY. Adding RenderingHints didn't help.
            bitmapType = BufferedImage.TYPE_BYTE_GRAY;
            //bitmapType = BufferedImage.TYPE_INT_RGB; //Use to enable Batik gradients
        } else {
            bitmapType = BufferedImage.TYPE_BYTE_BINARY;
        }
        return new BufferedImage(
                bitmapWidth, bitmapHeight, bitmapType);
    }

    /** {@inheritDoc} */
    public void endPageContent() throws IFException {
        if (this.currentImage != null) {
            try {
                Rectangle printArea = this.currentPageDefinition.getLogicalPageRect();
                gen.setCursorPos(0, 0);
                gen.paintBitmap(this.currentImage, printArea.getSize(), true, pclUtil);
            } catch (IOException ioe) {
                throw new IFException("I/O error while encoding page image", ioe);
            } finally {
                this.currentImage = null;
            }
        }
    }

    /** {@inheritDoc} */
    public void endPage() throws IFException {
        try {
            //Eject page
            gen.formFeed();
        } catch (IOException ioe) {
            throw new IFException("I/O error in endPage()", ioe);
        }
    }

    /** {@inheritDoc} */
    public void handleExtensionObject(Object extension) throws IFException {
        if (false) {
            //TODO Handle extensions
        } else {
            log.debug("Don't know how to handle extension object. Ignoring: "
                    + extension + " (" + extension.getClass().getName() + ")");
        }
    }

    private void selectPageFormat(long pagewidth, long pageheight) throws IOException {
        //Only set the page format if it changes (otherwise duplex printing won't work)
        if ((pagewidth != this.pageWidth) || (pageheight != this.pageHeight))  {
            this.pageWidth = pagewidth;
            this.pageHeight = pageheight;

            this.currentPageDefinition = PCLPageDefinition.getPageDefinition(
                    pagewidth, pageheight, 1000);

            if (this.currentPageDefinition == null) {
                this.currentPageDefinition = PCLPageDefinition.getDefaultPageDefinition();
                log.warn("Paper type could not be determined. Falling back to: "
                        + this.currentPageDefinition.getName());
            }
            if (log.isDebugEnabled()) {
                log.debug("page size: " + currentPageDefinition.getPhysicalPageSize());
                log.debug("logical page: " + currentPageDefinition.getLogicalPageRect());
            }

            if (this.currentPageDefinition.isLandscapeFormat()) {
                gen.writeCommand("&l1O"); //Landscape Orientation
            } else {
                gen.writeCommand("&l0O"); //Portrait Orientation
            }
            gen.selectPageSize(this.currentPageDefinition.getSelector());

            gen.clearHorizontalMargins();
            gen.setTopMargin(0);
        }
    }

}