| /* MetalRootPaneUI.java |
| Copyright (C) 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.swing.plaf.metal; |
| |
| 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.Insets; |
| import java.awt.LayoutManager; |
| import java.awt.LayoutManager2; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| import java.awt.Window; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.MouseEvent; |
| import java.beans.PropertyChangeEvent; |
| |
| import javax.swing.AbstractAction; |
| import javax.swing.Action; |
| import javax.swing.Icon; |
| import javax.swing.JButton; |
| import javax.swing.JComponent; |
| import javax.swing.JDialog; |
| import javax.swing.JFrame; |
| import javax.swing.JLabel; |
| import javax.swing.JLayeredPane; |
| import javax.swing.JMenu; |
| import javax.swing.JMenuBar; |
| import javax.swing.JRootPane; |
| import javax.swing.SwingConstants; |
| import javax.swing.SwingUtilities; |
| import javax.swing.UIManager; |
| import javax.swing.border.AbstractBorder; |
| import javax.swing.event.MouseInputAdapter; |
| import javax.swing.plaf.ComponentUI; |
| import javax.swing.plaf.basic.BasicRootPaneUI; |
| |
| /** |
| * A UI delegate for the {@link JRootPane} component. This implementation |
| * supports the JRootPane <code>windowDecorationStyle</code> property. |
| * |
| * @author Roman Kennke (kennke@aicas.com) |
| * |
| * @since 1.4 |
| */ |
| public class MetalRootPaneUI |
| extends BasicRootPaneUI |
| { |
| |
| /** |
| * The border that is used on JRootPane when the windowDecorationStyle |
| * property of the JRootPane is set to a different value than NONE. |
| * |
| * @author Roman Kennke (kennke@aicas.com) |
| */ |
| private static class MetalFrameBorder |
| extends AbstractBorder |
| { |
| /** |
| * Returns the border insets. |
| * |
| * @param c the component |
| * @param newInsets the insets to be filled with the return value, may be |
| * <code>null</code> in which case a new object is created |
| * |
| * @return the border insets |
| */ |
| public Insets getBorderInsets(Component c, Insets newInsets) |
| { |
| if (newInsets == null) |
| newInsets = new Insets(5, 5, 5, 5); |
| else |
| { |
| newInsets.top = 5; |
| newInsets.left = 5; |
| newInsets.bottom = 5; |
| newInsets.right = 5; |
| } |
| return newInsets; |
| } |
| |
| /** |
| * Returns the border insets. |
| * |
| * @param c the component |
| * |
| * @return the border insets |
| */ |
| public Insets getBorderInsets(Component c) |
| { |
| return getBorderInsets(c, null); |
| } |
| |
| /** |
| * Paints the border for the specified component. |
| * |
| * @param c the component |
| * @param g the graphics device |
| * @param x the x-coordinate |
| * @param y the y-coordinate |
| * @param w the width |
| * @param h the height |
| */ |
| public void paintBorder(Component c, Graphics g, int x, int y, int w, |
| int h) |
| { |
| JRootPane f = (JRootPane) c; |
| Window frame = SwingUtilities.getWindowAncestor(f); |
| if (frame.isActive()) |
| g.setColor(MetalLookAndFeel.getPrimaryControlDarkShadow()); |
| else |
| g.setColor(MetalLookAndFeel.getControlDarkShadow()); |
| |
| // Fill the border background. |
| g.fillRect(x, y, w, 5); |
| g.fillRect(x, y, 5, h); |
| g.fillRect(x + w - 5, y, 5, h); |
| g.fillRect(x, y + h - 5, w, 5); |
| |
| // Draw a dot in each corner. |
| g.setColor(MetalLookAndFeel.getControl()); |
| g.fillRect(x, y, 1, 1); |
| g.fillRect(x + w - 1, y, 1, 1); |
| g.fillRect(x + w - 1, y + h - 1, 1, 1); |
| g.fillRect(x, y + h - 1, 1, 1); |
| |
| // Draw the lines. |
| g.setColor(MetalLookAndFeel.getBlack()); |
| g.drawLine(x + 14, y + 2, x + w - 15, y + 2); |
| g.drawLine(x + 14, y + h - 3, x + w - 15, y + h - 3); |
| g.drawLine(x + 2, y + 14, x + 2, y + h - 15); |
| g.drawLine(x + w - 3, y + 14, x + w - 3, y + h - 15); |
| |
| // Draw the line highlights. |
| if (frame.isActive()) |
| g.setColor(MetalLookAndFeel.getPrimaryControlShadow()); |
| else |
| g.setColor(MetalLookAndFeel.getControlShadow()); |
| g.drawLine(x + 15, y + 3, x + w - 14, y + 3); |
| g.drawLine(x + 15, y + h - 2, x + w - 14, y + h - 2); |
| g.drawLine(x + 3, y + 15, x + 3, y + h - 14); |
| g.drawLine(x + w - 2, y + 15, x + w - 2, y + h - 14); |
| } |
| } |
| |
| /** |
| * The component that renders the title bar for frames. This duplicates |
| * most of {@link MetalInternalFrameTitlePane}. It is not reasonably possible |
| * to reuse that class because that is bound to the JInternalFrame and we |
| * need to handle JFrames/JRootPanes here. |
| * |
| * @author Roman Kennke (kennke@aicas.com) |
| */ |
| private static class MetalTitlePane extends JComponent |
| { |
| |
| /** |
| * Handles dragging of the title pane and moves the window accordingly. |
| */ |
| private class MouseHandler |
| extends MouseInputAdapter |
| { |
| /** |
| * The point where the dragging started. |
| */ |
| Point lastDragLocation; |
| |
| /** |
| * Receives notification when the mouse gets pressed on the title pane. |
| * This updates the lastDragLocation. |
| * |
| * @param ev the mouse event |
| */ |
| public void mousePressed(MouseEvent ev) |
| { |
| lastDragLocation = ev.getPoint(); |
| } |
| |
| /** |
| * Receives notification when the mouse is dragged on the title pane. |
| * This will move the nearest window accordingly. |
| * |
| * @param ev the mouse event |
| */ |
| public void mouseDragged(MouseEvent ev) |
| { |
| Point dragLocation = ev.getPoint(); |
| int deltaX = dragLocation.x - lastDragLocation.x; |
| int deltaY = dragLocation.y - lastDragLocation.y; |
| Window window = SwingUtilities.getWindowAncestor(rootPane); |
| Point loc = window.getLocation(); |
| window.setLocation(loc.x + deltaX, loc.y + deltaY); |
| // Note that we do not update the lastDragLocation. This is because |
| // we move the underlying window while dragging the component, which |
| // results in having the same lastDragLocation under the mouse while |
| // dragging. |
| } |
| } |
| |
| /** |
| * The Action responsible for closing the JInternalFrame. |
| */ |
| private class CloseAction extends AbstractAction |
| { |
| /** |
| * Creates a new action. |
| */ |
| public CloseAction() |
| { |
| super("Close"); |
| } |
| |
| /** |
| * This method is called when something closes the frame. |
| * |
| * @param e the ActionEvent |
| */ |
| public void actionPerformed(ActionEvent e) |
| { |
| Window frame = SwingUtilities.getWindowAncestor(rootPane); |
| if (frame instanceof JFrame) |
| { |
| JFrame jframe = (JFrame) frame; |
| switch (jframe.getDefaultCloseOperation()) |
| { |
| case JFrame.EXIT_ON_CLOSE: |
| jframe.setVisible(false); |
| jframe.dispose(); |
| System.exit(0); |
| break; |
| case JFrame.DISPOSE_ON_CLOSE: |
| jframe.setVisible(false); |
| jframe.dispose(); |
| break; |
| case JFrame.HIDE_ON_CLOSE: |
| jframe.setVisible(false); |
| break; |
| case JFrame.DO_NOTHING_ON_CLOSE: |
| default: |
| break; |
| } |
| } |
| else if (frame instanceof JDialog) |
| { |
| JDialog jdialog = (JDialog) frame; |
| switch (jdialog.getDefaultCloseOperation()) |
| { |
| case JFrame.DISPOSE_ON_CLOSE: |
| jdialog.setVisible(false); |
| jdialog.dispose(); |
| break; |
| case JFrame.HIDE_ON_CLOSE: |
| jdialog.setVisible(false); |
| break; |
| case JFrame.DO_NOTHING_ON_CLOSE: |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * This action is performed when the iconify button is pressed. |
| */ |
| private class IconifyAction |
| extends AbstractAction |
| { |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| Window w = SwingUtilities.getWindowAncestor(rootPane); |
| if (w instanceof Frame) |
| { |
| Frame f = (Frame) w; |
| int state = f.getExtendedState(); |
| f.setExtendedState(Frame.ICONIFIED); |
| } |
| } |
| |
| } |
| |
| /** |
| * This action is performed when the maximize button is pressed. |
| */ |
| private class MaximizeAction |
| extends AbstractAction |
| { |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| Window w = SwingUtilities.getWindowAncestor(rootPane); |
| if (w instanceof Frame) |
| { |
| Frame f = (Frame) w; |
| int state = f.getExtendedState(); |
| f.setExtendedState(Frame.MAXIMIZED_BOTH); |
| } |
| } |
| } |
| |
| /** |
| * This helper class is used to create the minimize, maximize and close |
| * buttons in the top right corner of the Title Pane. These buttons are |
| * special since they cannot be given focus and have no border. |
| */ |
| private class PaneButton extends JButton |
| { |
| /** |
| * Creates a new PaneButton object with the given Action. |
| * |
| * @param a The Action that the button uses. |
| */ |
| public PaneButton(Action a) |
| { |
| super(a); |
| setMargin(new Insets(0, 0, 0, 0)); |
| } |
| |
| /** |
| * This method returns true if the Component can be focused. |
| * |
| * @return false. |
| */ |
| public boolean isFocusable() |
| { |
| // These buttons cannot be given focus. |
| return false; |
| } |
| |
| } |
| |
| /** |
| * The layout for the JRootPane when the <code>windowDecorationStyle</code> |
| * property is set. In addition to the usual JRootPane.RootLayout behaviour |
| * this lays out the titlePane. |
| * |
| * @author Roman Kennke (kennke@aicas.com) |
| */ |
| private class MetalTitlePaneLayout implements LayoutManager |
| { |
| /** |
| * Creates a new <code>TitlePaneLayout</code> object. |
| */ |
| public MetalTitlePaneLayout() |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * Adds a Component to the Container. |
| * |
| * @param name The name to reference the added Component by. |
| * @param c The Component to add. |
| */ |
| public void addLayoutComponent(String name, Component c) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * This method is called to lay out the children of the Title Pane. |
| * |
| * @param c The Container to lay out. |
| */ |
| public void layoutContainer(Container c) |
| { |
| |
| Dimension size = c.getSize(); |
| Insets insets = c.getInsets(); |
| int width = size.width - insets.left - insets.right; |
| int height = size.height - insets.top - insets.bottom; |
| |
| int loc = width - insets.right - 1; |
| int top = insets.top + 2; |
| int buttonHeight = height - 4; |
| if (closeButton.isVisible()) |
| { |
| int buttonWidth = closeIcon.getIconWidth(); |
| loc -= buttonWidth + 2; |
| closeButton.setBounds(loc, top, buttonWidth, buttonHeight); |
| loc -= 6; |
| } |
| |
| if (maxButton.isVisible()) |
| { |
| int buttonWidth = maxIcon.getIconWidth(); |
| loc -= buttonWidth + 4; |
| maxButton.setBounds(loc, top, buttonWidth, buttonHeight); |
| } |
| |
| if (iconButton.isVisible()) |
| { |
| int buttonWidth = minIcon.getIconWidth(); |
| loc -= buttonWidth + 4; |
| iconButton.setBounds(loc, top, buttonWidth, buttonHeight); |
| loc -= 2; |
| } |
| |
| Dimension titlePreferredSize = title.getPreferredSize(); |
| title.setBounds(insets.left + 5, insets.top, |
| Math.min(titlePreferredSize.width, loc - insets.left - 10), |
| height); |
| |
| } |
| |
| /** |
| * This method returns the minimum size of the given Container given the |
| * children that it has. |
| * |
| * @param c The Container to get a minimum size for. |
| * |
| * @return The minimum size of the Container. |
| */ |
| public Dimension minimumLayoutSize(Container c) |
| { |
| return preferredLayoutSize(c); |
| } |
| |
| /** |
| * Returns the preferred size of the given Container taking |
| * into account the children that it has. |
| * |
| * @param c The Container to lay out. |
| * |
| * @return The preferred size of the Container. |
| */ |
| public Dimension preferredLayoutSize(Container c) |
| { |
| return new Dimension(22, 22); |
| } |
| |
| /** |
| * Removes a Component from the Container. |
| * |
| * @param c The Component to remove. |
| */ |
| public void removeLayoutComponent(Component c) |
| { |
| // Nothing to do here. |
| } |
| } |
| |
| JRootPane rootPane; |
| |
| /** The button that closes the JInternalFrame. */ |
| JButton closeButton; |
| |
| /** The button that iconifies the JInternalFrame. */ |
| JButton iconButton; |
| |
| /** The button that maximizes the JInternalFrame. */ |
| JButton maxButton; |
| |
| Icon minIcon; |
| |
| /** The icon displayed in the maximize button. */ |
| Icon maxIcon; |
| |
| /** The icon displayed in the iconify button. */ |
| private Icon iconIcon; |
| |
| /** The icon displayed in the close button. */ |
| Icon closeIcon; |
| |
| /** |
| * The background color of the TitlePane when the JInternalFrame is not |
| * selected. |
| */ |
| private Color notSelectedTitleColor; |
| |
| /** |
| * The background color of the TitlePane when the JInternalFrame is |
| * selected. |
| */ |
| private Color selectedTitleColor; |
| |
| /** |
| * The label used to display the title. This label is not added to the |
| * TitlePane. |
| */ |
| JLabel title; |
| |
| /** The action associated with closing the JInternalFrame. */ |
| private Action closeAction; |
| |
| /** The action associated with iconifying the JInternalFrame. */ |
| private Action iconifyAction; |
| |
| /** The action associated with maximizing the JInternalFrame. */ |
| private Action maximizeAction; |
| |
| /** The JMenuBar that is located at the top left of the Title Pane. */ |
| private JMenuBar menuBar; |
| |
| /** The JMenu inside the menuBar. */ |
| protected JMenu windowMenu; |
| |
| MetalTitlePane(JRootPane rp) |
| { |
| rootPane = rp; |
| setLayout(createLayout()); |
| title = new JLabel(); |
| title.setHorizontalAlignment(SwingConstants.LEFT); |
| title.setHorizontalTextPosition(SwingConstants.LEFT); |
| title.setOpaque(false); |
| installTitlePane(); |
| } |
| |
| protected LayoutManager createLayout() |
| { |
| return new MetalTitlePaneLayout(); |
| } |
| |
| /** |
| * This method installs the TitlePane onto the JInternalFrameTitlePane. It |
| * also creates any children components that need to be created and adds |
| * listeners to the appropriate components. |
| */ |
| protected void installTitlePane() |
| { |
| installDefaults(); |
| installListeners(); |
| createActions(); |
| assembleSystemMenu(); |
| createButtons(); |
| setButtonIcons(); |
| addSubComponents(); |
| enableActions(); |
| } |
| |
| private void enableActions() |
| { |
| // TODO: Implement this. |
| } |
| |
| private void addSubComponents() |
| { |
| add(menuBar); |
| add(closeButton); |
| add(iconButton); |
| add(maxButton); |
| } |
| |
| private void installListeners() |
| { |
| MouseInputAdapter mouseHandler = new MouseHandler(); |
| addMouseListener(mouseHandler); |
| addMouseMotionListener(mouseHandler); |
| } |
| |
| private void createActions() |
| { |
| closeAction = new CloseAction(); |
| iconifyAction = new IconifyAction(); |
| maximizeAction = new MaximizeAction(); |
| } |
| |
| private void assembleSystemMenu() |
| { |
| menuBar = createSystemMenuBar(); |
| windowMenu = createSystemMenu(); |
| menuBar.add(windowMenu); |
| addSystemMenuItems(windowMenu); |
| enableActions(); |
| } |
| |
| protected JMenuBar createSystemMenuBar() |
| { |
| if (menuBar == null) |
| menuBar = new JMenuBar(); |
| menuBar.removeAll(); |
| return menuBar; |
| } |
| |
| protected JMenu createSystemMenu() |
| { |
| if (windowMenu == null) |
| windowMenu = new JMenu(); |
| windowMenu.removeAll(); |
| return windowMenu; |
| } |
| |
| private void addSystemMenuItems(JMenu menu) |
| { |
| // TODO: Implement this. |
| } |
| |
| protected void createButtons() |
| { |
| closeButton = new PaneButton(closeAction); |
| closeButton.setText(null); |
| iconButton = new PaneButton(iconifyAction); |
| iconButton.setText(null); |
| maxButton = new PaneButton(maximizeAction); |
| maxButton.setText(null); |
| closeButton.setBorderPainted(false); |
| closeButton.setContentAreaFilled(false); |
| iconButton.setBorderPainted(false); |
| iconButton.setContentAreaFilled(false); |
| maxButton.setBorderPainted(false); |
| maxButton.setContentAreaFilled(false); |
| } |
| |
| protected void setButtonIcons() |
| { |
| if (closeIcon != null && closeButton != null) |
| closeButton.setIcon(closeIcon); |
| if (iconIcon != null && iconButton != null) |
| iconButton.setIcon(iconIcon); |
| if (maxIcon != null && maxButton != null) |
| maxButton.setIcon(maxIcon); |
| } |
| |
| /** |
| * Paints a representation of the current state of the internal frame. |
| * |
| * @param g the graphics device. |
| */ |
| public void paintComponent(Graphics g) |
| { |
| Window frame = SwingUtilities.getWindowAncestor(rootPane); |
| Color savedColor = g.getColor(); |
| paintTitleBackground(g); |
| paintChildren(g); |
| Dimension d = getSize(); |
| if (frame.isActive()) |
| g.setColor(MetalLookAndFeel.getPrimaryControlDarkShadow()); |
| else |
| g.setColor(MetalLookAndFeel.getControlDarkShadow()); |
| |
| // put a dot in each of the top corners |
| g.drawLine(0, 0, 0, 0); |
| g.drawLine(d.width - 1, 0, d.width - 1, 0); |
| |
| g.drawLine(0, d.height - 1, d.width - 1, d.height - 1); |
| |
| // draw the metal pattern |
| if (UIManager.get("InternalFrame.activeTitleGradient") != null |
| && frame.isActive()) |
| { |
| MetalUtils.paintGradient(g, 0, 0, getWidth(), getHeight(), |
| SwingConstants.VERTICAL, |
| "InternalFrame.activeTitleGradient"); |
| } |
| |
| Rectangle b = title.getBounds(); |
| int startX = b.x + b.width + 5; |
| int endX = startX; |
| if (iconButton.isVisible()) |
| endX = Math.max(iconButton.getX(), endX); |
| else if (maxButton.isVisible()) |
| endX = Math.max(maxButton.getX(), endX); |
| else if (closeButton.isVisible()) |
| endX = Math.max(closeButton.getX(), endX); |
| endX -= 7; |
| if (endX > startX) |
| MetalUtils.fillMetalPattern(this, g, startX, 3, endX - startX, getHeight() - 6, Color.white, Color.gray); |
| g.setColor(savedColor); |
| } |
| |
| /** |
| * This method paints the TitlePane's background. |
| * |
| * @param g The Graphics object to paint with. |
| */ |
| protected void paintTitleBackground(Graphics g) |
| { |
| Window frame = SwingUtilities.getWindowAncestor(rootPane); |
| |
| if (!isOpaque()) |
| return; |
| |
| Color saved = g.getColor(); |
| Dimension dims = getSize(); |
| |
| Color bg = getBackground(); |
| if (frame.isActive()) |
| bg = selectedTitleColor; |
| else |
| bg = notSelectedTitleColor; |
| g.setColor(bg); |
| g.fillRect(0, 0, dims.width, dims.height); |
| g.setColor(saved); |
| } |
| |
| /** |
| * This method installs the defaults determined by the look and feel. |
| */ |
| private void installDefaults() |
| { |
| title.setFont(UIManager.getFont("InternalFrame.titleFont")); |
| selectedTitleColor = UIManager.getColor("InternalFrame.activeTitleBackground"); |
| notSelectedTitleColor = UIManager.getColor("InternalFrame.inactiveTitleBackground"); |
| closeIcon = UIManager.getIcon("InternalFrame.closeIcon"); |
| iconIcon = UIManager.getIcon("InternalFrame.iconifyIcon"); |
| maxIcon = UIManager.getIcon("InternalFrame.maximizeIcon"); |
| minIcon = MetalIconFactory.getInternalFrameAltMaximizeIcon(16); |
| Frame frame = (Frame) SwingUtilities.getWindowAncestor(rootPane); |
| title = new JLabel(frame.getTitle(), |
| MetalIconFactory.getInternalFrameDefaultMenuIcon(), |
| SwingConstants.LEFT); |
| } |
| } |
| |
| private static class MetalRootLayout |
| implements LayoutManager2 |
| { |
| |
| /** |
| * The cached layout info for the glass pane. |
| */ |
| private Rectangle glassPaneBounds; |
| |
| /** |
| * The cached layout info for the layered pane. |
| */ |
| private Rectangle layeredPaneBounds; |
| |
| /** |
| * The cached layout info for the content pane. |
| */ |
| private Rectangle contentPaneBounds; |
| |
| /** |
| * The cached layout info for the menu bar. |
| */ |
| private Rectangle menuBarBounds; |
| |
| /** |
| * The cached layout info for the title pane. |
| */ |
| private Rectangle titlePaneBounds; |
| |
| /** |
| * The cached preferred size. |
| */ |
| private Dimension prefSize; |
| |
| /** |
| * The title pane for l&f decorated frames. |
| */ |
| private MetalTitlePane titlePane; |
| |
| /** |
| * Creates a new MetalRootLayout. |
| * |
| * @param tp the title pane |
| */ |
| MetalRootLayout(MetalTitlePane tp) |
| { |
| titlePane = tp; |
| } |
| |
| public void addLayoutComponent(Component component, Object constraints) |
| { |
| // Nothing to do here. |
| } |
| |
| public Dimension maximumLayoutSize(Container target) |
| { |
| return preferredLayoutSize(target); |
| } |
| |
| public float getLayoutAlignmentX(Container target) |
| { |
| return 0.0F; |
| } |
| |
| public float getLayoutAlignmentY(Container target) |
| { |
| return 0.0F; |
| } |
| |
| public void invalidateLayout(Container target) |
| { |
| synchronized (this) |
| { |
| glassPaneBounds = null; |
| layeredPaneBounds = null; |
| contentPaneBounds = null; |
| menuBarBounds = null; |
| titlePaneBounds = null; |
| prefSize = null; |
| } |
| } |
| |
| public void addLayoutComponent(String name, Component component) |
| { |
| // Nothing to do here. |
| } |
| |
| public void removeLayoutComponent(Component component) |
| { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public Dimension preferredLayoutSize(Container parent) |
| { |
| JRootPane rp = (JRootPane) parent; |
| JLayeredPane layeredPane = rp.getLayeredPane(); |
| Component contentPane = rp.getContentPane(); |
| Component menuBar = rp.getJMenuBar(); |
| |
| // We must synchronize here, otherwise we cannot guarantee that the |
| // prefSize is still non-null when returning. |
| synchronized (this) |
| { |
| if (prefSize == null) |
| { |
| Insets i = parent.getInsets(); |
| prefSize = new Dimension(i.left + i.right, i.top + i.bottom); |
| Dimension contentPrefSize = contentPane.getPreferredSize(); |
| prefSize.width += contentPrefSize.width; |
| prefSize.height += contentPrefSize.height |
| + titlePane.getPreferredSize().height; |
| if (menuBar != null) |
| { |
| Dimension menuBarSize = menuBar.getPreferredSize(); |
| if (menuBarSize.width > contentPrefSize.width) |
| prefSize.width += menuBarSize.width - contentPrefSize.width; |
| prefSize.height += menuBarSize.height; |
| } |
| } |
| // Return a copy here so the cached value won't get trashed by some |
| // other component. |
| return new Dimension(prefSize); |
| } |
| } |
| |
| public Dimension minimumLayoutSize(Container parent) |
| { |
| return preferredLayoutSize(parent); |
| } |
| |
| public void layoutContainer(Container parent) |
| { |
| JRootPane rp = (JRootPane) parent; |
| JLayeredPane layeredPane = rp.getLayeredPane(); |
| Component contentPane = rp.getContentPane(); |
| Component menuBar = rp.getJMenuBar(); |
| Component glassPane = rp.getGlassPane(); |
| |
| if (glassPaneBounds == null || layeredPaneBounds == null |
| || contentPaneBounds == null || menuBarBounds == null) |
| { |
| Insets i = rp.getInsets(); |
| int containerWidth = parent.getBounds().width - i.left - i.right; |
| int containerHeight = parent.getBounds().height - i.top - i.bottom; |
| |
| // 1. The glassPane fills entire viewable region (bounds - insets). |
| // 2. The layeredPane filles entire viewable region. |
| // 3. The titlePane is placed at the upper edge of the layeredPane. |
| // 4. The menuBar is positioned at the upper edge of layeredPane. |
| // 5. The contentPane fills viewable region minus menuBar minus |
| // titlePane, if present. |
| |
| // +-------------------------------+ |
| // | JLayeredPane | |
| // | +--------------------------+ | |
| // | | titlePane + | |
| // | +--------------------------+ | |
| // | +--------------------------+ | |
| // | | menuBar | | |
| // | +--------------------------+ | |
| // | +--------------------------+ | |
| // | |contentPane | | |
| // | | | | |
| // | | | | |
| // | | | | |
| // | +--------------------------+ | |
| // +-------------------------------+ |
| |
| // Setup titlePaneBounds. |
| if (titlePaneBounds == null) |
| titlePaneBounds = new Rectangle(); |
| titlePaneBounds.width = containerWidth; |
| titlePaneBounds.height = titlePane.getPreferredSize().height; |
| |
| // Setup menuBarBounds. |
| if (menuBarBounds == null) |
| menuBarBounds = new Rectangle(); |
| menuBarBounds.setBounds(0, |
| titlePaneBounds.y + titlePaneBounds.height, |
| containerWidth, 0); |
| if (menuBar != null) |
| { |
| Dimension menuBarSize = menuBar.getPreferredSize(); |
| if (menuBarSize.height > containerHeight) |
| menuBarBounds.height = containerHeight; |
| else |
| menuBarBounds.height = menuBarSize.height; |
| } |
| |
| // Setup contentPaneBounds. |
| if (contentPaneBounds == null) |
| contentPaneBounds = new Rectangle(); |
| contentPaneBounds.setBounds(0, |
| menuBarBounds.y + menuBarBounds.height, |
| containerWidth, |
| containerHeight - menuBarBounds.y |
| - menuBarBounds.height); |
| glassPaneBounds = new Rectangle(i.left, i.top, containerWidth, containerHeight); |
| layeredPaneBounds = new Rectangle(i.left, i.top, containerWidth, containerHeight); |
| } |
| |
| // Layout components. |
| glassPane.setBounds(glassPaneBounds); |
| layeredPane.setBounds(layeredPaneBounds); |
| if (menuBar != null) |
| menuBar.setBounds(menuBarBounds); |
| contentPane.setBounds(contentPaneBounds); |
| titlePane.setBounds(titlePaneBounds); |
| } |
| |
| } |
| |
| /** |
| * The shared UI instance for MetalRootPaneUIs. |
| */ |
| private static MetalRootPaneUI instance; |
| |
| /** |
| * Constructs a shared instance of <code>MetalRootPaneUI</code>. |
| */ |
| public MetalRootPaneUI() |
| { |
| super(); |
| } |
| |
| /** |
| * Returns a shared instance of <code>MetalRootPaneUI</code>. |
| * |
| * @param component the component for which we return an UI instance |
| * |
| * @return A shared instance of <code>MetalRootPaneUI</code>. |
| */ |
| public static ComponentUI createUI(JComponent component) |
| { |
| if (instance == null) |
| instance = new MetalRootPaneUI(); |
| return instance; |
| } |
| |
| /** |
| * Installs this UI to the root pane. If the |
| * <code>windowDecorationsStyle</code> property is set on the root pane, |
| * the Metal window decorations are installed on the root pane. |
| * |
| * @param c |
| */ |
| public void installUI(JComponent c) |
| { |
| super.installUI(c); |
| JRootPane rp = (JRootPane) c; |
| if (rp.getWindowDecorationStyle() != JRootPane.NONE) |
| installWindowDecorations(rp); |
| } |
| |
| /** |
| * Uninstalls the UI from the root pane. This performs the superclass |
| * behaviour and uninstalls the window decorations that have possibly been |
| * installed by {@link #installUI}. |
| * |
| * @param c the root pane |
| */ |
| public void uninstallUI(JComponent c) |
| { |
| JRootPane rp = (JRootPane) c; |
| if (rp.getWindowDecorationStyle() != JRootPane.NONE) |
| uninstallWindowDecorations(rp); |
| super.uninstallUI(c); |
| } |
| |
| /** |
| * Receives notification if any of the JRootPane's property changes. In |
| * particular this catches changes to the <code>windowDecorationStyle</code> |
| * property and installs the window decorations accordingly. |
| * |
| * @param ev the property change event |
| */ |
| public void propertyChange(PropertyChangeEvent ev) |
| { |
| super.propertyChange(ev); |
| String propertyName = ev.getPropertyName(); |
| if (propertyName.equals("windowDecorationStyle")) |
| { |
| JRootPane rp = (JRootPane) ev.getSource(); |
| if (rp.getWindowDecorationStyle() != JRootPane.NONE) |
| installWindowDecorations(rp); |
| else |
| uninstallWindowDecorations(rp); |
| } |
| } |
| |
| /** |
| * Installs the window decorations to the root pane. This sets up a border, |
| * a title pane and a layout manager that can layout the root pane with that |
| * title pane. |
| * |
| * @param rp the root pane. |
| */ |
| private void installWindowDecorations(JRootPane rp) |
| { |
| rp.setBorder(new MetalFrameBorder()); |
| MetalTitlePane titlePane = new MetalTitlePane(rp); |
| rp.setLayout(new MetalRootLayout(titlePane)); |
| // We should have a contentPane already. |
| assert rp.getLayeredPane().getComponentCount() > 0 |
| : "We should have a contentPane already"; |
| |
| rp.getLayeredPane().add(titlePane, |
| JLayeredPane.FRAME_CONTENT_LAYER, 1); |
| } |
| |
| /** |
| * Uninstalls the window decorations from the root pane. This should rarely |
| * be necessary, but we do it anyway. |
| * |
| * @param rp the root pane |
| */ |
| private void uninstallWindowDecorations(JRootPane rp) |
| { |
| rp.setBorder(null); |
| JLayeredPane lp = rp.getLayeredPane(); |
| for (int i = lp.getComponentCount() - 1; i >= 0; --i) |
| { |
| if (lp.getComponent(i) instanceof MetalTitlePane) |
| { |
| lp.remove(i); |
| break; |
| } |
| } |
| } |
| } |
