| /* BasicInternalFrameTitlePane.java -- | |
| Copyright (C) 2004, 2005 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.basic; | |
| import java.awt.Color; | |
| import java.awt.Component; | |
| import java.awt.Container; | |
| import java.awt.Dimension; | |
| import java.awt.Font; | |
| import java.awt.FontMetrics; | |
| import java.awt.Graphics; | |
| import java.awt.Insets; | |
| import java.awt.LayoutManager; | |
| import java.awt.Rectangle; | |
| import java.awt.event.ActionEvent; | |
| import java.awt.event.KeyEvent; | |
| import java.beans.PropertyChangeEvent; | |
| import java.beans.PropertyChangeListener; | |
| import java.beans.PropertyVetoException; | |
| import javax.swing.AbstractAction; | |
| import javax.swing.Action; | |
| import javax.swing.Icon; | |
| import javax.swing.JButton; | |
| import javax.swing.JComponent; | |
| import javax.swing.JInternalFrame; | |
| import javax.swing.JLabel; | |
| import javax.swing.JMenu; | |
| import javax.swing.JMenuBar; | |
| import javax.swing.JMenuItem; | |
| import javax.swing.SwingConstants; | |
| import javax.swing.SwingUtilities; | |
| import javax.swing.UIManager; | |
| /** | |
| * This class acts as a titlebar for JInternalFrames. | |
| */ | |
| public class BasicInternalFrameTitlePane extends JComponent | |
| { | |
| /** | |
| * The Action responsible for closing the JInternalFrame. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class CloseAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public CloseAction() | |
| { | |
| super("Close"); | |
| } | |
| /** | |
| * This method is called when something closes the JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| if (frame.isClosable()) | |
| { | |
| try | |
| { | |
| frame.setClosed(true); | |
| } | |
| catch (PropertyVetoException pve) | |
| { | |
| // We do nothing if the attempt has been vetoed. | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * This Action is responsible for iconifying the JInternalFrame. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class IconifyAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public IconifyAction() | |
| { | |
| super("Minimize"); | |
| } | |
| /** | |
| * This method is called when the user wants to iconify the | |
| * JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| if (frame.isIconifiable() && ! frame.isIcon()) | |
| { | |
| try | |
| { | |
| frame.setIcon(true); | |
| } | |
| catch (PropertyVetoException pve) | |
| { | |
| // We do nothing if the attempt has been vetoed. | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * This Action is responsible for maximizing the JInternalFrame. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class MaximizeAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public MaximizeAction() | |
| { | |
| super("Maximize"); | |
| } | |
| /** | |
| * This method is called when the user wants to maximize the | |
| * JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| try | |
| { | |
| if (frame.isMaximizable() && ! frame.isMaximum()) | |
| { | |
| frame.setMaximum(true); | |
| maxButton.setIcon(minIcon); | |
| } | |
| else if (frame.isMaximum()) | |
| { | |
| frame.setMaximum(false); | |
| maxButton.setIcon(maxIcon); | |
| } | |
| } | |
| catch (PropertyVetoException pve) | |
| { | |
| // We do nothing if the attempt has been vetoed. | |
| } | |
| } | |
| } | |
| /** | |
| * This Action is responsible for dragging the JInternalFrame. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class MoveAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public MoveAction() | |
| { | |
| super("Move"); | |
| } | |
| /** | |
| * This method is called when the user wants to drag the JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| // FIXME: Implement keyboard driven? move actions. | |
| } | |
| } | |
| /** | |
| * This Action is responsible for restoring the JInternalFrame. Restoring | |
| * the JInternalFrame is the same as setting the maximum property to false. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class RestoreAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public RestoreAction() | |
| { | |
| super("Restore"); | |
| } | |
| /** | |
| * This method is called when the user wants to restore the | |
| * JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| if (frame.isMaximum()) | |
| { | |
| try | |
| { | |
| frame.setMaximum(false); | |
| } | |
| catch (PropertyVetoException pve) | |
| { | |
| // We do nothing if the attempt has been vetoed. | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * This action is responsible for sizing the JInternalFrame. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class SizeAction extends AbstractAction | |
| { | |
| /** | |
| * Creates a new action. | |
| */ | |
| public SizeAction() | |
| { | |
| super("Size"); | |
| } | |
| /** | |
| * This method is called when the user wants to resize the JInternalFrame. | |
| * | |
| * @param e The ActionEvent. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| // FIXME: Not sure how size actions should be handled. | |
| } | |
| } | |
| /** | |
| * This class is responsible for handling property change events from the | |
| * JInternalFrame and adjusting the Title Pane as necessary. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class PropertyChangeHandler implements PropertyChangeListener | |
| { | |
| /** | |
| * This method is called when a PropertyChangeEvent is received by the | |
| * Title Pane. | |
| * | |
| * @param evt The PropertyChangeEvent. | |
| */ | |
| public void propertyChange(PropertyChangeEvent evt) | |
| { | |
| String propName = evt.getPropertyName(); | |
| if (propName.equals("closable")) | |
| { | |
| if (evt.getNewValue().equals(Boolean.TRUE)) | |
| closeButton.setVisible(true); | |
| else | |
| closeButton.setVisible(false); | |
| } | |
| else if (propName.equals("iconable")) | |
| { | |
| if (evt.getNewValue().equals(Boolean.TRUE)) | |
| iconButton.setVisible(true); | |
| else | |
| iconButton.setVisible(false); | |
| } | |
| else if (propName.equals("maximizable")) | |
| { | |
| if (evt.getNewValue().equals(Boolean.TRUE)) | |
| maxButton.setVisible(true); | |
| else | |
| maxButton.setVisible(false); | |
| } | |
| enableActions(); | |
| } | |
| } | |
| /** | |
| * This class acts as the MenuBar for the TitlePane. Clicking on the Frame | |
| * Icon in the top left corner will activate it. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class SystemMenuBar extends JMenuBar | |
| { | |
| /** | |
| * This method returns true if it can receive focus. | |
| * | |
| * @return True if this Component can receive focus. | |
| */ | |
| public boolean isFocusTraversable() | |
| { | |
| return true; | |
| } | |
| /** | |
| * This method returns true if this Component is expected to paint all of | |
| * itself. | |
| * | |
| * @return True if this Component is expect to paint all of itself. | |
| */ | |
| public boolean isOpaque() | |
| { | |
| return true; | |
| } | |
| /** | |
| * This method paints this Component. | |
| * | |
| * @param g The Graphics object to paint with. | |
| */ | |
| public void paint(Graphics g) | |
| { | |
| Icon frameIcon = frame.getFrameIcon(); | |
| if (frameIcon == null) | |
| frameIcon = BasicDesktopIconUI.defaultIcon; | |
| frameIcon.paintIcon(this, g, 0, 0); | |
| } | |
| /** | |
| * This method requests that focus be given to this Component. | |
| */ | |
| public void requestFocus() | |
| { | |
| super.requestFocus(); | |
| } | |
| } | |
| /** | |
| * This class acts as the Layout Manager for the TitlePane. | |
| * | |
| * @specnote Apparently this class was intended to be protected, | |
| * but was made public by a compiler bug and is now | |
| * public for compatibility. | |
| */ | |
| public class TitlePaneLayout implements LayoutManager | |
| { | |
| /** | |
| * Creates a new <code>TitlePaneLayout</code> object. | |
| */ | |
| public TitlePaneLayout() | |
| { | |
| // Do nothing. | |
| } | |
| /** | |
| * This method is called when adding 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; | |
| // MenuBar is always present and located at the top left corner. | |
| Dimension menupref = menuBar.getPreferredSize(); | |
| menuBar.setBounds(insets.left, insets.top, menupref.width, height); | |
| int loc = width + insets.left - 1; | |
| int top = insets.top + 1; | |
| int buttonHeight = height - 4; | |
| if (closeButton.isVisible()) | |
| { | |
| int buttonWidth = closeIcon.getIconWidth(); | |
| loc -= buttonWidth + 2; | |
| closeButton.setBounds(loc, top, buttonWidth, buttonHeight); | |
| } | |
| if (maxButton.isVisible()) | |
| { | |
| int buttonWidth = maxIcon.getIconWidth(); | |
| loc -= buttonWidth + 2; | |
| maxButton.setBounds(loc, top, buttonWidth, buttonHeight); | |
| } | |
| if (iconButton.isVisible()) | |
| { | |
| int buttonWidth = iconIcon.getIconWidth(); | |
| loc -= buttonWidth + 2; | |
| iconButton.setBounds(loc, top, buttonWidth, buttonHeight); | |
| } | |
| if (title != null) | |
| title.setBounds(insets.left + menupref.width, insets.top, | |
| loc - menupref.width - insets.left, 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); | |
| } | |
| /** | |
| * This method 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, 18); | |
| } | |
| /** | |
| * This method is called when removing a Component from the Container. | |
| * | |
| * @param c The Component to remove. | |
| */ | |
| public void removeLayoutComponent(Component c) | |
| { | |
| // Nothing to do here. | |
| } | |
| } | |
| /** | |
| * 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 action command for the Close action. */ | |
| protected static final String CLOSE_CMD; | |
| /** The action command for the Minimize action. */ | |
| protected static final String ICONIFY_CMD; | |
| /** The action command for the Maximize action. */ | |
| protected static final String MAXIMIZE_CMD; | |
| /** The action command for the Move action. */ | |
| protected static final String MOVE_CMD; | |
| /** The action command for the Restore action. */ | |
| protected static final String RESTORE_CMD; | |
| /** The action command for the Size action. */ | |
| protected static final String SIZE_CMD; | |
| /** The action associated with closing the JInternalFrame. */ | |
| protected Action closeAction; | |
| /** The action associated with iconifying the JInternalFrame. */ | |
| protected Action iconifyAction; | |
| /** The action associated with maximizing the JInternalFrame. */ | |
| protected Action maximizeAction; | |
| /** The action associated with moving the JInternalFrame. */ | |
| protected Action moveAction; | |
| /** The action associated with restoring the JInternalFrame. */ | |
| protected Action restoreAction; | |
| /** The action associated with resizing the JInternalFrame. */ | |
| protected Action sizeAction; | |
| /** The button that closes the JInternalFrame. */ | |
| protected JButton closeButton; | |
| /** The button that iconifies the JInternalFrame. */ | |
| protected JButton iconButton; | |
| /** The button that maximizes the JInternalFrame. */ | |
| protected JButton maxButton; | |
| /** The icon displayed in the restore button. */ | |
| protected Icon minIcon = BasicIconFactory.createEmptyFrameIcon(); | |
| /** The icon displayed in the maximize button. */ | |
| protected Icon maxIcon = BasicIconFactory.createEmptyFrameIcon(); | |
| /** The icon displayed in the iconify button. */ | |
| protected Icon iconIcon = BasicIconFactory.createEmptyFrameIcon(); | |
| /** The icon displayed in the close button. */ | |
| protected Icon closeIcon; | |
| /** The JInternalFrame that this TitlePane is used in. */ | |
| protected JInternalFrame frame; | |
| /** The JMenuBar that is located at the top left of the Title Pane. */ | |
| protected JMenuBar menuBar; | |
| /** The JMenu inside the menuBar. */ | |
| protected JMenu windowMenu; | |
| /** | |
| * The text color of the TitlePane when the JInternalFrame is not selected. | |
| */ | |
| protected Color notSelectedTextColor; | |
| /** | |
| * The background color of the TitlePane when the JInternalFrame is not | |
| * selected. | |
| */ | |
| protected Color notSelectedTitleColor; | |
| /** The text color of the titlePane when the JInternalFrame is selected. */ | |
| protected Color selectedTextColor; | |
| /** | |
| * The background color of the TitlePane when the JInternalFrame is | |
| * selected. | |
| */ | |
| protected Color selectedTitleColor; | |
| /** The Property Change listener that listens to the JInternalFrame. */ | |
| protected PropertyChangeListener propertyChangeListener; | |
| /** | |
| * The label used to display the title. This label is not added to the | |
| * TitlePane. | |
| * This is package-private to avoid an accessor method. | |
| */ | |
| transient JLabel title; | |
| static | |
| { | |
| // not constants in JDK | |
| CLOSE_CMD = "Close"; | |
| ICONIFY_CMD = "Minimize"; | |
| MAXIMIZE_CMD = "Maximize"; | |
| MOVE_CMD = "Move"; | |
| RESTORE_CMD = "Restore"; | |
| SIZE_CMD = "Size"; | |
| } | |
| /** | |
| * Creates a new BasicInternalFrameTitlePane object that is used in the | |
| * given JInternalFrame. | |
| * | |
| * @param f The JInternalFrame this BasicInternalFrameTitlePane will be used | |
| * in. | |
| */ | |
| public BasicInternalFrameTitlePane(JInternalFrame f) | |
| { | |
| frame = f; | |
| setLayout(createLayout()); | |
| title = new JLabel(); | |
| title.setHorizontalAlignment(SwingConstants.LEFT); | |
| title.setHorizontalTextPosition(SwingConstants.LEFT); | |
| title.setOpaque(false); | |
| setOpaque(true); | |
| setBackground(Color.LIGHT_GRAY); | |
| setOpaque(true); | |
| installTitlePane(); | |
| } | |
| /** | |
| * 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(); | |
| } | |
| /** | |
| * This method adds the sub components to the TitlePane. | |
| */ | |
| protected void addSubComponents() | |
| { | |
| add(menuBar); | |
| add(closeButton); | |
| add(iconButton); | |
| add(maxButton); | |
| } | |
| /** | |
| * This method creates the actions that are used to manipulate the | |
| * JInternalFrame. | |
| */ | |
| protected void createActions() | |
| { | |
| closeAction = new CloseAction(); | |
| closeAction.putValue(AbstractAction.ACTION_COMMAND_KEY, CLOSE_CMD); | |
| iconifyAction = new IconifyAction(); | |
| iconifyAction.putValue(AbstractAction.ACTION_COMMAND_KEY, ICONIFY_CMD); | |
| maximizeAction = new MaximizeAction(); | |
| maximizeAction.putValue(AbstractAction.ACTION_COMMAND_KEY, MAXIMIZE_CMD); | |
| sizeAction = new SizeAction(); | |
| sizeAction.putValue(AbstractAction.ACTION_COMMAND_KEY, SIZE_CMD); | |
| restoreAction = new RestoreAction(); | |
| restoreAction.putValue(AbstractAction.ACTION_COMMAND_KEY, RESTORE_CMD); | |
| moveAction = new MoveAction(); | |
| moveAction.putValue(AbstractAction.ACTION_COMMAND_KEY, MOVE_CMD); | |
| } | |
| /** | |
| * This method is used to install the listeners. | |
| */ | |
| protected void installListeners() | |
| { | |
| propertyChangeListener = createPropertyChangeListener(); | |
| frame.addPropertyChangeListener(propertyChangeListener); | |
| } | |
| /** | |
| * This method is used to uninstall the listeners. | |
| */ | |
| protected void uninstallListeners() | |
| { | |
| frame.removePropertyChangeListener(propertyChangeListener); | |
| propertyChangeListener = null; | |
| } | |
| /** | |
| * This method installs the defaults determined by the look and feel. | |
| */ | |
| protected void installDefaults() | |
| { | |
| title.setFont(UIManager.getFont("InternalFrame.titleFont")); | |
| selectedTextColor = UIManager.getColor("InternalFrame.activeTitleForeground"); | |
| selectedTitleColor = UIManager.getColor("InternalFrame.activeTitleBackground"); | |
| notSelectedTextColor = UIManager.getColor("InternalFrame.inactiveTitleForeground"); | |
| notSelectedTitleColor = UIManager.getColor("InternalFrame.inactiveTitleBackground"); | |
| closeIcon = UIManager.getIcon("InternalFrame.closeIcon"); | |
| iconIcon = UIManager.getIcon("InternalFrame.iconifyIcon"); | |
| maxIcon = UIManager.getIcon("InternalFrame.maximizeIcon"); | |
| } | |
| /** | |
| * This method uninstalls the defaults. | |
| */ | |
| protected void uninstallDefaults() | |
| { | |
| setFont(null); | |
| selectedTextColor = null; | |
| selectedTitleColor = null; | |
| notSelectedTextColor = null; | |
| notSelectedTitleColor = null; | |
| closeIcon = null; | |
| iconIcon = null; | |
| maxIcon = null; | |
| } | |
| /** | |
| * This method creates the buttons used in the TitlePane. | |
| */ | |
| protected void createButtons() | |
| { | |
| closeButton = new PaneButton(closeAction); | |
| closeButton.setText(null); | |
| if (!frame.isClosable()) | |
| closeButton.setVisible(false); | |
| iconButton = new PaneButton(iconifyAction); | |
| iconButton.setText(null); | |
| if (!frame.isIconifiable()) | |
| iconButton.setVisible(false); | |
| maxButton = new PaneButton(maximizeAction); | |
| maxButton.setText(null); | |
| if (!frame.isMaximizable()) | |
| maxButton.setVisible(false); | |
| } | |
| /** | |
| * Set icons for the minimize-, maximize- and close-buttons. | |
| */ | |
| 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); | |
| } | |
| /** | |
| * This method creates the MenuBar used in the TitlePane. | |
| */ | |
| protected void assembleSystemMenu() | |
| { | |
| menuBar = createSystemMenuBar(); | |
| windowMenu = createSystemMenu(); | |
| menuBar.add(windowMenu); | |
| addSystemMenuItems(windowMenu); | |
| enableActions(); | |
| } | |
| /** | |
| * This method adds the MenuItems to the given JMenu. | |
| * | |
| * @param systemMenu The JMenu to add MenuItems to. | |
| */ | |
| protected void addSystemMenuItems(JMenu systemMenu) | |
| { | |
| JMenuItem tmp; | |
| tmp = new JMenuItem(RESTORE_CMD); | |
| tmp.addActionListener(restoreAction); | |
| tmp.setMnemonic(KeyEvent.VK_R); | |
| systemMenu.add(tmp); | |
| tmp = new JMenuItem(MOVE_CMD); | |
| tmp.addActionListener(moveAction); | |
| tmp.setMnemonic(KeyEvent.VK_M); | |
| systemMenu.add(tmp); | |
| tmp = new JMenuItem(SIZE_CMD); | |
| tmp.addActionListener(sizeAction); | |
| tmp.setMnemonic(KeyEvent.VK_S); | |
| systemMenu.add(tmp); | |
| tmp = new JMenuItem(ICONIFY_CMD); | |
| tmp.addActionListener(iconifyAction); | |
| tmp.setMnemonic(KeyEvent.VK_N); | |
| systemMenu.add(tmp); | |
| tmp = new JMenuItem(MAXIMIZE_CMD); | |
| tmp.addActionListener(maximizeAction); | |
| tmp.setMnemonic(KeyEvent.VK_X); | |
| systemMenu.add(tmp); | |
| systemMenu.addSeparator(); | |
| tmp = new JMenuItem(CLOSE_CMD); | |
| tmp.addActionListener(closeAction); | |
| tmp.setMnemonic(KeyEvent.VK_C); | |
| systemMenu.add(tmp); | |
| } | |
| /** | |
| * This method creates a new JMenubar. | |
| * | |
| * @return A new JMenuBar. | |
| */ | |
| protected JMenuBar createSystemMenuBar() | |
| { | |
| if (menuBar == null) | |
| menuBar = new SystemMenuBar(); | |
| menuBar.removeAll(); | |
| return menuBar; | |
| } | |
| /** | |
| * This method creates a new JMenu. | |
| * | |
| * @return A new JMenu. | |
| */ | |
| protected JMenu createSystemMenu() | |
| { | |
| if (windowMenu == null) | |
| windowMenu = new JMenu(); | |
| windowMenu.removeAll(); | |
| return windowMenu; | |
| } | |
| /** | |
| * This method programmatically shows the JMenu. | |
| */ | |
| protected void showSystemMenu() | |
| { | |
| // FIXME: Untested as KeyEvents are not hooked up. | |
| menuBar.getMenu(1).getPopupMenu().show(); | |
| } | |
| /** | |
| * This method paints the TitlePane. | |
| * | |
| * @param g The Graphics object to paint with. | |
| */ | |
| public void paintComponent(Graphics g) | |
| { | |
| paintTitleBackground(g); | |
| if (frame.getTitle() != null && title != null) | |
| { | |
| Color saved = g.getColor(); | |
| Font f = title.getFont(); | |
| g.setFont(f); | |
| FontMetrics fm = g.getFontMetrics(f); | |
| if (frame.isSelected()) | |
| g.setColor(selectedTextColor); | |
| else | |
| g.setColor(notSelectedTextColor); | |
| title.setText(getTitle(frame.getTitle(), fm, title.getBounds().width)); | |
| SwingUtilities.paintComponent(g, title, null, title.getBounds()); | |
| g.setColor(saved); | |
| } | |
| } | |
| /** | |
| * This method paints the TitlePane's background. | |
| * | |
| * @param g The Graphics object to paint with. | |
| */ | |
| protected void paintTitleBackground(Graphics g) | |
| { | |
| if (!isOpaque()) | |
| return; | |
| Color saved = g.getColor(); | |
| Dimension dims = getSize(); | |
| Color bg = getBackground(); | |
| if (frame.isSelected()) | |
| bg = selectedTitleColor; | |
| else | |
| bg = notSelectedTitleColor; | |
| g.setColor(bg); | |
| g.fillRect(0, 0, dims.width, dims.height); | |
| g.setColor(saved); | |
| } | |
| /** | |
| * This method returns the title string based on the available width and the | |
| * font metrics. | |
| * | |
| * @param text The desired title. | |
| * @param fm The FontMetrics of the font used. | |
| * @param availableWidth The available width. | |
| * | |
| * @return The allowable string. | |
| */ | |
| protected String getTitle(String text, FontMetrics fm, int availableWidth) | |
| { | |
| Rectangle vr = new Rectangle(0, 0, availableWidth, fm.getHeight()); | |
| Rectangle ir = new Rectangle(); | |
| Rectangle tr = new Rectangle(); | |
| String value = SwingUtilities.layoutCompoundLabel(this, fm, text, null, | |
| SwingConstants.CENTER, | |
| SwingConstants.LEFT, | |
| SwingConstants.CENTER, | |
| SwingConstants.LEFT, vr, | |
| ir, tr, 0); | |
| return value; | |
| } | |
| /** | |
| * This method fires something similar to a WINDOW_CLOSING event. | |
| * | |
| * @param frame The JInternalFrame that is being closed. | |
| */ | |
| protected void postClosingEvent(JInternalFrame frame) | |
| { | |
| // FIXME: Implement postClosingEvent when I figure out what | |
| // it's supposed to do. | |
| // It says that this fires an WINDOW_CLOSING like event. | |
| // So the closest thing is some kind of InternalFrameEvent. | |
| // But none is fired. | |
| // Can't see it called or anything. | |
| } | |
| /** | |
| * This method enables the actions for the TitlePane given the frame's | |
| * properties. | |
| */ | |
| protected void enableActions() | |
| { | |
| closeAction.setEnabled(frame.isClosable()); | |
| iconifyAction.setEnabled(frame.isIconifiable()); | |
| // The maximize action is responsible for restoring it | |
| // as well, if clicked from the button | |
| maximizeAction.setEnabled(frame.isMaximizable()); | |
| // The restoring action is only active when selected | |
| // from the menu. | |
| restoreAction.setEnabled(frame.isMaximum()); | |
| sizeAction.setEnabled(frame.isResizable()); | |
| // FIXME: Tie MoveAction enabled status to a variable. | |
| moveAction.setEnabled(false); | |
| } | |
| /** | |
| * This method creates a new PropertyChangeListener. | |
| * | |
| * @return A new PropertyChangeListener. | |
| */ | |
| protected PropertyChangeListener createPropertyChangeListener() | |
| { | |
| return new PropertyChangeHandler(); | |
| } | |
| /** | |
| * This method creates a new LayoutManager for the TitlePane. | |
| * | |
| * @return A new LayoutManager. | |
| */ | |
| protected LayoutManager createLayout() | |
| { | |
| return new TitlePaneLayout(); | |
| } | |
| } |