public Dimension preferredLayoutSize(Container parent) {
JToolBar tb = (JToolBar) parent;
Insets insets = tb.getInsets();
Dimension dim = new Dimension();
SeaGlassContext context = getContext(tb);
if (tb.getOrientation() == JToolBar.HORIZONTAL) {
dim.width = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;
Dimension compDim;
for (int i = 0; i < tb.getComponentCount(); i++) {
Component component = tb.getComponent(i);
if (component.isVisible()) {
compDim = component.getPreferredSize();
dim.width += compDim.width;
dim.height = Math.max(dim.height, compDim.height);
}
}
} else {
dim.height = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;
Dimension compDim;
for (int i = 0; i < tb.getComponentCount(); i++) {
Component component = tb.getComponent(i);
if (component.isVisible()) {
compDim = component.getPreferredSize();
dim.width = Math.max(dim.width, compDim.width);
dim.height += compDim.height;
}
}
}
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
context.dispose();
return dim;
}
/**
* Used to forcibly insert items at the end of the primary menu. Useful if you have items that you
* don't want who knows how many levels deep in the more structure.
*/
public void insertStatic(Component c) {
// Determine if the Component can fit already
// If yes
// Just do a regular insert, we're done.
// else
// do
// Put the standard item closest to the more
// menu in the more menu
// until the static component (c) can fit in this menu
// do a regular insert(component)
double componentHeight = c.getPreferredSize().getHeight();
if ((myHeight + componentHeight) < maximumHeight - componentHeight) {
// Force the component to go below the moreMenu
super.add(c);
myHeight += c.getPreferredSize().getHeight();
} else {
int itemCount = getMenuComponentCount();
Component componentToMove = null;
do {
// the standard item is 1 before
// the more menu hence -1
int index = getComponentIndex(moreMenu);
componentToMove = getComponentAtIndex(index - 1);
moreMenu.insert(componentToMove, 0);
// super.remove(componentToMove);
myHeight -= componentToMove.getPreferredSize().getHeight();
itemCount = getMenuComponentCount();
} while ((componentHeight + myHeight) >= maximumHeight);
super.add(c);
myHeight += c.getPreferredSize().getHeight();
}
}
/**
* Calculates the maximum size dimensions for the specified panal given the components in the
* specified parent container.
*/
public Dimension maximumLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int size = actions.size();
if ((grip != null) && grip.isVisible()) {
Dimension d = grip.getPreferredSize();
dim.width += d.width;
dim.width += hgap;
}
Component last = null;
for (int i = 0; i < size; i++) {
Component comp = (Component) actions.elementAt(i);
if (comp.isVisible()) {
Dimension d = comp.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(dim.height, d.height);
dim.width += hgap;
last = comp;
}
}
if (last != null) {
Dimension prefSize = last.getPreferredSize();
Dimension maxSize = last.getMaximumSize();
if (prefSize != maxSize) {
dim.width = dim.width - prefSize.width + maxSize.width;
dim.height = Math.max(dim.height, maxSize.height);
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
public void packColumn(JTable table, int vColIndex, int margin) {
DefaultTableColumnModel colModel = (DefaultTableColumnModel) table.getColumnModel();
TableColumn col = colModel.getColumn(vColIndex);
int width = 0;
// Get width of column header
TableCellRenderer renderer = col.getHeaderRenderer();
if (renderer == null) {
renderer = table.getTableHeader().getDefaultRenderer();
}
Component comp =
renderer.getTableCellRendererComponent(table, col.getHeaderValue(), false, false, 0, 0);
width = comp.getPreferredSize().width;
// Get maximum width of column data
for (int r = 0; r < table.getRowCount(); r++) {
renderer = table.getCellRenderer(r, vColIndex);
comp =
renderer.getTableCellRendererComponent(
table, table.getValueAt(r, vColIndex), false, false, r, vColIndex);
width = Math.max(width, comp.getPreferredSize().width);
}
// Add margin
width += 2 * margin;
// Set the width
col.setPreferredWidth(width);
}
public void
setColumnWidths() { // See
// "http://java.sun.com/docs/books/tutorial/uiswing/components/table.html#custom"
int n = getModel().getColumnCount();
for (int j = 0; j < n; ++j) {
TableColumn column = getColumnModel().getColumn(j);
TableCellRenderer headerRenderer = column.getHeaderRenderer();
if (headerRenderer == null)
headerRenderer = getTableHeader().getDefaultRenderer(); // the new 1.3 way
Component columnComponent =
headerRenderer.getTableCellRendererComponent(
this, column.getHeaderValue(), false, false, -1, j);
Component cellComponent =
getDefaultRenderer(getColumnClass(j))
.getTableCellRendererComponent(this, getModel().getValueAt(0, j), false, false, 0, j);
int wantWidth =
Math.max(
columnComponent.getPreferredSize().width
+ 10, // fudge factor ... seems to always be too small otherwise (on x86 Linux)
cellComponent.getPreferredSize().width
+ 10 // fudge factor ... seems to always be too small otherwise (on Mac OS X)
);
column.setPreferredWidth(wantWidth);
}
}
/**
* Returns the {@link Constraints} object associated with the specified component.
*
* @param c the component for which to determine the constraint.
* @return the {@link Constraints} object associated with the specified component.
*/
public SpringLayout.Constraints getConstraints(Component c) {
Constraints constraints = (Constraints) constraintsMap.get(c);
if (constraints == null) {
Container parent = c.getParent();
constraints = new Constraints();
if (parent != null) {
constraints.setX(Spring.constant(parent.getInsets().left));
constraints.setY(Spring.constant(parent.getInsets().top));
} else {
constraints.setX(Spring.constant(0));
constraints.setY(Spring.constant(0));
}
}
constraints.setWidth(
Spring.constant(
c.getMinimumSize().width, c.getPreferredSize().width, c.getMaximumSize().width));
constraints.setHeight(
Spring.constant(
c.getMinimumSize().height, c.getPreferredSize().height, c.getMaximumSize().height));
constraintsMap.put(c, constraints);
return constraints;
}
public void layoutContainer(Container target) {
int barwidth = 0;
int i;
for (i = 1; i < target.getComponentCount(); i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
if (d.width > barwidth) barwidth = d.width;
}
}
Insets insets = target.insets();
int targetw = target.size().width - insets.left - insets.right;
int cw = targetw - barwidth;
int targeth = target.size().height - (insets.top + insets.bottom);
target.getComponent(0).move(insets.left, insets.top);
target.getComponent(0).resize(cw, targeth);
cw += insets.left;
int h = insets.top;
for (i = 1; i < target.getComponentCount(); i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
if (m instanceof DecentScrollbar || m instanceof TextComponent) d.width = barwidth;
if (m instanceof Choice && d.width > barwidth) d.width = barwidth;
if (m instanceof Label) {
h += d.height / 5;
d.width = barwidth;
}
m.move(cw, h);
m.resize(d.width, d.height);
h += d.height;
}
}
}
@Override
int getHeight(boolean isPreferred) {
int labelHeight = (isPreferred ? l.getPreferredSize().height : l.getMinimumSize().height);
int controlHeight = (isPreferred ? c.getPreferredSize().height : c.getMinimumSize().height);
return Math.max(labelHeight, controlHeight);
}
/** Lays out the container in the specified panel. */
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
Dimension dim = target.getSize();
int fullHeight = dim.height;
int bottom = dim.height - insets.bottom - 1;
int top = 0 + insets.top;
int left = insets.left;
int maxPosition = dim.width - (insets.left + insets.right) - hgap;
int right = dim.width - insets.right;
maxPosition = right;
int height = bottom - top;
int size = actions.size();
int w, h;
if ((grip != null) && grip.isVisible()) {
Dimension d = grip.getPreferredSize();
grip.setBounds(left, top + vgap, d.width, bottom - top - 2 * vgap);
left += d.width;
left += hgap;
}
for (int i = 0; i < size; i++) {
left += hgap;
Component comp = (Component) actions.elementAt(i);
Dimension d;
Dimension minSize = comp.getMinimumSize();
if (i == size - 1) d = comp.getMaximumSize();
else d = comp.getPreferredSize();
w = d.width;
h = Math.min(height, d.height);
if ((left < maxPosition) && (left + w > maxPosition)) {
if (maxPosition - left >= minSize.width) w = maxPosition - left;
}
comp.setBounds(left, (fullHeight - d.height) / 2, w, h);
// if (i == size - 1)
// d = comp.getMaximumSize();
// else
// d = comp.getPreferredSize();
// if ((left + d.width) > right)
// w = right - left;
// else
// w = d.width;
// h = Math.min (height, d.height);
// comp.setBounds (left, (fullHeight - d.height)/2, w, h);
left += d.width;
}
}
}
public void layoutContainer(Container parent) {
Insets insets = parent.getInsets();
int maxWidth = parent.getSize().width - (insets.left + insets.right);
int maxHeight = parent.getSize().height - (insets.top + insets.bottom);
int nComps = parent.getComponentCount();
if (this.sizeUnknown) {
setSizes(parent);
}
Component c;
if (nComps < 2) {
c = parent.getComponent(0);
if (c.isVisible()) {
Dimension d = c.getPreferredSize();
c.setBounds(0, 0, d.width, d.height);
return;
}
return;
}
double radialCurrent = Math.toRadians(SpiderWebPlot.DEFAULT_START_ANGLE);
double radialIncrement = 6.283185307179586d / ((double) nComps);
int midX = maxWidth / 2;
int midY = maxHeight / 2;
int a = midX - this.maxCompWidth;
int b = midY - this.maxCompHeight;
for (int i = 0; i < nComps; i++) {
c = parent.getComponent(i);
if (c.isVisible()) {
d = c.getPreferredSize();
double d2 = (double) midX;
double d3 = (double) a;
int x =
(int)
(((r0 - (r0 * Math.cos(radialCurrent)))
- (d.getWidth() / DateAxis.DEFAULT_AUTO_RANGE_MINIMUM_SIZE_IN_MILLISECONDS))
+ ((double) insets.left));
d2 = (double) midY;
d3 = (double) b;
c.setBounds(
x,
(int)
(((r0 - (r0 * Math.sin(radialCurrent)))
- (d.getHeight()
/ DateAxis.DEFAULT_AUTO_RANGE_MINIMUM_SIZE_IN_MILLISECONDS))
+ ((double) insets.top)),
d.width,
d.height);
}
radialCurrent += radialIncrement;
}
}
/**
* Size each column to something reasonable We do this by getting the width of the letter 'M" from
* the default Table Header Renderer and set the preferred width of the column as the width of
* some number of 'M's.
*
* @return int
*/
private int getStandardCharacterWidth() {
// The preferredSize of the component is more than just the character
// So we remove the extra determining the delta
// between one and two chars
final JTableHeader th = getTableHeader();
final TableCellRenderer renderer = th.getDefaultRenderer();
Component comp =
renderer.getTableCellRendererComponent(this, ONE_STANDARD_CHARACTER, false, false, 0, 0);
final int oneStandardCharacterWidth = comp.getPreferredSize().width;
comp =
renderer.getTableCellRendererComponent(this, TWO_STANDARD_CHARACTERS, false, false, 0, 0);
final int twoStandardCharactersWidth = comp.getPreferredSize().width;
return twoStandardCharactersWidth - oneStandardCharacterWidth;
}
@Override
public Insets getBorderInsets(Component c) {
Dimension size = comp.getPreferredSize();
Insets insets = border.getBorderInsets(c);
insets.top = Math.max(insets.top, size.height);
return insets;
}
public void pack() {
Component component = getComponent();
if (component != null) {
component.setSize(component.getPreferredSize());
}
}
private int getHeaderHeight() {
if ((header == null) || (header.getTable() == null)) {
return 0;
}
int height = 0;
boolean accomodatedDefault = false;
TableColumnModel columnModel = header.getColumnModel();
for (int column = 0; column < columnModel.getColumnCount(); column++) {
TableColumn aColumn = columnModel.getColumn(column);
boolean isDefault = (aColumn.getHeaderRenderer() == null);
if (!isDefault || !accomodatedDefault) {
Component comp = getHeaderRenderer(column);
int rendererHeight = comp.getPreferredSize().height;
height = Math.max(height, rendererHeight);
// Configuring the header renderer to calculate its preferred size
// is expensive. Optimise this by assuming the default renderer
// always has the same height as the first non-zero height that
// it returns for a non-null/non-empty value.
if (isDefault && rendererHeight > 0) {
Object headerValue = aColumn.getHeaderValue();
if (headerValue != null) {
headerValue = headerValue.toString();
if (headerValue != null && !headerValue.equals("")) {
accomodatedDefault = true;
}
}
}
}
}
return height + 2;
}
@Override
public java.awt.Dimension preferredLayoutSize(java.awt.Container parent) {
synchronized (parent.getTreeLock()) {
org.lgna.croquet.CardOwnerComposite cardOwner =
(org.lgna.croquet.CardOwnerComposite) getComposite();
int widthMax = 0;
int heightMax = 0;
for (org.lgna.croquet.Composite<?> card : cardOwner.getCards()) {
if (cardOwner.isCardAccountedForInPreferredSizeCalculation(card)) {
java.awt.Component awtChild = card.getRootComponent().getAwtComponent();
java.awt.Dimension awtChildPreferredSize = awtChild.getPreferredSize();
widthMax = Math.max(widthMax, awtChildPreferredSize.width);
heightMax = Math.max(heightMax, awtChildPreferredSize.height);
}
}
java.awt.Insets insets = parent.getInsets();
int hgap = this.getHgap();
int vgap = this.getVgap();
return new java.awt.Dimension(
hgap + insets.left + widthMax + insets.right + hgap,
vgap + insets.top + heightMax + insets.bottom + vgap);
}
}
private static Pair<Image, Point> createDragImage(
final Tree tree, final Component c, Point dragOrigin, boolean adjustToPathUnderDragOrigin) {
if (c instanceof JComponent) {
((JComponent) c).setOpaque(true);
}
c.setForeground(tree.getForeground());
c.setBackground(tree.getBackground());
c.setFont(tree.getFont());
c.setSize(c.getPreferredSize());
final BufferedImage image =
new BufferedImage(c.getWidth(), c.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = (Graphics2D) image.getGraphics();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.7f));
c.paint(g2);
g2.dispose();
Point point = new Point(-image.getWidth(null) / 2, -image.getHeight(null) / 2);
if (adjustToPathUnderDragOrigin) {
TreePath path = tree.getPathForLocation(dragOrigin.x, dragOrigin.y);
if (path != null) {
Rectangle bounds = tree.getPathBounds(path);
point = new Point(bounds.x - dragOrigin.x, bounds.y - dragOrigin.y);
}
}
return new Pair<Image, Point>(image, point);
}
private void packColumns(int inMargin) {
TableModel model = this.table.getModel();
DefaultTableColumnModel columnModel = (DefaultTableColumnModel) table.getColumnModel();
for (int col = 0; col < this.table.getColumnCount(); col++) {
TableColumn column = columnModel.getColumn(col);
int width = 0;
// determine widest row in column
for (int row = 0; row < this.table.getRowCount(); row++) {
TableCellRenderer renderer = this.table.getCellRenderer(row, col);
Component component =
renderer.getTableCellRendererComponent(
this.table, this.table.getValueAt(row, col), false, false, row, col);
width = Math.max(width, component.getPreferredSize().width);
}
// add the margin
width += 2 * inMargin;
column.setPreferredWidth(width);
}
}
/**
* Calculates the optimal width for the header of the given table. The calculation is based on the
* preferred width of the header renderer.
*
* @param table the table to calculate the column width
* @param col the column to calculate the widths
* @return the width, -1 if error
*/
public static int calcHeaderWidth(JTable table, int col) {
if (table == null) return -1;
if (col < 0 || col > table.getColumnCount()) {
System.out.println("invalid col " + col);
return -1;
}
JTableHeader header = table.getTableHeader();
TableCellRenderer defaultHeaderRenderer = null;
if (header != null) defaultHeaderRenderer = header.getDefaultRenderer();
TableColumnModel columns = table.getColumnModel();
TableModel data = table.getModel();
TableColumn column = columns.getColumn(col);
int width = -1;
TableCellRenderer h = column.getHeaderRenderer();
if (h == null) h = defaultHeaderRenderer;
if (h != null) {
// Not explicitly impossible
Component c =
h.getTableCellRendererComponent(table, column.getHeaderValue(), false, false, -1, col);
width = c.getPreferredSize().width + 5;
}
return width;
}
private void disposeAndUpdate(boolean update) {
if (myView != null) {
boolean visible = myView.isVisible();
myView.setVisible(false);
Container container = myContent.getParent();
if (container != null) {
container.remove(myContent);
}
if (myView instanceof Window) {
myViewBounds = myView.getBounds();
Window window = (Window) myView;
if (!push(UIUtil.getWindow(myOwner), window)) {
window.dispose();
}
} else {
Container parent = myView.getParent();
if (parent == null) {
myViewBounds = new Rectangle(myContent.getPreferredSize());
} else {
myViewBounds = new Rectangle(myView.getBounds());
parent.remove(myView);
Point point = new Point(myViewBounds.x, myViewBounds.y);
SwingUtilities.convertPointToScreen(point, parent);
myViewBounds.x = point.x;
myViewBounds.y = point.y;
}
}
myView = null;
if (update && visible) {
setVisible(true);
}
}
}
private void setSizes(Container parent) {
int nComps = parent.getComponentCount();
Dimension d = null;
// Reset preferred/minimum width and height.
preferredWidth = 0;
preferredHeight = 0;
minWidth = 0;
minHeight = 0;
for (int i = 0; i < nComps; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
d = c.getPreferredSize();
if (i > 0) {
preferredWidth += d.width / 2;
preferredHeight += vgap;
} else {
preferredWidth = d.width;
}
preferredHeight += d.height;
minWidth = Math.max(c.getMinimumSize().width, minWidth);
minHeight = preferredHeight;
}
}
}
private void setSizes(Container parent) {
int nComps = parent.getComponentCount();
this.preferredWidth = 0;
this.preferredHeight = 0;
this.minWidth = 0;
this.minHeight = 0;
for (int i = 0; i < nComps; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
Dimension d = c.getPreferredSize();
if (this.maxCompWidth < d.width) {
this.maxCompWidth = d.width;
}
if (this.maxCompHeight < d.height) {
this.maxCompHeight = d.height;
}
this.preferredWidth += d.width;
this.preferredHeight += d.height;
}
}
this.preferredWidth /= 2;
this.preferredHeight /= 2;
this.minWidth = this.preferredWidth;
this.minHeight = this.preferredHeight;
}
@Override
public int getRowHeight() {
if (myRowHeightIsComputing) {
return super.getRowHeight();
}
if (myRowHeight < 0) {
try {
myRowHeightIsComputing = true;
for (int row = 0; row < getRowCount(); row++) {
for (int column = 0; column < getColumnCount(); column++) {
final TableCellRenderer renderer = getCellRenderer(row, column);
if (renderer != null) {
final Object value = getValueAt(row, column);
final Component component =
renderer.getTableCellRendererComponent(this, value, true, true, row, column);
if (component != null) {
final Dimension size = component.getPreferredSize();
myRowHeight = Math.max(size.height, myRowHeight);
}
}
}
}
} finally {
myRowHeightIsComputing = false;
}
}
if (myMinRowHeight == null) {
myMinRowHeight = getFontMetrics(UIManager.getFont("Label.font")).getHeight();
}
return Math.max(myRowHeight, myMinRowHeight);
}
@Override
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
setFont(table.getFont());
setText((value == null) ? "" : " " + value.toString());
if ((row == -1) && (column == 0)) { // No. column header
int width_header = getPreferredSize().width + 2;
int width_numbers = 25;
if (data.getRowCount() > 0) {
TableCellRenderer r = table.getCellRenderer(data.getRowCount() - 1, 0);
Component c =
r.getTableCellRendererComponent(
table,
((ConstructionTableData) data).getValueAt(data.getRowCount() - 1, 0),
false,
false,
data.getRowCount() - 1,
0);
// width = Math.max(width, c.getPreferredSize().width +2);
width_numbers = Math.max(width_numbers, c.getPreferredSize().width + 2);
}
// tableColumns[0].setMaxWidth(width);
tableColumns[0].setMinWidth(width_numbers);
tableColumns[0].setMaxWidth(Math.max(width_numbers, width_header));
// tableColumns[0].setPreferredWidth(width);
}
return this;
}
@Override
public Dimension preferredLayoutSize(final Container parent) {
synchronized (parent.getTreeLock()) {
final Insets in = parent.getInsets();
final int nr = parent.getComponentCount();
int maxW = 0;
int maxH = 0;
for (int i = 0; i < cols; ++i) {
posX[i] = maxW;
final int w = maxW;
int h = 0;
for (int j = 0; j < rows; ++j) {
final int n = j * cols + i;
if (n >= nr) break;
final Component c = parent.getComponent(n);
final Dimension d = c.getPreferredSize();
if (maxW < w + d.width) maxW = w + d.width;
if (posY[j] < h) posY[j] = h;
else h = posY[j];
h += d.height;
}
if (maxH < h) maxH = h;
}
width = in.left + maxW + (cols - 1) * insetX + in.right;
height = in.top + maxH + (rows - 1) * insetY + in.bottom;
return new Dimension(width, height);
}
}
private static Point fixPopupLocation(final Component contents, final int x, final int y) {
if (!(contents instanceof JToolTip)) return new Point(x, y);
final PointerInfo info;
try {
info = MouseInfo.getPointerInfo();
} catch (InternalError e) {
// http://www.jetbrains.net/jira/browse/IDEADEV-21390
// may happen under Mac OSX 10.5
return new Point(x, y);
}
int deltaY = 0;
if (info != null) {
final Point mouse = info.getLocation();
deltaY = mouse.y - y;
}
final Dimension size = contents.getPreferredSize();
final Rectangle rec = new Rectangle(new Point(x, y), size);
ScreenUtil.moveRectangleToFitTheScreen(rec);
if (rec.y < y) {
rec.y += deltaY;
}
return rec.getLocation();
}
public void layoutContainer(Container target) {
Insets insets = target.getInsets();
int ncomponents = target.getComponentCount();
int top = 0;
int left = insets.left;
Dimension tps = target.getPreferredSize();
Dimension targetSize = target.getSize();
Component comp;
Dimension ps;
if (horizontalOrientation == Orientation.CENTER)
left = left + (targetSize.width / 2) - (tps.width / 2);
if (horizontalOrientation == Orientation.RIGHT) left = left + targetSize.width - tps.width;
for (int i = 0; i < ncomponents; i++) {
comp = target.getComponent(i);
if (comp.isVisible()) {
ps = comp.getPreferredSize();
if (verticalOrientation == Orientation.CENTER)
top = (targetSize.height / 2) - (ps.height / 2);
else if (verticalOrientation == Orientation.TOP) top = insets.top;
else if (verticalOrientation == Orientation.BOTTOM)
top = targetSize.height - ps.height - insets.bottom;
comp.setBounds(left, top, ps.width, ps.height);
left += ps.width + gap;
}
}
}
public void layoutContainer(Container parent) {
Dimension size = parent.getSize();
Insets insets = parent.getInsets();
int itop = insets.top;
int ileft = insets.left;
int ibottom = insets.bottom;
int iright = insets.right;
int rightWidth = right.getPreferredSize().width;
int bottomHeight = bottom.getPreferredSize().height;
int centerWidth = size.width - rightWidth - ileft - iright;
int centerHeight = size.height - bottomHeight - itop - ibottom;
center.setBounds(ileft, itop, centerWidth, centerHeight);
right.setBounds(ileft + centerWidth, itop, rightWidth, centerHeight);
// Lay out all status components, in order
Enumeration status = leftOfScrollBar.elements();
while (status.hasMoreElements()) {
Component comp = (Component) status.nextElement();
Dimension dim = comp.getPreferredSize();
comp.setBounds(ileft, itop + centerHeight, dim.width, bottomHeight);
ileft += dim.width;
}
bottom.setBounds(
ileft, itop + centerHeight, size.width - rightWidth - ileft - iright, bottomHeight);
}
public Dimension preferredLayoutSize(Container target) {
Insets insets = target.getInsets();
Dimension compMax = new Dimension(0, 0);
int maxheight = target.getBounds().height - (insets.top + insets.bottom + vgap * 2);
int nmembers = target.getComponentCount();
int visiblecount = 0;
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
++visiblecount;
Dimension d = m.getPreferredSize();
compMax.width = Math.max(compMax.width, d.width);
compMax.height = Math.max(compMax.height, d.height);
}
}
if (visiblecount > 0) {
int nrows = Math.max(1, (maxheight + compMax.height / 4) / compMax.height);
int ncols = (visiblecount + nrows - 1) / nrows;
compMax.height = compMax.height * nrows + vgap * (nrows - 1);
compMax.width = compMax.width * ncols + hgap * (ncols - 1);
}
compMax.height += insets.top + insets.bottom + vgap * 2;
compMax.width += insets.left + insets.right + hgap * 2;
return compMax;
}
/**
* Calculates the preferred size dimensions for the specified panel given the components in the
* specified parent container.
*
* @param target The component to be laid out.
* @return A size deemed suitable for laying out the container.
* @see #minimumLayoutSize
*/
public Dimension preferredLayoutSize(Container target) {
int count;
Component component;
Dimension dimension;
Insets insets;
Dimension ret;
synchronized (target.getTreeLock()) {
// get the the total height and maximum width component
ret = new Dimension(0, 0);
count = target.getComponentCount();
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
dimension = component.getPreferredSize();
ret.width = Math.max(ret.width, dimension.width);
ret.height += dimension.height;
}
}
insets = target.getInsets();
ret.width += insets.left + insets.right;
ret.height += insets.top + insets.bottom;
}
return (ret);
}
public Dimension preferredLayoutSize(Container parent) {
return LayoutUtil.add(
useSelectedComponentSize
? component == null ? new Dimension(0, 0) : component.getPreferredSize()
: LayoutUtil.getMaxPreferredSize(parent.getComponents()),
parent.getInsets());
}
