/**
* 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;
}
}
private void hideDropDownButton() {
for (Component component : this.getComponents()) {
if (component instanceof AbstractButton && component.isVisible()) {
component.setVisible(false);
this.revalidate();
}
}
}
/** 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;
}
}
}
/**
* Sets a specified <code>Component</code> to be the glass pane for this root pane. The glass pane
* should normally be a lightweight, transparent component, because it will be made visible when
* ever the root pane needs to grab input events.
*
* <p>The new glass pane's visibility is changed to match that of the current glass pane. An
* implication of this is that care must be taken when you want to replace the glass pane and make
* it visible. Either of the following will work:
*
* <pre>
* root.setGlassPane(newGlassPane);
* newGlassPane.setVisible(true);
* </pre>
*
* or:
*
* <pre>
* root.getGlassPane().setVisible(true);
* root.setGlassPane(newGlassPane);
* </pre>
*
* @param glass the <code>Component</code> to use as the glass pane for this <code>JRootPane
* </code>
* @exception NullPointerException if the <code>glass</code> parameter is <code>null</code>
*/
public void setGlassPane(Component glass) {
if (glass == null) {
throw new NullPointerException("glassPane cannot be set to null.");
}
AWTAccessor.getComponentAccessor().setMixingCutoutShape(glass, new Rectangle());
boolean visible = false;
if (glassPane != null && glassPane.getParent() == this) {
this.remove(glassPane);
visible = glassPane.isVisible();
}
glass.setVisible(visible);
glassPane = glass;
this.add(glassPane, 0);
if (visible) {
repaint();
}
}
/**
* The <code>glassPane</code> and <code>contentPane</code> have the same bounds, which means
* <code>JRootPane</code> does not tiles its children and this should return false. On the other
* hand, the <code>glassPane</code> is normally not visible, and so this can return true if the
* <code>glassPane</code> isn't visible. Therefore, the return value here depends upon the
* visibility of the <code>glassPane</code>.
*
* @return true if this component's children don't overlap
*/
public boolean isOptimizedDrawingEnabled() {
return !glassPane.isVisible();
}