/* * $Id: ColumnText.java,v 1.28 2002/11/19 08:33:35 blowagie Exp $ * $Name:  $ * * Copyright 2001, 2002 by Paulo Soares. * * The contents of this file are subject to the Mozilla Public License Version 1.1 * (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.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the License. * * The Original Code is 'iText, a free JAVA-PDF library'. * * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie. * All Rights Reserved. * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved. * * Contributor(s): all the names of the contributors are added in the source code * where applicable. * * Alternatively, the contents of this file may be used under the terms of the * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the * provisions of LGPL are applicable instead of those above.  If you wish to * allow use of your version of this file only under the terms of the LGPL * License and not to allow others to use your version of this file under * the MPL, indicate your decision by deleting the provisions above and * replace them with the notice and other provisions required by the LGPL. * If you do not delete the provisions above, a recipient may use your version * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE. * * This library is free software; you can redistribute it and/or modify it * under the terms of the MPL as stated above or under the terms of the GNU * Library General Public License as published by the Free Software Foundation; * either version 2 of the License, or any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more * details. * * If you didn't download this code from the following link, you should check if * you aren't using an obsolete version: * http://www.lowagie.com/iText/ */package com.lowagie.text.pdf;import java.util.ArrayList;import java.util.Iterator;import com.lowagie.text.Phrase;import com.lowagie.text.Chunk;import com.lowagie.text.Element;import com.lowagie.text.DocumentException;/** * Formats text in a columnwise form. The text is bound * on the left and on the right by a sequence of lines. This allows the column * to have any shape, not only rectangular. * <P> * Several parameters can be set like the first paragraph line indent and * extra space between paragraphs. * <P> * A call to the method <CODE>go</CODE> will return one of the following * situations: the column ended or the text ended. * <P> * I the column ended, a new column definition can be loaded with the method * <CODE>setColumns</CODE> and the method <CODE>go</CODE> can be called again. * <P> * If the text ended, more text can be loaded with <CODE>addText</CODE> * and the method <CODE>go</CODE> can be called again.<BR> * The only limitation is that one or more complete paragraphs must be loaded * each time. * <P> * Full bidirectional reordering is supported. If the run direction is * <CODE>PdfWriter.RUN_DIRECTION_RTL</CODE> the meaning of the horizontal * alignments and margins is mirrored. * @author Paulo Soares (psoares@consiste.pt) */public class ColumnText {        protected int runDirection = PdfWriter.RUN_DIRECTION_DEFAULT;    public static final float GLOBAL_SPACE_CHAR_RATIO = 0;        /** Signals that there is no more text available. */    public static final int NO_MORE_TEXT = 1;        /** Signals that there is no more column. */    public static final int NO_MORE_COLUMN = 2;        /** The column is valid. */    protected static final int LINE_STATUS_OK = 0;        /** The line is out the column limits. */    protected static final int LINE_STATUS_OFFLIMITS = 1;        /** The line cannot fit this column position. */    protected static final int LINE_STATUS_NOLINE = 2;        /** Upper bound of the column. */    protected float maxY;        /** Lower bound of the column. */    protected float minY;        /** The column alignment. Default is left alignment. */    protected int alignment = Element.ALIGN_LEFT;        /** The left column bound. */    protected ArrayList leftWall;        /** The right column bound. */    protected ArrayList rightWall;        /** The chunks that form the text. *///    protected ArrayList chunks = new ArrayList();    protected BidiLine bidiLine = new BidiLine();        /** The current y line location. Text will be written at this line minus the leading. */    protected float yLine;        /** The leading for the current line. */    protected float currentLeading = 16;        /** The fixed text leading. */    protected float fixedLeading = 16;        /** The text leading that is multiplied by the biggest font size in the line. */    protected float multipliedLeading = 0;        /** The <CODE>PdfContent</CODE> where the text will be written to. */    protected PdfContentByte canvas;        /** The line status when trying to fit a line to a column. */    protected int lineStatus;        /** The first paragraph line indent. */    protected float indent = 0;        /** The following paragraph lines indent. */    protected float followingIndent = 0;        /** The right paragraph lines indent. */    protected float rightIndent = 0;        /** The extra space between paragraphs. */    protected float extraParagraphSpace = 0;        /** Marks the chunks to be eliminated when the line is written. */    protected int currentChunkMarker = -1;        /** The chunk created by the splitting. */    protected PdfChunk currentStandbyChunk;        /** The chunk created by the splitting. */    protected String splittedChunkText;        /** The width of the line when the column is defined as a simple rectangle. */    protected float rectangularWidth = -1;        /** Holds value of property spaceCharRatio. */    private float spaceCharRatio = GLOBAL_SPACE_CHAR_RATIO;    private boolean lastWasNewline = true;    /**     * Creates a <CODE>ColumnText</CODE>.     * @param canvas the place where the text will be written to. Can     * be a template.     */    public ColumnText(PdfContentByte canvas) {        this.canvas = canvas;    }        /**     * Adds a <CODE>Phrase</CODE> to the current text array.     * @param phrase the text     */    public void addText(Phrase phrase) {        for (Iterator j = phrase.getChunks().iterator(); j.hasNext();) {            bidiLine.addChunk(new PdfChunk((Chunk)j.next(), null));        }    }        /**     * Adds a <CODE>Chunk</CODE> to the current text array.     * @param chunk the text     */    public void addText(Chunk chunk) {        bidiLine.addChunk(new PdfChunk(chunk, null));    }        /**     * Converts a sequence of lines representing one of the column bounds into     * an internal format.     * <p>     * Each array element will contain a <CODE>float[4]</CODE> representing     * the line x = ax + b.     * @param cLine the column array     * @return the converted array     */    protected ArrayList convertColumn(float cLine[]) {        if (cLine.length < 4)            throw new RuntimeException("No valid column line found.");        ArrayList cc = new ArrayList();        for (int k = 0; k < cLine.length - 2; k += 2) {            float x1 = cLine[k];            float y1 = cLine[k + 1];            float x2 = cLine[k + 2];            float y2 = cLine[k + 3];            if (y1 == y2)                continue;            // x = ay + b            float a = (x1 - x2) / (y1 - y2);            float b = x1 - a * y1;            float r[] = new float[4];            r[0] = Math.min(y1, y2);            r[1] = Math.max(y1, y2);            r[2] = a;            r[3] = b;            cc.add(r);            maxY = Math.max(maxY, r[1]);            minY = Math.min(minY, r[0]);        }        if (cc.size() == 0)            throw new RuntimeException("No valid column line found.");        return cc;    }        /**     * Finds the intersection between the <CODE>yLine</CODE> and the column. It will     * set the <CODE>lineStatus</CODE> apropriatly.     * @param wall the column to intersect     * @return the x coordinate of the intersection     */    protected float findLimitsPoint(ArrayList wall) {        lineStatus = LINE_STATUS_OK;        if (yLine < minY || yLine > maxY) {            lineStatus = LINE_STATUS_OFFLIMITS;            return 0;        }        for (int k = 0; k < wall.size(); ++k) {            float r[] = (float[])wall.get(k);            if (yLine < r[0] || yLine > r[1])                continue;            return r[2] * yLine + r[3];        }        lineStatus = LINE_STATUS_NOLINE;        return 0;    }        /**     * Finds the intersection between the <CODE>yLine</CODE> and the two     * column bounds. It will set the <CODE>lineStatus</CODE> apropriatly.     * @return a <CODE>float[2]</CODE>with the x coordinates of the intersection     */    protected float[] findLimitsOneLine() {        for (;;) {            float x1 = findLimitsPoint(leftWall);            if (lineStatus == LINE_STATUS_OFFLIMITS || lineStatus == LINE_STATUS_NOLINE)                return null;            float x2 = findLimitsPoint(rightWall);            if (lineStatus == LINE_STATUS_NOLINE)                return null;            return new float[]{x1, x2};        }    }        /**     * Finds the intersection between the <CODE>yLine</CODE>,     * the <CODE>yLine-leading</CODE>and the two     * column bounds. It will set the <CODE>lineStatus</CODE> apropriatly.     * @return a <CODE>float[4]</CODE>with the x coordinates of the intersection     */    protected float[] findLimitsTwoLines() {        for (;;) {            float x1[] = findLimitsOneLine();            if (lineStatus == LINE_STATUS_OFFLIMITS)                return null;            yLine -= currentLeading;            if (lineStatus == LINE_STATUS_NOLINE) {                continue;            }            float x2[] = findLimitsOneLine();            if (lineStatus == LINE_STATUS_OFFLIMITS)                return null;            if (lineStatus == LINE_STATUS_NOLINE) {                yLine -= currentLeading;                continue;            }            if (x1[0] >= x2[1] || x2[0] >= x1[1])                continue;            return new float[]{x1[0], x1[1], x2[0], x2[1]};        }    }        /**     * Sets the columns bounds. Each column bound is described by a     * <CODE>float[]</CODE> with the line points [x1,y1,x2,y2,...].     * The array must have at least 4 elements.     * @param leftLine the left column bound     * @param rightLine the right column bound     */    public void setColumns(float leftLine[], float rightLine[]) {        rightWall = convertColumn(rightLine);        leftWall = convertColumn(leftLine);        rectangularWidth = -1;    }        /**     * Simplified method for rectangular columns.     * @param phrase a <CODE>Phrase</CODE>     * @param llx the lower left x corner     * @param lly the lower left y corner     * @param urx the upper right x corner     * @param ury the upper right y corner     * @param leading the leading     * @param alignment the column alignment     */    public void setSimpleColumn(Phrase phrase, float llx, float lly, float urx, float ury, float leading, int alignment) {        addText(phrase);        setSimpleColumn(llx, lly, urx, ury, leading, alignment);    }        /**     * Simplified method for rectangular columns.     * @param llx the lower left x corner     * @param lly the lower left y corner     * @param urx the upper right x corner     * @param ury the upper right y corner     * @param leading the leading     * @param alignment the column alignment     */