| /* | |
| * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code 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 General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.swing.text.html; | |
| import java.awt.*; | |
| import java.util.BitSet; | |
| import java.util.Vector; | |
| import java.util.Arrays; | |
| import javax.swing.SizeRequirements; | |
| import javax.swing.event.DocumentEvent; | |
| import javax.swing.text.*; | |
| /** | |
| * HTML table view. | |
| * | |
| * @author Timothy Prinzing | |
| * @see View | |
| */ | |
| /*public*/ class TableView extends BoxView implements ViewFactory { | |
| /** | |
| * Constructs a TableView for the given element. | |
| * | |
| * @param elem the element that this view is responsible for | |
| */ | |
| public TableView(Element elem) { | |
| super(elem, View.Y_AXIS); | |
| rows = new Vector<RowView>(); | |
| gridValid = false; | |
| captionIndex = -1; | |
| totalColumnRequirements = new SizeRequirements(); | |
| } | |
| /** | |
| * Creates a new table row. | |
| * | |
| * @param elem an element | |
| * @return the row | |
| */ | |
| protected RowView createTableRow(Element elem) { | |
| // PENDING(prinz) need to add support for some of the other | |
| // elements, but for now just ignore anything that is not | |
| // a TR. | |
| Object o = elem.getAttributes().getAttribute(StyleConstants.NameAttribute); | |
| if (o == HTML.Tag.TR) { | |
| return new RowView(elem); | |
| } | |
| return null; | |
| } | |
| /** | |
| * The number of columns in the table. | |
| */ | |
| public int getColumnCount() { | |
| return columnSpans.length; | |
| } | |
| /** | |
| * Fetches the span (width) of the given column. | |
| * This is used by the nested cells to query the | |
| * sizes of grid locations outside of themselves. | |
| */ | |
| public int getColumnSpan(int col) { | |
| if (col < columnSpans.length) { | |
| return columnSpans[col]; | |
| } | |
| return 0; | |
| } | |
| /** | |
| * The number of rows in the table. | |
| */ | |
| public int getRowCount() { | |
| return rows.size(); | |
| } | |
| /** | |
| * Fetch the span of multiple rows. This includes | |
| * the border area. | |
| */ | |
| public int getMultiRowSpan(int row0, int row1) { | |
| RowView rv0 = getRow(row0); | |
| RowView rv1 = getRow(row1); | |
| if ((rv0 != null) && (rv1 != null)) { | |
| int index0 = rv0.viewIndex; | |
| int index1 = rv1.viewIndex; | |
| int span = getOffset(Y_AXIS, index1) - getOffset(Y_AXIS, index0) + | |
| getSpan(Y_AXIS, index1); | |
| return span; | |
| } | |
| return 0; | |
| } | |
| /** | |
| * Fetches the span (height) of the given row. | |
| */ | |
| public int getRowSpan(int row) { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| return getSpan(Y_AXIS, rv.viewIndex); | |
| } | |
| return 0; | |
| } | |
| RowView getRow(int row) { | |
| if (row < rows.size()) { | |
| return rows.elementAt(row); | |
| } | |
| return null; | |
| } | |
| protected View getViewAtPoint(int x, int y, Rectangle alloc) { | |
| int n = getViewCount(); | |
| View v; | |
| Rectangle allocation = new Rectangle(); | |
| for (int i = 0; i < n; i++) { | |
| allocation.setBounds(alloc); | |
| childAllocation(i, allocation); | |
| v = getView(i); | |
| if (v instanceof RowView) { | |
| v = ((RowView)v).findViewAtPoint(x, y, allocation); | |
| if (v != null) { | |
| alloc.setBounds(allocation); | |
| return v; | |
| } | |
| } | |
| } | |
| return super.getViewAtPoint(x, y, alloc); | |
| } | |
| /** | |
| * Determines the number of columns occupied by | |
| * the table cell represented by given element. | |
| */ | |
| protected int getColumnsOccupied(View v) { | |
| AttributeSet a = v.getElement().getAttributes(); | |
| if (a.isDefined(HTML.Attribute.COLSPAN)) { | |
| String s = (String) a.getAttribute(HTML.Attribute.COLSPAN); | |
| if (s != null) { | |
| try { | |
| return Integer.parseInt(s); | |
| } catch (NumberFormatException nfe) { | |
| // fall through to one column | |
| } | |
| } | |
| } | |
| return 1; | |
| } | |
| /** | |
| * Determines the number of rows occupied by | |
| * the table cell represented by given element. | |
| */ | |
| protected int getRowsOccupied(View v) { | |
| AttributeSet a = v.getElement().getAttributes(); | |
| if (a.isDefined(HTML.Attribute.ROWSPAN)) { | |
| String s = (String) a.getAttribute(HTML.Attribute.ROWSPAN); | |
| if (s != null) { | |
| try { | |
| return Integer.parseInt(s); | |
| } catch (NumberFormatException nfe) { | |
| // fall through to one row | |
| } | |
| } | |
| } | |
| return 1; | |
| } | |
| protected void invalidateGrid() { | |
| gridValid = false; | |
| } | |
| protected StyleSheet getStyleSheet() { | |
| HTMLDocument doc = (HTMLDocument) getDocument(); | |
| return doc.getStyleSheet(); | |
| } | |
| /** | |
| * Update the insets, which contain the caption if there | |
| * is a caption. | |
| */ | |
| void updateInsets() { | |
| short top = (short) painter.getInset(TOP, this); | |
| short bottom = (short) painter.getInset(BOTTOM, this); | |
| if (captionIndex != -1) { | |
| View caption = getView(captionIndex); | |
| short h = (short) caption.getPreferredSpan(Y_AXIS); | |
| AttributeSet a = caption.getAttributes(); | |
| Object align = a.getAttribute(CSS.Attribute.CAPTION_SIDE); | |
| if ((align != null) && (align.equals("bottom"))) { | |
| bottom += h; | |
| } else { | |
| top += h; | |
| } | |
| } | |
| setInsets(top, (short) painter.getInset(LEFT, this), | |
| bottom, (short) painter.getInset(RIGHT, this)); | |
| } | |
| /** | |
| * Update any cached values that come from attributes. | |
| */ | |
| protected void setPropertiesFromAttributes() { | |
| StyleSheet sheet = getStyleSheet(); | |
| attr = sheet.getViewAttributes(this); | |
| painter = sheet.getBoxPainter(attr); | |
| if (attr != null) { | |
| setInsets((short) painter.getInset(TOP, this), | |
| (short) painter.getInset(LEFT, this), | |
| (short) painter.getInset(BOTTOM, this), | |
| (short) painter.getInset(RIGHT, this)); | |
| CSS.LengthValue lv = (CSS.LengthValue) | |
| attr.getAttribute(CSS.Attribute.BORDER_SPACING); | |
| if (lv != null) { | |
| cellSpacing = (int) lv.getValue(); | |
| } else { | |
| // Default cell spacing equals 2 | |
| cellSpacing = 2; | |
| } | |
| lv = (CSS.LengthValue) | |
| attr.getAttribute(CSS.Attribute.BORDER_TOP_WIDTH); | |
| if (lv != null) { | |
| borderWidth = (int) lv.getValue(); | |
| } else { | |
| borderWidth = 0; | |
| } | |
| } | |
| } | |
| /** | |
| * Fill in the grid locations that are placeholders | |
| * for multi-column, multi-row, and missing grid | |
| * locations. | |
| */ | |
| void updateGrid() { | |
| if (! gridValid) { | |
| relativeCells = false; | |
| multiRowCells = false; | |
| // determine which views are table rows and clear out | |
| // grid points marked filled. | |
| captionIndex = -1; | |
| rows.removeAllElements(); | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| if (v instanceof RowView) { | |
| rows.addElement((RowView) v); | |
| RowView rv = (RowView) v; | |
| rv.clearFilledColumns(); | |
| rv.rowIndex = rows.size() - 1; | |
| rv.viewIndex = i; | |
| } else { | |
| Object o = v.getElement().getAttributes().getAttribute(StyleConstants.NameAttribute); | |
| if (o instanceof HTML.Tag) { | |
| HTML.Tag kind = (HTML.Tag) o; | |
| if (kind == HTML.Tag.CAPTION) { | |
| captionIndex = i; | |
| } | |
| } | |
| } | |
| } | |
| int maxColumns = 0; | |
| int nrows = rows.size(); | |
| for (int row = 0; row < nrows; row++) { | |
| RowView rv = getRow(row); | |
| int col = 0; | |
| for (int cell = 0; cell < rv.getViewCount(); cell++, col++) { | |
| View cv = rv.getView(cell); | |
| if (! relativeCells) { | |
| AttributeSet a = cv.getAttributes(); | |
| CSS.LengthValue lv = (CSS.LengthValue) | |
| a.getAttribute(CSS.Attribute.WIDTH); | |
| if ((lv != null) && (lv.isPercentage())) { | |
| relativeCells = true; | |
| } | |
| } | |
| // advance to a free column | |
| for (; rv.isFilled(col); col++); | |
| int rowSpan = getRowsOccupied(cv); | |
| if (rowSpan > 1) { | |
| multiRowCells = true; | |
| } | |
| int colSpan = getColumnsOccupied(cv); | |
| if ((colSpan > 1) || (rowSpan > 1)) { | |
| // fill in the overflow entries for this cell | |
| int rowLimit = row + rowSpan; | |
| int colLimit = col + colSpan; | |
| for (int i = row; i < rowLimit; i++) { | |
| for (int j = col; j < colLimit; j++) { | |
| if (i != row || j != col) { | |
| addFill(i, j); | |
| } | |
| } | |
| } | |
| if (colSpan > 1) { | |
| col += colSpan - 1; | |
| } | |
| } | |
| } | |
| maxColumns = Math.max(maxColumns, col); | |
| } | |
| // setup the column layout/requirements | |
| columnSpans = new int[maxColumns]; | |
| columnOffsets = new int[maxColumns]; | |
| columnRequirements = new SizeRequirements[maxColumns]; | |
| for (int i = 0; i < maxColumns; i++) { | |
| columnRequirements[i] = new SizeRequirements(); | |
| columnRequirements[i].maximum = Integer.MAX_VALUE; | |
| } | |
| gridValid = true; | |
| } | |
| } | |
| /** | |
| * Mark a grid location as filled in for a cells overflow. | |
| */ | |
| void addFill(int row, int col) { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| rv.fillColumn(col); | |
| } | |
| } | |
| /** | |
| * Layout the columns to fit within the given target span. | |
| * | |
| * @param targetSpan the given span for total of all the table | |
| * columns | |
| * @param reqs the requirements desired for each column. This | |
| * is the column maximum of the cells minimum, preferred, and | |
| * maximum requested span | |
| * @param spans the return value of how much to allocated to | |
| * each column | |
| * @param offsets the return value of the offset from the | |
| * origin for each column | |
| * @return the offset from the origin and the span for each column | |
| * in the offsets and spans parameters | |
| */ | |
| protected void layoutColumns(int targetSpan, int[] offsets, int[] spans, | |
| SizeRequirements[] reqs) { | |
| //clean offsets and spans | |
| Arrays.fill(offsets, 0); | |
| Arrays.fill(spans, 0); | |
| colIterator.setLayoutArrays(offsets, spans, targetSpan); | |
| CSS.calculateTiledLayout(colIterator, targetSpan); | |
| } | |
| /** | |
| * Calculate the requirements for each column. The calculation | |
| * is done as two passes over the table. The table cells that | |
| * occupy a single column are scanned first to determine the | |
| * maximum of minimum, preferred, and maximum spans along the | |
| * give axis. Table cells that span multiple columns are excluded | |
| * from the first pass. A second pass is made to determine if | |
| * the cells that span multiple columns are satisfied. If the | |
| * column requirements are not satisfied, the needs of the | |
| * multi-column cell is mixed into the existing column requirements. | |
| * The calculation of the multi-column distribution is based upon | |
| * the proportions of the existing column requirements and taking | |
| * into consideration any constraining maximums. | |
| */ | |
| void calculateColumnRequirements(int axis) { | |
| // clean columnRequirements | |
| for (SizeRequirements req : columnRequirements) { | |
| req.minimum = 0; | |
| req.preferred = 0; | |
| req.maximum = Integer.MAX_VALUE; | |
| } | |
| Container host = getContainer(); | |
| if (host != null) { | |
| if (host instanceof JTextComponent) { | |
| skipComments = !((JTextComponent)host).isEditable(); | |
| } else { | |
| skipComments = true; | |
| } | |
| } | |
| // pass 1 - single column cells | |
| boolean hasMultiColumn = false; | |
| int nrows = getRowCount(); | |
| for (int i = 0; i < nrows; i++) { | |
| RowView row = getRow(i); | |
| int col = 0; | |
| int ncells = row.getViewCount(); | |
| for (int cell = 0; cell < ncells; cell++) { | |
| View cv = row.getView(cell); | |
| if (skipComments && !(cv instanceof CellView)) { | |
| continue; | |
| } | |
| for (; row.isFilled(col); col++); // advance to a free column | |
| int rowSpan = getRowsOccupied(cv); | |
| int colSpan = getColumnsOccupied(cv); | |
| if (colSpan == 1) { | |
| checkSingleColumnCell(axis, col, cv); | |
| } else { | |
| hasMultiColumn = true; | |
| col += colSpan - 1; | |
| } | |
| col++; | |
| } | |
| } | |
| // pass 2 - multi-column cells | |
| if (hasMultiColumn) { | |
| for (int i = 0; i < nrows; i++) { | |
| RowView row = getRow(i); | |
| int col = 0; | |
| int ncells = row.getViewCount(); | |
| for (int cell = 0; cell < ncells; cell++) { | |
| View cv = row.getView(cell); | |
| if (skipComments && !(cv instanceof CellView)) { | |
| continue; | |
| } | |
| for (; row.isFilled(col); col++); // advance to a free column | |
| int colSpan = getColumnsOccupied(cv); | |
| if (colSpan > 1) { | |
| checkMultiColumnCell(axis, col, colSpan, cv); | |
| col += colSpan - 1; | |
| } | |
| col++; | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * check the requirements of a table cell that spans a single column. | |
| */ | |
| void checkSingleColumnCell(int axis, int col, View v) { | |
| SizeRequirements req = columnRequirements[col]; | |
| req.minimum = Math.max((int) v.getMinimumSpan(axis), req.minimum); | |
| req.preferred = Math.max((int) v.getPreferredSpan(axis), req.preferred); | |
| } | |
| /** | |
| * check the requirements of a table cell that spans multiple | |
| * columns. | |
| */ | |
| void checkMultiColumnCell(int axis, int col, int ncols, View v) { | |
| // calculate the totals | |
| long min = 0; | |
| long pref = 0; | |
| long max = 0; | |
| for (int i = 0; i < ncols; i++) { | |
| SizeRequirements req = columnRequirements[col + i]; | |
| min += req.minimum; | |
| pref += req.preferred; | |
| max += req.maximum; | |
| } | |
| // check if the minimum size needs adjustment. | |
| int cmin = (int) v.getMinimumSpan(axis); | |
| if (cmin > min) { | |
| /* | |
| * the columns that this cell spans need adjustment to fit | |
| * this table cell.... calculate the adjustments. | |
| */ | |
| SizeRequirements[] reqs = new SizeRequirements[ncols]; | |
| for (int i = 0; i < ncols; i++) { | |
| reqs[i] = columnRequirements[col + i]; | |
| } | |
| int[] spans = new int[ncols]; | |
| int[] offsets = new int[ncols]; | |
| SizeRequirements.calculateTiledPositions(cmin, null, reqs, | |
| offsets, spans); | |
| // apply the adjustments | |
| for (int i = 0; i < ncols; i++) { | |
| SizeRequirements req = reqs[i]; | |
| req.minimum = Math.max(spans[i], req.minimum); | |
| req.preferred = Math.max(req.minimum, req.preferred); | |
| req.maximum = Math.max(req.preferred, req.maximum); | |
| } | |
| } | |
| // check if the preferred size needs adjustment. | |
| int cpref = (int) v.getPreferredSpan(axis); | |
| if (cpref > pref) { | |
| /* | |
| * the columns that this cell spans need adjustment to fit | |
| * this table cell.... calculate the adjustments. | |
| */ | |
| SizeRequirements[] reqs = new SizeRequirements[ncols]; | |
| for (int i = 0; i < ncols; i++) { | |
| reqs[i] = columnRequirements[col + i]; | |
| } | |
| int[] spans = new int[ncols]; | |
| int[] offsets = new int[ncols]; | |
| SizeRequirements.calculateTiledPositions(cpref, null, reqs, | |
| offsets, spans); | |
| // apply the adjustments | |
| for (int i = 0; i < ncols; i++) { | |
| SizeRequirements req = reqs[i]; | |
| req.preferred = Math.max(spans[i], req.preferred); | |
| req.maximum = Math.max(req.preferred, req.maximum); | |
| } | |
| } | |
| } | |
| // --- BoxView methods ----------------------------------------- | |
| /** | |
| * Calculate the requirements for the minor axis. This is called by | |
| * the superclass whenever the requirements need to be updated (i.e. | |
| * a preferenceChanged was messaged through this view). | |
| * <p> | |
| * This is implemented to calculate the requirements as the sum of the | |
| * requirements of the columns and then adjust it if the | |
| * CSS width or height attribute is specified and applicable to | |
| * the axis. | |
| */ | |
| protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) { | |
| updateGrid(); | |
| // calculate column requirements for each column | |
| calculateColumnRequirements(axis); | |
| // the requirements are the sum of the columns. | |
| if (r == null) { | |
| r = new SizeRequirements(); | |
| } | |
| long min = 0; | |
| long pref = 0; | |
| int n = columnRequirements.length; | |
| for (int i = 0; i < n; i++) { | |
| SizeRequirements req = columnRequirements[i]; | |
| min += req.minimum; | |
| pref += req.preferred; | |
| } | |
| int adjust = (n + 1) * cellSpacing + 2 * borderWidth; | |
| min += adjust; | |
| pref += adjust; | |
| r.minimum = (int) min; | |
| r.preferred = (int) pref; | |
| r.maximum = (int) pref; | |
| AttributeSet attr = getAttributes(); | |
| CSS.LengthValue cssWidth = (CSS.LengthValue)attr.getAttribute( | |
| CSS.Attribute.WIDTH); | |
| if (BlockView.spanSetFromAttributes(axis, r, cssWidth, null)) { | |
| if (r.minimum < (int)min) { | |
| // The user has requested a smaller size than is needed to | |
| // show the table, override it. | |
| r.maximum = r.minimum = r.preferred = (int) min; | |
| } | |
| } | |
| totalColumnRequirements.minimum = r.minimum; | |
| totalColumnRequirements.preferred = r.preferred; | |
| totalColumnRequirements.maximum = r.maximum; | |
| // set the alignment | |
| Object o = attr.getAttribute(CSS.Attribute.TEXT_ALIGN); | |
| if (o != null) { | |
| // set horizontal alignment | |
| String ta = o.toString(); | |
| if (ta.equals("left")) { | |
| r.alignment = 0; | |
| } else if (ta.equals("center")) { | |
| r.alignment = 0.5f; | |
| } else if (ta.equals("right")) { | |
| r.alignment = 1; | |
| } else { | |
| r.alignment = 0; | |
| } | |
| } else { | |
| r.alignment = 0; | |
| } | |
| return r; | |
| } | |
| /** | |
| * Calculate the requirements for the major axis. This is called by | |
| * the superclass whenever the requirements need to be updated (i.e. | |
| * a preferenceChanged was messaged through this view). | |
| * <p> | |
| * This is implemented to provide the superclass behavior adjusted for | |
| * multi-row table cells. | |
| */ | |
| protected SizeRequirements calculateMajorAxisRequirements(int axis, SizeRequirements r) { | |
| updateInsets(); | |
| rowIterator.updateAdjustments(); | |
| r = CSS.calculateTiledRequirements(rowIterator, r); | |
| r.maximum = r.preferred; | |
| return r; | |
| } | |
| /** | |
| * Perform layout for the minor axis of the box (i.e. the | |
| * axis orthogonal to the axis that it represents). The results | |
| * of the layout should be placed in the given arrays which represent | |
| * the allocations to the children along the minor axis. This | |
| * is called by the superclass whenever the layout needs to be | |
| * updated along the minor axis. | |
| * <p> | |
| * This is implemented to call the | |
| * <a href="#layoutColumns">layoutColumns</a> method, and then | |
| * forward to the superclass to actually carry out the layout | |
| * of the tables rows. | |
| * | |
| * @param targetSpan the total span given to the view, which | |
| * would be used to layout the children | |
| * @param axis the axis being laid out | |
| * @param offsets the offsets from the origin of the view for | |
| * each of the child views. This is a return value and is | |
| * filled in by the implementation of this method | |
| * @param spans the span of each child view; this is a return | |
| * value and is filled in by the implementation of this method | |
| * @return the offset and span for each child view in the | |
| * offsets and spans parameters | |
| */ | |
| protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) { | |
| // make grid is properly represented | |
| updateGrid(); | |
| // all of the row layouts are invalid, so mark them that way | |
| int n = getRowCount(); | |
| for (int i = 0; i < n; i++) { | |
| RowView row = getRow(i); | |
| row.layoutChanged(axis); | |
| } | |
| // calculate column spans | |
| layoutColumns(targetSpan, columnOffsets, columnSpans, columnRequirements); | |
| // continue normal layout | |
| super.layoutMinorAxis(targetSpan, axis, offsets, spans); | |
| } | |
| /** | |
| * Perform layout for the major axis of the box (i.e. the | |
| * axis that it represents). The results | |
| * of the layout should be placed in the given arrays which represent | |
| * the allocations to the children along the minor axis. This | |
| * is called by the superclass whenever the layout needs to be | |
| * updated along the minor axis. | |
| * <p> | |
| * This method is where the layout of the table rows within the | |
| * table takes place. This method is implemented to call the use | |
| * the RowIterator and the CSS collapsing tile to layout | |
| * with border spacing and border collapsing capabilities. | |
| * | |
| * @param targetSpan the total span given to the view, which | |
| * would be used to layout the children | |
| * @param axis the axis being laid out | |
| * @param offsets the offsets from the origin of the view for | |
| * each of the child views; this is a return value and is | |
| * filled in by the implementation of this method | |
| * @param spans the span of each child view; this is a return | |
| * value and is filled in by the implementation of this method | |
| * @return the offset and span for each child view in the | |
| * offsets and spans parameters | |
| */ | |
| protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, int[] spans) { | |
| rowIterator.setLayoutArrays(offsets, spans); | |
| CSS.calculateTiledLayout(rowIterator, targetSpan); | |
| if (captionIndex != -1) { | |
| // place the caption | |
| View caption = getView(captionIndex); | |
| int h = (int) caption.getPreferredSpan(Y_AXIS); | |
| spans[captionIndex] = h; | |
| short boxBottom = (short) painter.getInset(BOTTOM, this); | |
| if (boxBottom != getBottomInset()) { | |
| offsets[captionIndex] = targetSpan + boxBottom; | |
| } else { | |
| offsets[captionIndex] = - getTopInset(); | |
| } | |
| } | |
| } | |
| /** | |
| * Fetches the child view that represents the given position in | |
| * the model. This is implemented to walk through the children | |
| * looking for a range that contains the given position. In this | |
| * view the children do not necessarily have a one to one mapping | |
| * with the child elements. | |
| * | |
| * @param pos the search position >= 0 | |
| * @param a the allocation to the table on entry, and the | |
| * allocation of the view containing the position on exit | |
| * @return the view representing the given position, or | |
| * null if there isn't one | |
| */ | |
| protected View getViewAtPosition(int pos, Rectangle a) { | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| int p0 = v.getStartOffset(); | |
| int p1 = v.getEndOffset(); | |
| if ((pos >= p0) && (pos < p1)) { | |
| // it's in this view. | |
| if (a != null) { | |
| childAllocation(i, a); | |
| } | |
| return v; | |
| } | |
| } | |
| if (pos == getEndOffset()) { | |
| View v = getView(n - 1); | |
| if (a != null) { | |
| this.childAllocation(n - 1, a); | |
| } | |
| return v; | |
| } | |
| return null; | |
| } | |
| // --- View methods --------------------------------------------- | |
| /** | |
| * Fetches the attributes to use when rendering. This is | |
| * implemented to multiplex the attributes specified in the | |
| * model with a StyleSheet. | |
| */ | |
| public AttributeSet getAttributes() { | |
| if (attr == null) { | |
| StyleSheet sheet = getStyleSheet(); | |
| attr = sheet.getViewAttributes(this); | |
| } | |
| return attr; | |
| } | |
| /** | |
| * Renders using the given rendering surface and area on that | |
| * surface. This is implemented to delegate to the css box | |
| * painter to paint the border and background prior to the | |
| * interior. The superclass culls rendering the children | |
| * that don't directly intersect the clip and the row may | |
| * have cells hanging from a row above in it. The table | |
| * does not use the superclass rendering behavior and instead | |
| * paints all of the rows and lets the rows cull those | |
| * cells not intersecting the clip region. | |
| * | |
| * @param g the rendering surface to use | |
| * @param allocation the allocated region to render into | |
| * @see View#paint | |
| */ | |
| public void paint(Graphics g, Shape allocation) { | |
| // paint the border | |
| Rectangle a = allocation.getBounds(); | |
| setSize(a.width, a.height); | |
| if (captionIndex != -1) { | |
| // adjust the border for the caption | |
| short top = (short) painter.getInset(TOP, this); | |
| short bottom = (short) painter.getInset(BOTTOM, this); | |
| if (top != getTopInset()) { | |
| int h = getTopInset() - top; | |
| a.y += h; | |
| a.height -= h; | |
| } else { | |
| a.height -= getBottomInset() - bottom; | |
| } | |
| } | |
| painter.paint(g, a.x, a.y, a.width, a.height, this); | |
| // paint interior | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| v.paint(g, getChildAllocation(i, allocation)); | |
| } | |
| //super.paint(g, a); | |
| } | |
| /** | |
| * Establishes the parent view for this view. This is | |
| * guaranteed to be called before any other methods if the | |
| * parent view is functioning properly. | |
| * <p> | |
| * This is implemented | |
| * to forward to the superclass as well as call the | |
| * <a href="#setPropertiesFromAttributes">setPropertiesFromAttributes</a> | |
| * method to set the paragraph properties from the css | |
| * attributes. The call is made at this time to ensure | |
| * the ability to resolve upward through the parents | |
| * view attributes. | |
| * | |
| * @param parent the new parent, or null if the view is | |
| * being removed from a parent it was previously added | |
| * to | |
| */ | |
| public void setParent(View parent) { | |
| super.setParent(parent); | |
| if (parent != null) { | |
| setPropertiesFromAttributes(); | |
| } | |
| } | |
| /** | |
| * Fetches the ViewFactory implementation that is feeding | |
| * the view hierarchy. | |
| * This replaces the ViewFactory with an implementation that | |
| * calls through to the createTableRow and createTableCell | |
| * methods. If the element given to the factory isn't a | |
| * table row or cell, the request is delegated to the factory | |
| * produced by the superclass behavior. | |
| * | |
| * @return the factory, null if none | |
| */ | |
| public ViewFactory getViewFactory() { | |
| return this; | |
| } | |
| /** | |
| * Gives notification that something was inserted into | |
| * the document in a location that this view is responsible for. | |
| * This replaces the ViewFactory with an implementation that | |
| * calls through to the createTableRow and createTableCell | |
| * methods. If the element given to the factory isn't a | |
| * table row or cell, the request is delegated to the factory | |
| * passed as an argument. | |
| * | |
| * @param e the change information from the associated document | |
| * @param a the current allocation of the view | |
| * @param f the factory to use to rebuild if the view has children | |
| * @see View#insertUpdate | |
| */ | |
| public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) { | |
| super.insertUpdate(e, a, this); | |
| } | |
| /** | |
| * Gives notification that something was removed from the document | |
| * in a location that this view is responsible for. | |
| * This replaces the ViewFactory with an implementation that | |
| * calls through to the createTableRow and createTableCell | |
| * methods. If the element given to the factory isn't a | |
| * table row or cell, the request is delegated to the factory | |
| * passed as an argument. | |
| * | |
| * @param e the change information from the associated document | |
| * @param a the current allocation of the view | |
| * @param f the factory to use to rebuild if the view has children | |
| * @see View#removeUpdate | |
| */ | |
| public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) { | |
| super.removeUpdate(e, a, this); | |
| } | |
| /** | |
| * Gives notification from the document that attributes were changed | |
| * in a location that this view is responsible for. | |
| * This replaces the ViewFactory with an implementation that | |
| * calls through to the createTableRow and createTableCell | |
| * methods. If the element given to the factory isn't a | |
| * table row or cell, the request is delegated to the factory | |
| * passed as an argument. | |
| * | |
| * @param e the change information from the associated document | |
| * @param a the current allocation of the view | |
| * @param f the factory to use to rebuild if the view has children | |
| * @see View#changedUpdate | |
| */ | |
| public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) { | |
| super.changedUpdate(e, a, this); | |
| } | |
| protected void forwardUpdate(DocumentEvent.ElementChange ec, | |
| DocumentEvent e, Shape a, ViewFactory f) { | |
| super.forwardUpdate(ec, e, a, f); | |
| // A change in any of the table cells usually effects the whole table, | |
| // so redraw it all! | |
| if (a != null) { | |
| Component c = getContainer(); | |
| if (c != null) { | |
| Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : | |
| a.getBounds(); | |
| c.repaint(alloc.x, alloc.y, alloc.width, alloc.height); | |
| } | |
| } | |
| } | |
| /** | |
| * Change the child views. This is implemented to | |
| * provide the superclass behavior and invalidate the | |
| * grid so that rows and columns will be recalculated. | |
| */ | |
| public void replace(int offset, int length, View[] views) { | |
| super.replace(offset, length, views); | |
| invalidateGrid(); | |
| } | |
| // --- ViewFactory methods ------------------------------------------ | |
| /** | |
| * The table itself acts as a factory for the various | |
| * views that actually represent pieces of the table. | |
| * All other factory activity is delegated to the factory | |
| * returned by the parent of the table. | |
| */ | |
| public View create(Element elem) { | |
| Object o = elem.getAttributes().getAttribute(StyleConstants.NameAttribute); | |
| if (o instanceof HTML.Tag) { | |
| HTML.Tag kind = (HTML.Tag) o; | |
| if (kind == HTML.Tag.TR) { | |
| return createTableRow(elem); | |
| } else if ((kind == HTML.Tag.TD) || (kind == HTML.Tag.TH)) { | |
| return new CellView(elem); | |
| } else if (kind == HTML.Tag.CAPTION) { | |
| return new javax.swing.text.html.ParagraphView(elem); | |
| } | |
| } | |
| // default is to delegate to the normal factory | |
| View p = getParent(); | |
| if (p != null) { | |
| ViewFactory f = p.getViewFactory(); | |
| if (f != null) { | |
| return f.create(elem); | |
| } | |
| } | |
| return null; | |
| } | |
| // ---- variables ---------------------------------------------------- | |
| private AttributeSet attr; | |
| private StyleSheet.BoxPainter painter; | |
| private int cellSpacing; | |
| private int borderWidth; | |
| /** | |
| * The index of the caption view if there is a caption. | |
| * This has a value of -1 if there is no caption. The | |
| * caption lives in the inset area of the table, and is | |
| * updated with each time the grid is recalculated. | |
| */ | |
| private int captionIndex; | |
| /** | |
| * Do any of the table cells contain a relative size | |
| * specification? This is updated with each call to | |
| * updateGrid(). If this is true, the ColumnIterator | |
| * will do extra work to calculate relative cell | |
| * specifications. | |
| */ | |
| private boolean relativeCells; | |
| /** | |
| * Do any of the table cells span multiple rows? If | |
| * true, the RowRequirementIterator will do additional | |
| * work to adjust the requirements of rows spanned by | |
| * a single table cell. This is updated with each call to | |
| * updateGrid(). | |
| */ | |
| private boolean multiRowCells; | |
| int[] columnSpans; | |
| int[] columnOffsets; | |
| /** | |
| * SizeRequirements for all the columns. | |
| */ | |
| SizeRequirements totalColumnRequirements; | |
| SizeRequirements[] columnRequirements; | |
| RowIterator rowIterator = new RowIterator(); | |
| ColumnIterator colIterator = new ColumnIterator(); | |
| Vector<RowView> rows; | |
| // whether to display comments inside table or not. | |
| boolean skipComments = false; | |
| boolean gridValid; | |
| private static final BitSet EMPTY = new BitSet(); | |
| class ColumnIterator implements CSS.LayoutIterator { | |
| /** | |
| * Disable percentage adjustments which should only apply | |
| * when calculating layout, not requirements. | |
| */ | |
| void disablePercentages() { | |
| percentages = null; | |
| } | |
| /** | |
| * Update percentage adjustments if they are needed. | |
| */ | |
| private void updatePercentagesAndAdjustmentWeights(int span) { | |
| adjustmentWeights = new int[columnRequirements.length]; | |
| if (relativeCells) { | |
| percentages = new int[columnRequirements.length]; | |
| } else { | |
| percentages = null; | |
| } | |
| int nrows = getRowCount(); | |
| for (int rowIndex = 0; rowIndex < nrows; rowIndex++) { | |
| RowView row = getRow(rowIndex); | |
| int col = 0; | |
| int ncells = row.getViewCount(); | |
| for (int cell = 0; cell < ncells; cell++, col++) { | |
| View cv = row.getView(cell); | |
| for (; row.isFilled(col); col++); // advance to a free column | |
| int rowSpan = getRowsOccupied(cv); | |
| int colSpan = getColumnsOccupied(cv); | |
| AttributeSet a = cv.getAttributes(); | |
| CSS.LengthValue lv = (CSS.LengthValue) | |
| a.getAttribute(CSS.Attribute.WIDTH); | |
| if ( lv != null ) { | |
| int len = (int) (lv.getValue(span) / colSpan + 0.5f); | |
| for (int i = 0; i < colSpan; i++) { | |
| if (lv.isPercentage()) { | |
| // add a percentage requirement | |
| percentages[col+i] = Math.max(percentages[col+i], len); | |
| adjustmentWeights[col + i] = Math.max(adjustmentWeights[col + i], WorstAdjustmentWeight); | |
| } else { | |
| adjustmentWeights[col + i] = Math.max(adjustmentWeights[col + i], WorstAdjustmentWeight - 1); | |
| } | |
| } | |
| } | |
| col += colSpan - 1; | |
| } | |
| } | |
| } | |
| /** | |
| * Set the layout arrays to use for holding layout results | |
| */ | |
| public void setLayoutArrays(int[] offsets, int[] spans, int targetSpan) { | |
| this.offsets = offsets; | |
| this.spans = spans; | |
| updatePercentagesAndAdjustmentWeights(targetSpan); | |
| } | |
| // --- RequirementIterator methods ------------------- | |
| public int getCount() { | |
| return columnRequirements.length; | |
| } | |
| public void setIndex(int i) { | |
| col = i; | |
| } | |
| public void setOffset(int offs) { | |
| offsets[col] = offs; | |
| } | |
| public int getOffset() { | |
| return offsets[col]; | |
| } | |
| public void setSpan(int span) { | |
| spans[col] = span; | |
| } | |
| public int getSpan() { | |
| return spans[col]; | |
| } | |
| public float getMinimumSpan(float parentSpan) { | |
| // do not care for percentages, since min span can't | |
| // be less than columnRequirements[col].minimum, | |
| // but can be less than percentage value. | |
| return columnRequirements[col].minimum; | |
| } | |
| public float getPreferredSpan(float parentSpan) { | |
| if ((percentages != null) && (percentages[col] != 0)) { | |
| return Math.max(percentages[col], columnRequirements[col].minimum); | |
| } | |
| return columnRequirements[col].preferred; | |
| } | |
| public float getMaximumSpan(float parentSpan) { | |
| return columnRequirements[col].maximum; | |
| } | |
| public float getBorderWidth() { | |
| return borderWidth; | |
| } | |
| public float getLeadingCollapseSpan() { | |
| return cellSpacing; | |
| } | |
| public float getTrailingCollapseSpan() { | |
| return cellSpacing; | |
| } | |
| public int getAdjustmentWeight() { | |
| return adjustmentWeights[col]; | |
| } | |
| /** | |
| * Current column index | |
| */ | |
| private int col; | |
| /** | |
| * percentage values (may be null since there | |
| * might not be any). | |
| */ | |
| private int[] percentages; | |
| private int[] adjustmentWeights; | |
| private int[] offsets; | |
| private int[] spans; | |
| } | |
| class RowIterator implements CSS.LayoutIterator { | |
| RowIterator() { | |
| } | |
| void updateAdjustments() { | |
| int axis = Y_AXIS; | |
| if (multiRowCells) { | |
| // adjust requirements of multi-row cells | |
| int n = getRowCount(); | |
| adjustments = new int[n]; | |
| for (int i = 0; i < n; i++) { | |
| RowView rv = getRow(i); | |
| if (rv.multiRowCells == true) { | |
| int ncells = rv.getViewCount(); | |
| for (int j = 0; j < ncells; j++) { | |
| View v = rv.getView(j); | |
| int nrows = getRowsOccupied(v); | |
| if (nrows > 1) { | |
| int spanNeeded = (int) v.getPreferredSpan(axis); | |
| adjustMultiRowSpan(spanNeeded, nrows, i); | |
| } | |
| } | |
| } | |
| } | |
| } else { | |
| adjustments = null; | |
| } | |
| } | |
| /** | |
| * Fixup preferences to accommodate a multi-row table cell | |
| * if not already covered by existing preferences. This is | |
| * a no-op if not all of the rows needed (to do this check/fixup) | |
| * have arrived yet. | |
| */ | |
| void adjustMultiRowSpan(int spanNeeded, int nrows, int rowIndex) { | |
| if ((rowIndex + nrows) > getCount()) { | |
| // rows are missing (could be a bad rowspan specification) | |
| // or not all the rows have arrived. Do the best we can with | |
| // the current set of rows. | |
| nrows = getCount() - rowIndex; | |
| if (nrows < 1) { | |
| return; | |
| } | |
| } | |
| int span = 0; | |
| for (int i = 0; i < nrows; i++) { | |
| RowView rv = getRow(rowIndex + i); | |
| span += rv.getPreferredSpan(Y_AXIS); | |
| } | |
| if (spanNeeded > span) { | |
| int adjust = (spanNeeded - span); | |
| int rowAdjust = adjust / nrows; | |
| int firstAdjust = rowAdjust + (adjust - (rowAdjust * nrows)); | |
| RowView rv = getRow(rowIndex); | |
| adjustments[rowIndex] = Math.max(adjustments[rowIndex], | |
| firstAdjust); | |
| for (int i = 1; i < nrows; i++) { | |
| adjustments[rowIndex + i] = Math.max( | |
| adjustments[rowIndex + i], rowAdjust); | |
| } | |
| } | |
| } | |
| void setLayoutArrays(int[] offsets, int[] spans) { | |
| this.offsets = offsets; | |
| this.spans = spans; | |
| } | |
| // --- RequirementIterator methods ------------------- | |
| public void setOffset(int offs) { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| offsets[rv.viewIndex] = offs; | |
| } | |
| } | |
| public int getOffset() { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| return offsets[rv.viewIndex]; | |
| } | |
| return 0; | |
| } | |
| public void setSpan(int span) { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| spans[rv.viewIndex] = span; | |
| } | |
| } | |
| public int getSpan() { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| return spans[rv.viewIndex]; | |
| } | |
| return 0; | |
| } | |
| public int getCount() { | |
| return rows.size(); | |
| } | |
| public void setIndex(int i) { | |
| row = i; | |
| } | |
| public float getMinimumSpan(float parentSpan) { | |
| return getPreferredSpan(parentSpan); | |
| } | |
| public float getPreferredSpan(float parentSpan) { | |
| RowView rv = getRow(row); | |
| if (rv != null) { | |
| int adjust = (adjustments != null) ? adjustments[row] : 0; | |
| return rv.getPreferredSpan(TableView.this.getAxis()) + adjust; | |
| } | |
| return 0; | |
| } | |
| public float getMaximumSpan(float parentSpan) { | |
| return getPreferredSpan(parentSpan); | |
| } | |
| public float getBorderWidth() { | |
| return borderWidth; | |
| } | |
| public float getLeadingCollapseSpan() { | |
| return cellSpacing; | |
| } | |
| public float getTrailingCollapseSpan() { | |
| return cellSpacing; | |
| } | |
| public int getAdjustmentWeight() { | |
| return 0; | |
| } | |
| /** | |
| * Current row index | |
| */ | |
| private int row; | |
| /** | |
| * Adjustments to the row requirements to handle multi-row | |
| * table cells. | |
| */ | |
| private int[] adjustments; | |
| private int[] offsets; | |
| private int[] spans; | |
| } | |
| /** | |
| * View of a row in a row-centric table. | |
| */ | |
| public class RowView extends BoxView { | |
| /** | |
| * Constructs a TableView for the given element. | |
| * | |
| * @param elem the element that this view is responsible for | |
| */ | |
| public RowView(Element elem) { | |
| super(elem, View.X_AXIS); | |
| fillColumns = new BitSet(); | |
| RowView.this.setPropertiesFromAttributes(); | |
| } | |
| void clearFilledColumns() { | |
| fillColumns.and(EMPTY); | |
| } | |
| void fillColumn(int col) { | |
| fillColumns.set(col); | |
| } | |
| boolean isFilled(int col) { | |
| return fillColumns.get(col); | |
| } | |
| /** | |
| * The number of columns present in this row. | |
| */ | |
| int getColumnCount() { | |
| int nfill = 0; | |
| int n = fillColumns.size(); | |
| for (int i = 0; i < n; i++) { | |
| if (fillColumns.get(i)) { | |
| nfill ++; | |
| } | |
| } | |
| return getViewCount() + nfill; | |
| } | |
| /** | |
| * Fetches the attributes to use when rendering. This is | |
| * implemented to multiplex the attributes specified in the | |
| * model with a StyleSheet. | |
| */ | |
| public AttributeSet getAttributes() { | |
| return attr; | |
| } | |
| View findViewAtPoint(int x, int y, Rectangle alloc) { | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| if (getChildAllocation(i, alloc).contains(x, y)) { | |
| childAllocation(i, alloc); | |
| return getView(i); | |
| } | |
| } | |
| return null; | |
| } | |
| protected StyleSheet getStyleSheet() { | |
| HTMLDocument doc = (HTMLDocument) getDocument(); | |
| return doc.getStyleSheet(); | |
| } | |
| /** | |
| * This is called by a child to indicate its | |
| * preferred span has changed. This is implemented to | |
| * execute the superclass behavior and well as try to | |
| * determine if a row with a multi-row cell hangs across | |
| * this row. If a multi-row cell covers this row it also | |
| * needs to propagate a preferenceChanged so that it will | |
| * recalculate the multi-row cell. | |
| * | |
| * @param child the child view | |
| * @param width true if the width preference should change | |
| * @param height true if the height preference should change | |
| */ | |
| public void preferenceChanged(View child, boolean width, boolean height) { | |
| super.preferenceChanged(child, width, height); | |
| if (TableView.this.multiRowCells && height) { | |
| for (int i = rowIndex - 1; i >= 0; i--) { | |
| RowView rv = TableView.this.getRow(i); | |
| if (rv.multiRowCells) { | |
| rv.preferenceChanged(null, false, true); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // The major axis requirements for a row are dictated by the column | |
| // requirements. These methods use the value calculated by | |
| // TableView. | |
| protected SizeRequirements calculateMajorAxisRequirements(int axis, SizeRequirements r) { | |
| SizeRequirements req = new SizeRequirements(); | |
| req.minimum = totalColumnRequirements.minimum; | |
| req.maximum = totalColumnRequirements.maximum; | |
| req.preferred = totalColumnRequirements.preferred; | |
| req.alignment = 0f; | |
| return req; | |
| } | |
| public float getMinimumSpan(int axis) { | |
| float value; | |
| if (axis == View.X_AXIS) { | |
| value = totalColumnRequirements.minimum + getLeftInset() + | |
| getRightInset(); | |
| } | |
| else { | |
| value = super.getMinimumSpan(axis); | |
| } | |
| return value; | |
| } | |
| public float getMaximumSpan(int axis) { | |
| float value; | |
| if (axis == View.X_AXIS) { | |
| // We're flexible. | |
| value = (float)Integer.MAX_VALUE; | |
| } | |
| else { | |
| value = super.getMaximumSpan(axis); | |
| } | |
| return value; | |
| } | |
| public float getPreferredSpan(int axis) { | |
| float value; | |
| if (axis == View.X_AXIS) { | |
| value = totalColumnRequirements.preferred + getLeftInset() + | |
| getRightInset(); | |
| } | |
| else { | |
| value = super.getPreferredSpan(axis); | |
| } | |
| return value; | |
| } | |
| public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) { | |
| super.changedUpdate(e, a, f); | |
| int pos = e.getOffset(); | |
| if (pos <= getStartOffset() && (pos + e.getLength()) >= | |
| getEndOffset()) { | |
| RowView.this.setPropertiesFromAttributes(); | |
| } | |
| } | |
| /** | |
| * Renders using the given rendering surface and area on that | |
| * surface. This is implemented to delegate to the css box | |
| * painter to paint the border and background prior to the | |
| * interior. | |
| * | |
| * @param g the rendering surface to use | |
| * @param allocation the allocated region to render into | |
| * @see View#paint | |
| */ | |
| public void paint(Graphics g, Shape allocation) { | |
| Rectangle a = (Rectangle) allocation; | |
| painter.paint(g, a.x, a.y, a.width, a.height, this); | |
| super.paint(g, a); | |
| } | |
| /** | |
| * Change the child views. This is implemented to | |
| * provide the superclass behavior and invalidate the | |
| * grid so that rows and columns will be recalculated. | |
| */ | |
| public void replace(int offset, int length, View[] views) { | |
| super.replace(offset, length, views); | |
| invalidateGrid(); | |
| } | |
| /** | |
| * Calculate the height requirements of the table row. The | |
| * requirements of multi-row cells are not considered for this | |
| * calculation. The table itself will check and adjust the row | |
| * requirements for all the rows that have multi-row cells spanning | |
| * them. This method updates the multi-row flag that indicates that | |
| * this row and rows below need additional consideration. | |
| */ | |
| protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) { | |
| // return super.calculateMinorAxisRequirements(axis, r); | |
| long min = 0; | |
| long pref = 0; | |
| long max = 0; | |
| multiRowCells = false; | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| if (getRowsOccupied(v) > 1) { | |
| multiRowCells = true; | |
| max = Math.max((int) v.getMaximumSpan(axis), max); | |
| } else { | |
| min = Math.max((int) v.getMinimumSpan(axis), min); | |
| pref = Math.max((int) v.getPreferredSpan(axis), pref); | |
| max = Math.max((int) v.getMaximumSpan(axis), max); | |
| } | |
| } | |
| if (r == null) { | |
| r = new SizeRequirements(); | |
| r.alignment = 0.5f; | |
| } | |
| r.preferred = (int) pref; | |
| r.minimum = (int) min; | |
| r.maximum = (int) max; | |
| return r; | |
| } | |
| /** | |
| * Perform layout for the major axis of the box (i.e. the | |
| * axis that it represents). The results of the layout should | |
| * be placed in the given arrays which represent the allocations | |
| * to the children along the major axis. | |
| * <p> | |
| * This is re-implemented to give each child the span of the column | |
| * width for the table, and to give cells that span multiple columns | |
| * the multi-column span. | |
| * | |
| * @param targetSpan the total span given to the view, which | |
| * would be used to layout the children | |
| * @param axis the axis being laid out | |
| * @param offsets the offsets from the origin of the view for | |
| * each of the child views; this is a return value and is | |
| * filled in by the implementation of this method | |
| * @param spans the span of each child view; this is a return | |
| * value and is filled in by the implementation of this method | |
| * @return the offset and span for each child view in the | |
| * offsets and spans parameters | |
| */ | |
| protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, int[] spans) { | |
| int col = 0; | |
| int ncells = getViewCount(); | |
| for (int cell = 0; cell < ncells; cell++) { | |
| View cv = getView(cell); | |
| if (skipComments && !(cv instanceof CellView)) { | |
| continue; | |
| } | |
| for (; isFilled(col); col++); // advance to a free column | |
| int colSpan = getColumnsOccupied(cv); | |
| spans[cell] = columnSpans[col]; | |
| offsets[cell] = columnOffsets[col]; | |
| if (colSpan > 1) { | |
| int n = columnSpans.length; | |
| for (int j = 1; j < colSpan; j++) { | |
| // Because the table may be only partially formed, some | |
| // of the columns may not yet exist. Therefore we check | |
| // the bounds. | |
| if ((col+j) < n) { | |
| spans[cell] += columnSpans[col+j]; | |
| spans[cell] += cellSpacing; | |
| } | |
| } | |
| col += colSpan - 1; | |
| } | |
| col++; | |
| } | |
| } | |
| /** | |
| * Perform layout for the minor axis of the box (i.e. the | |
| * axis orthogonal to the axis that it represents). The results | |
| * of the layout should be placed in the given arrays which represent | |
| * the allocations to the children along the minor axis. This | |
| * is called by the superclass whenever the layout needs to be | |
| * updated along the minor axis. | |
| * <p> | |
| * This is implemented to delegate to the superclass, then adjust | |
| * the span for any cell that spans multiple rows. | |
| * | |
| * @param targetSpan the total span given to the view, which | |
| * would be used to layout the children | |
| * @param axis the axis being laid out | |
| * @param offsets the offsets from the origin of the view for | |
| * each of the child views; this is a return value and is | |
| * filled in by the implementation of this method | |
| * @param spans the span of each child view; this is a return | |
| * value and is filled in by the implementation of this method | |
| * @return the offset and span for each child view in the | |
| * offsets and spans parameters | |
| */ | |
| protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) { | |
| super.layoutMinorAxis(targetSpan, axis, offsets, spans); | |
| int col = 0; | |
| int ncells = getViewCount(); | |
| for (int cell = 0; cell < ncells; cell++, col++) { | |
| View cv = getView(cell); | |
| for (; isFilled(col); col++); // advance to a free column | |
| int colSpan = getColumnsOccupied(cv); | |
| int rowSpan = getRowsOccupied(cv); | |
| if (rowSpan > 1) { | |
| int row0 = rowIndex; | |
| int row1 = Math.min(rowIndex + rowSpan - 1, getRowCount()-1); | |
| spans[cell] = getMultiRowSpan(row0, row1); | |
| } | |
| if (colSpan > 1) { | |
| col += colSpan - 1; | |
| } | |
| } | |
| } | |
| /** | |
| * Determines the resizability of the view along the | |
| * given axis. A value of 0 or less is not resizable. | |
| * | |
| * @param axis may be either View.X_AXIS or View.Y_AXIS | |
| * @return the resize weight | |
| * @throws IllegalArgumentException for an invalid axis | |
| */ | |
| public int getResizeWeight(int axis) { | |
| return 1; | |
| } | |
| /** | |
| * Fetches the child view that represents the given position in | |
| * the model. This is implemented to walk through the children | |
| * looking for a range that contains the given position. In this | |
| * view the children do not necessarily have a one to one mapping | |
| * with the child elements. | |
| * | |
| * @param pos the search position >= 0 | |
| * @param a the allocation to the table on entry, and the | |
| * allocation of the view containing the position on exit | |
| * @return the view representing the given position, or | |
| * null if there isn't one | |
| */ | |
| protected View getViewAtPosition(int pos, Rectangle a) { | |
| int n = getViewCount(); | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| int p0 = v.getStartOffset(); | |
| int p1 = v.getEndOffset(); | |
| if ((pos >= p0) && (pos < p1)) { | |
| // it's in this view. | |
| if (a != null) { | |
| childAllocation(i, a); | |
| } | |
| return v; | |
| } | |
| } | |
| if (pos == getEndOffset()) { | |
| View v = getView(n - 1); | |
| if (a != null) { | |
| this.childAllocation(n - 1, a); | |
| } | |
| return v; | |
| } | |
| return null; | |
| } | |
| /** | |
| * Update any cached values that come from attributes. | |
| */ | |
| void setPropertiesFromAttributes() { | |
| StyleSheet sheet = getStyleSheet(); | |
| attr = sheet.getViewAttributes(this); | |
| painter = sheet.getBoxPainter(attr); | |
| } | |
| private StyleSheet.BoxPainter painter; | |
| private AttributeSet attr; | |
| /** columns filled by multi-column or multi-row cells */ | |
| BitSet fillColumns; | |
| /** | |
| * The row index within the overall grid | |
| */ | |
| int rowIndex; | |
| /** | |
| * The view index (for row index to view index conversion). | |
| * This is set by the updateGrid method. | |
| */ | |
| int viewIndex; | |
| /** | |
| * Does this table row have cells that span multiple rows? | |
| */ | |
| boolean multiRowCells; | |
| } | |
| /** | |
| * Default view of an html table cell. This needs to be moved | |
| * somewhere else. | |
| */ | |
| static class CellView extends BlockView { | |
| /** | |
| * Constructs a TableCell for the given element. | |
| * | |
| * @param elem the element that this view is responsible for | |
| */ | |
| public CellView(Element elem) { | |
| super(elem, Y_AXIS); | |
| } | |
| /** | |
| * Perform layout for the major axis of the box (i.e. the | |
| * axis that it represents). The results of the layout should | |
| * be placed in the given arrays which represent the allocations | |
| * to the children along the major axis. This is called by the | |
| * superclass to recalculate the positions of the child views | |
| * when the layout might have changed. | |
| * <p> | |
| * This is implemented to delegate to the superclass to | |
| * tile the children. If the target span is greater than | |
| * was needed, the offsets are adjusted to align the children | |
| * (i.e. position according to the html valign attribute). | |
| * | |
| * @param targetSpan the total span given to the view, which | |
| * would be used to layout the children | |
| * @param axis the axis being laid out | |
| * @param offsets the offsets from the origin of the view for | |
| * each of the child views; this is a return value and is | |
| * filled in by the implementation of this method | |
| * @param spans the span of each child view; this is a return | |
| * value and is filled in by the implementation of this method | |
| * @return the offset and span for each child view in the | |
| * offsets and spans parameters | |
| */ | |
| protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, int[] spans) { | |
| super.layoutMajorAxis(targetSpan, axis, offsets, spans); | |
| // calculate usage | |
| int used = 0; | |
| int n = spans.length; | |
| for (int i = 0; i < n; i++) { | |
| used += spans[i]; | |
| } | |
| // calculate adjustments | |
| int adjust = 0; | |
| if (used < targetSpan) { | |
| // PENDING(prinz) change to use the css alignment. | |
| String valign = (String) getElement().getAttributes().getAttribute( | |
| HTML.Attribute.VALIGN); | |
| if (valign == null) { | |
| AttributeSet rowAttr = getElement().getParentElement().getAttributes(); | |
| valign = (String) rowAttr.getAttribute(HTML.Attribute.VALIGN); | |
| } | |
| if ((valign == null) || valign.equals("middle")) { | |
| adjust = (targetSpan - used) / 2; | |
| } else if (valign.equals("bottom")) { | |
| adjust = targetSpan - used; | |
| } | |
| } | |
| // make adjustments. | |
| if (adjust != 0) { | |
| for (int i = 0; i < n; i++) { | |
| offsets[i] += adjust; | |
| } | |
| } | |
| } | |
| /** | |
| * Calculate the requirements needed along the major axis. | |
| * This is called by the superclass whenever the requirements | |
| * need to be updated (i.e. a preferenceChanged was messaged | |
| * through this view). | |
| * <p> | |
| * This is implemented to delegate to the superclass, but | |
| * indicate the maximum size is very large (i.e. the cell | |
| * is willing to expend to occupy the full height of the row). | |
| * | |
| * @param axis the axis being laid out. | |
| * @param r the requirements to fill in. If null, a new one | |
| * should be allocated. | |
| */ | |
| protected SizeRequirements calculateMajorAxisRequirements(int axis, | |
| SizeRequirements r) { | |
| SizeRequirements req = super.calculateMajorAxisRequirements(axis, r); | |
| req.maximum = Integer.MAX_VALUE; | |
| return req; | |
| } | |
| @Override | |
| protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) { | |
| SizeRequirements rv = super.calculateMinorAxisRequirements(axis, r); | |
| //for the cell the minimum should be derived from the child views | |
| //the parent behaviour is to use CSS for that | |
| int n = getViewCount(); | |
| int min = 0; | |
| for (int i = 0; i < n; i++) { | |
| View v = getView(i); | |
| min = Math.max((int) v.getMinimumSpan(axis), min); | |
| } | |
| rv.minimum = Math.min(rv.minimum, min); | |
| return rv; | |
| } | |
| } | |
| } |