Back to index...

	/*
	* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing.plaf.basic;

	import sun.swing.SwingUtilities2;
	import sun.awt.AppContext;

	import java.awt.*;
	import java.awt.event.*;
	import java.io.Serializable;
	import javax.swing.*;
	import javax.swing.border.*;
	import java.awt.*;
	import java.awt.event.*;
	import javax.swing.plaf.ButtonUI;
	import javax.swing.plaf.UIResource;
	import javax.swing.plaf.ComponentUI;
	import javax.swing.text.View;

	/**
	* BasicButton implementation
	*
	* @author Jeff Dinkins
	*/
	public class BasicButtonUI extends ButtonUI{
	// Visual constants
	// NOTE: This is not used or set any where. Were we allowed to remove
	// fields, this would be removed.
	protected int defaultTextIconGap;

	// Amount to offset text, the value of this comes from
	// defaultTextShiftOffset once setTextShiftOffset has been invoked.
	private int shiftOffset = 0;
	// Value that is set in shiftOffset once setTextShiftOffset has been
	// invoked. The value of this comes from the defaults table.
	protected int defaultTextShiftOffset;

	private final static String propertyPrefix = "Button" + ".";

	private static final Object BASIC_BUTTON_UI_KEY = new Object();

	// ********************************
	// Create PLAF
	// ********************************
	public static ComponentUI createUI(JComponent c) {
	AppContext appContext = AppContext.getAppContext();
	BasicButtonUI buttonUI =
	(BasicButtonUI) appContext.get(BASIC_BUTTON_UI_KEY);
	if (buttonUI == null) {
	buttonUI = new BasicButtonUI();
	appContext.put(BASIC_BUTTON_UI_KEY, buttonUI);
	}
	return buttonUI;
	}

	protected String getPropertyPrefix() {
	return propertyPrefix;
	}


	// ********************************
	// Install PLAF
	// ********************************
	public void installUI(JComponent c) {
	installDefaults((AbstractButton) c);
	installListeners((AbstractButton) c);
	installKeyboardActions((AbstractButton) c);
	BasicHTML.updateRenderer(c, ((AbstractButton) c).getText());
	}

	protected void installDefaults(AbstractButton b) {
	// load shared instance defaults
	String pp = getPropertyPrefix();

	defaultTextShiftOffset = UIManager.getInt(pp + "textShiftOffset");

	// set the following defaults on the button
	if (b.isContentAreaFilled()) {
	LookAndFeel.installProperty(b, "opaque", Boolean.TRUE);
	} else {
	LookAndFeel.installProperty(b, "opaque", Boolean.FALSE);
	}

	if(b.getMargin() == null \|\| (b.getMargin() instanceof UIResource)) {
	b.setMargin(UIManager.getInsets(pp + "margin"));
	}

	LookAndFeel.installColorsAndFont(b, pp + "background",
	pp + "foreground", pp + "font");
	LookAndFeel.installBorder(b, pp + "border");

	Object rollover = UIManager.get(pp + "rollover");
	if (rollover != null) {
	LookAndFeel.installProperty(b, "rolloverEnabled", rollover);
	}

	LookAndFeel.installProperty(b, "iconTextGap", Integer.valueOf(4));
	}

	protected void installListeners(AbstractButton b) {
	BasicButtonListener listener = createButtonListener(b);
	if(listener != null) {
	b.addMouseListener(listener);
	b.addMouseMotionListener(listener);
	b.addFocusListener(listener);
	b.addPropertyChangeListener(listener);
	b.addChangeListener(listener);
	}
	}

	protected void installKeyboardActions(AbstractButton b){
	BasicButtonListener listener = getButtonListener(b);

	if(listener != null) {
	listener.installKeyboardActions(b);
	}
	}


	// ********************************
	// Uninstall PLAF
	// ********************************
	public void uninstallUI(JComponent c) {
	uninstallKeyboardActions((AbstractButton) c);
	uninstallListeners((AbstractButton) c);
	uninstallDefaults((AbstractButton) c);
	BasicHTML.updateRenderer(c, "");
	}

	protected void uninstallKeyboardActions(AbstractButton b) {
	BasicButtonListener listener = getButtonListener(b);
	if(listener != null) {
	listener.uninstallKeyboardActions(b);
	}
	}

	protected void uninstallListeners(AbstractButton b) {
	BasicButtonListener listener = getButtonListener(b);
	if(listener != null) {
	b.removeMouseListener(listener);
	b.removeMouseMotionListener(listener);
	b.removeFocusListener(listener);
	b.removeChangeListener(listener);
	b.removePropertyChangeListener(listener);
	}
	}

	protected void uninstallDefaults(AbstractButton b) {
	LookAndFeel.uninstallBorder(b);
	}

	// ********************************
	// Create Listeners
	// ********************************
	protected BasicButtonListener createButtonListener(AbstractButton b) {
	return new BasicButtonListener(b);
	}

	public int getDefaultTextIconGap(AbstractButton b) {
	return defaultTextIconGap;
	}

	/* These rectangles/insets are allocated once for all
	* ButtonUI.paint() calls. Re-using rectangles rather than
	* allocating them in each paint call substantially reduced the time
	* it took paint to run. Obviously, this method can't be re-entered.
	*/
	private static Rectangle viewRect = new Rectangle();
	private static Rectangle textRect = new Rectangle();
	private static Rectangle iconRect = new Rectangle();

	// ********************************
	// Paint Methods
	// ********************************

	public void paint(Graphics g, JComponent c)
	{
	AbstractButton b = (AbstractButton) c;
	ButtonModel model = b.getModel();

	String text = layout(b, SwingUtilities2.getFontMetrics(b, g),
	b.getWidth(), b.getHeight());

	clearTextShiftOffset();

	// perform UI specific press action, e.g. Windows L&F shifts text
	if (model.isArmed() && model.isPressed()) {
	paintButtonPressed(g,b);
	}

	// Paint the Icon
	if(b.getIcon() != null) {
	paintIcon(g,c,iconRect);
	}

	if (text != null && !text.equals("")){
	View v = (View) c.getClientProperty(BasicHTML.propertyKey);
	if (v != null) {
	v.paint(g, textRect);
	} else {
	paintText(g, b, textRect, text);
	}
	}

	if (b.isFocusPainted() && b.hasFocus()) {
	// paint UI specific focus
	paintFocus(g,b,viewRect,textRect,iconRect);
	}
	}

	protected void paintIcon(Graphics g, JComponent c, Rectangle iconRect){
	AbstractButton b = (AbstractButton) c;
	ButtonModel model = b.getModel();
	Icon icon = b.getIcon();
	Icon tmpIcon = null;

	if(icon == null) {
	return;
	}

	Icon selectedIcon = null;

	/* the fallback icon should be based on the selected state */
	if (model.isSelected()) {
	selectedIcon = b.getSelectedIcon();
	if (selectedIcon != null) {
	icon = selectedIcon;
	}
	}

	if(!model.isEnabled()) {
	if(model.isSelected()) {
	tmpIcon = b.getDisabledSelectedIcon();
	if (tmpIcon == null) {
	tmpIcon = selectedIcon;
	}
	}

	if (tmpIcon == null) {
	tmpIcon = b.getDisabledIcon();
	}
	} else if(model.isPressed() && model.isArmed()) {
	tmpIcon = b.getPressedIcon();
	if(tmpIcon != null) {
	// revert back to 0 offset
	clearTextShiftOffset();
	}
	} else if(b.isRolloverEnabled() && model.isRollover()) {
	if(model.isSelected()) {
	tmpIcon = b.getRolloverSelectedIcon();
	if (tmpIcon == null) {
	tmpIcon = selectedIcon;
	}
	}

	if (tmpIcon == null) {
	tmpIcon = b.getRolloverIcon();
	}
	}

	if(tmpIcon != null) {
	icon = tmpIcon;
	}

	if(model.isPressed() && model.isArmed()) {
	icon.paintIcon(c, g, iconRect.x + getTextShiftOffset(),
	iconRect.y + getTextShiftOffset());
	} else {
	icon.paintIcon(c, g, iconRect.x, iconRect.y);
	}

	}

	/**
	* As of Java 2 platform v 1.4 this method should not be used or overriden.
	* Use the paintText method which takes the AbstractButton argument.
	*/
	protected void paintText(Graphics g, JComponent c, Rectangle textRect, String text) {
	AbstractButton b = (AbstractButton) c;
	ButtonModel model = b.getModel();
	FontMetrics fm = SwingUtilities2.getFontMetrics(c, g);
	int mnemonicIndex = b.getDisplayedMnemonicIndex();

	/* Draw the Text */
	if(model.isEnabled()) {
	/*** paint the text normally */
	g.setColor(b.getForeground());
	SwingUtilities2.drawStringUnderlineCharAt(c, g,text, mnemonicIndex,
	textRect.x + getTextShiftOffset(),
	textRect.y + fm.getAscent() + getTextShiftOffset());
	}
	else {
	/* paint the text disabled */
	g.setColor(b.getBackground().brighter());
	SwingUtilities2.drawStringUnderlineCharAt(c, g,text, mnemonicIndex,
	textRect.x, textRect.y + fm.getAscent());
	g.setColor(b.getBackground().darker());
	SwingUtilities2.drawStringUnderlineCharAt(c, g,text, mnemonicIndex,
	textRect.x - 1, textRect.y + fm.getAscent() - 1);
	}
	}

	/**
	* Method which renders the text of the current button.
	* <p>
	* @param g Graphics context
	* @param b Current button to render
	* @param textRect Bounding rectangle to render the text.
	* @param text String to render
	* @since 1.4
	*/
	protected void paintText(Graphics g, AbstractButton b, Rectangle textRect, String text) {
	paintText(g, (JComponent)b, textRect, text);
	}

	// Method signature defined here overriden in subclasses.
	// Perhaps this class should be abstract?
	protected void paintFocus(Graphics g, AbstractButton b,
	Rectangle viewRect, Rectangle textRect, Rectangle iconRect){
	}



	protected void paintButtonPressed(Graphics g, AbstractButton b){
	}

	protected void clearTextShiftOffset(){
	this.shiftOffset = 0;
	}

	protected void setTextShiftOffset(){
	this.shiftOffset = defaultTextShiftOffset;
	}

	protected int getTextShiftOffset() {
	return shiftOffset;
	}

	// ********************************
	// Layout Methods
	// ********************************
	public Dimension getMinimumSize(JComponent c) {
	Dimension d = getPreferredSize(c);
	View v = (View) c.getClientProperty(BasicHTML.propertyKey);
	if (v != null) {
	d.width -= v.getPreferredSpan(View.X_AXIS) - v.getMinimumSpan(View.X_AXIS);
	}
	return d;
	}

	public Dimension getPreferredSize(JComponent c) {
	AbstractButton b = (AbstractButton)c;
	return BasicGraphicsUtils.getPreferredButtonSize(b, b.getIconTextGap());
	}

	public Dimension getMaximumSize(JComponent c) {
	Dimension d = getPreferredSize(c);
	View v = (View) c.getClientProperty(BasicHTML.propertyKey);
	if (v != null) {
	d.width += v.getMaximumSpan(View.X_AXIS) - v.getPreferredSpan(View.X_AXIS);
	}
	return d;
	}

	/**
	* 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);
	AbstractButton b = (AbstractButton)c;
	String text = b.getText();
	if (text == null \|\| "".equals(text)) {
	return -1;
	}
	FontMetrics fm = b.getFontMetrics(b.getFont());
	layout(b, fm, width, height);
	return BasicHTML.getBaseline(b, textRect.y, fm.getAscent(),
	textRect.width, textRect.height);
	}

	/**
	* 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);
	if (c.getClientProperty(BasicHTML.propertyKey) != null) {
	return Component.BaselineResizeBehavior.OTHER;
	}
	switch(((AbstractButton)c).getVerticalAlignment()) {
	case AbstractButton.TOP:
	return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
	case AbstractButton.BOTTOM:
	return Component.BaselineResizeBehavior.CONSTANT_DESCENT;
	case AbstractButton.CENTER:
	return Component.BaselineResizeBehavior.CENTER_OFFSET;
	}
	return Component.BaselineResizeBehavior.OTHER;
	}

	private String layout(AbstractButton b, FontMetrics fm,
	int width, int height) {
	Insets i = b.getInsets();
	viewRect.x = i.left;
	viewRect.y = i.top;
	viewRect.width = width - (i.right + viewRect.x);
	viewRect.height = height - (i.bottom + viewRect.y);

	textRect.x = textRect.y = textRect.width = textRect.height = 0;
	iconRect.x = iconRect.y = iconRect.width = iconRect.height = 0;

	// layout the text and icon
	return SwingUtilities.layoutCompoundLabel(
	b, fm, b.getText(), b.getIcon(),
	b.getVerticalAlignment(), b.getHorizontalAlignment(),
	b.getVerticalTextPosition(), b.getHorizontalTextPosition(),
	viewRect, iconRect, textRect,
	b.getText() == null ? 0 : b.getIconTextGap());
	}

	/**
	* Returns the ButtonListener for the passed in Button, or null if one
	* could not be found.
	*/
	private BasicButtonListener getButtonListener(AbstractButton b) {
	MouseMotionListener[] listeners = b.getMouseMotionListeners();

	if (listeners != null) {
	for (MouseMotionListener listener : listeners) {
	if (listener instanceof BasicButtonListener) {
	return (BasicButtonListener) listener;
	}
	}
	}
	return null;
	}

	}

Back to index...