Back to index...

	/*
	* Copyright (c) 1998, 2013, 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.metal;

	import javax.swing.*;
	import java.awt.Color;
	import java.awt.Component;
	import java.awt.Container;
	import java.awt.Dimension;
	import java.awt.Frame;
	import java.awt.Graphics;
	import java.awt.GraphicsEnvironment;
	import java.awt.Insets;
	import java.awt.Point;
	import java.awt.Rectangle;
	import java.awt.event.*;
	import java.lang.ref.WeakReference;
	import java.util.*;

	import java.beans.PropertyChangeListener;

	import javax.swing.event.*;
	import javax.swing.border.*;
	import javax.swing.plaf.*;
	import javax.swing.plaf.basic.*;

	/**
	* A Metal Look and Feel implementation of ToolBarUI. This implementation
	* is a "combined" view/controller.
	* <p>
	*
	* @author Jeff Shapiro
	*/
	public class MetalToolBarUI extends BasicToolBarUI
	{
	/**
	* An array of WeakReferences that point to JComponents. This will contain
	* instances of JToolBars and JMenuBars and is used to find
	* JToolBars/JMenuBars that border each other.
	*/
	private static List<WeakReference<JComponent>> components = new ArrayList<WeakReference<JComponent>>();

	/**
	* This protected field is implementation specific. Do not access directly
	* or override. Use the create method instead.
	*
	* @see #createContainerListener
	*/
	protected ContainerListener contListener;

	/**
	* This protected field is implementation specific. Do not access directly
	* or override. Use the create method instead.
	*
	* @see #createRolloverListener
	*/
	protected PropertyChangeListener rolloverListener;

	private static Border nonRolloverBorder;

	/**
	* Last menubar the toolbar touched. This is only useful for ocean.
	*/
	private JMenuBar lastMenuBar;

	/**
	* Registers the specified component.
	*/
	synchronized static void register(JComponent c) {
	if (c == null) {
	// Exception is thrown as convenience for callers that are
	// typed to throw an NPE.
	throw new NullPointerException("JComponent must be non-null");
	}
	components.add(new WeakReference<JComponent>(c));
	}

	/**
	* Unregisters the specified component.
	*/
	synchronized static void unregister(JComponent c) {
	for (int counter = components.size() - 1; counter >= 0; counter--) {
	// Search for the component, removing any flushed references
	// along the way.
	JComponent target = components.get(counter).get();

	if (target == c \|\| target == null) {
	components.remove(counter);
	}
	}
	}

	/**
	* Finds a previously registered component of class <code>target</code>
	* that shares the JRootPane ancestor of <code>from</code>.
	*/
	synchronized static Object findRegisteredComponentOfType(JComponent from,
	Class target) {
	JRootPane rp = SwingUtilities.getRootPane(from);
	if (rp != null) {
	for (int counter = components.size() - 1; counter >= 0; counter--){
	Object component = ((WeakReference)components.get(counter)).
	get();

	if (component == null) {
	// WeakReference has gone away, remove the WeakReference
	components.remove(counter);
	}
	else if (target.isInstance(component) && SwingUtilities.
	getRootPane((Component)component) == rp) {
	return component;
	}
	}
	}
	return null;
	}

	/**
	* Returns true if the passed in JMenuBar is above a horizontal
	* JToolBar.
	*/
	static boolean doesMenuBarBorderToolBar(JMenuBar c) {
	JToolBar tb = (JToolBar)MetalToolBarUI.
	findRegisteredComponentOfType(c, JToolBar.class);
	if (tb != null && tb.getOrientation() == JToolBar.HORIZONTAL) {
	JRootPane rp = SwingUtilities.getRootPane(c);
	Point point = new Point(0, 0);
	point = SwingUtilities.convertPoint(c, point, rp);
	int menuX = point.x;
	int menuY = point.y;
	point.x = point.y = 0;
	point = SwingUtilities.convertPoint(tb, point, rp);
	return (point.x == menuX && menuY + c.getHeight() == point.y &&
	c.getWidth() == tb.getWidth());
	}
	return false;
	}

	public static ComponentUI createUI( JComponent c )
	{
	return new MetalToolBarUI();
	}

	public void installUI( JComponent c )
	{
	super.installUI( c );
	register(c);
	}

	public void uninstallUI( JComponent c )
	{
	super.uninstallUI( c );
	nonRolloverBorder = null;
	unregister(c);
	}

	protected void installListeners() {
	super.installListeners();

	contListener = createContainerListener();
	if (contListener != null) {
	toolBar.addContainerListener(contListener);
	}
	rolloverListener = createRolloverListener();
	if (rolloverListener != null) {
	toolBar.addPropertyChangeListener(rolloverListener);
	}
	}

	protected void uninstallListeners() {
	super.uninstallListeners();

	if (contListener != null) {
	toolBar.removeContainerListener(contListener);
	}
	rolloverListener = createRolloverListener();
	if (rolloverListener != null) {
	toolBar.removePropertyChangeListener(rolloverListener);
	}
	}

	protected Border createRolloverBorder() {
	return super.createRolloverBorder();
	}

	protected Border createNonRolloverBorder() {
	return super.createNonRolloverBorder();
	}


	/**
	* Creates a non rollover border for Toggle buttons in the toolbar.
	*/
	private Border createNonRolloverToggleBorder() {
	return createNonRolloverBorder();
	}

	protected void setBorderToNonRollover(Component c) {
	if (c instanceof JToggleButton && !(c instanceof JCheckBox)) {
	// 4735514, 4886944: The method createNonRolloverToggleBorder() is
	// private in BasicToolBarUI so we can't override it. We still need
	// to call super from this method so that it can save away the
	// original border and then we install ours.

	// Before calling super we get a handle to the old border, because
	// super will install a non-UIResource border that we can't
	// distinguish from one provided by an application.
	JToggleButton b = (JToggleButton)c;
	Border border = b.getBorder();
	super.setBorderToNonRollover(c);
	if (border instanceof UIResource) {
	if (nonRolloverBorder == null) {
	nonRolloverBorder = createNonRolloverToggleBorder();
	}
	b.setBorder(nonRolloverBorder);
	}
	} else {
	super.setBorderToNonRollover(c);
	}
	}


	/**
	* Creates a container listener that will be added to the JToolBar.
	* If this method returns null then it will not be added to the
	* toolbar.
	*
	* @return an instance of a <code>ContainerListener</code> or null
	*/
	protected ContainerListener createContainerListener() {
	return null;
	}

	/**
	* Creates a property change listener that will be added to the JToolBar.
	* If this method returns null then it will not be added to the
	* toolbar.
	*
	* @return an instance of a <code>PropertyChangeListener</code> or null
	*/
	protected PropertyChangeListener createRolloverListener() {
	return null;
	}

	protected MouseInputListener createDockingListener( )
	{
	return new MetalDockingListener( toolBar );
	}

	protected void setDragOffset(Point p) {
	if (!GraphicsEnvironment.isHeadless()) {
	if (dragWindow == null) {
	dragWindow = createDragWindow(toolBar);
	}
	dragWindow.setOffset(p);
	}
	}

	/**
	* If necessary paints the background of the component, then invokes
	* <code>paint</code>.
	*
	* @param g Graphics to paint to
	* @param c JComponent painting on
	* @throws NullPointerException if <code>g</code> or <code>c</code> is
	* null
	* @see javax.swing.plaf.ComponentUI#update
	* @see javax.swing.plaf.ComponentUI#paint
	* @since 1.5
	*/
	public void update(Graphics g, JComponent c) {
	if (g == null) {
	throw new NullPointerException("graphics must be non-null");
	}
	if (c.isOpaque() && (c.getBackground() instanceof UIResource) &&
	((JToolBar)c).getOrientation() ==
	JToolBar.HORIZONTAL && UIManager.get(
	"MenuBar.gradient") != null) {
	JRootPane rp = SwingUtilities.getRootPane(c);
	JMenuBar mb = (JMenuBar)findRegisteredComponentOfType(
	c, JMenuBar.class);
	if (mb != null && mb.isOpaque() &&
	(mb.getBackground() instanceof UIResource)) {
	Point point = new Point(0, 0);
	point = SwingUtilities.convertPoint(c, point, rp);
	int x = point.x;
	int y = point.y;
	point.x = point.y = 0;
	point = SwingUtilities.convertPoint(mb, point, rp);
	if (point.x == x && y == point.y + mb.getHeight() &&
	mb.getWidth() == c.getWidth() &&
	MetalUtils.drawGradient(c, g, "MenuBar.gradient",
	0, -mb.getHeight(), c.getWidth(), c.getHeight() +
	mb.getHeight(), true)) {
	setLastMenuBar(mb);
	paint(g, c);
	return;
	}
	}
	if (MetalUtils.drawGradient(c, g, "MenuBar.gradient",
	0, 0, c.getWidth(), c.getHeight(), true)) {
	setLastMenuBar(null);
	paint(g, c);
	return;
	}
	}
	setLastMenuBar(null);
	super.update(g, c);
	}

	private void setLastMenuBar(JMenuBar lastMenuBar) {
	if (MetalLookAndFeel.usingOcean()) {
	if (this.lastMenuBar != lastMenuBar) {
	// The menubar we previously touched has changed, force it
	// to repaint.
	if (this.lastMenuBar != null) {
	this.lastMenuBar.repaint();
	}
	if (lastMenuBar != null) {
	lastMenuBar.repaint();
	}
	this.lastMenuBar = lastMenuBar;
	}
	}
	}

	// No longer used. Cannot remove for compatibility reasons
	protected class MetalContainerListener
	extends BasicToolBarUI.ToolBarContListener {}

	// No longer used. Cannot remove for compatibility reasons
	protected class MetalRolloverListener
	extends BasicToolBarUI.PropertyListener {}

	protected class MetalDockingListener extends DockingListener {
	private boolean pressedInBumps = false;

	public MetalDockingListener(JToolBar t) {
	super(t);
	}

	public void mousePressed(MouseEvent e) {
	super.mousePressed(e);
	if (!toolBar.isEnabled()) {
	return;
	}
	pressedInBumps = false;
	Rectangle bumpRect = new Rectangle();

	if (toolBar.getOrientation() == JToolBar.HORIZONTAL) {
	int x = MetalUtils.isLeftToRight(toolBar) ? 0 : toolBar.getSize().width-14;
	bumpRect.setBounds(x, 0, 14, toolBar.getSize().height);
	} else { // vertical
	bumpRect.setBounds(0, 0, toolBar.getSize().width, 14);
	}
	if (bumpRect.contains(e.getPoint())) {
	pressedInBumps = true;
	Point dragOffset = e.getPoint();
	if (!MetalUtils.isLeftToRight(toolBar)) {
	dragOffset.x -= (toolBar.getSize().width
	- toolBar.getPreferredSize().width);
	}
	setDragOffset(dragOffset);
	}
	}

	public void mouseDragged(MouseEvent e) {
	if (pressedInBumps) {
	super.mouseDragged(e);
	}
	}
	} // end class MetalDockingListener
	}

Back to index...