public void acceptMinimumSize(Component c) { Dimension minimumSize = getMinimumSize(c); c.setMinimumSize( new Dimension( Math.max(minimumSize.width, c.getMinimumSize().width), Math.max(minimumSize.height, c.getMinimumSize().height))); }
/** * 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 Dimension minimumLayoutSize(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.getMinimumSize(); 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.getMinimumSize(); 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; }
@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); }
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 Dimension minimumNodeSize(Node root) { if (root instanceof Leaf) { Component child = childForNode(root); return (child != null) ? child.getMinimumSize() : new Dimension(0, 0); } else if (root instanceof Divider) { int dividerSize = getDividerSize(); return new Dimension(dividerSize, dividerSize); } else { Split split = (Split) root; List<Node> splitChildren = split.getChildren(); int width = 0; int height = 0; if (split.isRowLayout()) { for (Node splitChild : splitChildren) { Dimension size = minimumNodeSize(splitChild); width += size.width; height = Math.max(height, size.height); } } else { for (Node splitChild : splitChildren) { Dimension size = minimumNodeSize(splitChild); width = Math.max(width, size.width); height += size.height; } } return new Dimension(width, height); } }
public Dimension minimumLayoutSize(Container target) { 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(); if (fVerticalLayout) { dim.width = Math.max(dim.width, d.width); if (i > 0) { dim.height += fGap; } dim.height += d.height; } else { dim.height = Math.max(dim.height, d.height); if (i > 0) { dim.width += fGap; } dim.width += d.width; } } } Insets insets = target.getInsets(); dim.width += insets.left + insets.right; dim.width += 2 * fBorder.x; dim.height += insets.top + insets.bottom; dim.height += 2 * fBorder.y; return dim; }
/** @see java.awt.event.ComponentAdapter#componentResized(java.awt.event.ComponentEvent) */ public void componentResized(ComponentEvent evt) { /* 获取目标组件 */ Component component = evt.getComponent(); /* 获取目标组件设置的边界和最小最大尺寸 */ Rectangle bounds = component.getBounds(); Dimension minSize = component.getMinimumSize(); Dimension maxSize = component.getMaximumSize(); /* 确定目标组件新的x轴坐标及宽度 */ if (bounds.width < minSize.width) { bounds.x -= (bounds.x == m_oldBounds.x ? 0 : minSize.width - bounds.width); bounds.width = minSize.width; } else if (bounds.width > maxSize.width) { bounds.x += (bounds.x == m_oldBounds.x ? 0 : bounds.width - maxSize.width); bounds.width = maxSize.width; } /* 确定目标组件新的y轴坐标及高度 */ if (bounds.height < minSize.height) { bounds.y -= (bounds.y == m_oldBounds.y ? 0 : minSize.height - bounds.height); bounds.height = minSize.height; } else if (bounds.height > maxSize.height) { bounds.y += (bounds.y == m_oldBounds.y ? 0 : bounds.height - maxSize.height); bounds.height = maxSize.height; } /* 设置目标组件的新边界 */ component.setBounds(bounds); /* 保存新的边界 */ m_oldBounds = bounds; }
protected void enforceMinimumAndMaximumWidgetSizes(java.awt.Component component) { java.awt.Dimension size = component.getSize(); boolean changed = false; // enforce minimum java.awt.Dimension minimumSize = component.getMinimumSize(); if (size.width < minimumSize.width) { size.width = minimumSize.width; changed = true; } if (size.height < minimumSize.height) { size.height = minimumSize.height; changed = true; } // enforce maximum java.awt.Dimension maximumSize = component.getMaximumSize(); if (maximumSize != null) { if (size.width > maximumSize.width && maximumSize.width > 0) { size.width = maximumSize.width; changed = true; } if (size.height > maximumSize.height && maximumSize.height > 0) { size.height = maximumSize.height; changed = true; } } if (changed) { component.setSize(size); } }
@Override public Dimension minimumLayoutSize(Container parent) { Component toolbar = parent.getComponent(0); Dimension toolbarSize = toolbar.isVisible() ? toolbar.getMinimumSize() : new Dimension(); Dimension contentSize = parent.getComponent(1).getMinimumSize(); return new Dimension( Math.max(toolbarSize.width, contentSize.width), toolbarSize.height + contentSize.height); }
public void layoutContainer(Container parent) { int n = rows.size(); Insets border = parent.getInsets(); int lastY = border.top; // figure out where the second column should start int secondColumn = 0; for (int i = 0; i < n; i++) { Row r = (Row) rows.get(i); if (r instanceof NormalRow) { NormalRow nr = (NormalRow) r; secondColumn = Math.max( secondColumn, // nr.l.getMinimumSize().width); nr.getLabelWidth(false)); } } secondColumn += border.left + EXTRA; for (int i = 0; i < n; i++) { Row r = (Row) rows.get(i); if (r instanceof HeaderRow) { // header Component header = ((HeaderRow) r).h; int w = parent.getWidth() - (border.left + border.right); int h = header.getMinimumSize().height; int x = border.left; int y = lastY; header.setBounds(x, y, w, h); lastY += h; } else if (r instanceof NormalRow) { // label JLabel l = (JLabel) ((NormalRow) r).l; int w1 = l.getMinimumSize().width; // int h1 = l.getPreferredSize().height; int h1 = l.getMinimumSize().height; int x1 = secondColumn - w1; int y1 = lastY; l.setBounds(x1, y1, w1, h1); // control Component c = ((NormalRow) r).c; // WAS: int w2 = c.getPreferredSize().width; int w2 = c.getMaximumSize().width; // NEW! w2 = Math.min(w2, parent.getWidth() - (border.right + PADDING + secondColumn)); int h2 = c.getPreferredSize().height; int x2 = secondColumn + PADDING; // buffer between 'em int y2 = lastY; c.setBounds(x2, y2, w2, h2); lastY += Math.max(h1, h2); } } // focus on the first one? (is that my job?) (is it even possible?) }
public void layoutContainer(Container parent) { Dimension ourSize = preferredLayoutSize(parent), // Does the following do something useful? // And shouldn't we cater to real instead of maximum sizes? // This way, if a VerticallyLaidout component had a particular size forced upon it, // wouldn't we neglect to scale down to using minimum sizes so long as its maximum // size was bigger than our preferred? all: [Davis] maxSize = parent.getMaximumSize(), size = parent.getSize(); Insets isets = parent.getInsets(); Dimension compSize; int n = parent.getComponentCount(); int y; boolean usingPreferredSize = true; if (ourSize.width > maxSize.width || ourSize.height > maxSize.height) { ourSize = minimumLayoutSize(parent); usingPreferredSize = false; } switch (verticalAlignment) { case TOP: y = isets.top; break; case BOTTOM: y = (size.height - ourSize.height); break; default: // assume MIDDLE y = (size.height - ourSize.height) / 2 + isets.top; break; } for (int i = 0; i < n; i++) { Component c = parent.getComponent(i); compSize = usingPreferredSize ? c.getPreferredSize() : c.getMinimumSize(); switch (horizontalAlignment) { case LEFT: c.setBounds(isets.left, y, compSize.width, compSize.height); break; case RIGHT: c.setBounds( ourSize.width - isets.right - compSize.width + isets.left, y, compSize.width, compSize.height); break; default: // assume CENTER c.setBounds( (ourSize.width - isets.left - isets.right - compSize.width + isets.left) / 2, y, compSize.width, compSize.height); } y += compSize.height + vgap; } }
/** * @param dim * @param cc */ private Dimension rozmer(final Dimension dim, final Component cc) { final Dimension prs = cc.getPreferredSize(); final Dimension mis = cc.getMinimumSize(); final Dimension mas = cc.getMaximumSize(); final int dx = rozmer(ratiox, dim.width, prs.width, mis.width, mas.width); final int dy = rozmer(ratioy, dim.height, prs.height, mis.height, mas.height); final Dimension v = new Dimension(dx, dy); return v; }
public Dimension preferredLayoutSize(Container parent) { Insets insets = parent.insets(); int ncomponents = parent.countComponents(); int nrows = getRows(); int ncols = getColumns(); int hgap = getHgap(); int vgap = getVgap(); if (nrows > 0) { ncols = (ncomponents + nrows - 1) / nrows; } else { nrows = (ncomponents + ncols - 1) / ncols; } int nComps = parent.getComponentCount(); int y = insets.top; for (int row = 0; row < nrows; row++) { int h = 0; for (int col = 0; col < ncols; col++) { if (row * ncols + col < nComps) { Component c = parent.getComponent(row * ncols + col); h = Math.max(h, c.getMinimumSize().height); } } y += h + vgap; } int x = insets.left; for (int col = 0; col < ncols; col++) { int w = 0; for (int row = 0; row < nrows; row++) { if (row * ncols + col < nComps) { Component c = parent.getComponent(row * ncols + col); w = Math.max(w, c.getMinimumSize().width); } } x += w + hgap; } return new Dimension(x, y); }
/** * Calculates the minimum size dimensions for the specified panel given the components in the * specified parent container. */ public Dimension minimumLayoutSize(Container container) { Component child = getChild(container); if (child == null) return new Dimension(0, 0); Dimension childMinSize = child.getMinimumSize(); Insets insets = container.getInsets(); int width = childMinSize.width + insets.left + insets.right; int height = childMinSize.height + insets.top + insets.bottom; int maxSize = Math.max(width, height); return new Dimension(maxSize, maxSize); }
public Dimension minimumLayoutSize(Container target) { if (_minimumLayoutSize == null) { int w = 0; int h = 0; for (Component c : target.getComponents()) { w += c.getMinimumSize().width; h += c.getMinimumSize().height + SEPARATOR_THICKNESS; } _minimumLayoutSize = new Dimension(w, h); } return _minimumLayoutSize; }
/** * Determines the minimum size of the <code>target</code> container using this layout manager. * * <p>This method is called when a container calls its <code>getMinimumSize</code> method. Most * applications do not call this method directly. * * @param target the container in which to do the layout. * @return the minimum dimensions needed to lay out the subcomponents of the specified container. * @see java.awt.Container * @see java.awt.BorderLayout#preferredLayoutSize * @see java.awt.Container#getMinimumSize() */ public Dimension minimumLayoutSize(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.getMinimumSize(); dim.width += d.width + hgap; dim.height = Math.max(d.height, dim.height); } if ((c = getChild(WEST, ltr)) != null) { Dimension d = c.getMinimumSize(); dim.width += d.width + hgap; dim.height = Math.max(d.height, dim.height); } if ((c = getChild(CENTER, ltr)) != null) { Dimension d = c.getMinimumSize(); dim.width += d.width; dim.height = Math.max(d.height, dim.height); } if ((c = getChild(NORTH, ltr)) != null) { Dimension d = c.getMinimumSize(); dim.width = Math.max(d.width, dim.width); dim.height += d.height + vgap; } if ((c = getChild(SOUTH, ltr)) != null) { Dimension d = c.getMinimumSize(); 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; } }
/** 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; } } }
/** * @param parent * @return */ public Dimension minimumLayoutSize(Container parent) { Insets insets = parent.getInsets(); int min_width = 0; int min_height = 0; for (int index = 0; index < parent.getComponentCount(); index++) { Component comp = parent.getComponent(index); Dimension minsz = comp.getMinimumSize(); min_width = Math.max(minsz.width, min_width); min_height = Math.max(minsz.height, min_height); } return new Dimension( min_width + insets.left + insets.right, min_height + insets.top + insets.bottom); }
/** * Resizes the <code>TableColumn</code> to fit the width of its header cell. This method does * nothing if the header renderer is <code>null</code> (the default case). Otherwise, it sets the * minimum, maximum and preferred widths of this column to the widths of the minimum, maximum and * preferred sizes of the Component delivered by the header renderer. The transient "width" * property of this TableColumn is also set to the preferred width. Note this method is not used * internally by the table package. * * @see #setPreferredWidth */ public void sizeWidthToFit() { if (headerRenderer == null) { return; } Component c = headerRenderer.getTableCellRendererComponent(null, getHeaderValue(), false, false, 0, 0); setMinWidth(c.getMinimumSize().width); setMaxWidth(c.getMaximumSize().width); setPreferredWidth(c.getPreferredSize().width); setWidth(getPreferredWidth()); }
@Override public Dimension minimumLayoutSize(Container parent) { if (parent.getComponentCount() == 0) { return new Dimension(0, 0); } else { int x = Integer.MAX_VALUE, y = Integer.MAX_VALUE; for (Component child : parent.getComponents()) { Dimension dim = child.getMinimumSize(); x = Math.min(dim.width, x); y = Math.min(dim.height, y); } return new Dimension(x, y); } }
/** {@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); } }
/* Required by LayoutManager. */ public Dimension minimumLayoutSize(Container parent) { // System.out.println("PL: minimumLayoutSize called"); Dimension dim = new Dimension(0, 0); // setSizes(parent); if (center != null) { dim = center.getMinimumSize(); System.out.println("minimum size of center component -> " + dim); dim.width /= (1 - insetLeft - insetRight - zonesetLeft - zonesetRight); dim.height /= (1 - insetTop - insetBottom - zonesetTop - zonesetBottom); } // Always add the container's insets! Insets insets = parent.getInsets(); dim.width += insets.left + insets.right; dim.height += insets.top + insets.bottom; return dim; }
/** * Calculates the minimum dimension for the specified panel given the components in the specified * parent container. * * @param parent the component to be laid out * @see #preferredLayoutSize */ public Dimension minimumLayoutSize(Container parent) { int maxWidth = 0; int maxHeight = 0; for (java.util.Enumeration e = constraints.keys(); e.hasMoreElements(); ) { Component comp = (Component) e.nextElement(); AbsoluteConstraints ac = (AbsoluteConstraints) constraints.get(comp); Dimension size = comp.getMinimumSize(); int width = ac.getWidth(); if (width == -1) width = size.width; int height = ac.getHeight(); if (height == -1) height = size.height; if (ac.x + width > maxWidth) maxWidth = ac.x + width; if (ac.y + height > maxHeight) maxHeight = ac.y + height; } return new Dimension(maxWidth, maxHeight); }
public Dimension minimumLayoutSize(Container target) { Insets insets = target.getInsets(); Dimension dim = new Dimension(0, 0); int ncomponents = target.getComponentCount(); Component comp; Dimension d; for (int i = 0; i < ncomponents; i++) { comp = target.getComponent(i); if (comp.isVisible()) { d = comp.getMinimumSize(); dim.width += d.width; dim.height = Math.max(d.height, dim.height); if (i > 0) dim.width += gap; } } dim.width += insets.left + insets.right; dim.height += insets.top + insets.bottom; return dim; }
/** * Algorithm for calculating the largest minimum or preferred cell size. * * <p>Largest cell size is calculated by getting the applicable size of each component and keeping * the maximum value, dividing the component's width by the number of columns it is specified to * occupy and dividing the component's height by the number of rows it is specified to occupy. * * @param parent the container in which to do the layout. * @param isPreferred true for calculating preferred size, false for calculating minimum size. * @return the largest cell size required. */ protected Dimension getLargestCellSize(Container parent, boolean isPreferred) { int ncomponents = parent.getComponentCount(); Dimension maxCellSize = new Dimension(0, 0); for (int i = 0; i < ncomponents; i++) { Component c = parent.getComponent(i); Rectangle rect = (Rectangle) compTable.get(c); if (c != null && rect != null) { Dimension componentSize; if (isPreferred) { componentSize = c.getPreferredSize(); } else { componentSize = c.getMinimumSize(); } // Note: rect dimensions are already asserted to be > 0 when the // component is added with constraints maxCellSize.width = Math.max(maxCellSize.width, componentSize.width / rect.width); maxCellSize.height = Math.max(maxCellSize.height, componentSize.height / rect.height); } } return maxCellSize; }
public void layoutContainer(Container target) { Insets insets = target.getInsets(); int nmembers = target.getComponentCount(); int x = insets.left + fBorder.x; int y = insets.top + fBorder.y; for (int i = 0; i < nmembers; i++) { Component m = target.getComponent(i); if (m.isVisible()) { Dimension d = m.getMinimumSize(); m.setBounds(x, y, d.width, d.height); if (fVerticalLayout) { y += d.height; y += fGap; } else { x += d.width; x += fGap; } } } }
@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); } }
/** * A debugging utility that prints to stdout the component's minimum, preferred, and maximum * sizes. */ public static void printSizes(Component c) { System.out.println("minimumSize = " + c.getMinimumSize()); System.out.println("preferredSize = " + c.getPreferredSize()); System.out.println("maximumSize = " + c.getMaximumSize()); }