What Is fop.jar in fop-2.7-bin.zip
What Is fop.jar? I got it from the fop-2.7-bin.zip.
✍: FYIcenter.com
fop.jar in fop-2.7-bin.zip is the JAR file for FOP 2.7, which
is a print formatter driven by XSL formatting objects (XSL-FO).
You can obtain fop.jar from the build folder of the fop-2.7-bin.zip file.
Below is the information about the fop.jar (2.2) file:
JAR File Size and Download Location:
JAR name: fop.jar, fop-2.7.jar Target JDK version: 1.7 File name: fop.jar File size: 4442817 bytes Release date: 20-Jan-2022 Download: Apache FOP Website
Java source code files for fop.jar:
⏎ org/apache/fop/render/AbstractPathOrientedRenderer.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: AbstractPathOrientedRenderer.java 1835810 2018-07-13 10:29:57Z ssteiner $ */
package org.apache.fop.render;
import java.awt.Color;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.util.List;
import java.util.Map;
import org.w3c.dom.Document;
import org.apache.batik.parser.AWTTransformProducer;
import org.apache.xmlgraphics.image.loader.ImageSize;
import org.apache.xmlgraphics.util.QName;
import org.apache.xmlgraphics.util.UnitConv;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
import org.apache.fop.area.BlockViewport;
import org.apache.fop.area.CTM;
import org.apache.fop.area.NormalFlow;
import org.apache.fop.area.RegionReference;
import org.apache.fop.area.RegionViewport;
import org.apache.fop.area.Trait;
import org.apache.fop.area.inline.ForeignObject;
import org.apache.fop.area.inline.InlineArea;
import org.apache.fop.area.inline.InlineViewport;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.extensions.ExtensionElementMapping;
import org.apache.fop.fonts.FontMetrics;
import org.apache.fop.traits.BorderProps;
/**
* Abstract base class for renderers like PDF and PostScript where many painting operations
* follow similar patterns which makes it possible to share some code.
*/
public abstract class AbstractPathOrientedRenderer extends PrintRenderer {
/**
* @param userAgent the user agent that contains configuration details. This cannot be null.
*/
public AbstractPathOrientedRenderer(FOUserAgent userAgent) {
super(userAgent);
}
/**
* Handle block traits.
* The block could be any sort of block with any positioning
* so this should render the traits such as border and background
* in its position.
*
* @param block the block to render the traits
*/
protected void handleBlockTraits(Block block) {
float borderPaddingStart = block.getBorderAndPaddingWidthStart() / 1000f;
float borderPaddingEnd = block.getBorderAndPaddingWidthEnd() / 1000f;
float borderPaddingBefore = block.getBorderAndPaddingWidthBefore() / 1000f;
float borderPaddingAfter = block.getBorderAndPaddingWidthAfter() / 1000f;
float startx = currentIPPosition / 1000f;
float starty = currentBPPosition / 1000f;
float width = block.getIPD() / 1000f;
float height = block.getBPD() / 1000f;
int level = block.getBidiLevel();
if ((level == -1) || ((level & 1) == 0)) {
startx += block.getStartIndent() / 1000f;
startx -= borderPaddingStart;
} else {
startx += block.getEndIndent() / 1000f;
startx -= borderPaddingEnd;
}
width += borderPaddingStart;
width += borderPaddingEnd;
height += borderPaddingBefore;
height += borderPaddingAfter;
drawBackAndBorders(block, startx, starty, width, height);
}
/**
* Handle the traits for a region
* This is used to draw the traits for the given page region.
* (See Sect. 6.4.1.2 of XSL-FO spec.)
* @param region the RegionViewport whose region is to be drawn
*/
protected void handleRegionTraits(RegionViewport region) {
Rectangle2D viewArea = region.getViewArea();
RegionReference referenceArea = region.getRegionReference();
float startx = (float)(viewArea.getX() / 1000f);
float starty = (float)(viewArea.getY() / 1000f);
float width = (float)(viewArea.getWidth() / 1000f);
float height = (float)(viewArea.getHeight() / 1000f);
// adjust the current position according to region borders and padding
currentBPPosition = referenceArea.getBorderAndPaddingWidthBefore();
int level = region.getBidiLevel();
if ((level == -1) || ((level & 1) == 0)) {
currentIPPosition = referenceArea.getBorderAndPaddingWidthStart();
} else {
currentIPPosition = referenceArea.getBorderAndPaddingWidthEnd();
}
// draw background (traits are in the RegionViewport)
// and borders (traits are in the RegionReference)
drawBackAndBorders(region, referenceArea, startx, starty, width, height);
}
/**
* Draw the background and borders.
* This draws the background and border traits for an area given
* the position.
*
* @param area the area to get the traits from
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
*/
protected void drawBackAndBorders(Area area,
float startx, float starty,
float width, float height) {
drawBackAndBorders(area, area, startx, starty, width, height);
}
/**
* Draw the background and borders.
* This draws the background and border traits for an area given
* the position.
*
* @param backgroundArea the area to get the background traits from
* @param borderArea the area to get the border traits from
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
*/
protected void drawBackAndBorders(Area backgroundArea, Area borderArea,
float startx, float starty,
float width, float height) {
// draw background then border
BorderProps bpsBefore = (BorderProps)borderArea.getTrait(Trait.BORDER_BEFORE);
BorderProps bpsAfter = (BorderProps)borderArea.getTrait(Trait.BORDER_AFTER);
BorderProps bpsStart = (BorderProps)borderArea.getTrait(Trait.BORDER_START);
BorderProps bpsEnd = (BorderProps)borderArea.getTrait(Trait.BORDER_END);
Trait.Background backgroundTrait
= (Trait.Background)backgroundArea.getTrait(Trait.BACKGROUND);
drawBackground(startx, starty, width, height,
(Trait.Background) backgroundArea.getTrait(Trait.BACKGROUND),
bpsBefore, bpsAfter, bpsStart, bpsEnd, backgroundArea.getBidiLevel());
// TODO what is the default bg color? Should we serialize it?
Color bg = Color.white;
if (backgroundTrait != null && backgroundTrait.getColor() != null) {
bg = backgroundTrait.getColor();
}
drawBorders(startx, starty, width, height,
bpsBefore, bpsAfter, bpsStart, bpsEnd, backgroundArea.getBidiLevel(), bg);
}
/**
* Draw the background.
* This draws the background given the position and the traits.
*
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
* @param back the background traits
* @param bpsBefore the border-before traits
* @param bpsAfter the border-after traits
* @param bpsStart the border-start traits
* @param bpsEnd the border-end traits
* @param level of bidirectional embedding
*/
protected void drawBackground(float startx, float starty, float width, float height, Trait.Background back,
BorderProps bpsBefore, BorderProps bpsAfter,
BorderProps bpsStart, BorderProps bpsEnd, int level) {
BorderProps bpsTop = bpsBefore;
BorderProps bpsBottom = bpsAfter;
BorderProps bpsLeft;
BorderProps bpsRight;
if ((level == -1) || ((level & 1) == 0)) {
bpsLeft = bpsStart;
bpsRight = bpsEnd;
} else {
bpsLeft = bpsEnd;
bpsRight = bpsStart;
}
drawBackground(startx, starty, width, height, back, bpsTop, bpsBottom, bpsLeft, bpsRight);
}
/**
* Draw the background.
* This draws the background given the position and the traits.
*
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
* @param back the background traits
* @param bpsTop the border specification on the top edge
* @param bpsBottom the border traits associated with bottom edge
* @param bpsLeft the border specification on the left edge
* @param bpsRight the border specification on the right edge
*/
protected void drawBackground(float startx, float starty, float width, float height, Trait.Background back,
BorderProps bpsTop, BorderProps bpsBottom,
BorderProps bpsLeft, BorderProps bpsRight) {
if (back != null) {
endTextObject();
//Calculate padding rectangle
float sx = startx;
float sy = starty;
float paddRectWidth = width;
float paddRectHeight = height;
if (bpsLeft != null) {
sx += bpsLeft.width / 1000f;
paddRectWidth -= bpsLeft.width / 1000f;
}
if (bpsTop != null) {
sy += bpsTop.width / 1000f;
paddRectHeight -= bpsTop.width / 1000f;
}
if (bpsRight != null) {
paddRectWidth -= bpsRight.width / 1000f;
}
if (bpsBottom != null) {
paddRectHeight -= bpsBottom.width / 1000f;
}
saveGraphicsState();
clipBackground(sx, sy, paddRectWidth, paddRectHeight, bpsTop, bpsBottom, bpsLeft, bpsRight);
if (back.getColor() != null) {
updateColor(back.getColor(), true);
fillRect(sx, sy, paddRectWidth, paddRectHeight);
}
if (back.getImageInfo() != null) {
ImageSize imageSize = back.getImageInfo().getSize();
int targetWidth = imageSize.getWidthMpt();
int targetHeight = imageSize.getHeightMpt();
double multiplier = 1.0;
if (back.getImageTargetWidth() != 0 && back.getImageTargetHeight() != 0) {
multiplier = Math.min(1.0 * back.getImageTargetWidth() / targetWidth,
1.0 * back.getImageTargetHeight() / targetHeight);
} else if (back.getImageTargetHeight() != 0) {
multiplier = 1.0 * back.getImageTargetHeight() / targetHeight;
} else if (back.getImageTargetWidth() != 0) {
multiplier = 1.0 * back.getImageTargetWidth() / targetWidth;
}
targetWidth = (int) (targetWidth * multiplier);
targetHeight = (int) (targetHeight * multiplier);
int horzCount = (int) ((paddRectWidth * 1000 / targetWidth) + 1.0f);
int vertCount = (int) ((paddRectHeight * 1000 / targetHeight) + 1.0f);
if (back.getRepeat() == EN_NOREPEAT) {
horzCount = 1;
vertCount = 1;
} else if (back.getRepeat() == EN_REPEATX) {
vertCount = 1;
} else if (back.getRepeat() == EN_REPEATY) {
horzCount = 1;
}
//change from points to millipoints
sx *= 1000;
sy *= 1000;
if (horzCount == 1) {
sx += back.getHoriz();
}
if (vertCount == 1) {
sy += back.getVertical();
}
for (int x = 0; x < horzCount; x++) {
for (int y = 0; y < vertCount; y++) {
// place once
Rectangle2D pos;
// Image positions are relative to the currentIP/BP
pos = new Rectangle2D.Float(sx - currentIPPosition + (x * targetWidth), sy
- currentBPPosition + (y * targetHeight), targetWidth, targetHeight);
drawImage(back.getURL(), pos);
}
}
}
restoreGraphicsState();
}
}
/**
* TODO represent border related parameters in a class
* Clip the background to the inner border.
* This draws the border traits given the position and the traits.
*
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
* @param bpsBefore the border-before traits
* @param bpsAfter the border-after traits
* @param bpsStart the border-start traits
* @param bpsEnd the border-end traits
*/
protected void clipBackground(float startx, float starty,
float width, float height,
BorderProps bpsBefore, BorderProps bpsAfter,
BorderProps bpsStart, BorderProps bpsEnd) {
clipRect(startx, starty, width, height);
}
/**
* Draw the borders.
* This draws the border traits given the position and the traits.
*
* @param startx the start x position
* @param starty the start y position
* @param width the width of the area
* @param height the height of the area
* @param bpsBefore the border traits associated with before edge
* @param bpsAfter the border traits associated with after edge
* @param bpsStart the border traits associated with start edge
* @param bpsEnd the border traits associated with end edge
* @param level of bidirectional embedding
* @param innerBackgroundColor the background color of the block
*/
protected void drawBorders(float startx, float starty, float width, float height,
BorderProps bpsBefore, BorderProps bpsAfter,
BorderProps bpsStart, BorderProps bpsEnd, int level, Color innerBackgroundColor) {
Rectangle2D.Float borderRect = new Rectangle2D.Float(startx, starty, width, height);
BorderProps bpsTop = bpsBefore;
BorderProps bpsBottom = bpsAfter;
BorderProps bpsLeft;
BorderProps bpsRight;
if ((level == -1) || ((level & 1) == 0)) {
bpsLeft = bpsStart;
bpsRight = bpsEnd;
} else {
bpsLeft = bpsEnd;
bpsRight = bpsStart;
}
drawBorders(borderRect, bpsTop, bpsBottom, bpsLeft, bpsRight, innerBackgroundColor);
}
private static final int TOP = 0;
private static final int RIGHT = 1;
private static final int BOTTOM = 2;
private static final int LEFT = 3;
/**
* Draws borders.
* @param borderRect the border rectangle
* @param bpsTop the border specification on the top edge
* @param bpsBottom the border traits associated with bottom edge
* @param bpsLeft the border specification on the left edge
* @param bpsRight the border specification on the right edge
* @param innerBackgroundColor the background color of the block
*/
protected void drawBorders(Rectangle2D.Float borderRect,
BorderProps bpsTop, BorderProps bpsBottom, BorderProps bpsLeft, BorderProps bpsRight,
Color innerBackgroundColor) {
//TODO generalize each of the four conditions into using a parameterized drawBorder()
boolean[] border = new boolean[] {
(bpsTop != null), (bpsRight != null),
(bpsBottom != null), (bpsLeft != null)};
float startx = borderRect.x;
float starty = borderRect.y;
float width = borderRect.width;
float height = borderRect.height;
float[] borderWidth = new float[] {
(border[TOP] ? bpsTop.width / 1000f : 0.0f),
(border[RIGHT] ? bpsRight.width / 1000f : 0.0f),
(border[BOTTOM] ? bpsBottom.width / 1000f : 0.0f),
(border[LEFT] ? bpsLeft.width / 1000f : 0.0f)};
float[] clipw = new float[] {
BorderProps.getClippedWidth(bpsTop) / 1000f,
BorderProps.getClippedWidth(bpsRight) / 1000f,
BorderProps.getClippedWidth(bpsBottom) / 1000f,
BorderProps.getClippedWidth(bpsLeft) / 1000f};
starty += clipw[TOP];
height -= clipw[TOP];
height -= clipw[BOTTOM];
startx += clipw[LEFT];
width -= clipw[LEFT];
width -= clipw[RIGHT];
boolean[] slant = new boolean[] {
(border[LEFT] && border[TOP]),
(border[TOP] && border[RIGHT]),
(border[RIGHT] && border[BOTTOM]),
(border[BOTTOM] && border[LEFT])};
if (bpsTop != null) {
endTextObject();
float sx1 = startx;
float sx2 = (slant[TOP] ? sx1 + borderWidth[LEFT] - clipw[LEFT] : sx1);
float ex1 = startx + width;
float ex2 = (slant[RIGHT] ? ex1 - borderWidth[RIGHT] + clipw[RIGHT] : ex1);
float outery = starty - clipw[TOP];
float clipy = outery + clipw[TOP];
float innery = outery + borderWidth[TOP];
saveGraphicsState();
moveTo(sx1, clipy);
float sx1a = sx1;
float ex1a = ex1;
if (isCollapseOuter(bpsTop)) {
if (isCollapseOuter(bpsLeft)) {
sx1a -= clipw[LEFT];
}
if (isCollapseOuter(bpsRight)) {
ex1a += clipw[RIGHT];
}
lineTo(sx1a, outery);
lineTo(ex1a, outery);
}
lineTo(ex1, clipy);
lineTo(ex2, innery);
lineTo(sx2, innery);
closePath();
clip();
drawBorderLine(sx1a, outery, ex1a, innery, true, true,
bpsTop.style, bpsTop.color);
restoreGraphicsState();
}
if (bpsRight != null) {
endTextObject();
float sy1 = starty;
float sy2 = (slant[RIGHT] ? sy1 + borderWidth[TOP] - clipw[TOP] : sy1);
float ey1 = starty + height;
float ey2 = (slant[BOTTOM] ? ey1 - borderWidth[BOTTOM] + clipw[BOTTOM] : ey1);
float outerx = startx + width + clipw[RIGHT];
float clipx = outerx - clipw[RIGHT];
float innerx = outerx - borderWidth[RIGHT];
saveGraphicsState();
moveTo(clipx, sy1);
float sy1a = sy1;
float ey1a = ey1;
if (isCollapseOuter(bpsRight)) {
if (isCollapseOuter(bpsTop)) {
sy1a -= clipw[TOP];
}
if (isCollapseOuter(bpsBottom)) {
ey1a += clipw[BOTTOM];
}
lineTo(outerx, sy1a);
lineTo(outerx, ey1a);
}
lineTo(clipx, ey1);
lineTo(innerx, ey2);
lineTo(innerx, sy2);
closePath();
clip();
drawBorderLine(innerx, sy1a, outerx, ey1a, false, false,
bpsRight.style, bpsRight.color);
restoreGraphicsState();
}
if (bpsBottom != null) {
endTextObject();
float sx1 = startx;
float sx2 = (slant[LEFT] ? sx1 + borderWidth[LEFT] - clipw[LEFT] : sx1);
float ex1 = startx + width;
float ex2 = (slant[BOTTOM] ? ex1 - borderWidth[RIGHT] + clipw[RIGHT] : ex1);
float outery = starty + height + clipw[BOTTOM];
float clipy = outery - clipw[BOTTOM];
float innery = outery - borderWidth[BOTTOM];
saveGraphicsState();
moveTo(ex1, clipy);
float sx1a = sx1;
float ex1a = ex1;
if (isCollapseOuter(bpsBottom)) {
if (isCollapseOuter(bpsLeft)) {
sx1a -= clipw[LEFT];
}
if (isCollapseOuter(bpsRight)) {
ex1a += clipw[RIGHT];
}
lineTo(ex1a, outery);
lineTo(sx1a, outery);
}
lineTo(sx1, clipy);
lineTo(sx2, innery);
lineTo(ex2, innery);
closePath();
clip();
drawBorderLine(sx1a, innery, ex1a, outery, true, false,
bpsBottom.style, bpsBottom.color);
restoreGraphicsState();
}
if (bpsLeft != null) {
endTextObject();
float sy1 = starty;
float sy2 = (slant[TOP] ? sy1 + borderWidth[TOP] - clipw[TOP] : sy1);
float ey1 = sy1 + height;
float ey2 = (slant[LEFT] ? ey1 - borderWidth[BOTTOM] + clipw[BOTTOM] : ey1);
float outerx = startx - clipw[LEFT];
float clipx = outerx + clipw[LEFT];
float innerx = outerx + borderWidth[LEFT];
saveGraphicsState();
moveTo(clipx, ey1);
float sy1a = sy1;
float ey1a = ey1;
if (isCollapseOuter(bpsLeft)) {
if (isCollapseOuter(bpsTop)) {
sy1a -= clipw[TOP];
}
if (isCollapseOuter(bpsBottom)) {
ey1a += clipw[BOTTOM];
}
lineTo(outerx, ey1a);
lineTo(outerx, sy1a);
}
lineTo(clipx, sy1);
lineTo(innerx, sy2);
lineTo(innerx, ey2);
closePath();
clip();
drawBorderLine(outerx, sy1a, innerx, ey1a, false, true, bpsLeft.style, bpsLeft.color);
restoreGraphicsState();
}
}
private boolean isCollapseOuter(BorderProps bp) {
return bp != null && bp.isCollapseOuter();
}
/**
* Common method to render the background and borders for any inline area.
* The all borders and padding are drawn outside the specified area.
* @param area the inline area for which the background, border and padding is to be
* rendered
*/
protected void renderInlineAreaBackAndBorders(InlineArea area) {
float borderPaddingStart = area.getBorderAndPaddingWidthStart() / 1000f;
float borderPaddingEnd = area.getBorderAndPaddingWidthEnd() / 1000f;
float borderPaddingBefore = area.getBorderAndPaddingWidthBefore() / 1000f;
float borderPaddingAfter = area.getBorderAndPaddingWidthAfter() / 1000f;
float bpwidth = borderPaddingStart + borderPaddingEnd;
float bpheight = borderPaddingBefore + borderPaddingAfter;
float height = area.getBPD() / 1000f;
if (height != 0.0f || bpheight != 0.0f && bpwidth != 0.0f) {
float x = currentIPPosition / 1000f;
float y = (currentBPPosition + area.getBlockProgressionOffset()) / 1000f;
float width = area.getIPD() / 1000f;
drawBackAndBorders(area, x, y - borderPaddingBefore
, width + bpwidth
, height + bpheight);
}
}
/** Constant for the fox:transform extension attribute */
protected static final QName FOX_TRANSFORM
= new QName(ExtensionElementMapping.URI, "fox:transform");
/** {@inheritDoc} */
protected void renderBlockViewport(BlockViewport bv, List children) {
// clip and position viewport if necessary
// save positions
int saveIP = currentIPPosition;
int saveBP = currentBPPosition;
CTM ctm = bv.getCTM();
int borderPaddingBefore = bv.getBorderAndPaddingWidthBefore();
int positioning = bv.getPositioning();
if (positioning == Block.ABSOLUTE || positioning == Block.FIXED) {
//For FIXED, we need to break out of the current viewports to the
//one established by the page. We save the state stack for restoration
//after the block-container has been painted. See below.
List breakOutList = null;
if (positioning == Block.FIXED) {
breakOutList = breakOutOfStateStack();
}
AffineTransform positionTransform = new AffineTransform();
positionTransform.translate(bv.getXOffset(), bv.getYOffset());
int level = bv.getBidiLevel();
int borderPaddingStart = bv.getBorderAndPaddingWidthStart();
int borderPaddingEnd = bv.getBorderAndPaddingWidthEnd();
//"left/"top" (bv.getX/YOffset()) specify the position of the content rectangle
if ((level == -1) || ((level & 1) == 0)) {
positionTransform.translate(-borderPaddingStart, -borderPaddingBefore);
} else {
positionTransform.translate(-borderPaddingEnd, -borderPaddingBefore);
}
//Free transformation for the block-container viewport
String transf;
transf = bv.getForeignAttributeValue(FOX_TRANSFORM);
if (transf != null) {
AffineTransform freeTransform = AWTTransformProducer.createAffineTransform(transf);
positionTransform.concatenate(freeTransform);
}
//Viewport position
if (!positionTransform.isIdentity()) {
establishTransformationMatrix(positionTransform);
}
//This is the content-rect
float width = bv.getIPD() / 1000f;
float height = bv.getBPD() / 1000f;
//Background and borders
float borderPaddingWidth
= (borderPaddingStart + borderPaddingEnd) / 1000f;
float borderPaddingHeight
= (borderPaddingBefore + bv.getBorderAndPaddingWidthAfter()) / 1000f;
drawBackAndBorders(bv, 0, 0, width + borderPaddingWidth, height + borderPaddingHeight);
//Shift to content rectangle after border painting
AffineTransform contentRectTransform = new AffineTransform();
if ((level == -1) || ((level & 1) == 0)) {
contentRectTransform.translate(borderPaddingStart, borderPaddingBefore);
} else {
contentRectTransform.translate(borderPaddingEnd, borderPaddingBefore);
}
if (!contentRectTransform.isIdentity()) {
establishTransformationMatrix(contentRectTransform);
}
//Clipping
if (bv.hasClip()) {
clipRect(0f, 0f, width, height);
}
//Set up coordinate system for content rectangle
AffineTransform contentTransform = ctm.toAffineTransform();
if (!contentTransform.isIdentity()) {
establishTransformationMatrix(contentTransform);
}
currentIPPosition = 0;
currentBPPosition = 0;
renderBlocks(bv, children);
if (!contentTransform.isIdentity()) {
restoreGraphicsState();
}
if (!contentRectTransform.isIdentity()) {
restoreGraphicsState();
}
if (!positionTransform.isIdentity()) {
restoreGraphicsState();
}
//For FIXED, we need to restore break out now we are done
if (positioning == Block.FIXED) {
if (breakOutList != null) {
restoreStateStackAfterBreakOut(breakOutList);
}
}
currentIPPosition = saveIP;
currentBPPosition = saveBP;
} else {
currentBPPosition += bv.getSpaceBefore();
//borders and background in the old coordinate system
handleBlockTraits(bv);
//Advance to start of content area
currentIPPosition += bv.getStartIndent();
CTM tempctm = new CTM(containingIPPosition, currentBPPosition);
ctm = tempctm.multiply(ctm);
//Now adjust for border/padding
currentBPPosition += borderPaddingBefore;
Rectangle clippingRect = null;
if (bv.hasClip()) {
clippingRect = new Rectangle(currentIPPosition, currentBPPosition,
bv.getIPD(), bv.getBPD());
}
startVParea(ctm, clippingRect);
currentIPPosition = 0;
currentBPPosition = 0;
renderBlocks(bv, children);
endVParea();
currentIPPosition = saveIP;
currentBPPosition = saveBP;
currentBPPosition += (bv.getAllocBPD());
}
}
/** {@inheritDoc} */
protected void renderReferenceArea(Block block) {
// save position and offset
int saveIP = currentIPPosition;
int saveBP = currentBPPosition;
int saveBO = getBeginOffset();
//Establish a new coordinate system
AffineTransform at = new AffineTransform();
at.translate(currentIPPosition, currentBPPosition);
at.translate(block.getXOffset(), block.getYOffset());
at.translate(0, block.getSpaceBefore());
setBeginOffset(saveBO - block.getXOffset());
if (!at.isIdentity()) {
establishTransformationMatrix(at);
}
currentIPPosition = 0;
currentBPPosition = 0;
handleBlockTraits(block);
List children = block.getChildAreas();
if (children != null) {
renderBlocks(block, children);
}
if (!at.isIdentity()) {
restoreGraphicsState();
}
setBeginOffset(saveBO);
// stacked and relative blocks effect stacking
currentIPPosition = saveIP;
currentBPPosition = saveBP;
}
/** {@inheritDoc} */
protected void renderFlow(NormalFlow flow) {
// save position and offset
int saveIP = currentIPPosition;
int saveBP = currentBPPosition;
//Establish a new coordinate system
AffineTransform at = new AffineTransform();
at.translate(currentIPPosition, currentBPPosition);
if (!at.isIdentity()) {
establishTransformationMatrix(at);
}
currentIPPosition = 0;
currentBPPosition = 0;
super.renderFlow(flow);
if (!at.isIdentity()) {
restoreGraphicsState();
}
// stacked and relative blocks effect stacking
currentIPPosition = saveIP;
currentBPPosition = saveBP;
}
/**
* Concatenates the current transformation matrix with the given one, therefore establishing
* a new coordinate system.
* @param at the transformation matrix to process (coordinates in points)
*/
protected abstract void concatenateTransformationMatrix(AffineTransform at);
/**
* Render an inline viewport.
* This renders an inline viewport by clipping if necessary.
* @param viewport the viewport to handle
*/
public void renderInlineViewport(InlineViewport viewport) {
int level = viewport.getBidiLevel();
float x = currentIPPosition / 1000f;
float y = (currentBPPosition + viewport.getBlockProgressionOffset()) / 1000f;
float width = viewport.getIPD() / 1000f;
float height = viewport.getBPD() / 1000f;
// TODO: Calculate the border rect correctly.
float borderPaddingStart = viewport.getBorderAndPaddingWidthStart() / 1000f;
float borderPaddingEnd = viewport.getBorderAndPaddingWidthEnd() / 1000f;
float borderPaddingBefore = viewport.getBorderAndPaddingWidthBefore() / 1000f;
float borderPaddingAfter = viewport.getBorderAndPaddingWidthAfter() / 1000f;
float bpwidth = borderPaddingStart + borderPaddingEnd;
float bpheight = borderPaddingBefore + borderPaddingAfter;
drawBackAndBorders(viewport, x, y, width + bpwidth, height + bpheight);
if (viewport.hasClip()) {
saveGraphicsState();
if ((level == -1) || ((level & 1) == 0)) {
clipRect(x + borderPaddingStart, y + borderPaddingBefore, width, height);
} else {
clipRect(x + borderPaddingEnd, y + borderPaddingBefore, width, height);
}
}
super.renderInlineViewport(viewport);
if (viewport.hasClip()) {
restoreGraphicsState();
}
}
/**
* Restores the state stack after a break out.
* @param breakOutList the state stack to restore.
*/
protected abstract void restoreStateStackAfterBreakOut(List breakOutList);
/**
* Breaks out of the state stack to handle fixed block-containers.
* @return the saved state stack to recreate later
*/
protected abstract List breakOutOfStateStack();
/** Saves the graphics state of the rendering engine. */
protected abstract void saveGraphicsState();
/** Restores the last graphics state of the rendering engine. */
protected abstract void restoreGraphicsState();
/** Indicates the beginning of a text object. */
protected abstract void beginTextObject();
/** Indicates the end of a text object. */
protected abstract void endTextObject();
/**
* Paints the text decoration marks.
* @param fm Current typeface
* @param fontsize Current font size
* @param inline inline area to paint the marks for
* @param baseline position of the baseline
* @param startx start IPD
*/
protected void renderTextDecoration(FontMetrics fm, int fontsize, InlineArea inline,
int baseline, int startx) {
boolean hasTextDeco = inline.hasUnderline()
|| inline.hasOverline()
|| inline.hasLineThrough();
if (hasTextDeco) {
endTextObject();
float descender = fm.getDescender(fontsize) / 1000f;
float capHeight = fm.getCapHeight(fontsize) / 1000f;
float halfLineWidth = (descender / -8f) / 2f;
float endx = (startx + inline.getIPD()) / 1000f;
if (inline.hasUnderline()) {
Color ct = (Color) inline.getTrait(Trait.UNDERLINE_COLOR);
float y = baseline - descender / 2f;
drawBorderLine(startx / 1000f, (y - halfLineWidth) / 1000f,
endx, (y + halfLineWidth) / 1000f,
true, true, Constants.EN_SOLID, ct);
}
if (inline.hasOverline()) {
Color ct = (Color) inline.getTrait(Trait.OVERLINE_COLOR);
float y = (float)(baseline - (1.1 * capHeight));
drawBorderLine(startx / 1000f, (y - halfLineWidth) / 1000f,
endx, (y + halfLineWidth) / 1000f,
true, true, Constants.EN_SOLID, ct);
}
if (inline.hasLineThrough()) {
Color ct = (Color) inline.getTrait(Trait.LINETHROUGH_COLOR);
float y = (float)(baseline - (0.45 * capHeight));
drawBorderLine(startx / 1000f, (y - halfLineWidth) / 1000f,
endx, (y + halfLineWidth) / 1000f,
true, true, Constants.EN_SOLID, ct);
}
}
}
/** Clip using the current path. */
protected abstract void clip();
/**
* Clip using a rectangular area.
* @param x the x coordinate (in points)
* @param y the y coordinate (in points)
* @param width the width of the rectangle (in points)
* @param height the height of the rectangle (in points)
*/
protected abstract void clipRect(float x, float y, float width, float height);
/**
* Moves the current point to (x, y), omitting any connecting line segment.
* @param x x coordinate
* @param y y coordinate
*/
protected abstract void moveTo(float x, float y);
/**
* Appends a straight line segment from the current point to (x, y). The
* new current point is (x, y).
* @param x x coordinate
* @param y y coordinate
*/
protected abstract void lineTo(float x, float y);
/**
* Closes the current subpath by appending a straight line segment from
* the current point to the starting point of the subpath.
*/
protected abstract void closePath();
/**
* Fill a rectangular area.
* @param x the x coordinate
* @param y the y coordinate
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
protected abstract void fillRect(float x, float y, float width, float height);
/**
* Establishes a new foreground or fill color.
* @param col the color to apply (null skips this operation)
* @param fill true to set the fill color, false for the foreground color
*/
protected abstract void updateColor(Color col, boolean fill);
/**
* Draw an image at the indicated location.
* @param url the URI/URL of the image
* @param pos the position of the image
* @param foreignAttributes an optional Map with foreign attributes, may be null
*/
protected abstract void drawImage(String url, Rectangle2D pos, Map foreignAttributes);
/**
* Draw an image at the indicated location.
* @param url the URI/URL of the image
* @param pos the position of the image
*/
protected final void drawImage(String url, Rectangle2D pos) {
drawImage(url, pos, null);
}
/**
* Draw a border segment of an XSL-FO style border.
* @param x1 starting x coordinate
* @param y1 starting y coordinate
* @param x2 ending x coordinate
* @param y2 ending y coordinate
* @param horz true for horizontal border segments, false for vertical border segments
* @param startOrBefore true for border segments on the start or before edge,
* false for end or after.
* @param style the border style (one of Constants.EN_DASHED etc.)
* @param col the color for the border segment
*/
protected abstract void drawBorderLine(float x1, float y1, float x2, float y2, boolean horz,
boolean startOrBefore, int style, Color col);
/** {@inheritDoc} */
public void renderForeignObject(ForeignObject fo, Rectangle2D pos) {
endTextObject();
Document doc = fo.getDocument();
String ns = fo.getNameSpace();
renderDocument(doc, ns, pos, fo.getForeignAttributes());
}
/**
* Establishes a new coordinate system with the given transformation matrix.
* The current graphics state is saved and the new coordinate system is concatenated.
* @param at the transformation matrix
*/
protected void establishTransformationMatrix(AffineTransform at) {
saveGraphicsState();
concatenateTransformationMatrix(UnitConv.mptToPt(at));
}
}
⏎ org/apache/fop/render/AbstractPathOrientedRenderer.java
Or download all of them as a single archive file:
File name: fop-2.7-src.zip File size: 3401312 bytes Release date: 2022-01-20 Download
⇒ "fop" Command in fop-2.7-bin.zip
2016-07-07, 36642👍, 0💬
Related Topics: