/*******************************************************************************
* Copyright (c) 2006 Sybase, Inc. and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Sybase, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.pagedesigner.css2.layout.table;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
import org.eclipse.jst.pagedesigner.PDPlugin;
import org.eclipse.jst.pagedesigner.css2.ICSSStyle;
import org.eclipse.jst.pagedesigner.css2.layout.CSSBlockFlowLayout;
import org.eclipse.jst.pagedesigner.css2.layout.CSSFigure;
import org.eclipse.jst.pagedesigner.css2.layout.ICSSPainter;
import org.eclipse.jst.pagedesigner.css2.property.ICSSPropertyID;
import org.eclipse.jst.pagedesigner.css2.style.ITagEditInfo;
import org.eclipse.swt.SWT;
/**
* see also http://www.w3.org/TR/REC-CSS2/tables.html
*
* @author mengbo
* @version 1.5
*/
public class CSSTableLayout2 extends CSSBlockFlowLayout implements ICSSPainter {
static Logger _log = PDPlugin.getLogger(CSSTableLayout2.class);
int _hspacing;
int _vspacing;
int[] _columnWidths;
int[] _rowHeights;
Dimension _captionSize;
// _tableInfo will be initialized in preLayout
TableInfo _tableInfo;
private int _internalTableWidth;
private int _internalTableHeight;
private int _rowx;
private int _rowwidth;
/**
* @param flowfigure
*/
public CSSTableLayout2(CSSFigure flowfigure) {
super(flowfigure);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.pagedesigner.css2.layout.CSSBlockFlowLayout#preLayout()
*/
protected void preLayout() {
// super.preLayout will setup the block box.
super.preLayout();
ICSSStyle style = this.getCSSStyle();
_hspacing = _vspacing = 3; // default value
if (style != null) {
Object borderspacing = style
.getStyleProperty(ICSSPropertyID.ATTR_BORDER_SPACING);
if (borderspacing instanceof int[]) {
int[] intvalues = (int[]) borderspacing;
_hspacing = intvalues[0];
_vspacing = intvalues[1];
} else {
ITagEditInfo info = (ITagEditInfo) style
.getAdapter(ITagEditInfo.class);
if (info != null && info.needTableDecorator()) {
// default decorating value. to make things look more
// separated.
if (_hspacing < 5) {
_hspacing = 5;
}
if (_vspacing < 5) {
_vspacing = 5;
}
}
}
}
// TODO: support caption
_tableInfo = new TableInfo(getCSSFigure());
// construct the table structure.
_tableInfo.constructTable();
// calculate the user specified width/height for table and cells.
// contentWidth is the user specified content width. If <= 0 means no
// user
// specification.
int contentWidth = this._blockBox.getContentWidth();
int availableWidth = this._blockBox.getRecommendedContentWidth();
int contentHeight = this._blockBox.getContentHeight();
_tableInfo.calculateWidth(contentWidth, availableWidth);
_tableInfo.calculateHeight(contentHeight);
int columnCount = _tableInfo.getColumnCount();
int columnMinWidths[] = new int[columnCount];
int columnMaxWidths[] = new int[columnCount];
// For each column, determine a maximum and minimum column width from
// the cells that span only that column. The minimum is that required by
// the cell with the largest minimum cell width (or the column 'width',
// whichever is larger). The maximum is that required by the cell with
// the
// largest maximum cell width (or the column 'width', whichever is
// larger).
List cells = _tableInfo.getCells();
for (int i = 0, size = cells.size(); i < size; i++) {
TableCellInfo cellinfo = (TableCellInfo) cells.get(i);
if (cellinfo.getColSpan() == 1) {
int column = cellinfo.getColumnIndex();
Dimension mincw = cellinfo.getMinCWDimension();
Dimension maxcw = cellinfo.getMaxCWDimension();
if (maxcw.width < mincw.width) {
maxcw.width = mincw.width;
}
if (mincw.width > columnMinWidths[column]) {
columnMinWidths[column] = mincw.width;
}
if (maxcw.width > columnMaxWidths[column]) {
columnMaxWidths[column] = maxcw.width;
}
}
}
// For caption, determine a maximum and minimum width from it.
int captionWidth = 0;
if (_tableInfo.getCaption() != null) {
captionWidth = _tableInfo.getCaption().getDimension().width;
}
// For each cell that spans more than one column, increase the
// minimum widths of the columns it spans so that together, they
// are at least as wide as the cell. Do the same for the maximum
// widths. If possible, widen all spanned columns by approximately
// the same amount.
for (int i = 0, size = cells.size(); i < size; i++) {
TableCellInfo cellinfo = (TableCellInfo) cells.get(i);
int colspan = cellinfo.getColSpan();
if (colspan > 1) {
int column = cellinfo.getColumnIndex();
Dimension mincw = cellinfo.getMinCWDimension();
Dimension maxcw = cellinfo.getMaxCWDimension();
adjustWidth(column, colspan, mincw.width, columnMinWidths);
adjustWidth(column, colspan, maxcw.width, columnMaxWidths);
}
}
int sigmaMinWidth = 0;
int sigmaMaxWidth = 0;
for (int i = 0; i < columnMinWidths.length; i++) {
sigmaMinWidth += columnMinWidths[i];
if (columnMaxWidths[i] == Integer.MAX_VALUE) {
sigmaMaxWidth = Integer.MAX_VALUE;
} else if (sigmaMaxWidth != Integer.MAX_VALUE) {
sigmaMaxWidth += columnMaxWidths[i];
if (sigmaMaxWidth < 0) {
sigmaMaxWidth = Integer.MAX_VALUE;
}
}
}
int spacingall = (columnMinWidths.length + 1) * _hspacing;
sigmaMinWidth += spacingall;
if (sigmaMaxWidth != Integer.MAX_VALUE) {
sigmaMaxWidth += spacingall;
if (sigmaMaxWidth < 0) {
sigmaMaxWidth = Integer.MAX_VALUE;
}
}
int tableWidth = _tableInfo.getTableWidth();
if (tableWidth > 0) {
// If the 'table' or 'inline-table' element's 'width' property has a
// specified value (W) other than 'auto', the property's computed
// value
// is the greater of W and the minimum width required by all the
// columns
// plus cell spacing or borders (MIN). If W is greater than MIN, the
// extra
// width should be distributed over the columns.
int maxMin = Math.max(captionWidth, sigmaMinWidth);
if (maxMin >= tableWidth) {
tableWidth = maxMin;
}
distribute(tableWidth - sigmaMinWidth, columnMinWidths,
columnMaxWidths);
} else {
// If the 'table' or 'inline-table' element has 'width: auto', the
// computed
// table width is the greater of the table's containing block width
// and MIN.
// However, if the maximum width required by the columns plus cell
// spacing or
// borders (MAX) is less than that of the containing block, use MAX.
// int availableWidth = this.getCurrentLine().getAvailableWidth();
int maxMin = Math.max(captionWidth, sigmaMaxWidth);
if (maxMin <= availableWidth) {
// TODO: if _tableInfo.hasWidthPercentage, then we need take
// that into consideration
// to distribute the column width. Left to next version.
tableWidth = maxMin;
// columnMinWidths = columnMaxWidths;
} else {
tableWidth = availableWidth;
}
distribute(tableWidth - sigmaMinWidth, columnMinWidths,
columnMaxWidths);
}
// now columnMinWidths contains width for each column
_columnWidths = columnMinWidths;
// ok, we have finished calculating column width.
// next we need to find out row heights.
_rowHeights = new int[_tableInfo.getRowCount()];
// first find out those TR that has height settings and use them.
List rows = _tableInfo.getRows();
for (int i = 0, size = rows.size(); i < size && i < _rowHeights.length; i++) {
TableRowInfo rowInfo = (TableRowInfo) rows.get(i);
if (rowInfo.getSpecifiedRowHeight() > 0) {
_rowHeights[i] = rowInfo.getSpecifiedRowHeight();
}
}
// First the cells don't span multiple rows.
cells = _tableInfo.getCells();
for (int i = 0, size = cells.size(); i < size; i++) {
TableCellInfo cellinfo = (TableCellInfo) cells.get(i);
IFigure figure = cellinfo.getFigure();
int rowspan = cellinfo.getRowSpan();
if (rowspan == 1) {
int cellWidth = getCellWidth(cellinfo, _columnWidths);
Dimension d = figure.getPreferredSize(cellWidth, cellinfo
.getHeight());
if (d.height > _rowHeights[cellinfo.getRowIndex()]) {
_rowHeights[cellinfo.getRowIndex()] = d.height;
}
}
}
// Next those cells span multiple rows.
cells = _tableInfo.getCells();
for (int i = 0, size = cells.size(); i < size; i++) {
TableCellInfo cellinfo = (TableCellInfo) cells.get(i);
IFigure figure = cellinfo.getFigure();
int rowspan = cellinfo.getRowSpan();
if (rowspan > 1) {
int cellWidth = getCellWidth(cellinfo, _columnWidths);
Dimension d = figure.getPreferredSize(cellWidth, cellinfo
.getHeight());
if (d.height > getCellHeight(cellinfo, _rowHeights)) {
adjustHeight(cellinfo.getRowIndex(), rowspan, d.height,
_rowHeights);
}
}
}
// Next we may need distribute height.
int sigmaHeight = (_tableInfo.getRowCount() + 1) * _vspacing;
for (int i = 0; i < _rowHeights.length; i++) {
sigmaHeight += _rowHeights[i];
}
if (sigmaHeight < contentHeight) {
distributeHeights(contentHeight - sigmaHeight, _rowHeights);
}
// now we have calculated the width and height of all cells.
// FIXME: border?
Insets insets = (style == null ? new Insets() : style.getBorderInsets()
.getAdded(style.getPaddingInsets()));
_internalTableWidth = (_tableInfo.getColumnCount() + 1) * _hspacing;
for (int i = 0; i < _columnWidths.length; i++) {
_internalTableWidth += _columnWidths[i];
}
int minWidth = getLengthValue(style, ICSSPropertyID.ATTR_MIN_WIDTH);
_internalTableWidth = _internalTableWidth > minWidth ? _internalTableWidth
: minWidth;
_blockBox.setWidth(_internalTableWidth + insets.getWidth());
_internalTableHeight = (_tableInfo.getRowCount() + 1) * _vspacing;
for (int i = 0; i < _rowHeights.length; i++) {
_internalTableHeight += _rowHeights[i];
}
int minHeight = getLengthValue(style, ICSSPropertyID.ATTR_MIN_HEIGHT);
_internalTableHeight = _internalTableHeight > minHeight ? _internalTableHeight
: minHeight;
int captionHeight = 0;
if (_tableInfo.getCaption() != null) {
_captionSize = _tableInfo.getCaption().getFigure().getPreferredSize(
_internalTableWidth, SWT.DEFAULT);
captionHeight = _captionSize.height;
} else {
_captionSize = null;
}
_internalTableHeight += captionHeight;
_blockBox.setHeight(_internalTableHeight + insets.getHeight());
_rowwidth = _internalTableWidth - 2 * _hspacing;
_rowx = _hspacing; // XXX: table border width left?
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.pagedesigner.css2.layout.CSSBlockFlowLayout#endBlock()
*/
protected void endBlock() {
_blockBox.setWidth(_internalTableWidth
+ _blockBox.getBorderPaddingWidth());
_blockBox.setHeight(_internalTableHeight
+ _blockBox.getBorderPaddingHeight());
super.endBlock();
}
//
// /**
// * when some of the column has percentage width, and sigmaMax smaller than
// container,
// * @param containerWidth
// * @param columnMinWidths
// * @param columnMaxWidths
// * @return
// */
// private int distribute2(int containerWidth, int[] columnMinWidths, int[]
// columnMaxWidths)
// {
//
// }
//
/**
* Distribute the additional width to columnMinWidths, using max width as a
* possible reference on how to distribute.
*
* @param toDistribute
* @param columnMinWidths
* @param columnMaxWidths
*/
private void distribute(int toDistribute, int[] columnMinWidths,
int[] columnMaxWidths) {
if (toDistribute <= 0)
return;
if (columnMinWidths.length == 0)
return;
int[] delta = new int[columnMinWidths.length];
int sigmaDelta = 0;
for (int i = 0; i < columnMinWidths.length; i++) {
if (_tableInfo.getWidthSpecified()[i]) {
delta[i] = 0;
} else {
delta[i] = columnMaxWidths[i] - columnMinWidths[i];
if (delta[i] <= 0) {
delta[i] = 0;
}
sigmaDelta += delta[i];
}
}
// re-calculate the width of columns that use a percentage
int[] widthPercentages = _tableInfo.getWidthPercentages();
int[] calculatedWidths = new int[columnMaxWidths.length];
int percentageWidthsTotal = 0;
for (int i=0; i < widthPercentages.length; i++) {
if (widthPercentages[i] > 0) {
// add the widths of the percent width columns
// back into the available pool
toDistribute += columnMinWidths[i];
}
}
for (int i=0; i < widthPercentages.length; i++) {
if (widthPercentages[i] > 0) {
double val = toDistribute * (widthPercentages[i] / 100.0);
calculatedWidths[i] = (int) val;
if (calculatedWidths[i] < columnMinWidths[i]) {
// percent width is too small, so use
// the columnMinWidth instead
calculatedWidths[i] = columnMinWidths[i];
}
percentageWidthsTotal += calculatedWidths[i];
} else {
calculatedWidths[i] = 0;
}
}
if (percentageWidthsTotal > toDistribute) {
// calculated width is too large, so shrink the columns
// to fit the available space
int widthColumnCount = 0;
for (int i=0; i < widthPercentages.length; i++) {
if (widthPercentages[i] > 0) {
widthColumnCount++;
}
}
int extraSpace = percentageWidthsTotal - toDistribute;
int shrinkBy = (int)
Math.ceil((double) extraSpace / (double) widthColumnCount);
for (int i=0; i < calculatedWidths.length; i++) {
if (calculatedWidths[i] > 0) {
calculatedWidths[i] -= shrinkBy;
}
}
}
// adjust the columnMinWidth values to compensate for the
// calculated percentages
for (int i=0; i < calculatedWidths.length; i++) {
// if column size was calculated, then re-calculate the delta
if (calculatedWidths[i] > 0) {
// remove the previous calculation from the sigmaDelta
int len = columnMaxWidths[i] - columnMinWidths[i];
delta[i] = 0;
if (len <= 0) {
len = 0;
}
sigmaDelta -= len;
// change the minSize to the calculated size
columnMinWidths[i] = calculatedWidths[i];
toDistribute -= columnMinWidths[i];
}
}
if (sigmaDelta == 0) {
// may happen with percent width column calculations.
// find out how much space is left and distribute it
// equally to all columns that are not fixed-width.
int extraSpace = toDistribute;
for (int i=0; i < columnMinWidths.length; i++) {
extraSpace -= columnMinWidths[i];
}
averageDeltaToCell(columnMinWidths, extraSpace);
} else {
int left = toDistribute;
for (int i = 0; i < columnMinWidths.length - 1; i++) {
if (delta[i] > 0) {
int add = delta[i] * toDistribute / sigmaDelta;
left -= add;
columnMinWidths[i] += add;
}
}
columnMinWidths[columnMinWidths.length - 1] += left;
}
}
private void averageDeltaToCell(int[] columnMinWidths, int toDistribute) {
if (toDistribute <= 0) {
return;
}
ArrayList list = new ArrayList();
for (int i = 0; i < columnMinWidths.length; i++) {
if (!_tableInfo.getWidthSpecified()[i]) {
list.add(new Integer(i));
}
}
if (list.size() == 0) {
for (int i = 0; i < columnMinWidths.length; i++) {
list.add(new Integer(i));
}
}
int padding = toDistribute / list.size();
int left = toDistribute % list.size();
for (int i = 0, n = list.size(); i < n; i++) {
columnMinWidths[((Integer) list.get(i)).intValue()] += padding;
}
if (left > 0) {
for (int i = 0; i < left; i++) {
columnMinWidths[((Integer) list.get(i)).intValue()] += 1;
}
}
}
/**
* @param i
* @param heights
*/
private void distributeHeights(int toDistribute, int[] heights) {
if (heights.length == 0)
return;
int eachDelta = toDistribute / heights.length;
for (int i = 0; i < heights.length - 1; i++) {
heights[i] += eachDelta;
}
heights[heights.length - 1] += toDistribute - (heights.length - 1)
* eachDelta;
}
/**
* @param cellinfo
* @param heights
* @return the cell height
*/
public int getCellHeight(TableCellInfo cellinfo, int[] heights) {
int rowIndex = cellinfo.getRowIndex();
int rowspan = cellinfo.getRowSpan();
int h = 0;
for (int i = 0; i < rowspan; i++) {
h += heights[rowIndex + i];
}
h += (rowspan - 1) * _vspacing;
return h;
}
/**
* @param cellinfo
* @param widths
* @return the cell width
*/
public int getCellWidth(TableCellInfo cellinfo, int[] widths) {
int columnIndex = cellinfo.getColumnIndex();
int colspan = cellinfo.getColSpan();
int w = 0;
for (int i = 0; i < colspan; i++) {
w += widths[columnIndex + i];
}
w += (colspan - 1) * _hspacing;
return w;
}
/**
* @param column
* the start column
* @param colspan
* number of columns
* @param width
* desired width
* @param columnWidths
* current columns widths. After the adjust, need make sure the
* columnWidths to be bigger than desired width
*/
private void adjustWidth(int column, int colspan, int width,
int[] columnWidths) {
adjustSpan(column, colspan, width, columnWidths, _hspacing);
}
/**
* @see #adjustWidth(int, int, int, int[])
*/
private void adjustHeight(int rowIndex, int rowspan, int height,
int[] heights) {
adjustSpan(rowIndex, rowspan, height, heights, _vspacing);
}
static private void adjustSpan(int column, int colspan, int width,
int[] columnWidths, int spacing) {
int spanwidth = 0;
for (int i = 0; i < colspan; i++) {
spanwidth += columnWidths[column + i];
}
// XXX: vspacing here?
spanwidth += (colspan - 1) * spacing;
if (spanwidth >= width) {
return;
}
int delta = width - spanwidth;
int deltaeach = delta / colspan;
for (int i = 0; i < colspan - 1; i++) {
columnWidths[column + i] += deltaeach;
}
columnWidths[column + colspan - 1] += (delta - (colspan - 1)
* deltaeach);
}
/**
* @return the row heights
*/
public int[] getRowHeights() {
return _rowHeights;
}
/**
* @return the column widths
*/
public int[] getColumnWidths() {
return _columnWidths;
}
/**
* @return the vertical spacing value
*/
public int getVSpacing() {
return _vspacing;
}
/**
* @return the horizontal spacing value
*/
public int getHSpacing() {
return _hspacing;
}
/**
* @param figure
* @return the table row info for the figure
*/
public TableRowInfo getRowInfo(CSSFigure figure) {
return _tableInfo.findRowInfo(figure);
}
/**
* @return the table caption info
*/
public TableCaptionInfo getCaptionInfo() {
return _tableInfo.getCaption();
}
/**
* @param figure
* @return the table row group info for the figure
*/
public TableRowGroupInfo getGroupInfo(CSSFigure figure) {
return _tableInfo.findGroupInfo(figure);
}
/**
* @return the row's x
*/
public int getRowX() {
return _rowx;
}
/**
* @return the row's width
*/
public int getRowWidth() {
return _rowwidth;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.pagedesigner.css2.layout.CSSBlockFlowLayout#shouldExpand()
*/
public boolean shouldExpand() {
return false;
}
/**
* @return the rendered dimensions of the table caption
*/
public Dimension getCaptionSize() {
return _captionSize;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.pagedesigner.css2.layout.ICSSPainter#paintFigure(org.eclipse.draw2d.Graphics)
*/
public void paintFigure(Graphics g) {
ICSSStyle style = this.getCSSStyle();
if (style != null) {
ITagEditInfo info = (ITagEditInfo) style
.getAdapter(ITagEditInfo.class);
if (info != null && info.needTableDecorator()) {
List cells = _tableInfo.getCells();
for (int i = 0, size = cells.size(); i < size; i++) {
TableCellInfo cellInfo = (TableCellInfo) cells.get(i);
IFigure cellfigure = cellInfo.getFigure();
Rectangle rect = cellfigure.getBounds().getCopy();
rect = rect.expand(1, 1);
g.setLineStyle(Graphics.LINE_SOLID);
g.setLineWidth(1);
g.setForegroundColor(ColorConstants.lightGray);
g.drawRectangle(rect);
}
}
}
}
}