* Sets the unset cell properties to be the table defaults. * * @param aCell The cell to set to table defaults as necessary. */    private void assumeTableDefaults(Cell aCell) {        if (aCell.border() == Rectangle.UNDEFINED) {            aCell.setBorder(defaultLayout.border());        }        if (aCell.borderWidth() == Rectangle.UNDEFINED) {            aCell.setBorderWidth(defaultLayout.borderWidth());        }        if (aCell.borderColor() == null) {            aCell.setBorderColor(defaultLayout.borderColor());        }        if (aCell.backgroundColor() == null) {            aCell.setBackgroundColor(defaultLayout.backgroundColor());        }        if (aCell.grayFill() == Rectangle.UNDEFINED) {            aCell.setGrayFill(defaultLayout.grayFill());        }        if (aCell.horizontalAlignment() == Element.ALIGN_UNDEFINED) {            aCell.setHorizontalAlignment(defaultLayout.horizontalAlignment());        }        if (aCell.verticalAlignment() == Element.ALIGN_UNDEFINED) {            aCell.setVerticalAlignment(defaultLayout.verticalAlignment());        }    }/** * Deletes a column in this table. * * @param       column  the number of the column that has to be deleted */    public void deleteColumn(int column) throws BadElementException {        float newWidths[] = new float[--columns];        for (int i = 0; i < column; i++) {            newWidths[i] = widths[i];        }        for (int i = column; i < columns; i++) {            newWidths[i] = widths[i + 1];        }        setWidths(newWidths);        for (int i = 0; i < columns; i++) {            newWidths[i] = widths[i];        }        widths = newWidths;        Row row;        int size = rows.size();        for (int i = 0; i < size; i++) {            row = (Row) rows.get(i);            row.deleteColumn(column);            rows.set(i, row);        }        if (column == columns) {            curPosition.setLocation(curPosition.x+1, 0);        }    }/** * Deletes a row. * * @param       row             the number of the row to delete * @return      boolean <CODE>true</CODE> if the row was deleted; <CODE>false</CODE> if not */    public boolean deleteRow(int row) {        if (row < 0 || row >= rows.size()) {            return false;        }        rows.remove(row);        curPosition.setLocation(curPosition.x-1, curPosition.y);        return true;    }/** * Deletes the last row in this table. * * @return      boolean <CODE>true</CODE> if the row was deleted; <CODE>false</CODE> if not */    public boolean deleteLastRow() {        return deleteRow(rows.size() - 1);    }/** * Marks the last row of the table headers. * * @return      the number of the last row of the table headers */    public int endHeaders() {        /* patch sep 8 2001 Francesco De Milato */        lastHeaderRow = curPosition.x - 1;        return lastHeaderRow;    }    // methods to set the membervariables/** * Sets the horizontal alignment. * * @param       value   the new value */    public void setLastHeaderRow(int value) {        lastHeaderRow = value;    }/** * Sets the horizontal alignment. * * @param       value   the new value */    public void setAlignment(int value) {        alignment = value;    }/** * Sets the alignment of this paragraph. * * @param    alignment        the new alignment as a <CODE>String</CODE> */    public void setAlignment(String alignment) {        if (ElementTags.ALIGN_LEFT.equalsIgnoreCase(alignment)) {            this.alignment = Element.ALIGN_LEFT;            return;        }        if (ElementTags.RIGHT.equalsIgnoreCase(alignment)) {            this.alignment = Element.ALIGN_RIGHT;            return;        }        this.alignment = Element.ALIGN_CENTER;    }/** * Sets the cellpadding. * * @param       value   the new value */    public void setSpaceInsideCell(float value) {        cellpadding = value;    }/** * Sets the cellspacing. * * @param       value   the new value */    public void setSpaceBetweenCells(float value) {        cellspacing = value;    }/** * Sets the cellpadding. * * @param       value   the new value */    public void setPadding(float value) {        cellpadding = value;    }/** * Sets the cellspacing. * * @param       value   the new value */    public void setSpacing(float value) {        cellspacing = value;    }/** * Sets the cellspacing (the meaning of cellpadding and cellspacing was inverted by mistake). * * @param       value   the new value * @deprecated  use setSpacing instead */    public void setCellpadding(float value) {        cellspacing = value;    }/** * Sets the cellpadding (the meaning of cellpadding and cellspacing was inverted by mistake). * * @param       value   the new value * @deprecated  use setPadding instead */    public void setCellspacing(float value) {        cellpadding = value;    }/** * Sets the width of this table (in percentage of the available space). * * @param       width           the width */    public void setWidth(float width) {        this.widthPercentage = width;    }/** * Sets the width of this table (in percentage of the available space). * * @param   width           the width */    public void setAbsWidth(String width) {        this.absWidth = width;    }/** * Sets the widths of the different columns (percentages). * <P> * You can give up relative values of borderwidths. * The sum of these values will be considered 100%. * The values will be recalculated as percentages of this sum. * <P> * example: * <BLOCKQUOTE><PRE> * float[] widths = {2, 1, 1}; * <STRONG>table.setWidths(widths)</STRONG> * </PRE></BLOCKQUOTE> * The widths will be: a width of 50% for the first column, * 25% for the second and third column. * * @param       widths  an array with values */    public void setWidths(float[] widths) throws BadElementException {        if (widths.length != columns) {            throw new BadElementException("Wrong number of columns.");        }        // The sum of all values is 100%        float hundredPercent = 0;        for (int i = 0; i < columns; i++) {            hundredPercent += widths[i];        }        // The different percentages are calculated        float width;        this.widths[columns - 1] = 100;        for (int i = 0; i < columns - 1; i++) {            width = (100.0f * widths[i]) / hundredPercent;            this.widths[i] = width;            this.widths[columns - 1] -= width;        }    }/** * Sets the widths of the different columns (percentages). * <P> * You can give up relative values of borderwidths. * The sum of these values will be considered 100%. * The values will be recalculated as percentages of this sum. * * @param       widths  an array with values */    public void setWidths(int[] widths) throws DocumentException {        float tb[] = new float[widths.length];        for (int k = 0; k < widths.length; ++k)            tb[k] = widths[k];        setWidths(tb);    }    // methods to retrieve the membervariables/** * Gets the number of columns. * * @return    a value */    public int columns() {        return columns;    }/** * Gets the number of rows in this <CODE>Table</CODE>. * * @return      the number of rows in this <CODE>Table</CODE> */    public int size() {        return rows.size();    }/** * Gets the proportional widths of the columns in this <CODE>Table</CODE>. * * @return      the proportional widths of the columns in this <CODE>Table</CODE> */    public float[] getProportionalWidths() {        return widths;    }/** * Gets an <CODE>Iterator</CODE> of all the <CODE>Row</CODE>s. * * @return      an <CODE>Iterator</CODE> */    public Iterator iterator() {        return rows.iterator();    }/** * Gets the horizontal alignment. * * @return  a value */    public int alignment() {        return alignment;    }/** * Gets the cellpadding. * * @return  a value */    public float cellpadding() {        return cellpadding;    }/** * Gets the cellspacing. * * @return  a value */    public float cellspacing() {        return cellspacing;    }/** * Gets the table width (a percentage). * * @return      the table width */    public float widthPercentage() {        return widthPercentage;    }/** * Gets the table width (in pixels). * * @return  the table width */    public String absWidth() {        return absWidth;    }/** * Gets the first number of the row that doesn't contain headers. * * @return      a rownumber */    public int firstDataRow() {        return lastHeaderRow + 1;    }/** * Gets the dimension of this table * * @return  dimension */    public Dimension getDimension() {        return new Dimension(columns, rows.size());    }/** * returns the element at the position row, column *          (Cast to Cell or Table) * * @return  dimension */    public Object getElement(int row, int column) {        return ((Row) rows.get(row)).getCell(column);    }/** * Integrates all added tables and recalculates column widths. */    private void mergeInsertedTables() {        int i=0, j=0;        float [] lNewWidths = null;        int [] lDummyWidths = new int[columns];     // to keep track in how many new cols this one will be split        float[][] lDummyColumnWidths = new float[columns][]; // bugfix Tony Copping        int [] lDummyHeights = new int[rows.size()]; // to keep track in how many new rows this one will be split        ArrayList newRows = null;        int lTotalRows  = 0, lTotalColumns      = 0;        int lNewMaxRows = 0, lNewMaxColumns     = 0;        Table lDummyTable = null;        // first we'll add new columns when needed