How to cover wide tables across multiple pages horizontally?

Question

I am looking for a method for dividing wide tables so that they span multiple pages. The goal is to make tables with a lot of readable columns. I found one discussion thread to which this question applies ; however, the example given here is not available. The staffing of iText in Action (2006) does not cover this topic.

Can this be done in version 1.4.8, if not, to which version of iText should I upgrade to?

Answer 1

Please see the examples in chapter 4 of my book , more specifically on Zhang . In this example, I have a table with four columns: (1) year, (2) movie name in English, (3) movie name in Chinese, and (4) path length. If you look at the resulting PDF file, you will see that this table is divided vertically.

This requires more work, and then just add a table and let iText decide how to split it between the rows. If you want to split between columns, you need to organize the layout in your code. This is done using the method writeSelectedRows()).

In my simple book example, I use the following lines:

// draw the first two columns on one page
table.writeSelectedRows(0, 2, 0, -1, 236, 806, canvas);
document.newPage();
// draw the remaining two columns on the next page
table.writeSelectedRows(2, -1, 0, -1, 36, 806, canvas);

0 2. 0 , 2 , , . 0 ( ) -1. : .

, 2 ( ) -1 ( : ).

(236, 806) (36, 806) : , . " ". , iText , , . , : , , .

Answer 2

, ,

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.pdf.PdfContentByte;
import com.lowagie.text.pdf.PdfPTable;
import com.lowagie.text.pdf.PdfWriter;

/**
 * Class that writes a <code>PdfPTable</code>, and spans it across multiple
 * pages if the columns won't fit on one page
 */
public class PdfPTableWriter {

    // Instance variables
    private PdfPTable table;
    private PdfWriter writer;
    private Document document;

    // List of how many columns per horizontal page
    private List numberOfColumnsPerPage;

    // List of how many rows per vertical page
    private List numberOfRowsPerPage;

    // Offsets if given
    private float widthOffset = 20;
    private float heightOffset = 70;

    /**
     * Class Constructor
     */
    public PdfPTableWriter(Document document, PdfWriter writer, PdfPTable table) {
        this.document = document;
        this.writer = writer;
        this.table = table;
        calculateColumns();
        calculateRows();
    }

    /**
     * Writes the table to the document
     */
    public void writeTable() throws DocumentException {
        // Begin at row 1 (row after the header)
        int rowBegin = 1;
        int rowEnd = 0;
        // Note the size of numberOfRowsPerPage is how many vertical
        // pages there are.
        Iterator rowsIter = numberOfRowsPerPage.iterator();
        while (rowsIter.hasNext()) {
            rowEnd = ((Integer) rowsIter.next()).intValue();
            writeSelectedRows(rowBegin, rowEnd);
            rowBegin = rowEnd;
        }
    }

    /**
     * Prints the Report columns (splitting horizontally if necessary) and
     * subsequent rows
     * 
     * @param rowBegin
     * @param rowEnd
     * @throws DocumentException
     */
    private void writeSelectedRows(int rowBegin, int rowEnd) throws DocumentException {
        int colBegin = 0;
        int colEnd = 0;
        float pageHeight = document.getPageSize().getHeight() - heightOffset;
        PdfContentByte contentByte = writer.getDirectContent();
        Iterator columnsIter = numberOfColumnsPerPage.iterator();
        while (columnsIter.hasNext()) {
            colEnd = colBegin + ((Integer) columnsIter.next()).intValue();
            // Writer table header
            writeSelectedRows(colBegin, colEnd, 0, 1, widthOffset, pageHeight);
            // Writes selected rows to the document
            writeSelectedRows(colBegin, colEnd, rowBegin, rowEnd, widthOffset, pageHeight - table.getRowHeight(0) /*table.getHeaderHeight()*/);
            // Add a new page
            document.newPage();
            colBegin = colEnd;
        }
    }

    public int getTotalPages() {
        return numberOfColumnsPerPage.size() * numberOfRowsPerPage.size();
    }

    public void setHeightOffset(float heightOffset) {
        this.heightOffset = heightOffset;
    }

    public void setWidthOffset(float widthOffset) {
        this.widthOffset = widthOffset;
    }

    private void writeSelectedRows(int colBegin, int colEnd, int rowBegin, int rowEnd, float x, float y) {
        PdfContentByte cb = writer.getDirectContent();
        table.writeSelectedRows(colBegin, colEnd, rowBegin, rowEnd, x, y, cb);
    }

    private void calculateColumns() {
        numberOfColumnsPerPage = new ArrayList();
        float pageWidth = document.getPageSize().getWidth() - widthOffset;
        float[] widths = table.getAbsoluteWidths();
        if (table.getTotalWidth() > pageWidth) {
            // tmp variable for amount of total width thus far
            float tmp = 0f;
            // How many columns for this page
            int columnCount = 0;
            // Current page we're on
            int currentPage = 0;
            // Iterate through the column widths
            for (int i = 0; i < widths.length; i++) {
                // Add to the temporary total
                tmp += widths[i];
                // If this column will not fit on the page
                if (tmp > pageWidth) {
                    // Add the current column count to this page
                    numberOfColumnsPerPage.add(new Integer(columnCount));
                    // Since this column won't fit, the tmp variable should
                    // start off the next iteration
                    // as this column width
                    tmp = widths[i];
                    // Set column count to 1, since we have moved this column to
                    // the next page
                    columnCount = 1;
                }
                // If this is will fit on the page
                else {
                    // Increase the column count
                    columnCount++;
                }
            }
            // Save the remaining columns
            numberOfColumnsPerPage.add(new Integer(columnCount));
        }

        // All the columns will fit on one horizontal page
        // Note: -1 means all the columns
        else {
            numberOfColumnsPerPage.add(new Integer(-1));
        }
    }

    private void calculateRows() {
        numberOfRowsPerPage = new ArrayList();
        float pageHeight = document.getPageSize().getHeight() - heightOffset - table.getRowHeight(0) /*table.getHeaderHeight()*/;
        // If the table won't fit on the first page
        if (table.getTotalHeight() > pageHeight /*table.getHeaderHeight()*/) {
            // Temp variables
            float tmp = 0f;
            // Determine the start and end rows for each page
            for (int i = 1; i < table.size(); i++) {
                // Add this row height to the tmp total
                tmp += table.getRowHeight(i);
                if (tmp > pageHeight - (heightOffset/2)) {
                    // This row won't fit so end at previous row
                    numberOfRowsPerPage.add(new Integer(i - 1));
                    // Since this row won't fit, the tmp variable should start
                    // off the next iteration
                    // as this row height
                    tmp = table.getRowHeight(i);
                }
            }
            // Last page always ends on totalRows
            numberOfRowsPerPage.add(new Integer(table.size()));
        }

        // All the rows will fit on one vertical page
        // Note: -1 means all the rows
        else {
            numberOfRowsPerPage.add(new Integer(-1));
        }
    }
}

Answer 3

, - . -, @mkl, 1.4.8 - . http://sourceforge.net/projects/itext/files/iText/, - , - 5.4.5. , , . "" - , , , -, . , , .

, .