diff options
12 files changed, 2105 insertions, 88 deletions
diff --git a/src/java/org/apache/fop/fo/flow/TableColumn.java b/src/java/org/apache/fop/fo/flow/TableColumn.java index 94cacf4e6..df3cd7663 100644 --- a/src/java/org/apache/fop/fo/flow/TableColumn.java +++ b/src/java/org/apache/fop/fo/flow/TableColumn.java @@ -25,7 +25,6 @@ import org.apache.fop.apps.FOPException; import org.apache.fop.datatypes.Length; import org.apache.fop.datatypes.Numeric; import org.apache.fop.fo.FONode; -import org.apache.fop.fo.FObj; import org.apache.fop.fo.PropertyList; import org.apache.fop.fo.ValidationException; import org.apache.fop.fo.expr.PropertyException; @@ -127,6 +126,14 @@ public class TableColumn extends TableFObj { } /** + * Sets the column width. + * @param columnWidth the column width + */ + public void setColumnWidth(Length columnWidth) { + this.columnWidth = columnWidth; + } + + /** * @return the "column-number" property. */ public int getColumnNumber() { @@ -176,5 +183,6 @@ public class TableColumn extends TableFObj { sb.append(" column-width=").append(getColumnWidth()); return sb.toString(); } + } diff --git a/src/java/org/apache/fop/render/RendererFactory.java b/src/java/org/apache/fop/render/RendererFactory.java index dbd94119d..d4d1460bd 100644 --- a/src/java/org/apache/fop/render/RendererFactory.java +++ b/src/java/org/apache/fop/render/RendererFactory.java @@ -33,6 +33,7 @@ import org.apache.fop.fo.Constants; import org.apache.fop.fo.FOEventHandler; import org.apache.fop.render.mif.MIFHandler; import org.apache.fop.render.rtf.RTFHandler; +import org.apache.fop.render.txt.TXTHandler; /** * Factory for FOEventHandlers and Renderers. @@ -132,6 +133,8 @@ public class RendererFactory { return new MIFHandler(userAgent, out); } else if (renderType == Constants.RENDER_RTF) { return new RTFHandler(userAgent, out); + } else if (renderType == Constants.RENDER_TXT) { + return new TXTHandler(userAgent, out); } else { if (renderType < Constants.RENDER_MIN_CONST || renderType > Constants.RENDER_MAX_CONST) { diff --git a/src/java/org/apache/fop/render/txt/Helper.java b/src/java/org/apache/fop/render/txt/Helper.java new file mode 100644 index 000000000..fe44e4ec1 --- /dev/null +++ b/src/java/org/apache/fop/render/txt/Helper.java @@ -0,0 +1,117 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt; + +/** + * This class has a few convenient static methods for number quantization. + */ +public final class Helper { + + /** + * Don't let anyone instantiate this class. + */ + private Helper() { } + + /** + * Returns nearest integer to <code>x</code>, divisible by + * <code>quantum</code>. + * + * @param x integer for quantization + * @param quantum integer, representing quantization + * @return computed nearest integer + */ + public static int round(int x, int quantum) { + int ceil = ceil(x, quantum); + int floor = floor(x, quantum); + return (ceil - x < x - floor) ? ceil : floor; + } + + /** + * Returns minimal possible integer, greater or equal than + * <code>x</code>, divisible by <code>quantum</code>. + * + * @param x integer for quantization + * @param quantum integer, representing quantization + * @return computed nearest integer + */ + public static int ceil(int x, int quantum) { + int dx = (x < 0) || (x % quantum == 0) ? 0 : 1; + return (x / quantum + dx) * quantum; + } + + /** + * Returns maximum possible integer, less or equal than + * <code>oldValue</code>, divisible by <code>quantum</code>. + * + * @param x integer for quantization + * @param quantum integer, representing quantization + * @return computed nearest integer + */ + public static int floor(int x, int quantum) { + int dx = (x > 0) || (x % quantum == 0) ? 0 : -1; + return (x / quantum + dx) * quantum; + } + + /** + * Returns the closest integer to <code>x/y</code> fraction. + * It's possible to consider this methos as a analog of Math.round(x/y), + * without having deal with non-integer. + * + * @param x integer, fraction numerator + * @param y integer, fraction denominator + * @return the value of the fraction rounded to the nearest + * @see java.lang.Math#round(double) + */ + public static int roundPosition(int x, int y) { + return round(x, y) / y; + } + + /** + * Returns the smallest integer that is greater than or equal to the + * <code>x/y</code> fraction. + * It's possible to consider this function as a analog of Math.ceil(x/y), + * without having deal with non-integer. + * + * @param x integer, fraction numerator + * @param y integer, fraction denominator + * @return the smallest integer that is greater than or equal to + * <code>x/y</code> fraction + * @see java.lang.Math#ceil(double) + */ + public static int ceilPosition(int x, int y) { + return ceil(x, y) / y; + } + + + /** + * Returns the largest integer that is less than or equal to the + * argument and is equal to <code>x/y</code> fraction. + * It's possible to consider this function as a analog of Math.floor(x/y), + * without having deal with non-integer. + * + * @param x integer, fraction numerator + * @param y integer, fraction denominator + * @return the largest integer that is less than or equal to + * the argument and is equal to <code>x/y</code> fraction + * @see java.lang.Math#ceil(double) + */ + public static int floorPosition(int x, int y) { + return floor(x, y) / y; + } +} diff --git a/src/java/org/apache/fop/render/txt/TXTHandler.java b/src/java/org/apache/fop/render/txt/TXTHandler.java new file mode 100644 index 000000000..d75e65f50 --- /dev/null +++ b/src/java/org/apache/fop/render/txt/TXTHandler.java @@ -0,0 +1,570 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt; + +import java.io.OutputStream; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; + +import org.apache.fop.apps.FOPException; +import org.apache.fop.apps.FOUserAgent; +import org.apache.fop.area.AreaTreeHandler; +import org.apache.fop.datatypes.CompoundDatatype; +import org.apache.fop.datatypes.Length; +import org.apache.fop.datatypes.PercentBaseContext; +import org.apache.fop.fo.Constants; +import org.apache.fop.fo.FONode; +import org.apache.fop.fo.FOText; +import org.apache.fop.fo.expr.NumericProperty; +import org.apache.fop.fo.expr.RelativeNumericProperty; +import org.apache.fop.fo.flow.Block; +import org.apache.fop.fo.flow.BlockContainer; +import org.apache.fop.fo.flow.ExternalGraphic; +import org.apache.fop.fo.flow.Inline; +import org.apache.fop.fo.flow.ListBlock; +import org.apache.fop.fo.flow.ListItem; +import org.apache.fop.fo.flow.PageNumber; +import org.apache.fop.fo.flow.Table; +import org.apache.fop.fo.flow.TableCell; +import org.apache.fop.fo.flow.TableColumn; +import org.apache.fop.fo.pagination.PageSequence; +import org.apache.fop.fo.properties.CommonAbsolutePosition; +import org.apache.fop.fo.properties.CommonBorderPaddingBackground; +import org.apache.fop.fo.properties.CommonFont; +import org.apache.fop.fo.properties.CommonMarginBlock; +import org.apache.fop.fo.properties.FixedLength; +import org.apache.fop.fo.properties.Property; +import org.apache.fop.fo.properties.SpaceProperty; +import org.apache.fop.layoutmgr.BlockLayoutManager; + +/** + * Handler for formatting objects in case of rendering to txt. + * + * This handler gets page-sequence, modifies formatting objects and return them + * to superclass. So areas are generated from modified FO. Idea of modifying is + * to quantize FO properties, making them divisible by width of char or height + * of char. + */ +public class TXTHandler extends AreaTreeHandler { + + /** Percent base context. Needed for line-height. */ + private static final PercentBaseContext CONTEXT + = new BlockLayoutManager(new Block(null)); + + /** Modified font size in millipoints. */ + private static final int MODIFIED_FONT_SIZE = 10000; + + /** Quantum for each side (BEFORE, AFTER, START, END). */ + private final int[] quantum = {TXTRenderer.CHAR_HEIGHT, + TXTRenderer.CHAR_HEIGHT, TXTRenderer.CHAR_WIDTH, + TXTRenderer.CHAR_WIDTH}; + + /** Keeps overpatching for each side. */ + private int[] overPatching = new int[4]; + + /** + * Keeps last overpatching for each side. Needed for selective modifying of + * start-indent and end-indent. + */ + private int[] lastOverPatching = new int[4]; + + /** + * Constructs a newly allocated <code>TXTHandler</code> object. + * + * @param userAgent FOUserAgent + * @param stream OutputStream + * @throws FOPException if the RenderPagesModel cannot be created + */ + public TXTHandler(FOUserAgent userAgent, OutputStream stream) + throws FOPException { + super(userAgent, Constants.RENDER_TXT, stream); + } + + /** + * Sets a component <code>CP_LENGTH</code> of <code>cd</code> to + * <code>value</code>. + + * @param cd CompoundDatatype + * @param value new integer value + */ + private static void setLength(CompoundDatatype cd, int value) { + cd.setComponent(Constants.CP_LENGTH, new FixedLength(value), true); + } + + /** + * Sets components <code>CP_MINIMUM, CP_OPTIMUM, CP_MAXIMUM</code> of + * <code>cd</code> to <code>p</code>. + * + * @param cd instance of CompoundDatatype for modifying. + * @param p property for setting. + */ + private static void setMinOptMax(CompoundDatatype cd, Property p) { + cd.setComponent(Constants.CP_MINIMUM, p, true); + cd.setComponent(Constants.CP_OPTIMUM, p, true); + cd.setComponent(Constants.CP_MAXIMUM, p, true); + } + + /** + * Modifies border of side. If there is no border of given side, does + * nothing, otherwise sets border-width to half of char width or char height + * depending on side. <p> + * Difference between values of new border-width and old border-width is + * saved in <code>lastOverPatching</code>. + * + * @param side side to modify. + * @param bpb instance of CommonBorderPaddingBackground for modifying. + */ + private void modifyBorder(int side, CommonBorderPaddingBackground bpb) { + CommonBorderPaddingBackground.BorderInfo bi = bpb.getBorderInfo(side); + + if (bi != null) { + int width = bpb.getBorderWidth(side, false); + setLength(bi.getWidth(), quantum[side] / 2); + lastOverPatching[side] += bpb.getBorderWidth(side, false) - width; + } + } + + /** + * Modifies padding of side. First rounds padding to nearest integer, + * divisible by char width or char height depending on side. If border of + * given side is available, modifies padding in such a way, so sum of border + * width and padding will be divisible by char width or char height, + * depending on side. <p> + * Difference between values of new padding and old padding is saved + * in <code>lastOverPatching</code>. + * + * @param side side to modify. + * @param bpb instance of CommonBorderPaddingBackground for modifying. + */ + private void modifyPadding(int side, CommonBorderPaddingBackground bpb) { + int oldPadding = bpb.getPadding(side, false, null); + int newPadding = Helper.round(oldPadding, quantum[side]); + if (bpb.getBorderInfo(side) != null) { + newPadding = Math.max(newPadding, quantum[side]) + - bpb.getBorderWidth(side, false); + } + + setLength(bpb.getPaddingLengthProperty(side), newPadding); + lastOverPatching[side] += newPadding - oldPadding; + } + + /** + * Modifies borders and paddings of <code>bpb</code>. + * + * @param bpb instance of CommonBorderPaddingBackground for modifying. + */ + private void modifyBPB(CommonBorderPaddingBackground bpb) { + modifyBorder(CommonBorderPaddingBackground.BEFORE, bpb); + modifyBorder(CommonBorderPaddingBackground.AFTER, bpb); + modifyBorder(CommonBorderPaddingBackground.START, bpb); + modifyBorder(CommonBorderPaddingBackground.END, bpb); + + modifyPadding(CommonBorderPaddingBackground.BEFORE, bpb); + modifyPadding(CommonBorderPaddingBackground.AFTER, bpb); + modifyPadding(CommonBorderPaddingBackground.START, bpb); + modifyPadding(CommonBorderPaddingBackground.END, bpb); + } + + /** + * Rounds optimum value of <code>space</code> to nearest integer, + * divisible by <code>q</code>. + * + * @param space instance of SpaceProperty. + * @param q integer. + */ + private void modifySpace(SpaceProperty space, int q) { + int value = space.getOptimum(null).getLength().getValue(); + setMinOptMax(space, new FixedLength(Helper.round(value, q))); + } + + /** + * @param length instance of Length. + * @param q integer. + * @return instance of Length, having value nearest to value of + * <code>length</code>, and divisible by <code>q</code>. + */ + private Length roundLength(Length length, int q) { + int x = Helper.round(length.getValue(), q); + return new FixedLength(x); + } + + /** + * @param length instance of Length. + * @param q integer. + * @return instance of Length, having minimal value, greater value of + * <code>length</code>, and divisible by <code>q</code>. + */ + private Length ceilLength(Length length, int q) { + int x = Helper.ceil(length.getValue(), q); + return new FixedLength(x); + } + + /** + * Modifies indent for given side. Summarizes value of indent and modifing + * error (i.e. overPatching). Rounds result to nearest integer, divisible by + * quantum. + * + * @param indent Length to modify. + * @param side an integer, representing side. + * @return modified Length. + */ + private Length modifyIndent(Length indent, int side) { + if (indent instanceof NumericProperty) { + overPatching[side] += lastOverPatching[side]; + } + int newValue = indent.getValue() + overPatching[side]; + newValue = Helper.round(newValue, quantum[side]); + return new FixedLength(newValue); + } + + /** + * Modifies Common Margin Properties-Block: + * <ul> + * <li>margin-top, margin-left, margin-bottom, margin-right + * <li>start-indent, end-indent + * <li>space-before, space-after. + * </ul> + * + * @param cmb instance of CommonMarginBlock to modify. + */ + private void modifyCommonMarginBlock(CommonMarginBlock cmb) { + cmb.marginTop = roundLength(cmb.marginTop, TXTRenderer.CHAR_HEIGHT); + cmb.marginBottom = roundLength(cmb.marginBottom, + TXTRenderer.CHAR_HEIGHT); + cmb.marginLeft = roundLength(cmb.marginLeft, TXTRenderer.CHAR_WIDTH); + cmb.marginRight = roundLength(cmb.marginRight, TXTRenderer.CHAR_WIDTH); + + modifySpace(cmb.spaceBefore, TXTRenderer.CHAR_HEIGHT); + modifySpace(cmb.spaceAfter, TXTRenderer.CHAR_HEIGHT); + + if (!(cmb.startIndent instanceof RelativeNumericProperty)) { + cmb.startIndent = modifyIndent(cmb.startIndent, + CommonBorderPaddingBackground.START); + } + if (!(cmb.endIndent instanceof RelativeNumericProperty)) { + cmb.endIndent = modifyIndent(cmb.endIndent, + CommonBorderPaddingBackground.END); + } + } + + /** + * Modifies fo:table attributes: + * <ul> + * <li>Common Margin Properties Block + * <li>Common Border, Padding, and Background Properties + * <li>columns. + * </ul> + * + * @param table Table to modify. + */ + private void modifyTable(Table table) { + CommonMarginBlock cmb = table.getCommonMarginBlock(); + if (table.getBorderCollapse() == Constants.EN_COLLAPSE) { + // If border-collapse == "collapse", add space-after in order to + // impove interaction with other FO. + int value = cmb.spaceAfter.getOptimum(null).getLength().getValue(); + value += TXTRenderer.CHAR_HEIGHT; + setMinOptMax(cmb.spaceAfter, new FixedLength(value)); + } + modifyCommonMarginBlock(cmb); + + modifyBPB(table.getCommonBorderPaddingBackground()); + + // modify all table-columns + List columnList = table.getColumns(); + Iterator iter = columnList.iterator(); + while (iter.hasNext()) { + modifyTableColumn((TableColumn) iter.next()); + } + } + + /** + * Modifies fo:table-column attributes: + * <ul> + * <li>width. + * </ul> + * + * @param column TableColumn to modify. + */ + private void modifyTableColumn(TableColumn column) { + column.setColumnWidth(ceilLength(column.getColumnWidth(), + TXTRenderer.CHAR_WIDTH)); + } + + /** + * Modifies padding of fo:table-cell. + * + * @param side side. + * @param bpb instance of CommonBorderPaddingBackground to modify. + */ + private void modifyCellPadding(int side, CommonBorderPaddingBackground bpb) { + if (bpb.getBorderInfo(side) == null) { + int oldPadding = bpb.getPadding(side, false, null); + int newPadding = oldPadding + quantum[side] / 2; + setLength(bpb.getPaddingLengthProperty(side), newPadding); + } + } + + /** + * Modifies table-cell properties: + * <ul> + * <li>Common Border, Padding, and Background Properties. + * </ul> + * + * @param c TableCell to modify. + */ + private void modifyTableCell(TableCell c) { + CommonBorderPaddingBackground bpb = c + .getCommonBorderPaddingBackground(); + modifyBPB(bpb); + modifyCellPadding(CommonBorderPaddingBackground.BEFORE, bpb); + modifyCellPadding(CommonBorderPaddingBackground.AFTER, bpb); + modifyCellPadding(CommonBorderPaddingBackground.START, bpb); + modifyCellPadding(CommonBorderPaddingBackground.END, bpb); + } + + /** + * Modifies Common Absolute Position Properties: + * <ul> + * <li>left + * <li>top. + * </ul> + * + * @param cap CommonAbsolutePosition to modify. + */ + private void modifyCommonAbsolutePosition(CommonAbsolutePosition cap) { + if (cap.absolutePosition == Constants.EN_ABSOLUTE) { + cap.left = roundLength(cap.left, TXTRenderer.CHAR_WIDTH); + cap.top = roundLength(cap.top, TXTRenderer.CHAR_HEIGHT); + } + } + + /** + * Modifies line-height property. Sets a value of line-height to max(char + * height; lowest integer, divisible by char height). + * + * @param lineHeight SpaceProperty to modify. + */ + private void modifyLineHeight(SpaceProperty lineHeight) { + Property p = lineHeight.getOptimum(null); + int value = p.getLength().getValue(CONTEXT); + + int height = TXTRenderer.CHAR_HEIGHT; + int newValue = Math.max(Helper.floor(value, height), height); + setMinOptMax(lineHeight, new FixedLength(newValue)); + } + + /** + * Modifies Common Font Properties: + * <ul> + * <li>font-family = Courier; + * <li>font-size = MODIFIED_FONT_SIZE; + * <li>font-stretch = EN_NORMAL; + * <li>font-weight = EN_NORMAL. + * </ul> + * + * @param cf the font to modify. + */ + private void modifyCommonFont(CommonFont cf) { + if (cf != null) { + cf.fontFamily = "Courier"; + cf.fontSize = new FixedLength(MODIFIED_FONT_SIZE); + cf.fontStretch = Constants.EN_NORMAL; + cf.fontWeight = Constants.EN_NORMAL; + } + } + + /** + * Modifies fo:block: + * <ul> + * <li>Common Border, Padding, and Background Properties + * <li>Common Margin Properties-Block + * <li>Common Font Properties + * <li>line-height. + * </ul> + * + * @param block Block to modify. + */ + private void modifyBlock(Block block) { + modifyBPB(block.getCommonBorderPaddingBackground()); + modifyCommonMarginBlock(block.getCommonMarginBlock()); + modifyCommonFont(block.getCommonFont()); + modifyLineHeight(block.getLineHeight()); + } + + /** + * Modifies fo:block-container: + * <ul> + * <li>Common Border, Padding, and Background Properties + * <li>Common Margin Properties-Block + * <li>Common Absolute Position Properties. + * </ul> + * + * @param bc BlockContainer to modify. + */ + private void modifyBlockContainer(BlockContainer bc) { + modifyBPB(bc.getCommonBorderPaddingBackground()); + modifyCommonMarginBlock(bc.getCommonMarginBlock()); + modifyCommonAbsolutePosition(bc.getCommonAbsolutePosition()); + } + + /** + * Modifies fo:inline: + * <ul> + * <li>Common Font Properties + * </ul> + * + * @param inline Inline to modify. + */ + private void modifyInline(Inline inline) { + modifyCommonFont(inline.getCommonFont()); + } + + /** + * Modifies FOText: + * <ul> + * <li>Common Font Properties + * </ul> + * + * @param text FOText to modify. + */ + private void modifyFOText(FOText text) { + modifyCommonFont(text.getCommonFont()); + } + + /** + * Modifies fo:external-graphic: + * <ul> + * <li>Common Border, Padding, and Background Properties + * <li>line-height. + * </ul> + * + * @param eg ExternalGraphic to modify. + */ + private void modifyExternalGraphic(ExternalGraphic eg) { + modifyBPB(eg.getCommonBorderPaddingBackground()); + modifyLineHeight(eg.getLineHeight()); + } + + /** + * Modifies fo:list-block: + * <ul> + * <li>Common Border, Padding, and Background Properties + * <li>Common Margin Properties-Block. + * </ul> + * + * @param lb ListBlock to modify. + */ + private void modifyListBlock(ListBlock lb) { + modifyBPB(lb.getCommonBorderPaddingBackground()); + modifyCommonMarginBlock(lb.getCommonMarginBlock()); + } + + /** + * Modifies fo:list-item: + * <ul> + * <li>Common Border, Padding, and Background Properties + * <li>Common Margin Properties-Block. + * </ul> + * <p> + * Make refinement for fo:list-item-label and fo:list-item-body. + * + * @param li ListItem to modify. + */ + private void modifyListItem(ListItem li) { + modifyBPB(li.getCommonBorderPaddingBackground()); + modifyCommonMarginBlock(li.getCommonMarginBlock()); + refinement(li.getLabel()); + refinement(li.getBody()); + } + + /** + * Does refinement for particular node. Modifies node's properties and + * refines its children recursively. + * + * @param node the node to refine. + */ + private void refinement(FONode node) { + int[] saveOverPatching = (int[]) overPatching.clone(); + Arrays.fill(lastOverPatching, 0); + + if (node instanceof Block) { + modifyBlock((Block) node); + } else if (node instanceof BlockContainer) { + modifyBlockContainer((BlockContainer) node); + } else if (node instanceof Inline) { + modifyInline((Inline) node); + } else if (node instanceof FOText) { + modifyFOText((FOText) node); + } else if (node instanceof Table) { + modifyTable((Table) node); + Arrays.fill(overPatching, 0); + } else if (node instanceof TableCell) { + modifyTableCell((TableCell) node); + } else if (node instanceof ExternalGraphic) { + modifyExternalGraphic((ExternalGraphic) node); + } else if (node instanceof ListBlock) { + modifyListBlock((ListBlock) node); + } else if (node instanceof ListItem) { + modifyListItem((ListItem) node); + } else if (node instanceof PageNumber) { + modifyCommonFont(((PageNumber) node).getCommonFont()); + } + + Iterator it = node.getChildNodes(); + if (it != null) { + while (it.hasNext()) { + refinement((FONode) it.next()); + } + } + overPatching = saveOverPatching; + } + + /** + * Run refinement for: + * <ul> + * <li>mainflow (xsl-region-body) + * <li>staticflow (xsl-region-before, xsl-region-after, xsl-region-start, + * xsl-region-end). + * </ul> + * + * @param pageSequence PageSequence to refine. + */ + public void endPageSequence(PageSequence pageSequence) { + Arrays.fill(overPatching, 0); + + refinement(pageSequence.getMainFlow()); + + if (pageSequence.getStaticContent("xsl-region-before") != null) { + refinement(pageSequence.getStaticContent("xsl-region-before")); + } + if (pageSequence.getStaticContent("xsl-region-after") != null) { + refinement(pageSequence.getStaticContent("xsl-region-after")); + } + if (pageSequence.getStaticContent("xsl-region-start") != null) { + refinement(pageSequence.getStaticContent("xsl-region-start")); + } + if (pageSequence.getStaticContent("xsl-region-end") != null) { + refinement(pageSequence.getStaticContent("xsl-region-end")); + } + + super.endPageSequence(pageSequence); + } +} diff --git a/src/java/org/apache/fop/render/txt/TXTRenderer.java b/src/java/org/apache/fop/render/txt/TXTRenderer.java index 0f9dda7fa..a06c815ea 100644 --- a/src/java/org/apache/fop/render/txt/TXTRenderer.java +++ b/src/java/org/apache/fop/render/txt/TXTRenderer.java @@ -18,122 +18,530 @@ package org.apache.fop.render.txt; -// FOP -import org.apache.fop.render.PrintRenderer; -import org.apache.fop.render.pcl.PCLStream; +import java.awt.Point; +import java.awt.geom.Rectangle2D; +import java.io.IOException; +import java.io.OutputStream; +import java.util.List; + +import org.apache.fop.apps.FOPException; +import org.apache.fop.area.Area; +import org.apache.fop.area.CTM; +import org.apache.fop.area.PageViewport; +import org.apache.fop.area.inline.Image; +import org.apache.fop.area.inline.TextArea; +import org.apache.fop.datatypes.ColorType; +import org.apache.fop.render.AbstractPathOrientedRenderer; +import org.apache.fop.render.txt.border.AbstractBorderElement; +import org.apache.fop.render.txt.border.BorderManager; /** - * Renderer that renders areas to plain text - * - * Created by Arthur E Welch III while at M&I EastPoint Technology - * Modified by Mark Lillywhite mark-fop@inomial.com to use the new - * Renderer interface. + * Renderer that renders areas to plain text. + * + * @author Art Welch + * @author <a href="mailto:mark-fop@inomial.com">Mark Lillywhite</a> (to use + * the new Renderer interface) */ -public class TXTRenderer extends PrintRenderer { +public class TXTRenderer extends AbstractPathOrientedRenderer { + + private static final char LIGHT_SHADE = '\u2591'; + + private static final char MEDIUM_SHADE = '\u2592'; + + private static final char DARK_SHADE = '\u2593'; - /** The MIME type for PostScript */ - public static final String MIME_TYPE = "text/plain"; + private static final char FULL_BLOCK = '\u2588'; - /** - * the current stream to add Text commands to - */ - private PCLStream currentStream; + private static final char IMAGE_CHAR = '#'; - private int pageHeight = 7920; + /**The stream for output */ + private OutputStream outputStream; - // These variables control the virtual paggination functionality. - private int curdiv = 0; - private int divisions = -1; - private int paperheight = -1; // Paper height in decipoints? - private int orientation = -1; // -1=default/unknown, 0=portrait, 1=landscape. - private int topmargin = -1; // Top margin in decipoints? - private int leftmargin = -1; // Left margin in decipoints? - private int fullmargin = 0; - private final boolean debug = false; + /** The current stream to add Text commands to. */ + private TXTStream currentStream; - // Variables for rendering text. - private StringBuffer charData[]; - private StringBuffer decoData[]; - private float textCPI = 16.67f; - private float textLPI = 8; - private int maxX = (int)(8.5f * textCPI + 1); - private int maxY = (int)(11f * textLPI + 1); - private float xFactor; - private float yFactor; - /** - * Every line except the last line on a page (which will end with + /** Buffer for text. */ + private StringBuffer[] charData; + + /** Buffer for background and images. */ + private StringBuffer[] decoData; + + /** Height of one symbol in Courier font size of 10pt. */ + public static final int CHAR_HEIGHT = 7860; + + /** Width of one symbol in Courier font size of 10pt. */ + public static final int CHAR_WIDTH = 6000; + + /** Current processing page width. */ + private int pageWidth; + + /** Current processing page height. */ + private int pageHeight; + + /** + * Every line except the last line on a page (which will end with * pageEnding) will be terminated with this string. */ private String lineEnding = "\r\n"; - /** - * Every page except the last one will end with this string. - */ + + /** Every page except the last one will end with this string. */ private String pageEnding = "\f"; + + /** Equals true, if current page is first. */ + private boolean firstPage = false; + + /** Manager for storing border's information. */ + private BorderManager bm; + + /** Char for current filling. */ + private char fillChar; + + /** Saves current coordinate transformation. */ + private TXTState currentState = new TXTState(); + /** - * If true then graphics/decorations will not be rendered - text only. + * Constructs a newly allocated <code>TXTRenderer</code> object. */ - private boolean suppressGraphics = false; - private boolean firstPage = false; + public TXTRenderer() { + } - private void addStr(int row, int col, String str, boolean ischar) { - if (debug) { - log.debug("TXTRenderer.addStr(" + row + ", " + col - + ", \"" + str + "\", " + ischar + ")"); - } - if (suppressGraphics && !ischar) { - return; + /** + * Indicates if point (x, y) lay inside currentPage. + * + * @param x x coordinate + * @param y y coordinate + * @return <b>true</b> if point lay inside page + */ + public boolean isLayInside(int x, int y) { + return (x >= 0) && (x < pageWidth) && (y >= 0) && (y < pageHeight); + } + + /** + * Add char to text buffer. + * + * @param x x coordinate + * @param y y coordinate + * @param ch char to add + * @param ischar boolean, repersenting is character adding to text buffer + */ + protected void addChar(int x, int y, char ch, boolean ischar) { + Point point = currentState.transformPoint(x, y); + putChar(point.x, point.y, ch, ischar); + } + + /** + * Add char to text or background buffer. + * + * @param x x coordinate + * @param y x coordinate + * @param ch char to add + * @param ischar indicates if it char or background + */ + protected void putChar(int x, int y, char ch, boolean ischar) { + if (isLayInside(x, y)) { + StringBuffer sb = ischar ? charData[y] : decoData[y]; + while (sb.length() <= x) { + sb.append(' '); + } + sb.setCharAt(x, ch); } - StringBuffer sb; - if (row < 0) { - row = 0; + } + + /** + * Adds string to text buffer (<code>charData</code>). <p> + * Chars of string map in turn. + * + * @param row x coordinate + * @param col y coordinate + * @param s string to add + */ + protected void addString(int row, int col, String s) { + for (int l = 0; l < s.length(); l++) { + addChar(col + l, row, s.charAt(l), true); } - if (ischar) { - sb = charData[row]; + } + + /** + * Render TextArea to Text. + * + * @param area inline area to render + */ + protected void renderText(TextArea area) { + int col = Helper.ceilPosition(this.currentIPPosition, CHAR_WIDTH); + int row = Helper.ceilPosition(this.currentBPPosition, CHAR_HEIGHT); + + String s = area.getText(); + + addString(row, col, s); + + super.renderText(area); + } + + /** + * @see org.apache.fop.render.Renderer#renderPage(PageViewport) + */ + public void renderPage(PageViewport page) throws IOException, FOPException { + if (firstPage) { + firstPage = false; } else { - sb = decoData[row]; + currentStream.add(pageEnding); } - if (sb == null) { - sb = new StringBuffer(); + + Rectangle2D bounds = page.getViewArea(); + double width = bounds.getWidth(); + double height = bounds.getHeight(); + + pageWidth = Helper.ceilPosition((int) width, CHAR_WIDTH); + pageHeight = Helper.ceilPosition((int) height, CHAR_HEIGHT); + + // init buffers + charData = new StringBuffer[pageHeight]; + decoData = new StringBuffer[pageHeight]; + for (int i = 0; i < pageHeight; i++) { + charData[i] = new StringBuffer(); + decoData[i] = new StringBuffer(); } - if ((col + str.length()) > maxX) { - col = maxX - str.length(); + + bm = new BorderManager(pageWidth, pageHeight, currentState); + + super.renderPage(page); + + flushBorderToBuffer(); + flushBuffer(); + } + + /** + * Projects current page borders (i.e.<code>bm</code>) to buffer for + * background and images (i.e.<code>decoData</code>). + */ + private void flushBorderToBuffer() { + for (int x = 0; x < pageWidth; x++) { + for (int y = 0; y < pageHeight; y++) { + Character c = bm.getCharacter(x, y); + if (c != null) { + putChar(x, y, c.charValue(), false); + } + } } - if (col < 0) { - col = 0; - if (str.length() > maxX) { - str = str.substring(0, maxX); + } + + /** + * Write out the buffer to output stream. + */ + private void flushBuffer() { + for (int row = 0; row < pageHeight; row++) { + StringBuffer cr = charData[row]; + StringBuffer dr = decoData[row]; + StringBuffer outr = null; + + if (cr != null && dr == null) { + outr = cr; + } else if (dr != null && cr == null) { + outr = dr; + } else if (cr != null && dr != null) { + int len = dr.length(); + if (cr.length() > len) { + len = cr.length(); + } + outr = new StringBuffer(); + for (int countr = 0; countr < len; countr++) { + if (countr < cr.length() && cr.charAt(countr) != ' ') { + outr.append(cr.charAt(countr)); + } else if (countr < dr.length()) { + outr.append(dr.charAt(countr)); + } else { + outr.append(' '); + } + } + } + + if (outr != null) { + currentStream.add(outr.toString()); + } + if (row < pageHeight) { + currentStream.add(lineEnding); } } - // Pad to col - for (int countr = sb.length(); countr < col; countr++) { - sb.append(' '); + } + + /** + * @see org.apache.fop.render.Renderer#startRenderer(java.io.OutputStream) + */ + public void startRenderer(OutputStream os) throws IOException { + log.info("Rendering areas to TEXT."); + this.outputStream = os; + currentStream = new TXTStream(os); + firstPage = true; + } + + /** + * @see org.apache.fop.render.Renderer#stopRenderer() + */ + public void stopRenderer() throws IOException { + log.info("writing out TEXT"); + outputStream.flush(); + super.stopRenderer(); + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void restoreStateStackAfterBreakOut(List breakOutList) { + } + + /** + * Does nothing. + * @return null + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected List breakOutOfStateStack() { + return null; + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void saveGraphicsState() { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void restoreGraphicsState() { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void beginTextObject() { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void endTextObject() { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void clip() { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void clipRect(float x, float y, float width, float height) { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void moveTo(float x, float y) { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void lineTo(float x, float y) { + } + + /** + * Does nothing. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void closePath() { + } + + /** + * Fills rectangle startX, startY, width, height with char + * <code>charToFill</code>. + * + * @param startX x-coordinate of upper left point + * @param startY y-coordinate of upper left point + * @param width width of rectangle + * @param height height of rectangle + * @param charToFill filling char + */ + private void fillRect(int startX, int startY, int width, int height, + char charToFill) { + for (int x = startX; x < startX + width; x++) { + for (int y = startY; y < startY + height; y++) { + addChar(x, y, charToFill, false); + } + } + } + + /** + * Fills a rectangular area with the current filling char. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void fillRect(float x, float y, float width, float height) { + fillRect(bm.getStartX(), bm.getStartY(), bm.getWidth(), bm.getHeight(), + fillChar); + } + + /** + * Changes current filling char. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void updateColor(ColorType col, boolean fill) { + if (col == null) { + return; } - if (debug) { - log.debug("TXTRenderer.addStr() sb.length()=" - + sb.length()); + // fillShade evaluation was taken from fop-0.20.5 + double fillShade = 0.30f * col.getRed() + + 0.59f * col.getGreen() + + 0.11f * col.getBlue(); + fillShade = 1 - fillShade; + + if (fillShade > 0.8f) { + fillChar = FULL_BLOCK; + } else if (fillShade > 0.6f) { + fillChar = DARK_SHADE; + } else if (fillShade > 0.4f) { + fillChar = MEDIUM_SHADE; + } else if (fillShade > 0.2f) { + fillChar = LIGHT_SHADE; + } else { + fillChar = ' '; } - for (int countr = col; countr < (col + str.length()); countr++) { - if (countr >= sb.length()) { - sb.append(str.charAt(countr - col)); - } else { - if (debug) { - log.debug("TXTRenderer.addStr() sb.length()=" - + sb.length() + " countr=" + countr); - } - sb.setCharAt(countr, str.charAt(countr - col)); - } + } + + /** + * Does nothing. + * @param url String + * @param pos Rectangle2D + */ + protected void drawImage(String url, Rectangle2D pos) { + } + + /** + * Fills image rectangle with a <code>IMAGE_CHAR</code>. + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + public void renderImage(Image image, Rectangle2D pos) { + int x1 = Helper.ceilPosition(currentIPPosition, CHAR_WIDTH); + int y1 = Helper.ceilPosition(currentBPPosition, CHAR_HEIGHT); + int width = Helper.ceilPosition((int) pos.getWidth(), CHAR_WIDTH); + int height = Helper.ceilPosition((int) pos.getHeight(), CHAR_HEIGHT); + + fillRect(x1, y1, width, height, IMAGE_CHAR); + } + + + /** + * Returns the closest integer to the multiplication of a number and 1000. + * + * @param x the value of the argument, multiplied by + * 1000 and rounded + * @return the value of the argument multiplied by + * 1000 and rounded to the nearest integer + */ + protected int toMilli(float x) { + return Math.round(x * 1000f); + } + + /** + * Adds one element of border. + * + * @param x x coordinate + * @param y y coordinate + * @param style integer, representing border style + * @param type integer, representing border element type + */ + private void addBitOfBorder(int x, int y, int style, int type) { + Point point = currentState.transformPoint(x, y); + if (isLayInside(point.x, point.y)) { + bm.addBorderElement(point.x, point.y, style, type); } + } + + /** + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void drawBorderLine(float x1, float y1, float x2, float y2, + boolean horz, boolean startOrBefore, int style, ColorType col) { - if (ischar) { - charData[row] = sb; + int borderHeight = bm.getHeight(); + int borderWidth = bm.getWidth(); + int borderStartX = bm.getStartX(); + int borderStartY = bm.getStartY(); + + int x, y; + if (horz && startOrBefore) { // BEFORE + x = borderStartX; + y = borderStartY; + } else if (horz && !startOrBefore) { // AFTER + x = borderStartX; + y = borderStartY + borderHeight - 1; + } else if (!horz && startOrBefore) { // START + x = borderStartX; + y = borderStartY; + } else { // END + x = borderStartX + borderWidth - 1; + y = borderStartY; + } + + int dx, dy, length, startType, endType; + if (horz) { + length = borderWidth; + dx = 1; + dy = 0; + startType = 1 << AbstractBorderElement.RIGHT; + endType = 1 << AbstractBorderElement.LEFT; } else { - decoData[row] = sb; + length = borderHeight; + dx = 0; + dy = 1; + startType = 1 << AbstractBorderElement.DOWN; + endType = 1 << AbstractBorderElement.UP; + } + + addBitOfBorder(x, y, style, startType); + for (int i = 0; i < length - 2; i++) { + x += dx; + y += dy; + addBitOfBorder(x, y, style, startType + endType); } + x += dx; + y += dy; + addBitOfBorder(x, y, style, endType); } - /** @see org.apache.fop.render.AbstractRenderer */ - public String getMimeType() { - return MIME_TYPE; + /** + * @see org.apache.fop.render.AbstractPathOrientedRenderer + */ + protected void drawBackAndBorders(Area area, float startx, float starty, + float width, float height) { + bm.setWidth(Helper.ceilPosition(toMilli(width), CHAR_WIDTH)); + bm.setHeight(Helper.ceilPosition(toMilli(height), CHAR_HEIGHT)); + bm.setStartX(Helper.ceilPosition(toMilli(startx), CHAR_WIDTH)); + bm.setStartY(Helper.ceilPosition(toMilli(starty), CHAR_HEIGHT)); + + super.drawBackAndBorders(area, startx, starty, width, height); + } + + /** + * @see org.apache.fop.render.AbstractRenderer#startVParea(CTM) + */ + protected void startVParea(CTM ctm) { + currentState.push(ctm); } + /** + * @see org.apache.fop.render.AbstractRenderer#endVParea() + */ + protected void endVParea() { + currentState.pop(); + } } diff --git a/src/java/org/apache/fop/render/txt/TXTState.java b/src/java/org/apache/fop/render/txt/TXTState.java new file mode 100644 index 000000000..b63f04922 --- /dev/null +++ b/src/java/org/apache/fop/render/txt/TXTState.java @@ -0,0 +1,137 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt; + +import java.awt.Point; +import java.awt.geom.Rectangle2D; +import java.util.Iterator; +import java.util.LinkedList; + +import org.apache.fop.area.CTM; + +/** + * This keeps information about the current state when writing to txt, i.e. + * manages coordinate transformation matrices for getting absolute coordinates. + */ +public class TXTState { + + /** Keeps all coordinate transformation matrices during rendering. */ + private LinkedList stackCTM = new LinkedList(); + + /** + * Current result coordinate transformation matrix. It's product of + * all matrices in order, saved in <code>stackCTM</code>. + */ + private CTM resultCTM = new CTM(); + + /** + * Constructs a newly allocated <code>TXTState</code> object. + */ + public TXTState() { + } + + /** + * Updates result coordinate transformation matrix + * (i.e. <code>resultCTM</code>), multipliing it by given matrix. + * + * @param ctm CTM + */ + private void updateResultCTM(CTM ctm) { + resultCTM = resultCTM.multiply(ctm); + } + + /** + * Recalculate current result coordinate transformation matrix. + */ + private void calcResultCTM() { + resultCTM = new CTM(); + for (Iterator i = stackCTM.iterator(); i.hasNext();) { + updateResultCTM((CTM) i.next()); + } + } + + /** + * Push the current coordinate transformation matrix onto the stack and + * reevaluate <code>resultCTM</code>. + * + * @param ctm instance of CTM + */ + public void push(CTM ctm) { + stackCTM.addLast(ctm); + updateResultCTM(ctm); + } + + /** + * Pop the coordinate transformation matrix from the stack and reevaluate + * <code>resultCTM</code>. + */ + public void pop() { + stackCTM.removeLast(); + calcResultCTM(); + } + + /** + * Modifies coordinate transformation matrix in such a way, so + * x-shift and y-shift will be transformed in text positions. + * + * @param ctm CTM to modify + * @return instance of CTM + */ + public CTM refineCTM(CTM ctm) { + double[] da = ctm.toArray(); + // refine x-shift + da[4] = Helper.roundPosition((int) da[4], TXTRenderer.CHAR_WIDTH); + // refine y-shift + da[5] = Helper.roundPosition((int) da[5], TXTRenderer.CHAR_HEIGHT); + + return new CTM(da[0], da[1], da[2], da[3], da[4], da[5]); + } + + /** + * Transforms <code>point</code> using <code>ctm</code>. + * + * @param p Point + * @param ctm CTM + * @return transformed Point + */ + public Point transformPoint(Point p, CTM ctm) { + Rectangle2D r = new Rectangle2D.Double(p.x, p.y, 0, 0); + CTM nctm = refineCTM(ctm); + r = nctm.transform(r); + return new Point((int) r.getX(), (int) r.getY()); + } + + /** + * Transforms point (x, y) using <code>resultCTM</code>. + * + * @param x x-coordinate + * @param y y-coordinate + * @return transformed Point + */ + public Point transformPoint(int x, int y) { + return transformPoint(new Point(x, y), resultCTM); + } + + /** + * @return current result coordinate transformation matrix + */ + public CTM getResultCTM() { + return resultCTM; + } +} diff --git a/src/java/org/apache/fop/render/txt/TXTStream.java b/src/java/org/apache/fop/render/txt/TXTStream.java index df38cd10e..f3dc9e194 100644 --- a/src/java/org/apache/fop/render/txt/TXTStream.java +++ b/src/java/org/apache/fop/render/txt/TXTStream.java @@ -1,5 +1,5 @@ /* - * Copyright 1999-2004 The Apache Software Foundation. + * Copyright 1999-2005 The Apache Software Foundation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -47,7 +47,7 @@ public class TXTStream { } try { - byte buff[] = str.getBytes("UTF-8"); + byte[] buff = str.getBytes("UTF-8"); out.write(buff); } catch (IOException e) { throw new RuntimeException(e.toString()); diff --git a/src/java/org/apache/fop/render/txt/border/AbstractBorderElement.java b/src/java/org/apache/fop/render/txt/border/AbstractBorderElement.java new file mode 100644 index 000000000..d02a8da1b --- /dev/null +++ b/src/java/org/apache/fop/render/txt/border/AbstractBorderElement.java @@ -0,0 +1,148 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt.border; + +import java.awt.Point; +import java.util.Arrays; + +import org.apache.fop.area.CTM; +import org.apache.fop.fo.Constants; +import org.apache.fop.render.txt.TXTState; + +/** + * This class keeps information about abstract border element, i.e. specifies + * border element for one text position. + */ +public abstract class AbstractBorderElement implements Constants { + + /** + * Constant for a line segment, directing from a center of symbol up + * the the symbol boundary. + */ + public static final int UP = 0; + + /** + * Constant for a line segment, directing from a center of symbol right + * the the symbol boundary. + */ + public static final int RIGHT = 1; + + /** + * Constant for a line segment, directing from a center of symbol down + * the the symbol boundary. + */ + public static final int DOWN = 2; + + /** + * Constant for a line segment, directing from a center of symbol left + * the the symbol boundary. + */ + public static final int LEFT = 3; + + /** + * I-th element of this array specify, if there line from center of symbol + * to corresponding side (UP, RIGHT, DOWN, LEFT). + */ + protected int[] data = {0, 0, 0, 0}; + + /** + * Initializes a newly created <code>AbstractBorderElement</code> object + * so that it represents an empty border element. + */ + public AbstractBorderElement() { + } + + /** + * Constructs a newly allocated <code>AbstractBorderElement</code> object. + * Fills array <code>data</code> using binary representation of + * <code>type</code>. + * + * @param type binary representation of type gives <code>data</code> + */ + public AbstractBorderElement(int type) { + for (int i = 0; i < 4; i++) { + data[i] = (type >> i) & 1; + } + } + + /** + * Returns value of side's element of <code>data</code>. + * + * @param side integer, representing side + * @return value of side's element + */ + public int getData(int side) { + return data[side]; + } + + /** + * Sets a value for <code>data[side]</code>. + * + * @param side integer, representing side + * @param value a new value for <code>data[side]</code> + */ + public void setData(int side, int value) { + data[side] = value; + } + + /** + * Transform border element in according with <code>state</code>. + * @param state instance of TXTState + */ + public void transformElement(TXTState state) { + // here we'll get CTM^-1 without shift + double[] da = state.getResultCTM().toArray(); + CTM ctm = new CTM(da[0], -da[1], -da[2], da[3], 0, 0); + + Point[] pa = new Point[4]; + pa[0] = new Point(0, data[UP]); + pa[1] = new Point(data[RIGHT], 0); + pa[2] = new Point(0, -data[DOWN]); + pa[3] = new Point(-data[LEFT], 0); + + Arrays.fill(data, 0); + for (int i = 0; i < 4; i++) { + Point p = state.transformPoint(pa[i], ctm); + + int length = (int) p.distance(0, 0); + if (p.x == 0 && p.y > 0) { + data[UP] = length; + } else if (p.x == 0 && p.y < 0) { + data[DOWN] = length; + } else if (p.x > 0 && p.y == 0) { + data[RIGHT] = length; + } else if (p.x < 0 && p.y == 0) { + data[LEFT] = length; + } + } + } + + /** + * Merges with border element. + * @param e instance of AbstractBorderElement + * @return instance of AbstractBorderElement + */ + public abstract AbstractBorderElement merge(AbstractBorderElement e); + + /** + * Convert internal representation of border element to char. + * @return corresponding char + */ + public abstract char convert2Char(); +} diff --git a/src/java/org/apache/fop/render/txt/border/BorderManager.java b/src/java/org/apache/fop/render/txt/border/BorderManager.java new file mode 100644 index 000000000..2e20d0cd3 --- /dev/null +++ b/src/java/org/apache/fop/render/txt/border/BorderManager.java @@ -0,0 +1,164 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt.border; + +import org.apache.fop.fo.Constants; +import org.apache.fop.render.txt.TXTState; + +/** + * This keeps all information about borders for current processed page. + */ +public class BorderManager { + + /** Matrix for storing information about one border element. */ + private AbstractBorderElement[][] borderInfo; + + /** Width of current processed border. */ + private int width; + + /** Height of current processed border. */ + private int height; + + /** x-coordinate of upper left point of current processed border. */ + private int startX; + + /** y-coordinate of upper left point of current processed border. */ + private int startY; + + /** Stores TXTState for transforming border elements. */ + private TXTState state; + + /** + * Constructs BorderManger, using <code>pageWidth</code> and + * <code>pageHeight</code> for creating <code>borderInfo</code>. + * + * @param pageWidth page width + * @param pageHeight page height + * @param state TXTState + */ + public BorderManager(int pageWidth, int pageHeight, TXTState state) { + this.state = state; + borderInfo = new AbstractBorderElement[pageHeight][pageWidth]; + } + + /** + * Adds border element to <code>borderInfo</code>. + * + * @param x x-coordinate + * @param y y-coordinate + * @param style border-style + * @param type border element type, binary representation of wich gives + * information about availability or absence of corresponding side. + */ + public void addBorderElement(int x, int y, int style, int type) { + AbstractBorderElement be = null; + + if (style == Constants.EN_SOLID || style == Constants.EN_DOUBLE) { + be = new SolidAndDoubleBorderElement(style, type); + } else if (style == Constants.EN_DOTTED) { + be = new DottedBorderElement(); + } else if (style == Constants.EN_DASHED) { + be = new DashedBorderElement(type); + } else { + return; + } + be.transformElement(state); + + if (borderInfo[y][x] != null) { + borderInfo[y][x] = borderInfo[y][x].merge(be); + } else { + borderInfo[y][x] = be; + } + } + + /** + * @param x x-coordinate + * @param y y-coordinate + * @return if border element at point (x,y) is available, returns instance + * of Character, created on char, given by corresponding border element, + * otherwise returns null. + */ + public Character getCharacter(int x, int y) { + Character c = null; + if (borderInfo[y][x] != null) { + c = new Character(borderInfo[y][x].convert2Char()); + } + return c; + } + + /** + * @return width of current processed border. + */ + public int getWidth() { + return width; + } + + /** + * Sets width of current processed border. + * @param width width of border + */ + public void setWidth(int width) { + this.width = width; + } + + /** + * @return height of current processed border. + */ + public int getHeight() { + return height; + } + + /** + * Sets height of current processed border. + * @param height height of border + */ + public void setHeight(int height) { + this.height = height; + } + + /** + * @return x-coordinate of upper left point of current processed border. + */ + public int getStartX() { + return startX; + } + + /** + * Sets x-coordinate of upper left point of current processed border. + * @param startX x-coordinate of upper left border's point. + */ + public void setStartX(int startX) { + this.startX = startX; + } + + /** + * @return y-coordinate of upper left point of current processed border. + */ + public int getStartY() { + return startY; + } + + /** + * Sets y-coordinate of upper left point of current processed border. + * @param startY y-coordinate of upper left border's point. + */ + public void setStartY(int startY) { + this.startY = startY; + } +} diff --git a/src/java/org/apache/fop/render/txt/border/DashedBorderElement.java b/src/java/org/apache/fop/render/txt/border/DashedBorderElement.java new file mode 100644 index 000000000..7e7aa7acd --- /dev/null +++ b/src/java/org/apache/fop/render/txt/border/DashedBorderElement.java @@ -0,0 +1,141 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt.border; + +import java.util.Arrays; + +/** + * This class is responsible for managing of dashed border elements. + */ +public class DashedBorderElement extends AbstractBorderElement { + + private static final char DASH_HORIZONTAL = '-'; + + private static final char DASH_VERTICAL = '|'; + + private static final char UNDEFINED = '?'; + + private static final int UP2 = 1; + + private static final int RIGHT2 = 2; + + private static final int DOWN2 = 4; + + private static final int LEFT2 = 8; + + private static char[] map = new char[20]; + + static { + Arrays.fill(map, UNDEFINED); + map[0] = ' '; + map[UP2] = DASH_VERTICAL; + map[DOWN2] = DASH_VERTICAL; + map[UP2 + DOWN2] = DASH_VERTICAL; + + map[LEFT2] = DASH_HORIZONTAL; + map[RIGHT2] = DASH_HORIZONTAL; + map[LEFT2 + RIGHT2] = DASH_HORIZONTAL; + } + + /** + * Constructs a newly allocated <code>DashedBorderElement</code> object. + * Fills <code>data</code> using superclass constructor. + * + * @param type binary representation of type gives <code>data</code> + */ + public DashedBorderElement(int type) { + super(type); + } + + /** + * Merges dashed border element with instance of solid and double border + * element, returns instance of <code>SolidAndDoubleBorderElement</code>. + * + * @param sdb instance of <code>SolidAndDoubleBorderElement</code> to merge + * @return merged border element + */ + private AbstractBorderElement mergeSolid(SolidAndDoubleBorderElement sdb) { + AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0); + for (int i = 0; i < 4; i++) { + e.setData(i, Math.max(data[i], sdb.getData(i))); + } + return e; + } + + /** + * Merges dashed border element with dashed border element and returns + * instance of <code>DashedBorderElement</code>. + * + * @param dbe instance of <code>DashedBorderElement</code> to merge + * @return merged border element + */ + private AbstractBorderElement mergeDashed(DashedBorderElement dbe) { + for (int i = 0; i < 4; i++) { + data[i] = Math.max(data[i], dbe.getData(i)); + } + return this; + } + + /** + * Converts dashed border element to + * <code>SolidAndDoubleBorderElement</code>. + * + * @return converted instance of <code>SolidAndDoubleBorderElement</code> + */ + private AbstractBorderElement toSolidAndDouble() { + AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0); + for (int i = 0; i < 4; i++) { + e.setData(i, data[i]); + } + return e; + } + + /** + * Merges with border element. + * @param e instance of AbstractBorderElement + * @return instance of AbstractBorderElement + */ + public AbstractBorderElement merge(AbstractBorderElement e) { + AbstractBorderElement abe = this; + if (e instanceof SolidAndDoubleBorderElement) { + abe = mergeSolid((SolidAndDoubleBorderElement) e); + } else if (e instanceof DashedBorderElement) { + abe = mergeDashed((DashedBorderElement) e); + } else { + abe = e; + } + return abe; + } + + /** + * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char() + */ + public char convert2Char() { + int key = 0; + key += data[UP] * UP2; + key += data[DOWN] * DOWN2; + key += data[LEFT] * LEFT2; + key += data[RIGHT] * RIGHT2; + char ch = map[key]; + if (ch == UNDEFINED) { + ch = toSolidAndDouble().convert2Char(); + } + return ch; + } +} diff --git a/src/java/org/apache/fop/render/txt/border/DottedBorderElement.java b/src/java/org/apache/fop/render/txt/border/DottedBorderElement.java new file mode 100644 index 000000000..8e693974b --- /dev/null +++ b/src/java/org/apache/fop/render/txt/border/DottedBorderElement.java @@ -0,0 +1,45 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt.border; + +/** + * This class is responsible for managing of dotted border elements. + */ +public class DottedBorderElement extends AbstractBorderElement { + + private static final char MIDDLE_DOT = '\u00B7'; + + /** + * Merges dotted border element with another border element. Here merging + * is quite simple: returning <code>this</code> without any comparing. + * + * @param e instance of AbstractBorderElement + * @return instance of DottedBorderElement + */ + public AbstractBorderElement merge(AbstractBorderElement e) { + return this; + } + + /** + * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char() + */ + public char convert2Char() { + return MIDDLE_DOT; + } +} diff --git a/src/java/org/apache/fop/render/txt/border/SolidAndDoubleBorderElement.java b/src/java/org/apache/fop/render/txt/border/SolidAndDoubleBorderElement.java new file mode 100644 index 000000000..72ca9d2dc --- /dev/null +++ b/src/java/org/apache/fop/render/txt/border/SolidAndDoubleBorderElement.java @@ -0,0 +1,276 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.txt.border; + +import java.util.Arrays; + +/** + * This class is responsible for solid and double border elements managing. + */ +public class SolidAndDoubleBorderElement extends AbstractBorderElement { + + private static final char LIGHT_HORIZONTAL = '\u2500'; + + private static final char LIGHT_VERTICAL = '\u2502'; + + private static final char LIGHT_DOWN_AND_RIGHT = '\u250C'; + + private static final char LIGHT_DOWN_AND_LEFT = '\u2510'; + + private static final char LIGHT_UP_AND_RIGHT = '\u2514'; + + private static final char LIGHT_UP_AND_LEFT = '\u2518'; + + private static final char LIGHT_VERTICAL_AND_RIGHT = '\u251C'; + + private static final char LIGHT_VERTICAL_AND_LEFT = '\u2524'; + + private static final char LIGHT_DOWN_AND_HORIZONTAL = '\u252C'; + + private static final char LIGHT_UP_AND_HORIZONTAL = '\u2534'; + + private static final char LIGHT_VERTICAL_AND_HORIZONTAL = '\u253C'; + + private static final char DOUBLE_HORIZONTAL = '\u2550'; + + private static final char DOUBLE_VERTICAL = '\u2551'; + + private static final char DOUBLE_DOWN_AND_RIGHT = '\u2554'; + + private static final char DOUBLE_DOWN_AND_LEFT = '\u2557'; + + private static final char DOUBLE_UP_AND_RIGHT = '\u255A'; + + private static final char DOUBLE_UP_AND_LEFT = '\u255D'; + + private static final char DOUBLE_VERTICAL_AND_RIGHT = '\u2560'; + + private static final char DOUBLE_VERTICAL_AND_LEFT = '\u2563'; + + private static final char DOUBLE_DOWN_AND_HORIZONTAL = '\u2566'; + + private static final char DOUBLE_UP_AND_HORIZONTAL = '\u2569'; + + private static final char DOUBLE_VERTICAL_AND_HORIZONTAL = '\u256C'; + + private static final char DOWN_SINGLE_AND_RIGHT_DOUBLE = '\u2552'; + + private static final char DOWN_DOUBLE_AND_RIGHT_SINGLE = '\u2553'; + + private static final char DOWN_SINGLE_AND_LEFT_DOUBLE = '\u2555'; + + private static final char DOWN_DOUBLE_AND_LEFT_SINGLE = '\u2556'; + + private static final char UP_SINGLE_AND_RIGHT_DOUBLE = '\u2558'; + + private static final char UP_DOUBLE_AND_RIGHT_SINGLE = '\u2559'; + + private static final char UP_SINGLE_AND_LEFT_DOUBLE = '\u255B'; + + private static final char UP_DOUBLE_AND_LEFT_SINGLE = '\u255C'; + + private static final char VERTICAL_SINGLE_AND_RIGHT_DOUBLE = '\u255E'; + + private static final char VERTICAL_DOUBLE_AND_RIGHT_SINGLE = '\u255F'; + + private static final char VERTICAL_SINGLE_AND_LEFT_DOUBLE = '\u2561'; + + private static final char VERTICAL_DOUBLE_AND_LEFT_SINGLE = '\u2562'; + + private static final char DOWN_SINGLE_AND_HORIZONTAL_DOUBLE = '\u2564'; + + private static final char DOWN_DOUBLE_AND_HORIZONTAL_SINGLE = '\u2565'; + + private static final char UP_SINGLE_AND_HORIZONTAL_DOUBLE = '\u2567'; + + private static final char UP_DOUBLE_AND_HORIZONTAL_SINGLE = '\u2568'; + + private static final char VERTICAL_SINGLE_AND_HORIZONTAL_DOUBLE = '\u256A'; + + private static final char VERTICAL_DOUBLE_AND_HORIZONTAL_SINGLE = '\u256B'; + + private static final char UNDEFINED = '?'; + + private static final int UP3 = 1; + + private static final int DOWN3 = 3; + + private static final int LEFT3 = 9; + + private static final int RIGHT3 = 27; + + private static final char[] MAP = new char[100]; + + static { + Arrays.fill(MAP, UNDEFINED); + MAP[0] = ' '; + MAP[UP3] = LIGHT_VERTICAL; + MAP[DOWN3] = LIGHT_VERTICAL; + MAP[RIGHT3] = LIGHT_HORIZONTAL; + MAP[LEFT3] = LIGHT_HORIZONTAL; + MAP[UP3 + DOWN3] = LIGHT_VERTICAL; + MAP[LEFT3 + RIGHT3] = LIGHT_HORIZONTAL; + MAP[UP3 + LEFT3] = LIGHT_UP_AND_LEFT; + MAP[LEFT3 + DOWN3] = LIGHT_DOWN_AND_LEFT; + MAP[DOWN3 + RIGHT3] = LIGHT_DOWN_AND_RIGHT; + MAP[UP3 + RIGHT3] = LIGHT_UP_AND_RIGHT; + MAP[UP3 + DOWN3 + RIGHT3] = LIGHT_VERTICAL_AND_RIGHT; + MAP[UP3 + LEFT3 + DOWN3] = LIGHT_VERTICAL_AND_LEFT; + MAP[LEFT3 + DOWN3 + RIGHT3] = LIGHT_DOWN_AND_HORIZONTAL; + MAP[UP3 + LEFT3 + RIGHT3] = LIGHT_UP_AND_HORIZONTAL; + MAP[UP3 + LEFT3 + DOWN3 + RIGHT3] = LIGHT_VERTICAL_AND_HORIZONTAL; + //DOUBLE + MAP[2 * UP3] = DOUBLE_VERTICAL; + MAP[2 * DOWN3] = DOUBLE_VERTICAL; + MAP[2 * RIGHT3] = DOUBLE_HORIZONTAL; + MAP[2 * LEFT3] = DOUBLE_HORIZONTAL; + MAP[2 * UP3 + 2 * DOWN3] = DOUBLE_VERTICAL; + MAP[2 * LEFT3 + 2 * RIGHT3] = DOUBLE_HORIZONTAL; + MAP[2 * UP3 + 2 * LEFT3] = DOUBLE_UP_AND_LEFT; + MAP[2 * LEFT3 + 2 * DOWN3] = DOUBLE_DOWN_AND_LEFT; + MAP[2 * DOWN3 + 2 * RIGHT3] = DOUBLE_DOWN_AND_RIGHT; + MAP[2 * UP3 + 2 * RIGHT3] = DOUBLE_UP_AND_RIGHT; + MAP[2 * UP3 + 2 * DOWN3 + 2 * RIGHT3] = DOUBLE_VERTICAL_AND_RIGHT; + MAP[2 * UP3 + 2 * DOWN3 + 2 * LEFT3] = DOUBLE_VERTICAL_AND_LEFT; + MAP[2 * DOWN3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_DOWN_AND_HORIZONTAL; + MAP[2 * UP3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_UP_AND_HORIZONTAL; + MAP[2 * UP3 + 2 * DOWN3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_VERTICAL_AND_HORIZONTAL; + //DOUBLE&SINGLE + MAP[DOWN3 + 2 * RIGHT3] = DOWN_SINGLE_AND_RIGHT_DOUBLE; + MAP[2 * DOWN3 + RIGHT3] = DOWN_DOUBLE_AND_RIGHT_SINGLE; + MAP[DOWN3 + 2 * LEFT3] = DOWN_SINGLE_AND_LEFT_DOUBLE; + MAP[2 * DOWN3 + LEFT3] = DOWN_DOUBLE_AND_LEFT_SINGLE; + MAP[UP3 + 2 * RIGHT3] = UP_SINGLE_AND_RIGHT_DOUBLE; + MAP[2 * UP3 + RIGHT3] = UP_DOUBLE_AND_RIGHT_SINGLE; + MAP[UP3 + 2 * LEFT3] = UP_SINGLE_AND_LEFT_DOUBLE; + MAP[2 * UP3 + LEFT3] = UP_DOUBLE_AND_LEFT_SINGLE; + MAP[UP3 + DOWN3 + 2 * RIGHT3] = VERTICAL_SINGLE_AND_RIGHT_DOUBLE; + MAP[2 * UP3 + 2 * DOWN3 + RIGHT3] = VERTICAL_DOUBLE_AND_RIGHT_SINGLE; + MAP[UP3 + DOWN3 + 2 * LEFT3] = VERTICAL_SINGLE_AND_LEFT_DOUBLE; + MAP[2 * UP3 + 2 * DOWN3 + LEFT3] = VERTICAL_DOUBLE_AND_LEFT_SINGLE; + MAP[DOWN3 + 2 * LEFT3 + 2 * RIGHT3] = DOWN_SINGLE_AND_HORIZONTAL_DOUBLE; + MAP[2 * DOWN3 + LEFT3 + RIGHT3] = DOWN_DOUBLE_AND_HORIZONTAL_SINGLE; + MAP[UP3 + 2 * LEFT3 + 2 * RIGHT3] = UP_SINGLE_AND_HORIZONTAL_DOUBLE; + MAP[2 * UP3 + LEFT3 + RIGHT3] = UP_DOUBLE_AND_HORIZONTAL_SINGLE; + MAP[UP3 + DOWN3 + 2 * LEFT3 + 2 * RIGHT3] = VERTICAL_SINGLE_AND_HORIZONTAL_DOUBLE; + MAP[2 * UP3 + 2 * DOWN3 + LEFT3 + RIGHT3] = VERTICAL_DOUBLE_AND_HORIZONTAL_SINGLE; + } + + /** + * Initializes a newly created <code>SolidAndDoubleBorderElement</code> + * object so that it represents an empty border element. + */ + public SolidAndDoubleBorderElement() { + } + + /** + * Constructs a newly allocated <code>SolidAndDoubleBorderElement</code> + * object. Fills <code>data</code> using binary representation of + * <code>type</code>. If border style is EN_DOUBLE, multiplies + * <code>data[side]</code> by 2 for every side to distinguish EN_SOLID and + * EN_DOUBLE. + * + * @param style integer, representing border style. + * @param type binary representation of type gives <code>data</code> + */ + public SolidAndDoubleBorderElement(int style, int type) { + super(type); + if (style == EN_DOUBLE) { + for (int i = 0; i < 4; i++) { + data[i] *= 2; + } + } + } + + /** + * Merges with <code>sde</code>. + * @param sde instance of SolidAndDoubleBorderElement + * @return instance of AbstractBorderElement + */ + public AbstractBorderElement mergeSolid(SolidAndDoubleBorderElement sde) { + AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0); + for (int i = 0; i < 4; i++) { + if (sde.getData(i) != 0) { + e.setData(i, sde.getData(i)); + } else { + e.setData(i, data[i]); + } + } + return e; + } + + /** + * Merges with e. + * @param e instance of AbstractBorderElement + * @return instance of AbstractBorderElement + */ + public AbstractBorderElement merge(AbstractBorderElement e) { + AbstractBorderElement abe = this; + if (e instanceof SolidAndDoubleBorderElement) { + abe = mergeSolid((SolidAndDoubleBorderElement) e); + } else if (e instanceof DottedBorderElement) { + abe = e; + } else if (e instanceof DashedBorderElement) { + abe = e.merge(this); + } + return abe; + } + + /** + * Maps to char. + * @return resulting mapping char + */ + private char map2Char() { + int key = 0; + key += data[UP] * UP3; + key += data[LEFT] * LEFT3; + key += data[DOWN] * DOWN3; + key += data[RIGHT] * RIGHT3; + return MAP[key]; + } + + /** + * Modifies data to nearest normal internal representation. + */ + private void modifyData() { + int c1 = 0; + int c2 = 0; + for (int i = 0; i < 4; i++) { + c1 += (data[i] == 1) ? 1 : 0; + c2 += (data[i] == 2) ? 1 : 0; + } + int m = c1 > c2 ? 1 : 0; + int[] p = {0, m, 2 * (1 - m)}; + for (int i = 0; i < 4; i++) { + data[i] = p[data[i]]; + } + } + + /** + * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char() + */ + public char convert2Char() { + char ch = map2Char(); + if (ch == UNDEFINED) { + modifyData(); + ch = map2Char(); + } + return ch; + } +} |