fop-core/src/main/java/org/apache/fop/render/bitmap/AbstractBitmapDocumentHandler.java - xmlgraphics-fop - Git at Google

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

 import java.awt.Dimension;
 import java.awt.Graphics2D;
 import java.awt.RenderingHints;
 import java.awt.geom.Point2D;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.io.OutputStream;
 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.image.writer.ImageWriter;
 import org.apache.xmlgraphics.image.writer.ImageWriterRegistry;
 import org.apache.xmlgraphics.image.writer.MultiImageWriter;

 import org.apache.fop.apps.FopFactoryConfig;
 import org.apache.fop.fonts.FontInfo;
 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;

 /**
  * Abstract {@link org.apache.fop.render.intermediate.IFDocumentHandler} implementation
  * for producing bitmap images.
  */
 public abstract class AbstractBitmapDocumentHandler extends AbstractBinaryWritingIFDocumentHandler {

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

     /**
      * Rendering Options key for the controlling the required bitmap size to create.
      * This is used to create thumbnails, for example. If used, the target resolution is ignored.
      * Value type: java.awt.Dimension (size in pixels)
      */
     public static final String TARGET_BITMAP_SIZE = "target-bitmap-size";

     private ImageWriter imageWriter;
     private MultiImageWriter multiImageWriter;

     /** Helper class for generating multiple files */
     private MultiFileRenderingUtil multiFileUtil;

     private int pageCount;
     private Dimension currentPageDimensions;
     private BufferedImage currentImage;

     private BitmapRenderingSettings bitmapSettings = new BitmapRenderingSettings();

     private double scaleFactor = 1.0;
     private Dimension targetBitmapSize;

     /**
      * Default constructor.
      */
     public AbstractBitmapDocumentHandler(IFContext context) {
         super(context);
         //Set target resolution
         int dpi = Math.round(context.getUserAgent().getTargetResolution());
         getSettings().setResolution(dpi);

         Map renderingOptions = getUserAgent().getRendererOptions();
         setTargetBitmapSize((Dimension)renderingOptions.get(TARGET_BITMAP_SIZE));
     }

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

     /** {@inheritDoc} */
     public abstract String getMimeType();

     /**
      * Returns the default file extension for the supported image type.
      * @return the default file extension (ex. "png")
      */
     public abstract String getDefaultExtension();

     /** {@inheritDoc} */
     public abstract IFDocumentHandlerConfigurator getConfigurator();

     /**
      * Returns the settings for bitmap rendering.
      * @return the settings object
      */
     public BitmapRenderingSettings getSettings() {
         return this.bitmapSettings;
     }

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

     /**
      * Sets the target bitmap size (in pixels) of the bitmap that should be produced. Normally,
      * the bitmap size is calculated automatically based on the page size and the target
      * resolution. But for example, if you want to create thumbnails or small preview bitmaps
      * from pages it is more practical (and efficient) to set the required bitmap size.
      * @param size the target bitmap size (in pixels)
      */
     public void setTargetBitmapSize(Dimension size) {
         this.targetBitmapSize = size;
     }

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

     /** {@inheritDoc} */
     public void startDocument() throws IFException {
         super.startDocument();
         try {
             // Creates writer
             this.imageWriter = ImageWriterRegistry.getInstance().getWriterFor(getMimeType());
             if (this.imageWriter == null) {
                 BitmapRendererEventProducer eventProducer
                     = BitmapRendererEventProducer.Provider.get(
                             getUserAgent().getEventBroadcaster());
                 eventProducer.noImageWriterFound(this, getMimeType());
             }
             if (this.imageWriter.supportsMultiImageWriter()) {
                 this.multiImageWriter = this.imageWriter.createMultiImageWriter(outputStream);
             } else {
                 this.multiFileUtil = new MultiFileRenderingUtil(getDefaultExtension(),
                         getUserAgent().getOutputFile());
             }
             this.pageCount = 0;
         } catch (IOException e) {
             throw new IFException("I/O error in startDocument()", e);
         }
     }

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

     /** {@inheritDoc} */
     public void endDocument() throws IFException {
         try {
             if (this.multiImageWriter != null) {
                 this.multiImageWriter.close();
             }
             this.multiImageWriter = null;
             this.imageWriter = null;
         } catch (IOException ioe) {
             throw new IFException("I/O error in endDocument()", ioe);
         }
         super.endDocument();
     }

     /** {@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 {
         this.pageCount++;
         this.currentPageDimensions = new Dimension(size);
     }

     /** {@inheritDoc} */
     public IFPainter startPageContent() throws IFException {
         int bitmapWidth;
         int bitmapHeight;
         double scale;
         Point2D offset = null;
         if (targetBitmapSize != null) {
             //Fit the generated page proportionally into the given rectangle (in pixels)
             double scale2w = 1000 * targetBitmapSize.width
                 / this.currentPageDimensions.getWidth();
             double scale2h = 1000 * targetBitmapSize.height
                 / this.currentPageDimensions.getHeight();
             bitmapWidth = targetBitmapSize.width;
             bitmapHeight = targetBitmapSize.height;

             //Centering the page in the given bitmap
             offset = new Point2D.Double();
             if (scale2w < scale2h) {
                 scale = scale2w;
                 double h = this.currentPageDimensions.height * scale / 1000;
                 offset.setLocation(0, (bitmapHeight - h) / 2.0);
             } else {
                 scale = scale2h;
                 double w = this.currentPageDimensions.width * scale / 1000;
                 offset.setLocation((bitmapWidth - w) / 2.0, 0);
             }
         } else {
             //Normal case: just scale according to the target resolution
             scale = scaleFactor
                 * getUserAgent().getTargetResolution()
                     / FopFactoryConfig.DEFAULT_TARGET_RESOLUTION;
             bitmapWidth = (int) ((this.currentPageDimensions.width * scale / 1000f) + 0.5f);
             bitmapHeight = (int) ((this.currentPageDimensions.height * scale / 1000f) + 0.5f);
         }

         //Set up bitmap to paint on
         if (currentImage == null || currentImage.getWidth() != bitmapWidth
                 || currentImage.getHeight() != bitmapHeight) {
             currentImage = createBufferedImage(bitmapWidth, bitmapHeight);
         }
         Graphics2D graphics2D = this.currentImage.createGraphics();

         // draw page background
         if (!getSettings().hasTransparentPageBackground()) {
             graphics2D.setBackground(getSettings().getPageBackgroundColor());
             graphics2D.setPaint(getSettings().getPageBackgroundColor());
             graphics2D.fillRect(0, 0, bitmapWidth, bitmapHeight);
         }

         //Set rendering hints
         graphics2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                 RenderingHints.VALUE_FRACTIONALMETRICS_ON);
         if (getSettings().isAntiAliasingEnabled()
                 && this.currentImage.getColorModel().getPixelSize() > 1) {
             graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                     RenderingHints.VALUE_ANTIALIAS_ON);
             graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                     RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
         } else {
             graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                     RenderingHints.VALUE_ANTIALIAS_OFF);
             graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                     RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
         }
         if (getSettings().isQualityRenderingEnabled()) {
             graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,
                     RenderingHints.VALUE_RENDER_QUALITY);
         } else {
             graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,
                     RenderingHints.VALUE_RENDER_SPEED);
         }
         graphics2D.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
                 RenderingHints.VALUE_STROKE_PURE);

         //Set up initial coordinate system for the page
         if (offset != null) {
             graphics2D.translate(offset.getX(), offset.getY());
         }
         graphics2D.scale(scale / 1000f, scale / 1000f);

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

     /**
      * Creates a new BufferedImage.
      * @param bitmapWidth the desired width in pixels
      * @param bitmapHeight the desired height in pixels
      * @return the new BufferedImage instance
      */
     protected BufferedImage createBufferedImage(int bitmapWidth, int bitmapHeight) {
         return new BufferedImage(bitmapWidth, bitmapHeight, getSettings().getBufferedImageType());
     }

     /** {@inheritDoc} */
     public void endPageContent() throws IFException {
         try {
             if (this.multiImageWriter == null) {
                 switch (this.pageCount) {
                 case 1:
                     this.imageWriter.writeImage(
                             this.currentImage, this.outputStream,
                             getSettings().getWriterParams());
                     IOUtils.closeQuietly(this.outputStream);
                     this.outputStream = null;
                     break;
                 default:
                     OutputStream out = this.multiFileUtil.createOutputStream(this.pageCount - 1);
                     if (out == null) {
                         BitmapRendererEventProducer eventProducer
                             = BitmapRendererEventProducer.Provider.get(
                                     getUserAgent().getEventBroadcaster());
                         eventProducer.stoppingAfterFirstPageNoFilename(this);
                     } else {
                         try {
                             this.imageWriter.writeImage(
                                     this.currentImage, out,
                                     getSettings().getWriterParams());
                         } finally {
                             IOUtils.closeQuietly(out);
                         }
                     }
                 }
             } else {
                 this.multiImageWriter.writeImage(this.currentImage,
                         getSettings().getWriterParams());
             }
         } catch (IOException ioe) {
             throw new IFException("I/O error while encoding BufferedImage", ioe);
         }
     }

     /** {@inheritDoc} */
     public void endPage() throws IFException {
         this.currentPageDimensions = null;
     }

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

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

	import java.awt.Dimension;
	import java.awt.Graphics2D;
	import java.awt.RenderingHints;
	import java.awt.geom.Point2D;
	import java.awt.image.BufferedImage;
	import java.io.IOException;
	import java.io.OutputStream;
	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.image.writer.ImageWriter;
	import org.apache.xmlgraphics.image.writer.ImageWriterRegistry;
	import org.apache.xmlgraphics.image.writer.MultiImageWriter;

	import org.apache.fop.apps.FopFactoryConfig;
	import org.apache.fop.fonts.FontInfo;
	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;

	/**
	* Abstract {@link org.apache.fop.render.intermediate.IFDocumentHandler} implementation
	* for producing bitmap images.
	*/
	public abstract class AbstractBitmapDocumentHandler extends AbstractBinaryWritingIFDocumentHandler {

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

	/**
	* Rendering Options key for the controlling the required bitmap size to create.
	* This is used to create thumbnails, for example. If used, the target resolution is ignored.
	* Value type: java.awt.Dimension (size in pixels)
	*/
	public static final String TARGET_BITMAP_SIZE = "target-bitmap-size";

	private ImageWriter imageWriter;
	private MultiImageWriter multiImageWriter;

	/** Helper class for generating multiple files */
	private MultiFileRenderingUtil multiFileUtil;

	private int pageCount;
	private Dimension currentPageDimensions;
	private BufferedImage currentImage;

	private BitmapRenderingSettings bitmapSettings = new BitmapRenderingSettings();

	private double scaleFactor = 1.0;
	private Dimension targetBitmapSize;

	/**
	* Default constructor.
	*/
	public AbstractBitmapDocumentHandler(IFContext context) {
	super(context);
	//Set target resolution
	int dpi = Math.round(context.getUserAgent().getTargetResolution());
	getSettings().setResolution(dpi);

	Map renderingOptions = getUserAgent().getRendererOptions();
	setTargetBitmapSize((Dimension)renderingOptions.get(TARGET_BITMAP_SIZE));
	}

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

	/** {@inheritDoc} */
	public abstract String getMimeType();

	/**
	* Returns the default file extension for the supported image type.
	* @return the default file extension (ex. "png")
	*/
	public abstract String getDefaultExtension();

	/** {@inheritDoc} */
	public abstract IFDocumentHandlerConfigurator getConfigurator();

	/**
	* Returns the settings for bitmap rendering.
	* @return the settings object
	*/
	public BitmapRenderingSettings getSettings() {
	return this.bitmapSettings;
	}

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

	/**
	* Sets the target bitmap size (in pixels) of the bitmap that should be produced. Normally,
	* the bitmap size is calculated automatically based on the page size and the target
	* resolution. But for example, if you want to create thumbnails or small preview bitmaps
	* from pages it is more practical (and efficient) to set the required bitmap size.
	* @param size the target bitmap size (in pixels)
	*/
	public void setTargetBitmapSize(Dimension size) {
	this.targetBitmapSize = size;
	}

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

	/** {@inheritDoc} */
	public void startDocument() throws IFException {
	super.startDocument();
	try {
	// Creates writer
	this.imageWriter = ImageWriterRegistry.getInstance().getWriterFor(getMimeType());
	if (this.imageWriter == null) {
	BitmapRendererEventProducer eventProducer
	= BitmapRendererEventProducer.Provider.get(
	getUserAgent().getEventBroadcaster());
	eventProducer.noImageWriterFound(this, getMimeType());
	}
	if (this.imageWriter.supportsMultiImageWriter()) {
	this.multiImageWriter = this.imageWriter.createMultiImageWriter(outputStream);
	} else {
	this.multiFileUtil = new MultiFileRenderingUtil(getDefaultExtension(),
	getUserAgent().getOutputFile());
	}
	this.pageCount = 0;
	} catch (IOException e) {
	throw new IFException("I/O error in startDocument()", e);
	}
	}

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

	/** {@inheritDoc} */
	public void endDocument() throws IFException {
	try {
	if (this.multiImageWriter != null) {
	this.multiImageWriter.close();
	}
	this.multiImageWriter = null;
	this.imageWriter = null;
	} catch (IOException ioe) {
	throw new IFException("I/O error in endDocument()", ioe);
	}
	super.endDocument();
	}

	/** {@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 {
	this.pageCount++;
	this.currentPageDimensions = new Dimension(size);
	}

	/** {@inheritDoc} */
	public IFPainter startPageContent() throws IFException {
	int bitmapWidth;
	int bitmapHeight;
	double scale;
	Point2D offset = null;
	if (targetBitmapSize != null) {
	//Fit the generated page proportionally into the given rectangle (in pixels)
	double scale2w = 1000 * targetBitmapSize.width
	/ this.currentPageDimensions.getWidth();
	double scale2h = 1000 * targetBitmapSize.height
	/ this.currentPageDimensions.getHeight();
	bitmapWidth = targetBitmapSize.width;
	bitmapHeight = targetBitmapSize.height;

	//Centering the page in the given bitmap
	offset = new Point2D.Double();
	if (scale2w < scale2h) {
	scale = scale2w;
	double h = this.currentPageDimensions.height * scale / 1000;
	offset.setLocation(0, (bitmapHeight - h) / 2.0);
	} else {
	scale = scale2h;
	double w = this.currentPageDimensions.width * scale / 1000;
	offset.setLocation((bitmapWidth - w) / 2.0, 0);
	}
	} else {
	//Normal case: just scale according to the target resolution
	scale = scaleFactor
	* getUserAgent().getTargetResolution()
	/ FopFactoryConfig.DEFAULT_TARGET_RESOLUTION;
	bitmapWidth = (int) ((this.currentPageDimensions.width * scale / 1000f) + 0.5f);
	bitmapHeight = (int) ((this.currentPageDimensions.height * scale / 1000f) + 0.5f);
	}

	//Set up bitmap to paint on
	if (currentImage == null \|\| currentImage.getWidth() != bitmapWidth
	\|\| currentImage.getHeight() != bitmapHeight) {
	currentImage = createBufferedImage(bitmapWidth, bitmapHeight);
	}
	Graphics2D graphics2D = this.currentImage.createGraphics();

	// draw page background
	if (!getSettings().hasTransparentPageBackground()) {
	graphics2D.setBackground(getSettings().getPageBackgroundColor());
	graphics2D.setPaint(getSettings().getPageBackgroundColor());
	graphics2D.fillRect(0, 0, bitmapWidth, bitmapHeight);
	}

	//Set rendering hints
	graphics2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
	RenderingHints.VALUE_FRACTIONALMETRICS_ON);
	if (getSettings().isAntiAliasingEnabled()
	&& this.currentImage.getColorModel().getPixelSize() > 1) {
	graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
	RenderingHints.VALUE_ANTIALIAS_ON);
	graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
	RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
	} else {
	graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
	RenderingHints.VALUE_ANTIALIAS_OFF);
	graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
	RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
	}
	if (getSettings().isQualityRenderingEnabled()) {
	graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,
	RenderingHints.VALUE_RENDER_QUALITY);
	} else {
	graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,
	RenderingHints.VALUE_RENDER_SPEED);
	}
	graphics2D.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
	RenderingHints.VALUE_STROKE_PURE);

	//Set up initial coordinate system for the page
	if (offset != null) {
	graphics2D.translate(offset.getX(), offset.getY());
	}
	graphics2D.scale(scale / 1000f, scale / 1000f);

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

	/**
	* Creates a new BufferedImage.
	* @param bitmapWidth the desired width in pixels
	* @param bitmapHeight the desired height in pixels
	* @return the new BufferedImage instance
	*/
	protected BufferedImage createBufferedImage(int bitmapWidth, int bitmapHeight) {
	return new BufferedImage(bitmapWidth, bitmapHeight, getSettings().getBufferedImageType());
	}

	/** {@inheritDoc} */
	public void endPageContent() throws IFException {
	try {
	if (this.multiImageWriter == null) {
	switch (this.pageCount) {
	case 1:
	this.imageWriter.writeImage(
	this.currentImage, this.outputStream,
	getSettings().getWriterParams());
	IOUtils.closeQuietly(this.outputStream);
	this.outputStream = null;
	break;
	default:
	OutputStream out = this.multiFileUtil.createOutputStream(this.pageCount - 1);
	if (out == null) {
	BitmapRendererEventProducer eventProducer
	= BitmapRendererEventProducer.Provider.get(
	getUserAgent().getEventBroadcaster());
	eventProducer.stoppingAfterFirstPageNoFilename(this);
	} else {
	try {
	this.imageWriter.writeImage(
	this.currentImage, out,
	getSettings().getWriterParams());
	} finally {
	IOUtils.closeQuietly(out);
	}
	}
	}
	} else {
	this.multiImageWriter.writeImage(this.currentImage,
	getSettings().getWriterParams());
	}
	} catch (IOException ioe) {
	throw new IFException("I/O error while encoding BufferedImage", ioe);
	}
	}

	/** {@inheritDoc} */
	public void endPage() throws IFException {
	this.currentPageDimensions = null;
	}

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

	}