/** {@inheritDoc} */
@Override
public Dimension getMaximumSize(JComponent c) {
if (c.getComponentCount() > 0 && c.getLayout() != null) {
return null;
}
AbstractButton b = (AbstractButton) c;
SynthContext ss = getContext(c);
Dimension size =
ss.getStyle()
.getGraphicsUtils(ss)
.getMaximumSize(
ss,
ss.getStyle().getFont(ss),
b.getText(),
getSizingIcon(b),
b.getHorizontalAlignment(),
b.getVerticalAlignment(),
b.getHorizontalTextPosition(),
b.getVerticalTextPosition(),
b.getIconTextGap(),
b.getDisplayedMnemonicIndex());
return size;
}
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
JScrollPane scroll = (JScrollPane) c;
JComponent colHeader = scroll.getColumnHeader();
int colHeaderHeight = 0;
if (colHeader != null) colHeaderHeight = colHeader.getHeight();
JComponent rowHeader = scroll.getRowHeader();
int rowHeaderWidth = 0;
if (rowHeader != null) rowHeaderWidth = rowHeader.getWidth();
g.translate(x, y);
g.setColor(MetalLookAndFeel.getControlDarkShadow());
g.drawRect(0, 0, w - 2, h - 2);
g.setColor(MetalLookAndFeel.getControlHighlight());
g.drawLine(w - 1, 1, w - 1, h - 1);
g.drawLine(1, h - 1, w - 1, h - 1);
g.setColor(MetalLookAndFeel.getControl());
g.drawLine(w - 2, 2 + colHeaderHeight, w - 2, 2 + colHeaderHeight);
g.drawLine(1 + rowHeaderWidth, h - 2, 1 + rowHeaderWidth, h - 2);
g.translate(-x, -y);
}
/**
* Instructs the layout manager to perform the layout for the specified container.
*
* @param the Container for which this layout manager is being used
*/
public void layoutContainer(Container parent) {
JRootPane root = (JRootPane) parent;
Rectangle b = root.getBounds();
Insets i = root.getInsets();
int nextY = 0;
int w = b.width - i.right - i.left;
int h = b.height - i.top - i.bottom;
if (root.getLayeredPane() != null) {
root.getLayeredPane().setBounds(i.left, i.top, w, h);
}
if (root.getGlassPane() != null) {
root.getGlassPane().setBounds(i.left, i.top, w, h);
}
// Note: This is laying out the children in the layeredPane,
// technically, these are not our children.
if (root.getWindowDecorationStyle() != JRootPane.NONE
&& (root.getUI() instanceof RootPaneUI)) {
JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
if (titlePane != null) {
Dimension tpd = titlePane.getPreferredSize();
if (tpd != null) {
int tpHeight = tpd.height;
titlePane.setBounds(0, 0, w, tpHeight);
nextY += tpHeight;
}
}
}
if (root.getContentPane() != null) {
root.getContentPane().setBounds(0, nextY, w, h < nextY ? 0 : h - nextY);
}
}
/** Returns the current state of the passed in <code>AbstractButton</code>. */
private int getComponentState(JComponent c) {
int state = ENABLED;
if (!c.isEnabled()) {
state = DISABLED;
}
if (SynthLookAndFeel.getSelectedUI() == this) {
return SynthLookAndFeel.getSelectedUIState() | SynthConstants.ENABLED;
}
AbstractButton button = (AbstractButton) c;
ButtonModel model = button.getModel();
if (model.isPressed()) {
if (model.isArmed()) {
state = PRESSED;
} else {
state = MOUSE_OVER;
}
}
if (model.isRollover()) {
state |= MOUSE_OVER;
}
if (model.isSelected()) {
state |= SELECTED;
}
if (c.isFocusOwner() && button.isFocusPainted()) {
state |= FOCUSED;
}
if ((c instanceof JButton) && ((JButton) c).isDefaultButton()) {
state |= DEFAULT;
}
return state;
}
public Rectangle getVisualBounds(JComponent c, int type, int width, int height) {
Rectangle bounds = new Rectangle(0, 0, width, height);
if (type == VisuallyLayoutable.CLIP_BOUNDS) {
return bounds;
}
AbstractButton b = (AbstractButton) c;
if (type == VisuallyLayoutable.COMPONENT_BOUNDS
&& b.getBorder() != null
&& b.isBorderPainted()) {
Border border = b.getBorder();
if (border instanceof BackgroundBorder) {
border = ((BackgroundBorder) border).getBackgroundBorder();
if (border instanceof VisualMargin) {
InsetsUtil.subtractInto(((VisualMargin) border).getVisualMargin(c), bounds);
} else if (border instanceof QuaquaButtonBorder) {
InsetsUtil.subtractInto(((QuaquaButtonBorder) border).getVisualMargin(c), bounds);
}
}
return bounds;
}
String text = b.getText();
boolean isEmpty = (text == null || text.length() == 0);
if (isEmpty) {
text = " ";
}
Icon icon = (b.isEnabled()) ? b.getIcon() : b.getDisabledIcon();
if ((icon == null) && (text == null)) {
return null;
}
FontMetrics fm = c.getFontMetrics(c.getFont());
Insets insets = c.getInsets(viewInsets);
viewR.x = insets.left;
viewR.y = insets.top;
viewR.width = width - (insets.left + insets.right);
viewR.height = height - (insets.top + insets.bottom);
iconR.x = iconR.y = iconR.width = iconR.height = 0;
textR.x = textR.y = textR.width = textR.height = 0;
String clippedText = layoutCL(b, fm, text, icon, viewR, iconR, textR);
Rectangle textBounds = Fonts.getPerceivedBounds(text, c.getFont(), c);
if (isEmpty) {
textBounds.width = 0;
}
int ascent = fm.getAscent();
textR.x += textBounds.x;
textR.width = textBounds.width;
textR.y += ascent + textBounds.y;
textR.height -= fm.getHeight() - textBounds.height;
bounds.setBounds(textR);
return bounds;
}
/**
* Returns the amount of space the layout would like to have.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's preferred size
*/
public Dimension preferredLayoutSize(Container parent) {
Dimension cpd, tpd;
int cpWidth = 0;
int cpHeight = 0;
int mbWidth = 0;
int mbHeight = 0;
int tpWidth = 0;
Insets i = parent.getInsets();
JRootPane root = (JRootPane) parent;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getPreferredSize();
} else {
cpd = root.getSize();
}
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
if (root.getWindowDecorationStyle() != JRootPane.NONE
&& (root.getUI() instanceof RootPaneUI)) {
JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
if (titlePane != null) {
tpd = titlePane.getPreferredSize();
if (tpd != null) {
tpWidth = tpd.width;
}
}
}
return new Dimension(
Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
cpHeight + mbHeight + tpWidth + i.top + i.bottom);
}
public void actionPerformed(ActionEvent ae) {
String cname = nameF.getText().trim();
int state = conditions[stateC.getSelectedIndex()];
try {
if (isSpecialCase(cname)) {
handleSpecialCase(cname, state);
} else {
JComponent comp = (JComponent) Class.forName(cname).newInstance();
ComponentUI cui = UIManager.getUI(comp);
cui.installUI(comp);
results.setText("Map entries for " + cname + ":\n\n");
if (inputB.isSelected()) {
loadInputMap(comp.getInputMap(state), "");
results.append("\n");
}
if (actionB.isSelected()) {
loadActionMap(comp.getActionMap(), "");
results.append("\n");
}
if (bindingB.isSelected()) {
loadBindingMap(comp, state);
}
}
} catch (ClassCastException cce) {
results.setText(cname + " is not a subclass of JComponent.");
} catch (ClassNotFoundException cnfe) {
results.setText(cname + " was not found.");
} catch (InstantiationException ie) {
results.setText(cname + " could not be instantiated.");
} catch (Exception e) {
results.setText("Exception found:\n" + e);
e.printStackTrace();
}
}
private Insets getScrollBarInsets(SynthContext context, Insets insets) {
int troughBorder = getClassSpecificIntValue(context, "trough-border", 1);
insets.left = insets.right = insets.top = insets.bottom = troughBorder;
JComponent c = context.getComponent();
if (c.getParent() instanceof JScrollPane) {
// This scrollbar is part of a scrollpane; use only the
// "scrollbar-spacing" style property to determine the padding
// between the scrollbar and its parent scrollpane.
int spacing = getClassSpecificIntValue(WidgetType.SCROLL_PANE, "scrollbar-spacing", 3);
if (((JScrollBar) c).getOrientation() == JScrollBar.HORIZONTAL) {
insets.top += spacing;
} else {
if (c.getComponentOrientation().isLeftToRight()) {
insets.left += spacing;
} else {
insets.right += spacing;
}
}
} else {
// This is a standalone scrollbar; leave enough room for the
// focus line in addition to the trough border.
if (c.isFocusable()) {
int focusSize = getClassSpecificIntValue(context, "focus-line-width", 1);
int focusPad = getClassSpecificIntValue(context, "focus-padding", 1);
int totalFocus = focusSize + focusPad;
insets.left += totalFocus;
insets.right += totalFocus;
insets.top += totalFocus;
insets.bottom += totalFocus;
}
}
return insets;
}
public void actionPerformed(ActionEvent ev) {
if (collapsed) {
if (label != null) {
remove(label);
}
add(comp);
moreOrLessButton.setIcon(collapseIcon);
} else {
remove(comp);
if (valueLabelStr != null) {
if (label == null) {
label = new JLabel(Resources.format(Messages.CURRENT_VALUE, valueLabelStr));
}
add(label);
}
moreOrLessButton.setIcon(expandIcon);
}
collapsed = !collapsed;
JComponent container = (JComponent) getParent();
if (container != null && container.getLayout() instanceof VariableGridLayout) {
((VariableGridLayout) container.getLayout()).setFillRow(this, !collapsed);
container.revalidate();
}
}
/**
* Notifies this UI delegate to repaint the specified component. This method paints the component
* background, then calls the {@link #paint(SynthContext,Graphics)} method.
*
* <p>In general, this method does not need to be overridden by subclasses. All Look and Feel
* rendering code should reside in the {@code paint} method.
*
* @param g the {@code Graphics} object used for painting
* @param c the component being painted
* @see #paint(SynthContext,Graphics)
*/
@Override
public void update(Graphics g, JComponent c) {
SynthContext context = getContext(c);
SynthLookAndFeel.update(context, g);
context.getPainter().paintScrollPaneBackground(context, g, 0, 0, c.getWidth(), c.getHeight());
paint(context, g);
}
/**
* Removes the previous content border from the specified component, and sets an empty border if
* there has been no border or an UIResource instance before.
*/
private void stripContentBorder(Object c) {
if (c instanceof JComponent) {
JComponent contentComp = (JComponent) c;
Border contentBorder = contentComp.getBorder();
if (contentBorder == null || contentBorder instanceof UIResource) {
contentComp.setBorder(handyEmptyBorder);
}
}
}
/**
* Creates a LabeledBorder instance with the specified border and label.
*
* @param border the border
* @param label the label the border should display
*/
public LabeledBorder(Border border, JComponent label) {
super(border);
this.label = label;
if (label instanceof JLabel && label.getForeground() instanceof ColorUIResource) {
label.setForeground(getTitleColor());
}
}
private void updateLabelSizes() {
Dictionary labelTable = getLabelTable();
if (labelTable != null) {
Enumeration labels = labelTable.elements();
while (labels.hasMoreElements()) {
JComponent component = (JComponent) labels.nextElement();
component.setSize(component.getPreferredSize());
}
}
}
protected void installDefaults() {
// Installs the text cursor on the component
super.installDefaults();
JComponent c = getComponent();
Object clientProperty = c.getClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES);
if (clientProperty == null || clientProperty == localFalse) {
c.putClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES, localTrue);
}
updateStyle((JTextComponent) getComponent());
}
/**
* Installs the UI.
*
* @param c
*/
@Override
public void installUI(JComponent c) {
super.installUI(c);
c.setOpaque(false);
// BasicBorders$SplitPaneBorder paints gray border
// resulting in a 2pt border for the left/right components
// but results in 1pt gray line on top/button of divider.
// Still, a 1 pt shaddow light gay line is painted
c.setBorder(null);
} // installUI
/**
* See readObject() and writeObject() in JComponent for more information about serialization in
* Swing.
*/
private void writeObject(ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
if (getUIClassID().equals(uiClassID)) {
byte count = JComponent.getWriteObjCounter(this);
JComponent.setWriteObjCounter(this, --count);
if (count == 0 && ui != null) {
ui.installUI(this);
}
}
}
/**
* Returns the maximum amount of space the layout can use.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's maximum size
*/
public Dimension maximumLayoutSize(Container target) {
Dimension cpd, mbd, tpd;
int cpWidth = Integer.MAX_VALUE;
int cpHeight = Integer.MAX_VALUE;
int mbWidth = Integer.MAX_VALUE;
int mbHeight = Integer.MAX_VALUE;
int tpWidth = Integer.MAX_VALUE;
int tpHeight = Integer.MAX_VALUE;
Insets i = target.getInsets();
JRootPane root = (JRootPane) target;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getMaximumSize();
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
}
if (root.getMenuBar() != null) {
mbd = root.getMenuBar().getMaximumSize();
if (mbd != null) {
mbWidth = mbd.width;
mbHeight = mbd.height;
}
}
if (root.getWindowDecorationStyle() != JRootPane.NONE
&& (root.getUI() instanceof HokageRootPaneUI)) {
JComponent titlePane = ((HokageRootPaneUI) root.getUI()).getTitlePane();
if (titlePane != null) {
tpd = titlePane.getMaximumSize();
if (tpd != null) {
tpWidth = tpd.width;
tpHeight = tpd.height;
}
}
}
int maxHeight = Math.max(Math.max(cpHeight, mbHeight), tpHeight);
// Only overflows if 3 real non-MAX_VALUE heights, sum to > MAX_VALUE
// Only will happen if sums to more than 2 billion units. Not likely.
if (maxHeight != Integer.MAX_VALUE) {
maxHeight = cpHeight + mbHeight + tpHeight + i.top + i.bottom;
}
int maxWidth = Math.max(Math.max(cpWidth, mbWidth), tpWidth);
// Similar overflow comment as above
if (maxWidth != Integer.MAX_VALUE) {
maxWidth += i.left + i.right;
}
return new Dimension(maxWidth, maxHeight);
}
/** Uninstalls the UI delegate for the specified component */
public void uninstallUI(JComponent c) {
frame = (JInternalFrame) c;
Container cont = ((JInternalFrame) (c)).getContentPane();
if (cont instanceof JComponent) {
JComponent content = (JComponent) cont;
if (content.getBorder() == handyEmptyBorder) {
content.setBorder(null);
}
}
super.uninstallUI(c);
}
/**
* Updates the UIs for the labels in the label table by calling {@code updateUI} on each label.
* The UIs are updated from the current look and feel. The labels are also set to their preferred
* size.
*
* @see #setLabelTable
* @see JComponent#updateUI
*/
protected void updateLabelUIs() {
Dictionary labelTable = getLabelTable();
if (labelTable == null) {
return;
}
Enumeration labels = labelTable.keys();
while (labels.hasMoreElements()) {
JComponent component = (JComponent) labelTable.get(labels.nextElement());
component.updateUI();
component.setSize(component.getPreferredSize());
}
}
/**
* Sets the window title pane -- the JComponent used to provide a plaf a way to override the
* native operating system's window title pane with one whose look and feel are controlled by the
* plaf. The plaf creates and sets this value; the default is null, implying a native operating
* system window title pane.
*
* @param content the <code>JComponent</code> to use for the window title pane.
*/
private void setTitlePane(JRootPane root, JComponent titlePane) {
JLayeredPane layeredPane = root.getLayeredPane();
JComponent oldTitlePane = getTitlePane();
if (oldTitlePane != null) {
oldTitlePane.setVisible(false);
layeredPane.remove(oldTitlePane);
}
if (titlePane != null) {
layeredPane.add(titlePane, JLayeredPane.FRAME_CONTENT_LAYER);
titlePane.setVisible(true);
}
this.titlePane = titlePane;
}
protected void uninstallDefaults() {
SynthContext context = getContext(getComponent(), ENABLED);
JComponent c = getComponent();
c.putClientProperty("caretAspectRatio", null);
style.uninstallDefaults(context);
context.dispose();
style = null;
Object clientProperty = c.getClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES);
if (clientProperty == localTrue) {
getComponent().putClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES, Boolean.FALSE);
}
super.uninstallDefaults();
}
/**
* Reinitialize the insets parameter with this Border's current Insets.
*
* @param c the component for which this border insets value applies
* @param insets the object to be reinitialized
*/
public Insets getBorderInsets(Component c, Insets insets) {
Border border = getBorder();
if (border != null) {
if (border instanceof AbstractBorder) {
((AbstractBorder) border).getBorderInsets(c, insets);
} else {
// Can't reuse border insets because the Border interface
// can't be enhanced.
Insets i = border.getBorderInsets(c);
insets.top = i.top;
insets.right = i.right;
insets.bottom = i.bottom;
insets.left = i.left;
}
} else {
insets.left = insets.top = insets.right = insets.bottom = 0;
}
insets.left += EDGE_SPACING + TEXT_SPACING;
insets.right += EDGE_SPACING + TEXT_SPACING;
insets.top += EDGE_SPACING + TEXT_SPACING;
insets.bottom += EDGE_SPACING + TEXT_SPACING;
if (c == null || label == null) {
return insets;
}
insets.top += label.getHeight();
return insets;
}
protected void paintBackground(Graphics g, JComponent c, int x, int y, int w, int h) {
JMenuItem b = (JMenuItem) c;
ButtonModel model = b.getModel();
if (c.getParent() instanceof JMenuBar) {
if (model.isArmed() || (c instanceof JMenu && model.isSelected())) {
g.setColor(AbstractLookAndFeel.getMenuSelectionBackgroundColor());
g.fillRect(x, y, w, h);
}
} else {
if (model.isArmed() || (c instanceof JMenu && model.isSelected())) {
g.setColor(AbstractLookAndFeel.getMenuSelectionBackgroundColor());
g.fillRect(x, y, w, h);
} else if (!AbstractLookAndFeel.getTheme().isMenuOpaque()) {
Graphics2D g2D = (Graphics2D) g;
Composite composite = g2D.getComposite();
AlphaComposite alpha =
AlphaComposite.getInstance(
AlphaComposite.SRC_OVER, AbstractLookAndFeel.getTheme().getMenuAlpha());
g2D.setComposite(alpha);
g.setColor(AbstractLookAndFeel.getMenuBackgroundColor());
g.fillRect(x, y, w, h);
g2D.setComposite(composite);
} else {
g.setColor(AbstractLookAndFeel.getMenuBackgroundColor());
g.fillRect(x, y, w, h);
}
}
if (menuItem.isSelected() && menuItem.isArmed()) {
g.setColor(AbstractLookAndFeel.getMenuSelectionForegroundColor());
} else {
g.setColor(AbstractLookAndFeel.getMenuForegroundColor());
}
}
/**
* Returns the minimum dimensions this border requires in order to fully display the border and
* title.
*
* @param c the component where this border will be drawn
*/
public Dimension getMinimumSize(Component c) {
Insets insets = getBorderInsets(c);
Dimension minSize = new Dimension(insets.right + insets.left, insets.top + insets.bottom);
minSize.width += label.getWidth();
return minSize;
}
/**
* Enables the component so that the knob position can be changed. When the disabled, the knob
* position cannot be changed.
*
* @param x a boolean value, where true enables the component and false disables it
*/
public void setEnabled(boolean x) {
super.setEnabled(x);
Component[] children = getComponents();
for (int i = 0; i < children.length; i++) {
children[i].setEnabled(x);
}
}
/**
* This method gets called when a bound property is changed on the associated JTextComponent. This
* is a hook which UI implementations may change to reflect how the UI displays bound properties
* of JTextComponent subclasses. If the font, foreground or document has changed, the the
* appropriate property is set in the default style of the document.
*
* @param evt the property change event
*/
@Override
protected void propertyChange(PropertyChangeEvent evt) {
super.propertyChange(evt);
String name = evt.getPropertyName();
if (name.equals("foreground")) {
updateForeground((Color) evt.getNewValue());
} else if (name.equals("font")) {
updateFont((Font) evt.getNewValue());
} else if (name.equals("document")) {
JComponent comp = getComponent();
updateForeground(comp.getForeground());
updateFont(comp.getFont());
}
}
/**
* Enables the component so that the knob position can be changed. When the disabled, the knob
* position cannot be changed.
*
* @param x a boolean value, where true enables the component and false disables it
*/
public void setEnabled(boolean x) {
super.setEnabled(x);
Component[] children = getComponents();
for (Component child : children) {
child.setEnabled(x);
}
}
@Override
public Dimension getMinimumSize(JComponent c) {
AbstractButton b = (AbstractButton) c;
String style = (String) c.getClientProperty("Quaqua.Button.style");
if (style == null) {
style = "push";
}
if (style.equals("help")) {
return getPreferredSize(c);
}
Dimension d = super.getMinimumSize(c);
if (isFixedHeight(c)) {
Dimension p = getPreferredSize(c);
if (d != null && p != null) {
d.height = Math.max(d.height, p.height);
}
}
if (!QuaquaUtilities.isSmallSizeVariant(c)
&& style.equals("push") //
&& b.getIcon() == null
&& b.getText() != null) {
if (d != null) {
d.width = Math.max(d.width, UIManager.getInt("Button.minimumWidth"));
}
}
return d;
}
/**
* Returns an enum indicating how the baseline of the component changes as the size changes.
*
* @throws NullPointerException {@inheritDoc}
* @see javax.swing.JComponent#getBaseline(int, int)
* @since 1.6
*/
public Component.BaselineResizeBehavior getBaselineResizeBehavior(JComponent c) {
super.getBaselineResizeBehavior(c);
Border border = c.getBorder();
if (border instanceof AbstractBorder) {
return ((AbstractBorder) border).getBaselineResizeBehavior(c);
}
return Component.BaselineResizeBehavior.OTHER;
}
/**
* Returns the baseline.
*
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @see javax.swing.JComponent#getBaseline(int, int)
* @since 1.6
*/
public int getBaseline(JComponent c, int width, int height) {
super.getBaseline(c, width, height);
Border border = c.getBorder();
if (border instanceof AbstractBorder) {
return ((AbstractBorder) border).getBaseline(c, width, height);
}
return -1;
}