org.apache.fop.afp.AFPPaintingState Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of fop Show documentation
Show all versions of fop Show documentation
Apache FOP (Formatting Objects Processor) is the world's first print formatter driven by XSL formatting objects (XSL-FO) and the world's first output independent formatter. It is a Java application that reads a formatting object (FO) tree and renders the resulting pages to a specified output. Output formats currently supported include PDF, PCL, PS, AFP, TIFF, PNG, SVG, XML (area tree representation), Print, AWT and TXT. The primary output target is PDF.
/*
* 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: AFPPaintingState.java 959945 2010-07-02 10:44:18Z jeremias $ */
package org.apache.fop.afp;
import java.awt.Point;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.xmlgraphics.java2d.color.ColorConverter;
import org.apache.xmlgraphics.java2d.color.DefaultColorConverter;
import org.apache.fop.afp.fonts.AFPPageFonts;
import org.apache.fop.util.AbstractPaintingState;
/**
* This keeps information about the current painting state when writing to an
* AFP datastream.
*/
public class AFPPaintingState extends org.apache.fop.util.AbstractPaintingState implements
Cloneable {
private static final long serialVersionUID = 8206711712452344473L;
private static Log log = LogFactory.getLog("org.apache.xmlgraphics.afp");
/** the portrait rotation */
private int portraitRotation = 0;
/** the landscape rotation */
private int landscapeRotation = 270;
/** color image support */
private boolean colorImages = false;
/** dithering quality setting (0.0f..1.0f) */
private float ditheringQuality;
/** color image handler */
private ColorConverter colorConverter = GrayScaleColorConverter.getInstance();
/**
* true if certain image formats may be embedded unchanged in their native
* format.
*/
private boolean nativeImagesSupported = false;
/**
* true if CMYK images (requires IOCA FS45 suppport on the target platform)
* may be generated
*/
private boolean cmykImagesSupported;
/** default value for image depth */
private int bitsPerPixel = 8;
/** the output resolution */
private int resolution = 240; // 240 dpi
/** the current page */
private transient AFPPagePaintingState pagePaintingState = new AFPPagePaintingState();
// /** reference orientation */
// private int orientation = 0;
/** a unit converter */
private final transient AFPUnitConverter unitConv = new AFPUnitConverter(this);
/**
* Sets the rotation to be used for portrait pages, valid values are 0
* (default), 90, 180, 270.
*
* @param rotation
* The rotation in degrees.
*/
public void setPortraitRotation(int rotation) {
if (rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270) {
portraitRotation = rotation;
} else {
throw new IllegalArgumentException("The portrait rotation must be one"
+ " of the values 0, 90, 180, 270");
}
}
/**
* Returns the rotation to be used for portrait pages
*
* @return the rotation to be used for portrait pages
*/
protected int getPortraitRotation() {
return this.portraitRotation;
}
/**
* Sets the rotation to be used for landscape pages, valid values are 0, 90,
* 180, 270 (default).
*
* @param rotation
* The rotation in degrees.
*/
public void setLandscapeRotation(int rotation) {
if (rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270) {
landscapeRotation = rotation;
} else {
throw new IllegalArgumentException("The landscape rotation must be one"
+ " of the values 0, 90, 180, 270");
}
}
/**
* Returns the landscape rotation
*
* @return the landscape rotation
*/
protected int getLandscapeRotation() {
return this.landscapeRotation;
}
/**
* Sets the number of bits used per pixel
*
* @param bitsPerPixel
* number of bits per pixel
*/
public void setBitsPerPixel(int bitsPerPixel) {
switch (bitsPerPixel) {
case 1:
case 4:
case 8:
this.bitsPerPixel = bitsPerPixel;
break;
default:
log.warn("Invalid bits_per_pixel value, must be 1, 4 or 8.");
this.bitsPerPixel = 8;
break;
}
}
/**
* Returns the number of bits per pixel
*
* @return the number of bits per pixel
*/
public int getBitsPerPixel() {
return this.bitsPerPixel;
}
/**
* Sets whether images are color or not and instantiates a ColorHandler
*
* @param colorImages
* color image output
*/
public void setColorImages(boolean colorImages) {
this.colorImages = colorImages;
if (colorImages) {
this.colorConverter = DefaultColorConverter.getInstance();
}
}
/**
* Returns true if color images are to be used
*
* @return true if color images are to be used
*/
public boolean isColorImages() {
return this.colorImages;
}
/**
* Used to convert color in respect of the colorImages flag
*
* @return the color converter
*/
public ColorConverter getColorConverter() {
return this.colorConverter;
}
/**
* Sets whether images are natively supported or not in the AFP environment
*
* @param nativeImagesSupported
* true if images are natively supported in this AFP environment
*/
public void setNativeImagesSupported(boolean nativeImagesSupported) {
this.nativeImagesSupported = nativeImagesSupported;
}
/**
* Returns true if images are supported natively in this AFP environment
*
* @return true if images are supported natively in this AFP environment
*/
public boolean isNativeImagesSupported() {
return this.nativeImagesSupported;
}
/**
* Controls whether CMYK images (IOCA FS45) are enabled. By default, support
* is disabled for wider compatibility. When disabled, any CMYK image is
* converted to the selected color format.
*
* @param value
* true to enabled CMYK images
*/
public void setCMYKImagesSupported(boolean value) {
this.cmykImagesSupported = value;
}
/**
* Indicates whether CMYK images (IOCA FS45) are enabled.
*
* @return true if IOCA FS45 is enabled
*/
public boolean isCMYKImagesSupported() {
return this.cmykImagesSupported;
}
/**
* Gets the dithering quality setting to use when converting images to monochrome images.
* @return the dithering quality (a value between 0.0f and 1.0f)
*/
public float getDitheringQuality() {
return this.ditheringQuality;
}
/**
* Sets the dithering quality setting to use when converting images to monochrome images.
* @param quality Defines the desired quality level for the conversion.
* Valid values: a value between 0.0f (fastest) and 1.0f (best)
*/
public void setDitheringQuality(float quality) {
quality = Math.max(quality, 0.0f);
quality = Math.min(quality, 1.0f);
this.ditheringQuality = quality;
}
/**
* Sets the output/device resolution
*
* @param resolution
* the output resolution (dpi)
*/
public void setResolution(int resolution) {
if (log.isDebugEnabled()) {
log.debug("renderer-resolution set to: " + resolution + "dpi");
}
this.resolution = resolution;
}
/**
* Returns the output/device resolution.
*
* @return the resolution in dpi
*/
public int getResolution() {
return this.resolution;
}
/** {@inheritDoc} */
protected AbstractData instantiateData() {
return new AFPData();
}
/** {@inheritDoc} */
protected AbstractPaintingState instantiate() {
return new AFPPaintingState();
}
/**
* Returns the painting state of the current page
*
* @return the painting state of the current page
*/
protected AFPPagePaintingState getPagePaintingState() {
return this.pagePaintingState;
}
/**
* Gets the current page fonts
*
* @return the current page fonts
*/
public AFPPageFonts getPageFonts() {
return pagePaintingState.getFonts();
}
/**
* Sets the page width
*
* @param pageWidth
* the page width
*/
public void setPageWidth(int pageWidth) {
pagePaintingState.setWidth(pageWidth);
}
/**
* Returns the page width
*
* @return the page width
*/
public int getPageWidth() {
return pagePaintingState.getWidth();
}
/**
* Sets the page height
*
* @param pageHeight
* the page height
*/
public void setPageHeight(int pageHeight) {
pagePaintingState.setHeight(pageHeight);
}
/**
* Returns the page height
*
* @return the page height
*/
public int getPageHeight() {
return pagePaintingState.getHeight();
}
/**
* Returns the page rotation
*
* @return the page rotation
*/
public int getPageRotation() {
return pagePaintingState.getOrientation();
}
/**
* Sets the uri of the current image
*
* @param uri
* the uri of the current image
*/
public void setImageUri(String uri) {
((AFPData) getData()).imageUri = uri;
}
/**
* Gets the uri of the current image
*
* @return the uri of the current image
*/
public String getImageUri() {
return ((AFPData) getData()).imageUri;
}
/**
* Returns the currently derived rotation
*
* @return the currently derived rotation
*/
public int getRotation() {
return getData().getDerivedRotation();
}
/**
* Returns the unit converter
*
* @return the unit converter
*/
public AFPUnitConverter getUnitConverter() {
return this.unitConv;
}
/**
* Returns a point on the current page, taking the current painting state
* into account.
*
* @param x
* the X-coordinate
* @param y
* the Y-coordinate
* @return a point on the current page
*/
public Point getPoint(int x, int y) {
Point p = new Point();
int rotation = getRotation();
switch (rotation) {
case 90:
p.x = y;
p.y = getPageWidth() - x;
break;
case 180:
p.x = getPageWidth() - x;
p.y = getPageHeight() - y;
break;
case 270:
p.x = getPageHeight() - y;
p.y = x;
break;
default:
p.x = x;
p.y = y;
break;
}
return p;
}
/** {@inheritDoc} */
public Object clone() {
AFPPaintingState paintingState = (AFPPaintingState) super.clone();
paintingState.pagePaintingState = (AFPPagePaintingState) this.pagePaintingState.clone();
paintingState.portraitRotation = this.portraitRotation;
paintingState.landscapeRotation = this.landscapeRotation;
paintingState.bitsPerPixel = this.bitsPerPixel;
paintingState.colorImages = this.colorImages;
paintingState.colorConverter = this.colorConverter;
paintingState.resolution = this.resolution;
return paintingState;
}
/** {@inheritDoc} */
public String toString() {
return "AFPPaintingState{" + "portraitRotation=" + portraitRotation
+ ", landscapeRotation=" + landscapeRotation + ", colorImages=" + colorImages
+ ", bitsPerPixel=" + bitsPerPixel + ", resolution=" + resolution + ", pageState="
+ pagePaintingState + super.toString() + "}";
}
/**
* Page level state data
*/
private class AFPPagePaintingState implements Cloneable {
/** page width */
private int width = 0;
/** page height */
private int height = 0;
/** page fonts */
private AFPPageFonts fonts = new AFPPageFonts();
/** page font count */
private int fontCount = 0;
/** page orientation */
private int orientation = 0;
/**
* Returns the page width
*
* @return the page width
*/
protected int getWidth() {
return width;
}
/**
* Sets the page width
*
* @param width
* the page width
*/
protected void setWidth(int width) {
this.width = width;
}
/**
* Returns the page height
*
* @return the page height
*/
protected int getHeight() {
return height;
}
/**
* Sets the page height
*
* @param height
* the page height
*/
protected void setHeight(int height) {
this.height = height;
}
/**
* Returns the page fonts
*
* @return the page fonts
*/
protected AFPPageFonts getFonts() {
return fonts;
}
/**
* Sets the current page fonts
*
* @param fonts
* the current page fonts
*/
protected void setFonts(AFPPageFonts fonts) {
this.fonts = fonts;
}
/**
* Increments and returns the current page font count
*
* @return increment and return the current page font count
*/
protected int incrementFontCount() {
return ++fontCount;
}
/**
* Returns the current page orientation
*
* @return the current page orientation
*/
protected int getOrientation() {
return orientation;
}
/**
* Sets the current page orientation
*
* @param orientation
* the current page orientation
*/
protected void setOrientation(int orientation) {
this.orientation = orientation;
}
/** {@inheritDoc} */
public Object clone() {
AFPPagePaintingState state = new AFPPagePaintingState();
state.width = this.width;
state.height = this.height;
state.orientation = this.orientation;
state.fonts = new AFPPageFonts(this.fonts);
state.fontCount = this.fontCount;
return state;
}
/** {@inheritDoc} */
public String toString() {
return "AFPPagePaintingState{width=" + width + ", height=" + height + ", orientation="
+ orientation + ", fonts=" + fonts + ", fontCount=" + fontCount + "}";
}
}
/**
* Block level state data
*/
private class AFPData extends org.apache.fop.util.AbstractPaintingState.AbstractData {
private static final long serialVersionUID = -1789481244175275686L;
/** The current fill status */
private boolean filled = false;
private String imageUri = null;
/** {@inheritDoc} */
public Object clone() {
AFPData obj = (AFPData) super.clone();
obj.filled = this.filled;
obj.imageUri = this.imageUri;
return obj;
}
/** {@inheritDoc} */
public String toString() {
return "AFPData{" + super.toString() + ", filled=" + filled + ", imageUri=" + imageUri
+ "}";
}
/** {@inheritDoc} */
protected AbstractData instantiate() {
return new AFPData();
}
}
}