/**
* Aligns the first <code>rows</code> * <code>cols</code> components of <code>parent</code> in a
* grid. Each component in a column is as wide as the maximum preferred width of the components in
* that column; height is similarly determined for each row. The parent is made just big enough to
* fit them all.
*
* @param rows number of rows
* @param cols number of columns
* @param initialX x location to start the grid at
* @param initialY y location to start the grid at
* @param xPad x padding between cells
* @param yPad y padding between cells
*/
public static void makeCompactGrid(
Container parent, int rows, int cols, int initialX, int initialY, int xPad, int yPad) {
SpringLayout layout;
try {
layout = (SpringLayout) parent.getLayout();
} catch (ClassCastException exc) {
System.err.println("The first argument to makeCompactGrid must use SpringLayout.");
return;
}
// Align all cells in each column and make them the same width.
Spring x = Spring.constant(initialX);
for (int c = 0; c < cols; c++) {
Spring width = Spring.constant(0);
for (int r = 0; r < rows; r++) {
width =
Spring.max(width, SpringUtilities.getConstraintsForCell(r, c, parent, cols).getWidth());
}
for (int r = 0; r < rows; r++) {
SpringLayout.Constraints constraints =
SpringUtilities.getConstraintsForCell(r, c, parent, cols);
constraints.setX(x);
constraints.setWidth(width);
}
x = Spring.sum(x, Spring.sum(width, Spring.constant(xPad)));
}
// Align all cells in each row and make them the same height.
Spring y = Spring.constant(initialY);
for (int r = 0; r < rows; r++) {
Spring height = Spring.constant(0);
for (int c = 0; c < cols; c++) {
height =
Spring.max(
height, SpringUtilities.getConstraintsForCell(r, c, parent, cols).getHeight());
}
for (int c = 0; c < cols; c++) {
SpringLayout.Constraints constraints =
SpringUtilities.getConstraintsForCell(r, c, parent, cols);
constraints.setY(y);
constraints.setHeight(height);
}
y = Spring.sum(y, Spring.sum(height, Spring.constant(yPad)));
}
// Set the parent's size.
SpringLayout.Constraints pCons = layout.getConstraints(parent);
pCons.setConstraint(SpringLayout.SOUTH, y);
pCons.setConstraint(SpringLayout.EAST, x);
}
/**
* Aligns the height of all cells in a row.
*
* @param layout
* @param grid
* @param cols
* @param rows
* @return
*/
private Spring alignRows(SpringLayout layout, List<List<Component>> grid, int cols, int rows) {
// Align all cells in each row and make them the same height.
Spring y = Spring.constant(this.topMargin);
int[] rowSpacing = new int[rows];
Arrays.fill(rowSpacing, this.yPad);
// no space above filler line
rowSpacing[rows - 2] = 0;
rowSpacing[rows - 1] = this.bottomMargin;
for (int r = 0; r < rows; r++) {
Spring height = Spring.constant(0);
for (int c = 0; c < cols; c++)
if (grid.get(r).get(c) != null)
height = Spring.max(height, layout.getConstraints(grid.get(r).get(c)).getHeight());
for (int c = 0; c < cols; c++)
if (grid.get(r).get(c) != null) {
SpringLayout.Constraints constraints = layout.getConstraints(grid.get(r).get(c));
constraints.setY(y);
constraints.setHeight(height);
}
y = Spring.sum(y, Spring.sum(height, Spring.constant(rowSpacing[r])));
}
return y;
}
public void beautify(Container panel) {
SpringLayout layout = new SpringLayout();
Map<Component, Boolean> spanToRight = new IdentityHashMap<>();
List<List<Component>> grid = extractGrid(panel, spanToRight);
int cols = 1;
for (List<Component> row : grid) cols = Math.max(cols, row.size());
// add empty stretchable line
List<Component> lastRow = new ArrayList<>();
for (int index = 0; index < cols; index++) lastRow.add(Box.createVerticalGlue());
grid.add(lastRow);
int rows = grid.size();
Map<Component, int[]> spannedComponents = findSpannedComponents(spanToRight, grid, cols);
readdComponents(panel, grid);
panel.setLayout(layout);
Spring x = alignColumns(layout, grid, cols, rows, spannedComponents);
Spring y = alignRows(layout, grid, cols, rows);
// Set the parent's size.
SpringLayout.Constraints pCons = layout.getConstraints(panel);
pCons.setConstraint(SpringLayout.SOUTH, y);
pCons.setConstraint(SpringLayout.EAST, x);
// if(rows == 2) {
// // SpringUtilities.makeCompactGrid(panel, rows, cols, leftMargin, topMargin, xPad, yPad);
// x = alignColumns(layout, grid, cols, rows, spannedComponents);
// y = alignRows(layout, grid, cols, rows);
// pCons.setConstraint(SpringLayout.SOUTH, y);
// pCons.setConstraint(SpringLayout.EAST, x);
// }
}
/**
* Aligns the widths of all columns and handles the spanned components.
*
* @param layout
* @param grid
* @param cols
* @param rows
* @param spannedComponents
* @return
*/
private Spring alignColumns(
SpringLayout layout,
List<List<Component>> grid,
int cols,
int rows,
Map<Component, int[]> spannedComponents) {
// Align all cells in each column and make them the same width.
Spring x = Spring.constant(this.leftMargin);
Spring[] colWidths = new Spring[cols], colXs = new Spring[cols];
for (int c = 0; c < cols; c++) {
colXs[c] = x;
colWidths[c] = Spring.constant(0);
for (int r = 0; r < rows; r++) {
final Component cell = grid.get(r).get(c);
if (cell != null && !spannedComponents.containsKey(cell))
colWidths[c] = Spring.max(colWidths[c], layout.getConstraints(cell).getWidth());
}
for (int r = 0; r < rows; r++) {
final Component cell = grid.get(r).get(c);
if (cell != null && !spannedComponents.containsKey(cell)) {
SpringLayout.Constraints constraints = layout.getConstraints(grid.get(r).get(c));
constraints.setX(x);
constraints.setWidth(colWidths[c]);
}
}
x =
Spring.sum(
x,
Spring.sum(
colWidths[c], Spring.constant(c == cols - 1 ? this.rightMargin : this.xPad)));
}
for (Entry<Component, int[]> spans : spannedComponents.entrySet()) {
SpringLayout.Constraints constraints = layout.getConstraints(spans.getKey());
final int[] colRange = spans.getValue();
constraints.setX(colXs[colRange[0]]);
Spring width = colWidths[colRange[0]];
for (int col = colRange[0] + 1; col <= colRange[1]; col++)
width = Spring.sum(Spring.sum(width, colWidths[col]), Spring.constant(this.xPad));
constraints.setWidth(width);
}
return x;
}
/**
* Aligns the first <code>rows</code> * <code>cols</code> components of <code>parent</code> in a
* grid. Each component is as big as the maximum preferred width and height of the components. The
* parent is made just big enough to fit them all.
*
* @param rows number of rows
* @param cols number of columns
* @param initialX x location to start the grid at
* @param initialY y location to start the grid at
* @param xPad x padding between cells
* @param yPad y padding between cells
*/
public static void makeGrid(
Container parent, int rows, int cols, int initialX, int initialY, int xPad, int yPad) {
SpringLayout layout;
try {
layout = (SpringLayout) parent.getLayout();
} catch (ClassCastException exc) {
System.err.println("The first argument to makeGrid must use SpringLayout.");
return;
}
Spring xPadSpring = Spring.constant(xPad);
Spring yPadSpring = Spring.constant(yPad);
Spring initialXSpring = Spring.constant(initialX);
Spring initialYSpring = Spring.constant(initialY);
int max = rows * cols;
// Calculate Springs that are the max of the width/height so that all
// cells have the same size.
Spring maxWidthSpring = layout.getConstraints(parent.getComponent(0)).getWidth();
Spring maxHeightSpring = layout.getConstraints(parent.getComponent(0)).getWidth();
for (int i = 1; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
maxWidthSpring = Spring.max(maxWidthSpring, cons.getWidth());
maxHeightSpring = Spring.max(maxHeightSpring, cons.getHeight());
}
// Apply the new width/height Spring. This forces all the
// components to have the same size.
for (int i = 0; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
cons.setWidth(maxWidthSpring);
cons.setHeight(maxHeightSpring);
}
// Then adjust the x/y constraints of all the cells so that they
// are aligned in a grid.
SpringLayout.Constraints lastCons = null;
SpringLayout.Constraints lastRowCons = null;
for (int i = 0; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
if (i % cols == 0) { // start of new row
lastRowCons = lastCons;
cons.setX(initialXSpring);
} else { // x position depends on previous component
cons.setX(Spring.sum(lastCons.getConstraint(SpringLayout.EAST), xPadSpring));
}
if (i / cols == 0) { // first row
cons.setY(initialYSpring);
} else { // y position depends on previous row
cons.setY(Spring.sum(lastRowCons.getConstraint(SpringLayout.SOUTH), yPadSpring));
}
lastCons = cons;
}
// Set the parent's size.
SpringLayout.Constraints pCons = layout.getConstraints(parent);
pCons.setConstraint(
SpringLayout.SOUTH,
Spring.sum(Spring.constant(yPad), lastCons.getConstraint(SpringLayout.SOUTH)));
pCons.setConstraint(
SpringLayout.EAST,
Spring.sum(Spring.constant(xPad), lastCons.getConstraint(SpringLayout.EAST)));
}
public static void makeGrid(
Container parent, int rows, int cols, int initialX, int initialY, int xPad, int yPad) {
SpringLayout layout;
try {
layout = (SpringLayout) parent.getLayout();
} catch (ClassCastException exc) {
System.err.println("The first argument to makeGrid must use SpringLayout.");
return;
}
Spring xPadSpring = Spring.constant(xPad);
Spring yPadSpring = Spring.constant(yPad);
Spring initialXSpring = Spring.constant(initialX);
Spring initialYSpring = Spring.constant(initialY);
int max = rows * cols;
Spring maxWidthSpring = layout.getConstraints(parent.getComponent(0)).getWidth();
Spring maxHeightSpring = layout.getConstraints(parent.getComponent(0)).getWidth();
for (int i = 1; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
maxWidthSpring = Spring.max(maxWidthSpring, cons.getWidth());
maxHeightSpring = Spring.max(maxHeightSpring, cons.getHeight());
}
for (int i = 0; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
cons.setWidth(maxWidthSpring);
cons.setHeight(maxHeightSpring);
}
SpringLayout.Constraints lastCons = null;
SpringLayout.Constraints lastRowCons = null;
for (int i = 0; i < max; i++) {
SpringLayout.Constraints cons = layout.getConstraints(parent.getComponent(i));
if (i % cols == 0) {
lastRowCons = lastCons;
cons.setX(initialXSpring);
} else {
cons.setX(Spring.sum(lastCons.getConstraint(SpringLayout.EAST), xPadSpring));
}
if (i / cols == 0) {
cons.setY(initialYSpring);
} else {
cons.setY(Spring.sum(lastRowCons.getConstraint(SpringLayout.SOUTH), yPadSpring));
}
lastCons = cons;
}
SpringLayout.Constraints pCons = layout.getConstraints(parent);
pCons.setConstraint(
SpringLayout.SOUTH,
Spring.sum(Spring.constant(yPad), lastCons.getConstraint(SpringLayout.SOUTH)));
pCons.setConstraint(
SpringLayout.EAST,
Spring.sum(Spring.constant(xPad), lastCons.getConstraint(SpringLayout.EAST)));
}