Download
Getting Started
Members
Projects
Community
Marketplace
Events
Planet Eclipse
Newsletter
Videos
Participate
Report a Bug
Forums
Mailing Lists
Wiki
IRC
How to Contribute
Working Groups
Automotive
Internet of Things
LocationTech
Long-Term Support
PolarSys
Science
OpenMDM
More
Community
Marketplace
Events
Planet Eclipse
Newsletter
Videos
Participate
Report a Bug
Forums
Mailing Lists
Wiki
IRC
How to Contribute
Working Groups
Automotive
Internet of Things
LocationTech
Long-Term Support
PolarSys
Science
OpenMDM
Toggle navigation
Bugzilla – Attachment 199556 Details for
Bug 351935
FEATURE - GridLayout - reorder components by GridData
Home
|
New
|
Browse
|
Search
|
[?]
|
Reports
|
Requests
|
Help
|
Log In
[x]
|
Terms of Use
|
Copyright Agent
modyfied GridLayout to work with index
GridLayout.java (text/x-java-source), 25.58 KB, created by
Ludwig Moser
on 2011-07-13 05:46:14 EDT
(
hide
)
Description:
modyfied GridLayout to work with index
Filename:
MIME Type:
Creator:
Ludwig Moser
Created:
2011-07-13 05:46:14 EDT
Size:
25.58 KB
patch
obsolete
>package listTests.layout; > >import java.util.Arrays; > >import org.eclipse.swt.SWT; >import org.eclipse.swt.graphics.Point; >import org.eclipse.swt.graphics.Rectangle; >import org.eclipse.swt.widgets.Composite; >import org.eclipse.swt.widgets.Control; >import org.eclipse.swt.widgets.Layout; >import org.eclipse.swt.widgets.Scrollable; > >/** > * Instances of this class lay out the control children of a > * <code>Composite</code> in a grid. > * <p> > * <code>GridLayout</code> has a number of configuration fields, and the > * controls it lays out can have an associated layout data object, called > * <code>GridData</code>. The power of <code>GridLayout</code> lies in the > * ability to configure <code>GridData</code> for each control in the layout. > * </p> > * <p> > * The following code creates a shell managed by a <code>GridLayout</code> with > * 3 columns: > * > * <pre> > * Display display = new Display(); > * Shell shell = new Shell(display); > * GridLayout gridLayout = new GridLayout(); > * gridLayout.numColumns = 3; > * shell.setLayout(gridLayout); > * </pre> > * > * The <code>numColumns</code> field is the most important field in a > * <code>GridLayout</code>. Widgets are laid out in columns from left to right, > * and a new row is created when <code>numColumns</code> + 1 controls are added > * to the <code>Composite<code>. > * </p> > * > * @see GridData > * @see <a href="http://www.eclipse.org/swt/snippets/#gridlayout">GridLayout > * snippets</a> > * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: > * LayoutExample</a> > * @see <a href="http://www.eclipse.org/swt/">Sample code and further > * information</a> > */ >public final class GridLayout extends Layout /* implements PropertyChangeListener */{ > > /** > * numColumns specifies the number of cell columns in the layout. If > * numColumns has a value less than 1, the layout will not set the size and > * position of any controls. > * > * The default value is 1. > */ > public int numColumns = 1; > > /** > * makeColumnsEqualWidth specifies whether all columns in the layout will be > * forced to have the same width. > * > * The default value is false. > */ > public boolean makeColumnsEqualWidth = false; > > /** > * marginWidth specifies the number of pixels of horizontal margin that will > * be placed along the left and right edges of the layout. > * > * The default value is 5. > */ > public int marginWidth = 5; > > /** > * marginHeight specifies the number of pixels of vertical margin that will > * be placed along the top and bottom edges of the layout. > * > * The default value is 5. > */ > public int marginHeight = 5; > > /** > * marginLeft specifies the number of pixels of horizontal margin that will > * be placed along the left edge of the layout. > * > * The default value is 0. > * > * @since 3.1 > */ > public int marginLeft = 0; > > /** > * marginTop specifies the number of pixels of vertical margin that will be > * placed along the top edge of the layout. > * > * The default value is 0. > * > * @since 3.1 > */ > public int marginTop = 0; > > /** > * marginRight specifies the number of pixels of horizontal margin that will > * be placed along the right edge of the layout. > * > * The default value is 0. > * > * @since 3.1 > */ > public int marginRight = 0; > > /** > * marginBottom specifies the number of pixels of vertical margin that will > * be placed along the bottom edge of the layout. > * > * The default value is 0. > * > * @since 3.1 > */ > public int marginBottom = 0; > > /** > * horizontalSpacing specifies the number of pixels between the right edge > * of one cell and the left edge of its neighbouring cell to the right. > * > * The default value is 5. > */ > public int horizontalSpacing = 5; > > /** > * verticalSpacing specifies the number of pixels between the bottom edge of > * one cell and the top edge of its neighbouring cell underneath. > * > * The default value is 5. > */ > public int verticalSpacing = 5; > > /** > * Constructs a new instance of this class. > */ > public GridLayout() { > } > > /** > * Constructs a new instance of this class given the number of columns, and > * whether or not the columns should be forced to have the same width. If > * numColumns has a value less than 1, the layout will not set the size and > * position of any controls. > * > * @param numColumns > * the number of columns in the grid > * @param makeColumnsEqualWidth > * whether or not the columns will have equal width > * > * @since 2.0 > */ > public GridLayout(int numColumns, boolean makeColumnsEqualWidth) { > this.numColumns = numColumns; > this.makeColumnsEqualWidth = makeColumnsEqualWidth; > } > > protected Point computeSize(Composite composite, int wHint, int hHint, > boolean flushCache) { > Point size = layout(composite, false, 0, 0, wHint, hHint, flushCache); > if (wHint != SWT.DEFAULT) > size.x = wHint; > if (hHint != SWT.DEFAULT) > size.y = hHint; > return size; > } > > protected boolean flushCache(Control control) { > Object data = control.getLayoutData(); > if (data != null) > ((GridData) data).flushCache(); > return true; > } > > GridData getData(Control[][] grid, int row, int column, int rowCount, > int columnCount, boolean first) { > Control control = grid[row][column]; > if (control != null) { > GridData data = (GridData) control.getLayoutData(); > int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount)); > int vSpan = Math.max(1, data.verticalSpan); > int i = first ? row + vSpan - 1 : row - vSpan + 1; > int j = first ? column + hSpan - 1 : column - hSpan + 1; > if (0 <= i && i < rowCount) { > if (0 <= j && j < columnCount) { > if (control == grid[i][j]) > return data; > } > } > } > return null; > } > > protected void layout(Composite composite, boolean flushCache) { > Rectangle rect = composite.getClientArea(); > layout(composite, true, rect.x, rect.y, rect.width, rect.height, > flushCache); > } > > Point layout(Composite composite, boolean move, int x, int y, int width, > int height, boolean flushCache) { > if (numColumns < 1) { > return new Point(marginLeft + marginWidth * 2 + marginRight, > marginTop + marginHeight * 2 + marginBottom); > } > Control[] children = composite.getChildren(); > > int count = 0; > for (int i = 0; i < children.length; i++) { > Control control = children[i]; > GridData data = (GridData) control.getLayoutData(); > if (data != null) { > children[i].setVisible(!data.exclude); > if (!data.exclude) { > children[count++] = children[i]; > } > } > } > > Arrays.sort(children, new GridLayoutComparator()); > > if (count == 0) { > return new Point(marginLeft + marginWidth * 2 + marginRight, > marginTop + marginHeight * 2 + marginBottom); > } > for (int i = 0; i < count; i++) { > Control child = children[i]; > GridData data = (GridData) child.getLayoutData(); > if (flushCache) { > data.flushCache(); > } > data.computeSize(child, data.widthHint, data.heightHint, flushCache); > if (data.grabExcessHorizontalSpace && data.minimumWidth > 0) { > if (data.cacheWidth < data.minimumWidth) { > int trim = 0; > // TEMPORARY CODE > if (child instanceof Scrollable) { > Rectangle rect = ((Scrollable) child).computeTrim(0, 0, > 0, 0); > trim = rect.width; > } else { > trim = child.getBorderWidth() * 2; > } > data.cacheWidth = data.cacheHeight = SWT.DEFAULT; > data.computeSize(child, > Math.max(0, data.minimumWidth - trim), > data.heightHint, false); > } > } > if (data.grabExcessVerticalSpace && data.minimumHeight > 0) { > data.cacheHeight = Math.max(data.cacheHeight, > data.minimumHeight); > } > } > > /* Build the grid */ > int row = 0, column = 0, rowCount = 0, columnCount = numColumns; > Control[][] grid = new Control[4][columnCount]; > for (int i = 0; i < count; i++) { > Control child = children[i]; > GridData data = (GridData) child.getLayoutData(); > int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount)); > int vSpan = Math.max(1, data.verticalSpan); > while (true) { > int lastRow = row + vSpan; > if (lastRow >= grid.length) { > Control[][] newGrid = new Control[lastRow + 4][columnCount]; > System.arraycopy(grid, 0, newGrid, 0, grid.length); > grid = newGrid; > } > if (grid[row] == null) { > grid[row] = new Control[columnCount]; > } > while (column < columnCount && grid[row][column] != null) { > column++; > } > int endCount = column + hSpan; > if (endCount <= columnCount) { > int index = column; > while (index < endCount && grid[row][index] == null) { > index++; > } > if (index == endCount) > break; > column = index; > } > if (column + hSpan >= columnCount) { > column = 0; > row++; > } > } > for (int j = 0; j < vSpan; j++) { > if (grid[row + j] == null) { > grid[row + j] = new Control[columnCount]; > } > for (int k = 0; k < hSpan; k++) { > grid[row + j][column + k] = child; > } > } > rowCount = Math.max(rowCount, row + vSpan); > column += hSpan; > } > > /* Column widths */ > int availableWidth = width - horizontalSpacing * (columnCount - 1) > - (marginLeft + marginWidth * 2 + marginRight); > int expandCount = 0; > int[] widths = new int[columnCount]; > int[] minWidths = new int[columnCount]; > boolean[] expandColumn = new boolean[columnCount]; > for (int j = 0; j < columnCount; j++) { > for (int i = 0; i < rowCount; i++) { > GridData data = getData(grid, i, j, rowCount, columnCount, true); > if (data != null) { > int hSpan = Math.max(1, > Math.min(data.horizontalSpan, columnCount)); > if (hSpan == 1) { > int w = data.cacheWidth + data.horizontalIndent; > widths[j] = Math.max(widths[j], w); > if (data.grabExcessHorizontalSpace) { > if (!expandColumn[j]) > expandCount++; > expandColumn[j] = true; > } > if (!data.grabExcessHorizontalSpace > || data.minimumWidth != 0) { > w = !data.grabExcessHorizontalSpace > || data.minimumWidth == SWT.DEFAULT ? data.cacheWidth > : data.minimumWidth; > w += data.horizontalIndent; > minWidths[j] = Math.max(minWidths[j], w); > } > } > } > } > for (int i = 0; i < rowCount; i++) { > GridData data = getData(grid, i, j, rowCount, columnCount, > false); > if (data != null) { > int hSpan = Math.max(1, > Math.min(data.horizontalSpan, columnCount)); > if (hSpan > 1) { > int spanWidth = 0, spanMinWidth = 0, spanExpandCount = 0; > for (int k = 0; k < hSpan; k++) { > spanWidth += widths[j - k]; > spanMinWidth += minWidths[j - k]; > if (expandColumn[j - k]) > spanExpandCount++; > } > if (data.grabExcessHorizontalSpace > && spanExpandCount == 0) { > expandCount++; > expandColumn[j] = true; > } > int w = data.cacheWidth + data.horizontalIndent > - spanWidth - (hSpan - 1) * horizontalSpacing; > if (w > 0) { > if (makeColumnsEqualWidth) { > int equalWidth = (w + spanWidth) / hSpan; > int remainder = (w + spanWidth) % hSpan, last = -1; > for (int k = 0; k < hSpan; k++) { > widths[last = j - k] = Math.max(equalWidth, > widths[j - k]); > } > if (last > -1) > widths[last] += remainder; > } else { > if (spanExpandCount == 0) { > widths[j] += w; > } else { > int delta = w / spanExpandCount; > int remainder = w % spanExpandCount, last = -1; > for (int k = 0; k < hSpan; k++) { > if (expandColumn[j - k]) { > widths[last = j - k] += delta; > } > } > if (last > -1) > widths[last] += remainder; > } > } > } > if (!data.grabExcessHorizontalSpace > || data.minimumWidth != 0) { > w = !data.grabExcessHorizontalSpace > || data.minimumWidth == SWT.DEFAULT ? data.cacheWidth > : data.minimumWidth; > w += data.horizontalIndent - spanMinWidth > - (hSpan - 1) * horizontalSpacing; > if (w > 0) { > if (spanExpandCount == 0) { > minWidths[j] += w; > } else { > int delta = w / spanExpandCount; > int remainder = w % spanExpandCount, last = -1; > for (int k = 0; k < hSpan; k++) { > if (expandColumn[j - k]) { > minWidths[last = j - k] += delta; > } > } > if (last > -1) > minWidths[last] += remainder; > } > } > } > } > } > } > } > if (makeColumnsEqualWidth) { > int minColumnWidth = 0; > int columnWidth = 0; > for (int i = 0; i < columnCount; i++) { > minColumnWidth = Math.max(minColumnWidth, minWidths[i]); > columnWidth = Math.max(columnWidth, widths[i]); > } > columnWidth = width == SWT.DEFAULT || expandCount == 0 ? columnWidth > : Math.max(minColumnWidth, availableWidth / columnCount); > for (int i = 0; i < columnCount; i++) { > expandColumn[i] = expandCount > 0; > widths[i] = columnWidth; > } > } else { > if (width != SWT.DEFAULT && expandCount > 0) { > int totalWidth = 0; > for (int i = 0; i < columnCount; i++) { > totalWidth += widths[i]; > } > int c = expandCount; > int delta = (availableWidth - totalWidth) / c; > int remainder = (availableWidth - totalWidth) % c; > int last = -1; > while (totalWidth != availableWidth) { > for (int j = 0; j < columnCount; j++) { > if (expandColumn[j]) { > if (widths[j] + delta > minWidths[j]) { > widths[last = j] = widths[j] + delta; > } else { > widths[j] = minWidths[j]; > expandColumn[j] = false; > c--; > } > } > } > if (last > -1) > widths[last] += remainder; > > for (int j = 0; j < columnCount; j++) { > for (int i = 0; i < rowCount; i++) { > GridData data = getData(grid, i, j, rowCount, > columnCount, false); > if (data != null) { > int hSpan = Math.max(1, Math.min( > data.horizontalSpan, columnCount)); > if (hSpan > 1) { > if (!data.grabExcessHorizontalSpace > || data.minimumWidth != 0) { > int spanWidth = 0, spanExpandCount = 0; > for (int k = 0; k < hSpan; k++) { > spanWidth += widths[j - k]; > if (expandColumn[j - k]) > spanExpandCount++; > } > int w = !data.grabExcessHorizontalSpace > || data.minimumWidth == SWT.DEFAULT ? data.cacheWidth > : data.minimumWidth; > w += data.horizontalIndent - spanWidth > - (hSpan - 1) > * horizontalSpacing; > if (w > 0) { > if (spanExpandCount == 0) { > widths[j] += w; > } else { > int delta2 = w > / spanExpandCount; > int remainder2 = w > % spanExpandCount, last2 = -1; > for (int k = 0; k < hSpan; k++) { > if (expandColumn[j - k]) { > widths[last2 = j - k] += delta2; > } > } > if (last2 > -1) > widths[last2] += remainder2; > } > } > } > } > } > } > } > if (c == 0) > break; > totalWidth = 0; > for (int i = 0; i < columnCount; i++) { > totalWidth += widths[i]; > } > delta = (availableWidth - totalWidth) / c; > remainder = (availableWidth - totalWidth) % c; > last = -1; > } > } > } > > /* Wrapping */ > GridData[] flush = null; > int flushLength = 0; > if (width != SWT.DEFAULT) { > for (int j = 0; j < columnCount; j++) { > for (int i = 0; i < rowCount; i++) { > GridData data = getData(grid, i, j, rowCount, columnCount, > false); > if (data != null) { > if (data.heightHint == SWT.DEFAULT) { > Control child = grid[i][j]; > // TEMPORARY CODE > int hSpan = Math.max(1, > Math.min(data.horizontalSpan, columnCount)); > int currentWidth = 0; > for (int k = 0; k < hSpan; k++) { > currentWidth += widths[j - k]; > } > currentWidth += (hSpan - 1) * horizontalSpacing > - data.horizontalIndent; > if ((currentWidth != data.cacheWidth && data.horizontalAlignment == SWT.FILL) > || (data.cacheWidth > currentWidth)) { > int trim = 0; > if (child instanceof Scrollable) { > Rectangle rect = ((Scrollable) child) > .computeTrim(0, 0, 0, 0); > trim = rect.width; > } else { > trim = child.getBorderWidth() * 2; > } > data.cacheWidth = data.cacheHeight = SWT.DEFAULT; > data.computeSize(child, > Math.max(0, currentWidth - trim), > data.heightHint, false); > if (data.grabExcessVerticalSpace > && data.minimumHeight > 0) { > data.cacheHeight = Math.max( > data.cacheHeight, > data.minimumHeight); > } > if (flush == null) > flush = new GridData[count]; > flush[flushLength++] = data; > } > } > } > } > } > } > > /* Row heights */ > int availableHeight = height - verticalSpacing * (rowCount - 1) > - (marginTop + marginHeight * 2 + marginBottom); > expandCount = 0; > int[] heights = new int[rowCount]; > int[] minHeights = new int[rowCount]; > boolean[] expandRow = new boolean[rowCount]; > for (int i = 0; i < rowCount; i++) { > for (int j = 0; j < columnCount; j++) { > GridData data = getData(grid, i, j, rowCount, columnCount, true); > if (data != null) { > int vSpan = Math.max(1, > Math.min(data.verticalSpan, rowCount)); > if (vSpan == 1) { > int h = data.cacheHeight + data.verticalIndent; > heights[i] = Math.max(heights[i], h); > if (data.grabExcessVerticalSpace) { > if (!expandRow[i]) > expandCount++; > expandRow[i] = true; > } > if (!data.grabExcessVerticalSpace > || data.minimumHeight != 0) { > h = !data.grabExcessVerticalSpace > || data.minimumHeight == SWT.DEFAULT ? data.cacheHeight > : data.minimumHeight; > h += data.verticalIndent; > minHeights[i] = Math.max(minHeights[i], h); > } > } > } > } > for (int j = 0; j < columnCount; j++) { > GridData data = getData(grid, i, j, rowCount, columnCount, > false); > if (data != null) { > int vSpan = Math.max(1, > Math.min(data.verticalSpan, rowCount)); > if (vSpan > 1) { > int spanHeight = 0, spanMinHeight = 0, spanExpandCount = 0; > for (int k = 0; k < vSpan; k++) { > spanHeight += heights[i - k]; > spanMinHeight += minHeights[i - k]; > if (expandRow[i - k]) > spanExpandCount++; > } > if (data.grabExcessVerticalSpace > && spanExpandCount == 0) { > expandCount++; > expandRow[i] = true; > } > int h = data.cacheHeight + data.verticalIndent > - spanHeight - (vSpan - 1) * verticalSpacing; > if (h > 0) { > if (spanExpandCount == 0) { > heights[i] += h; > } else { > int delta = h / spanExpandCount; > int remainder = h % spanExpandCount, last = -1; > for (int k = 0; k < vSpan; k++) { > if (expandRow[i - k]) { > heights[last = i - k] += delta; > } > } > if (last > -1) > heights[last] += remainder; > } > } > if (!data.grabExcessVerticalSpace > || data.minimumHeight != 0) { > h = !data.grabExcessVerticalSpace > || data.minimumHeight == SWT.DEFAULT ? data.cacheHeight > : data.minimumHeight; > h += data.verticalIndent - spanMinHeight > - (vSpan - 1) * verticalSpacing; > if (h > 0) { > if (spanExpandCount == 0) { > minHeights[i] += h; > } else { > int delta = h / spanExpandCount; > int remainder = h % spanExpandCount, last = -1; > for (int k = 0; k < vSpan; k++) { > if (expandRow[i - k]) { > minHeights[last = i - k] += delta; > } > } > if (last > -1) > minHeights[last] += remainder; > } > } > } > } > } > } > } > if (height != SWT.DEFAULT && expandCount > 0) { > int totalHeight = 0; > for (int i = 0; i < rowCount; i++) { > totalHeight += heights[i]; > } > int c = expandCount; > int delta = (availableHeight - totalHeight) / c; > int remainder = (availableHeight - totalHeight) % c; > int last = -1; > while (totalHeight != availableHeight) { > for (int i = 0; i < rowCount; i++) { > if (expandRow[i]) { > if (heights[i] + delta > minHeights[i]) { > heights[last = i] = heights[i] + delta; > } else { > heights[i] = minHeights[i]; > expandRow[i] = false; > c--; > } > } > } > if (last > -1) > heights[last] += remainder; > > for (int i = 0; i < rowCount; i++) { > for (int j = 0; j < columnCount; j++) { > GridData data = getData(grid, i, j, rowCount, > columnCount, false); > if (data != null) { > int vSpan = Math.max(1, > Math.min(data.verticalSpan, rowCount)); > if (vSpan > 1) { > if (!data.grabExcessVerticalSpace > || data.minimumHeight != 0) { > int spanHeight = 0, spanExpandCount = 0; > for (int k = 0; k < vSpan; k++) { > spanHeight += heights[i - k]; > if (expandRow[i - k]) > spanExpandCount++; > } > int h = !data.grabExcessVerticalSpace > || data.minimumHeight == SWT.DEFAULT ? data.cacheHeight > : data.minimumHeight; > h += data.verticalIndent - spanHeight > - (vSpan - 1) * verticalSpacing; > if (h > 0) { > if (spanExpandCount == 0) { > heights[i] += h; > } else { > int delta2 = h / spanExpandCount; > int remainder2 = h > % spanExpandCount, last2 = -1; > for (int k = 0; k < vSpan; k++) { > if (expandRow[i - k]) { > heights[last2 = i - k] += delta2; > } > } > if (last2 > -1) > heights[last2] += remainder2; > } > } > } > } > } > } > } > if (c == 0) > break; > totalHeight = 0; > for (int i = 0; i < rowCount; i++) { > totalHeight += heights[i]; > } > delta = (availableHeight - totalHeight) / c; > remainder = (availableHeight - totalHeight) % c; > last = -1; > } > } > > /* Position the controls */ > if (move) { > int gridY = y + marginTop + marginHeight; > for (int i = 0; i < rowCount; i++) { > int gridX = x + marginLeft + marginWidth; > for (int j = 0; j < columnCount; j++) { > GridData data = getData(grid, i, j, rowCount, columnCount, > true); > if (data != null) { > int hSpan = Math.max(1, > Math.min(data.horizontalSpan, columnCount)); > int vSpan = Math.max(1, data.verticalSpan); > int cellWidth = 0, cellHeight = 0; > for (int k = 0; k < hSpan; k++) { > cellWidth += widths[j + k]; > } > for (int k = 0; k < vSpan; k++) { > cellHeight += heights[i + k]; > } > cellWidth += horizontalSpacing * (hSpan - 1); > int childX = gridX + data.horizontalIndent; > int childWidth = Math.min(data.cacheWidth, cellWidth); > switch (data.horizontalAlignment) { > case SWT.CENTER: > case GridData.CENTER: > childX += Math.max(0, (cellWidth > - data.horizontalIndent - childWidth) / 2); > break; > case SWT.RIGHT: > case SWT.END: > case GridData.END: > childX += Math.max(0, cellWidth > - data.horizontalIndent - childWidth); > break; > case SWT.FILL: > childWidth = cellWidth - data.horizontalIndent; > break; > } > cellHeight += verticalSpacing * (vSpan - 1); > int childY = gridY + data.verticalIndent; > int childHeight = Math > .min(data.cacheHeight, cellHeight); > switch (data.verticalAlignment) { > case SWT.CENTER: > case GridData.CENTER: > childY += Math.max(0, (cellHeight > - data.verticalIndent - childHeight) / 2); > break; > case SWT.BOTTOM: > case SWT.END: > case GridData.END: > childY += Math.max(0, cellHeight > - data.verticalIndent - childHeight); > break; > case SWT.FILL: > childHeight = cellHeight - data.verticalIndent; > break; > } > Control child = grid[i][j]; > if (child != null) { > child.setBounds(childX, childY, childWidth, > childHeight); > } > } > gridX += widths[j] + horizontalSpacing; > } > gridY += heights[i] + verticalSpacing; > } > } > > // clean up cache > for (int i = 0; i < flushLength; i++) { > flush[i].cacheWidth = flush[i].cacheHeight = -1; > } > > int totalDefaultWidth = 0; > int totalDefaultHeight = 0; > for (int i = 0; i < columnCount; i++) { > totalDefaultWidth += widths[i]; > } > for (int i = 0; i < rowCount; i++) { > totalDefaultHeight += heights[i]; > } > totalDefaultWidth += horizontalSpacing * (columnCount - 1) + marginLeft > + marginWidth * 2 + marginRight; > totalDefaultHeight += verticalSpacing * (rowCount - 1) + marginTop > + marginHeight * 2 + marginBottom; > return new Point(totalDefaultWidth, totalDefaultHeight); > } > > String getName() { > String string = getClass().getName(); > int index = string.lastIndexOf('.'); > if (index == -1) > return string; > return string.substring(index + 1, string.length()); > } > > /** > * Returns a string containing a concise, human-readable description of the > * receiver. > * > * @return a string representation of the layout > */ > public String toString() { > String string = getName() + " {"; > if (numColumns != 1) > string += "numColumns=" + numColumns + " "; > if (makeColumnsEqualWidth) > string += "makeColumnsEqualWidth=" + makeColumnsEqualWidth + " "; > if (marginWidth != 0) > string += "marginWidth=" + marginWidth + " "; > if (marginHeight != 0) > string += "marginHeight=" + marginHeight + " "; > if (marginLeft != 0) > string += "marginLeft=" + marginLeft + " "; > if (marginRight != 0) > string += "marginRight=" + marginRight + " "; > if (marginTop != 0) > string += "marginTop=" + marginTop + " "; > if (marginBottom != 0) > string += "marginBottom=" + marginBottom + " "; > if (horizontalSpacing != 0) > string += "horizontalSpacing=" + horizontalSpacing + " "; > if (verticalSpacing != 0) > string += "verticalSpacing=" + verticalSpacing + " "; > string = string.trim(); > string += "}"; > return string; > } >}
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 351935
:
199555
| 199556 |
199557