/**
* 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;
}
}
@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);
}
}
/*--------------------------------------------------------------------------*/
public Dimension preferredLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
boolean firstVisibleComponent = true;
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
dim.height = Math.max(dim.height, d.height);
if (firstVisibleComponent) {
firstVisibleComponent = false;
} else {
dim.width += hgap;
}
dim.width += d.width;
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right + hgap * 2;
dim.height += insets.top + insets.bottom + vgap * 2;
return (dim);
}
}
@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);
}
}
/**
* 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);
}
/**
* Lays out the container in the specified container.
*
* @param parent the component which needs to be laid out
*/
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
Insets insets = parent.getInsets();
int ncomponents = parent.getComponentCount();
if (ncomponents == 0) {
return;
}
// Total parent dimensions
Dimension size = parent.getSize();
int totalW = size.width - (insets.left + insets.right);
int totalH = size.height - (insets.top + insets.bottom);
// Cell dimensions, including padding
int totalCellW = totalW / gridSize.width;
int totalCellH = totalH / gridSize.height;
// Cell dimensions, without padding
int cellW = (totalW - ((gridSize.width + 1) * hgap)) / gridSize.width;
int cellH = (totalH - ((gridSize.height + 1) * vgap)) / gridSize.height;
for (int i = 0; i < ncomponents; i++) {
Component c = parent.getComponent(i);
Rectangle rect = (Rectangle) compTable.get(c);
if (rect != null) {
int x = insets.left + (totalCellW * rect.x) + hgap;
int y = insets.top + (totalCellH * rect.y) + vgap;
int w = (cellW * rect.width) - hgap;
int h = (cellH * rect.height) - vgap;
c.setBounds(x, y, w, h);
}
}
}
}
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
DiagramView diagramView = (DiagramView) parent;
DesignView designView = diagramView.getDesignView();
double k = designView.getCorrectedZoom();
FBounds bounds = diagramView.getContentSize();
int offsetX = (int) Math.round((diagramView.getWidth() - bounds.width * k) / 2.0);
int offsetY = (int) Math.round((diagramView.getHeight() - bounds.height * k) / 2.0);
diagramView.setOffsets(offsetX, offsetY);
if (parent.getComponentCount() > 0) {
repositionDecorations(parent);
}
// Component component = parent.getComponent(0);
// if (!(component instanceof NavigationTools)) {
// return;
// }
// component.setBounds(0, 0, parent.getWidth(), parent.getHeight());
}
}
/** 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;
}
}
}
/** {@inheritDoc} */
public void layoutContainer(final Container parent) {
synchronized (parent.getTreeLock()) {
int width = parent.getWidth();
int height = parent.getHeight();
Rectangle bounds = new Rectangle(0, 0, width, height);
int componentsCount = components.size();
for (int i = 0; i < componentsCount; i++) {
Component comp = components.get(i);
comp.setBounds(bounds);
parent.setComponentZOrder(comp, componentsCount - i - 1);
}
}
}
/**
* Lays out the container.
*
* @param target The container which needs to be laid out.
*/
public void layoutContainer(Container target) {
int count;
Component component;
Dimension dimension;
synchronized (target.getTreeLock()) {
count = target.getComponentCount();
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
dimension = component.getPreferredSize();
component.setSize(dimension.width, dimension.height);
}
}
}
}
public void layoutContainer(Container target) {
/*
* Algorithm is as follows: - the "left-hand" components take 33% of
* horizontal space - scrollPane takes the remaining space
*/
synchronized (target.getTreeLock()) {
if (pane == null || spane == null) return;
Dimension dim = target.getSize();
if (dim.height < 20) return;
spane.setBounds(new Rectangle(0, 0, dim.width, dim.height));
// Dimension dim0 = new Dimension(dim.width-2, dim.height-2);
// pane.setPreferredSize(dim0);
// JViewport viewPort = spane.getViewport();
// viewPort.setViewSize(dim0);
// paramsLayout.setReferenceSize(dim0.width, dim0.height);
}
}
/** {@inheritDoc} */
public Dimension minimumLayoutSize(final Container parent) {
synchronized (parent.getTreeLock()) {
int width = 0;
int height = 0;
for (Component comp : components) {
Dimension size = comp.getMinimumSize();
width = Math.max(size.width, width);
height = Math.max(size.height, height);
}
Insets insets = parent.getInsets();
width += insets.left + insets.right;
height += insets.top + insets.bottom;
return new Dimension(width, height);
}
}
@Override
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int top = insets.top;
int bottom = target.getHeight() - insets.bottom;
int left = insets.left;
int right = target.getWidth() - insets.right;
northHeight = getPreferredDimension(north).height;
southHeight = getPreferredDimension(south).height;
eastWidth = getPreferredDimension(east).width;
westWidth = getPreferredDimension(west).width;
placeComponents(target, north, left, top, right - left, northHeight, TOP);
top += (northHeight + getVgap());
placeComponents(target, south, left, bottom - southHeight, right - left, southHeight, BOTTOM);
bottom -= (southHeight + getVgap());
placeComponents(target, east, right - eastWidth, top, eastWidth, bottom - top, RIGHT);
right -= (eastWidth + getHgap());
placeComponents(target, west, left, top, westWidth, bottom - top, LEFT);
left += (westWidth + getHgap());
if (center != null) {
center.setBounds(left, top, right - left, bottom - top);
}
}
}
/*--------------------------------------------------------------------------*/
private void moveComponents(
Container target,
int x,
int y,
int width,
int height,
int rowStart,
int rowEnd,
boolean ltr) {
synchronized (target.getTreeLock()) {
switch (newAlign) {
case LEFT:
x += ltr ? 0 : width;
break;
case CENTER:
x += width / 2;
break;
case RIGHT:
x += ltr ? width : 0;
break;
case LEADING:
break;
case TRAILING:
x += width;
break;
}
for (int i = rowStart; i < rowEnd; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
if (ltr) {
m.setLocation(x, y + (height - m.getSize().height) / 2);
} else {
m.setLocation(
target.getSize().width - x - m.getSize().width,
y + (height - m.getSize().height) / 2);
}
x += m.getSize().width + hgap;
}
}
}
}
@Override
public java.awt.Dimension preferredLayoutSize(java.awt.Container target) {
synchronized (target.getTreeLock()) {
java.awt.Dimension dim = new java.awt.Dimension(0, 0);
if (this.mainComponent != null) {
java.awt.Dimension d = this.mainComponent.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height + vGap;
}
if (this.bottomComponent != null) {
java.awt.Dimension d = this.bottomComponent.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height + vGap;
}
addInsets(dim, target);
// edu.cmu.cs.dennisc.java.util.logging.Logger.outln( "preferredLayoutSize", dim, target );
return dim;
}
}
@Override
public void layoutContainer(final Container p) {
preferredLayoutSize(p);
synchronized (p.getTreeLock()) {
final Insets in = p.getInsets();
final int nr = p.getComponentCount();
for (int j = 0; j < rows; ++j) {
for (int i = 0; i < cols; ++i) {
final int n = j * cols + i;
if (n >= nr) return;
final Dimension cs = p.getComponent(n).getPreferredSize();
final int x = in.left + posX[i] + i * insetX;
final int y = in.top + posY[j] + j * insetY;
final int w = cs.width > 0 ? cs.width : width - in.left - in.right;
final int h = cs.height > 0 ? cs.height : height - in.top - in.bottom;
p.getComponent(n).setBounds(x, y, w, h);
}
}
}
}
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
Insets margin = parent.getInsets();
int x = margin.left;
int y = margin.top;
int w = parent.getWidth() - (margin.left + margin.right);
int h = parent.getHeight() - (margin.top + margin.bottom);
Component header = findHeader(parent.getComponents());
if (header != null && header.isVisible()) {
Dimension dim = header.getPreferredSize();
header.setBounds(x, y, w, dim.height);
y += dim.height;
h -= dim.height;
}
Component body = findBody(parent.getComponents());
if (body != null && body.isVisible()) {
body.setBounds(x, y, w, h);
}
}
}
/**
* Lays out the container argument using this border layout.
*
* <p>This method actually reshapes the components in the specified container in order to satisfy
* the constraints of this <code>BorderLayout</code> object. The <code>NORTH</code> and <code>
* SOUTH</code> components, if any, are placed at the top and bottom of the container,
* respectively. The <code>WEST</code> and <code>EAST</code> components are then placed on the
* left and right, respectively. Finally, the <code>CENTER</code> object is placed in any
* remaining space in the middle.
*
* <p>Most applications do not call this method directly. This method is called when a container
* calls its <code>doLayout</code> method.
*
* @param target the container in which to do the layout.
* @see java.awt.Container
* @see java.awt.Container#doLayout()
*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int top = insets.top;
int bottom = target.getHeight() - insets.bottom;
int left = insets.left;
int right = target.getWidth() - insets.right;
boolean ltr = target.getComponentOrientation().isLeftToRight();
Component c = null;
if ((c = getChild(NORTH, ltr)) != null) {
c.setSize(right - left, c.getHeight());
Dimension d = c.getPreferredSize();
c.setBounds(left, top, right - left, d.height);
top += d.height + vgap;
}
if ((c = getChild(SOUTH, ltr)) != null) {
c.setSize(right - left, c.getHeight());
Dimension d = c.getPreferredSize();
c.setBounds(left, bottom - d.height, right - left, d.height);
bottom -= d.height + vgap;
}
if ((c = getChild(EAST, ltr)) != null) {
c.setSize(c.getWidth(), bottom - top);
Dimension d = c.getPreferredSize();
c.setBounds(right - d.width, top, d.width, bottom - top);
right -= d.width + hgap;
}
if ((c = getChild(WEST, ltr)) != null) {
c.setSize(c.getWidth(), bottom - top);
Dimension d = c.getPreferredSize();
c.setBounds(left, top, d.width, bottom - top);
left += d.width + hgap;
}
if ((c = getChild(CENTER, ltr)) != null) {
c.setBounds(left, top, right - left, bottom - top);
}
}
}
/**
* Determines the preferred size of the <code>target</code> container using this layout manager,
* based on the components in the container.
*
* <p>Most applications do not call this method directly. This method is called when a container
* calls its <code>getPreferredSize</code> method.
*
* @param target the container in which to do the layout.
* @return the preferred dimensions to lay out the subcomponents of the specified container.
* @see java.awt.Container
* @see java.awt.BorderLayout#minimumLayoutSize
* @see java.awt.Container#getPreferredSize()
*/
public Dimension preferredLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
boolean ltr = target.getComponentOrientation().isLeftToRight();
Component c = null;
if ((c = getChild(EAST, ltr)) != null) {
Dimension d = c.getPreferredSize();
dim.width += d.width + hgap;
dim.height = Math.max(d.height, dim.height);
}
if ((c = getChild(WEST, ltr)) != null) {
Dimension d = c.getPreferredSize();
dim.width += d.width + hgap;
dim.height = Math.max(d.height, dim.height);
}
if ((c = getChild(CENTER, ltr)) != null) {
Dimension d = c.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if ((c = getChild(NORTH, ltr)) != null) {
Dimension d = c.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height + vgap;
}
if ((c = getChild(SOUTH, ltr)) != null) {
Dimension d = c.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height + vgap;
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
/**
* Calculates the preferred size dimensions for the specified panel given the components in the
* specified parent container.
*
* @see #minimumLayoutSize
* @param target The component to be laid out.
* @return A size deemed suitable for laying out the container.
*/
public Dimension preferredLayoutSize(Container target) {
int count;
Container parent;
Component component;
Point point;
Dimension dimension;
Insets insets;
Dimension ret;
synchronized (target.getTreeLock()) {
count = target.getComponentCount();
if (0 == count) {
// be the same size unless we have a parent
ret = target.getSize();
parent = target.getParent();
if (null != parent) {
insets = parent.getInsets();
ret = parent.getSize();
ret.setSize(
ret.width - insets.left - insets.right, ret.height - insets.top - insets.bottom);
}
} else {
ret = new Dimension(0, 0);
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
point = component.getLocation();
dimension = component.getPreferredSize();
ret.width = Math.max(ret.width, point.x + dimension.width);
ret.height = Math.max(ret.height, point.y + dimension.height);
}
}
insets = target.getInsets();
ret.width += insets.left + insets.right;
ret.height += insets.top + insets.bottom;
}
}
return (ret);
}
@Override
public void layoutContainer(java.awt.Container target) {
synchronized (target.getTreeLock()) {
java.awt.Insets insets = target.getInsets();
int top = insets.top;
int left = insets.left;
int bottom = target.getHeight() - insets.bottom;
int right = target.getWidth() - insets.right;
int width = right - left;
int bottomHeight;
if (bottomComponent != null) {
bottomComponent.setSize(width, bottomComponent.getHeight());
java.awt.Dimension d = bottomComponent.getPreferredSize();
bottomHeight = d.height;
} else {
bottomHeight = 0;
}
if (this.mainComponent != null) {
this.mainComponent.setSize(width, this.mainComponent.getHeight());
java.awt.Dimension d = this.mainComponent.getPreferredSize();
if (this.mainComponent instanceof javax.swing.JScrollPane) {
javax.swing.JScrollPane jScrollPane = (javax.swing.JScrollPane) this.mainComponent;
if (d.width > (right - left)) {
d.height += jScrollPane.getHorizontalScrollBar().getPreferredSize().height;
}
}
d.height = Math.min(d.height, bottom - top - bottomHeight);
this.mainComponent.setBounds(left, top, width, d.height);
top += d.height + vGap;
}
if (bottomComponent != null) {
bottomComponent.setBounds(left, top, width, bottomHeight);
}
}
}
private void setComponentConstraintsImpl(
Component paramComponent, Object paramObject, boolean paramBoolean) {
Container localContainer = paramComponent.getParent();
synchronized (localContainer != null ? localContainer.getTreeLock() : new Object()) {
if ((!paramBoolean) && (!this.scrConstrMap.containsKey(paramComponent)))
throw new IllegalArgumentException("Component must already be added to parent!");
SwingComponentWrapper localSwingComponentWrapper = new SwingComponentWrapper(paramComponent);
if ((paramObject == null) || ((paramObject instanceof String))) {
String str = ConstraintParser.prepare((String) paramObject);
this.scrConstrMap.put(paramComponent, paramObject);
this.ccMap.put(localSwingComponentWrapper, ConstraintParser.parseComponentConstraint(str));
} else if ((paramObject instanceof CC)) {
this.scrConstrMap.put(paramComponent, paramObject);
this.ccMap.put(localSwingComponentWrapper, (CC) paramObject);
} else {
throw new IllegalArgumentException(
"Constraint must be String or ComponentConstraint: "
+ paramObject.getClass().toString());
}
this.dirty = true;
}
}
@Override
public Dimension preferredLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
Insets insets = target.getInsets();
// Provide a default if the panel has not been displayed yet (i.e. in a dialog)
int targetWidth = target.getWidth() == 0 ? 400 : target.getWidth();
int maxwidth = targetWidth - (insets.left + insets.right + getHgap() * 2);
int width = 0;
int height = 0;
int component = 0;
for (int i = 0; i < nmembers; i++, component++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
if (component > 0) {
if (width + d.width > maxwidth) {
dim.width = Math.max(dim.width, width);
dim.height += height + getVgap();
width = 0;
height = 0;
component = 0;
}
width += getHgap();
}
height = Math.max(height, d.height);
width += d.width;
}
}
dim.width = Math.max(dim.width, width);
dim.height += height;
dim.width += insets.left + insets.right + getHgap() * 2;
dim.height += insets.top + insets.bottom + getVgap() * 2;
return dim;
}
}
/*--------------------------------------------------------------------------*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int maxWidth = target.getSize().width - (insets.left + insets.right + hgap * 2);
int nMembers = target.getComponentCount();
int x = 0;
int y = insets.top + vgap;
int rowh = 0;
int start = 0;
boolean ltr = target.getComponentOrientation().isLeftToRight();
for (int i = 0; i < nMembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
m.setSize(d.width, d.height);
if ((x == 0) || ((x + d.width) <= maxWidth)) {
if (x > 0) {
x += hgap;
}
x += d.width;
rowh = Math.max(rowh, d.height);
} else {
moveComponents(target, insets.left, y, maxWidth - x, rowh, start, i, ltr);
x = d.width;
y += vgap + rowh;
rowh = d.height;
start = i;
}
}
}
moveComponents(target, insets.left, y, maxWidth - x, rowh, start, nMembers, ltr);
}
}
public Dimension preferredLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
DiagramView diagramView = (DiagramView) parent;
DesignView designView = diagramView.getDesignView();
int w = 0;
int h = 0;
double k = designView.getCorrectedZoom();
FBounds bounds = diagramView.getContentSize();
w = (int) Math.round(k * bounds.width + MARGIN_LEFT + MARGIN_RIGHT);
h = (int) Math.round(k * bounds.height + MARGIN_TOP + MARGIN_BOTTOM);
if (parent instanceof ProcessView) {
// int count = diagramView.getComponentCount();
// for (int i = 0; i < count; i++) {
// Component c = diagramView.getComponent(i);
// if (c instanceof NavigationTools) {
// continue;
// }
//
// w = Math.max(w, c.getX() + c.getWidth() + MARGIN_RIGHT);
// h = Math.max(h, c.getY() + c.getHeight() + MARGIN_BOTTOM);
// }
TriScrollPane scrollPane = designView.getScrollPane();
int leftWidth = scrollPane.getLeftPreferredWidth();
int rightWidth = scrollPane.getRightPreferredWidth();
w += leftWidth + rightWidth;
}
return new Dimension(w, h);
}
}
public void layoutContainer(Container paramContainer) {
synchronized (paramContainer.getTreeLock()) {
checkCache(paramContainer);
Insets localInsets = paramContainer.getInsets();
int[] arrayOfInt = {
localInsets.left,
localInsets.top,
paramContainer.getWidth() - localInsets.left - localInsets.right,
paramContainer.getHeight() - localInsets.top - localInsets.bottom
};
if (this.grid.layout(
arrayOfInt, this.lc.getAlignX(), this.lc.getAlignY(), getDebug(), true)) {
this.grid = null;
checkCache(paramContainer);
this.grid.layout(arrayOfInt, this.lc.getAlignX(), this.lc.getAlignY(), getDebug(), false);
}
long l = this.grid.getHeight()[1] + (this.grid.getWidth()[1] << 32);
if (this.lastSize != l) {
this.lastSize = l;
ContainerWrapper localContainerWrapper = checkParent(paramContainer);
Window localWindow =
(Window)
SwingUtilities.getAncestorOfClass(
Window.class, (Component) localContainerWrapper.getComponent());
if (localWindow != null)
if (localWindow.isVisible())
SwingUtilities.invokeLater(
new Runnable(localContainerWrapper) {
public void run() {
MigLayout.this.adjustWindowSize(this.val$containerWrapper);
}
});
else adjustWindowSize(localContainerWrapper);
}
this.lastInvalidSize = null;
}
}
@Override
public Dimension minimumLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
Insets insets = target.getInsets();
int maxwidth = target.getWidth() - (insets.left + insets.right + getHgap() * 2);
int width = 0;
int height = 0;
int component = 0;
for (int i = 0; i < nmembers; i++, component++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getMinimumSize();
if (component > 0) {
if (width + d.width > maxwidth) {
dim.width = Math.max(dim.width, width);
dim.height += height + getVgap();
width = 0;
height = 0;
component = 0;
}
width += getHgap();
}
height = Math.max(height, d.height);
width += d.width;
}
}
dim.width = Math.max(dim.width, width);
dim.height += height;
dim.width += insets.left + insets.right + getHgap() * 2;
dim.height += insets.top + insets.bottom + getVgap() * 2;
return dim;
}
}
/*--------------------------------------------------------------------------*/
public Dimension minimumLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getMinimumSize();
dim.height = Math.max(dim.height, d.height);
if (i > 0) {
dim.width += hgap;
}
dim.width += d.width;
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right + hgap * 2;
dim.height += insets.top + insets.bottom + vgap * 2;
return (dim);
}
}
/**
* Lays out the container.
*
* @param target The container which needs to be laid out.
*/
public void layoutContainer(Container target) {
Insets insets;
int x;
int y;
int count;
int width;
Component component;
Dimension dimension;
synchronized (target.getTreeLock()) {
insets = target.getInsets();
x = insets.left;
y = insets.top;
count = target.getComponentCount();
width = 0;
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
dimension = component.getPreferredSize();
width = Math.max(width, dimension.width);
component.setSize(dimension.width, dimension.height);
component.setLocation(x, y);
y += dimension.height;
}
}
// now set them all to the same width
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
dimension = component.getSize();
dimension.width = width;
component.setSize(dimension.width, dimension.height);
}
}
}
}
Dimension getLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Component[] comps = parent.getComponents();
int width = 0;
int height = 0;
Component header = findHeader(comps);
if (header != null && header.isVisible()) {
Dimension dim = header.getPreferredSize();
width = dim.width;
height = dim.height;
}
Component body = findBody(comps);
if (body != null && body.isVisible()) {
Dimension dim = body.getPreferredSize();
height += dim.height;
}
Insets margin = parent.getInsets();
width += (margin.left + margin.right);
height += (margin.top + margin.bottom);
return new Dimension(width, height);
}
}