/*
* 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.java2d;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.GeneralPath;
import org.apache.xmlgraphics.java2d.color.ColorUtil;
import org.apache.fop.fo.Constants;
import org.apache.fop.fonts.FontInfo;
/**
* Keeps information about the current state of the Graphics2D currentGraphics.
* It is also used as a stack to hold a graphics context.
* <p>
* The graphics context is updated with the updateXXX() methods.
*/
public class Java2DGraphicsState {
/** Holds the datas of the current state */
private Graphics2D currentGraphics;
private BasicStroke currentStroke;
private float currentStrokeWidth;
private int currentStrokeStyle;
/** Font configuration, passed from AWTRenderer */
private FontInfo fontInfo;
/** Initial AffinTransform passed by the renderer, includes scaling-info */
private AffineTransform initialTransform;
/**
* State for storing graphics state.
* @param graphics the graphics associated with the BufferedImage
* @param fontInfo the FontInfo from the renderer
* @param at the initial AffineTransform containing the scale transformation
*/
public Java2DGraphicsState(Graphics2D graphics, FontInfo fontInfo,
AffineTransform at) {
this.fontInfo = fontInfo;
this.currentGraphics = graphics;
this.initialTransform = at;
currentGraphics.setTransform(at);
}
/**
* Copy constructor.
* @param org the instance to copy
*/
public Java2DGraphicsState(Java2DGraphicsState org) {
this.currentGraphics = (Graphics2D)org.currentGraphics.create();
this.fontInfo = org.fontInfo;
this.initialTransform = org.initialTransform;
this.currentStroke = org.currentStroke;
this.currentStrokeStyle = org.currentStrokeStyle;
this.currentStrokeWidth = org.currentStrokeWidth;
}
/**
* @return the currently valid state
*/
public Graphics2D getGraph() {
return currentGraphics;
}
/** Frees resources allocated by the current Graphics2D instance. */
public void dispose() {
this.currentGraphics.dispose();
this.currentGraphics = null;
}
/**
* Set the current background color. Check if the background color will
* change and then set the new color.
*
* @param col the new color as a java.awt.Color
* @return true if the background color has changed
*/
public boolean updateColor(Color col) {
if (!ColorUtil.isSameColor(col, getGraph().getColor())) {
getGraph().setColor(col);
return true;
} else {
return false;
}
}
/**
* @return the current java.awt.Color
*/
public java.awt.Color getColor() {
return currentGraphics.getColor();
}
/**
* Set the current font name. Check if the font name will change and then
* set the new name.
*
* @param name the new font name
* @param size the font size
* @return true if the new Font changes the current Font
*/
public boolean updateFont(String name, int size) {
FontMetricsMapper mapper = (FontMetricsMapper) fontInfo.getMetricsFor(name);
boolean updateName = (!mapper.getFontName().equals(
getGraph().getFont().getFontName()));
boolean updateSize = (size != (getGraph().getFont().getSize() * 1000));
if (updateName || updateSize) {
// the font name and/or the font size have changed
java.awt.Font font = mapper.getFont(size);
currentGraphics.setFont(font);
return true;
} else {
return false;
}
}
/** @return the current java.awt.Font */
public java.awt.Font getFont() {
return currentGraphics.getFont();
}
/**
* Sets the current Stroke. The line width should be set with
* updateLineWidth() before calling this method
*
* @param width the line width
* @param style the constant for the style of the line as an int
* @return true if the new Stroke changes the current Stroke
*/
public boolean updateStroke(float width, int style) {
boolean update = false;
// only update if necessary
if ((width != currentStrokeWidth) || (style != currentStrokeStyle)) {
update = true;
switch (style) {
case Constants.EN_DOTTED:
currentStroke = new BasicStroke(width, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_BEVEL, 0f, new float[] {0, 2 * width}, width);
currentGraphics.setStroke(currentStroke);
currentStrokeWidth = width;
currentStrokeStyle = style;
break;
case Constants.EN_DASHED:
currentStroke = new BasicStroke(width, BasicStroke.CAP_BUTT,
BasicStroke.JOIN_BEVEL, 0f, new float[] {8f, 2f}, 0f);
currentGraphics.setStroke(currentStroke);
currentStrokeWidth = width;
currentStrokeStyle = style;
break;
default: // EN_SOLID:
currentStroke = new BasicStroke(width);
currentGraphics.setStroke(currentStroke);
currentStrokeWidth = width;
currentStrokeStyle = style;
break;
}
}
return update;
}
/** @return the currently active Stroke */
public BasicStroke getStroke() {
return (BasicStroke) currentGraphics.getStroke();
}
/**
* Set the current paint. This checks if the paint will change and then sets
* the current paint.
*
* @param p the new paint
* @return true if the new paint changes the current paint
*/
public boolean updatePaint(Paint p) {
Paint currentPaint = getGraph().getPaint();
if (currentPaint == null) {
if (p != null) {
getGraph().setPaint(p);
return true;
}
} else if (p instanceof Color && currentPaint instanceof Color) {
if (!ColorUtil.isSameColor((Color)p, (Color)currentPaint)) {
getGraph().setPaint(p);
return true;
}
} else if (!p.equals(currentPaint)) {
getGraph().setPaint(p);
return true;
}
return false;
}
/**
* Set the current clip. This either sets a new clip or sets the clip to the
* intersect of the old clip and the new clip.
*
* @param cl the new clip in the current state
* @return true if the clip shape needed to be updated
*/
public boolean updateClip(Shape cl) {
if (getGraph().getClip() != null) {
Area newClip = new Area(getGraph().getClip());
newClip.intersect(new Area(cl));
getGraph().setClip(new GeneralPath(newClip));
} else {
getGraph().setClip(cl);
}
return true; // TODO only update if necessary
}
/**
* Composes an AffineTransform object with the Transform in this Graphics2D
* according to the rule last-specified-first-applied.
* @see java.awt.Graphics2D#transform(AffineTransform)
*
* @param tf the transform to concatenate to the current level transform
*/
public void transform(AffineTransform tf) {
if (!tf.isIdentity()) {
getGraph().transform(tf);
}
}
/**
* Get the current transform. This gets the combination of all transforms in
* the current state.
*
* @return the calculate combined transform for the current state
*/
public AffineTransform getTransform() {
return getGraph().getTransform();
}
/** {@inheritDoc} */
@Override
public String toString() {
String s = "Java2DGraphicsState " + currentGraphics.toString()
+ ", Stroke (width: " + currentStrokeWidth + " style: "
+ currentStrokeStyle + "), " + getTransform();
return s;
}
}