Also see:

createContainerListener

Also see:

createRolloverListener

 protected ContainerListener createContainerListener() 
{
        return null;
}

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.

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

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

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

 protected PropertyChangeListener createRolloverListener() 
{
        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.

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

 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;
}

Returns true if the passed in JMenuBar is above a horizontal JToolBar.

 static synchronized 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;
}

Finds a previously registered component of class target that shares the JRootPane ancestor of from.

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

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

 static synchronized  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(c));
}

Registers the specified component.

 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);
        }
}

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

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

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

 static synchronized  void unregister(JComponent c) 
{
        for (int counter = components.size() - 1; counter  >= 0; counter--) {
            // Search for the component, removing any flushed references
            // along the way.
            WeakReference ref = (WeakReference)components.get(counter);
            Object target = ((WeakReference)components.get(counter)).get();
            if (target == c || target == null) {
                components.remove(counter);
            }
        }
}

Unregisters the specified component.

 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);
}

If necessary paints the background of the component, then invokes paint.