From 31e632d3e47f22d310f36709f6d983cb1a8dba92 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Fri, 16 Apr 2004 18:44:45 +0000 Subject: [multiple changes] 2004-04-09 Thomas Fitzsimmons * gnu/java/awt/peer/gtk/GtkPanelPeer.java (connectSignals): Remove method. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkPanelPeer.c: Remove unused code. 2004-04-02 Olga Rodimina * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/ImageIcon.java: (ImageIcon(file)): set description of the icon to the file name * javax/swing/JCheckBoxMenuItem.java: Mostly Implemented. Work in progress. * javax/swing/JRadioButtonMenuItem.java: Reimplement constructors to use JToggleButtonModel. * javax/swing/plaf/basic/BasicIconFactory.java: (getCheckBoxMenuItemIcon): return check box icon. * javax/swing/plaf/basic/BasicMenuItemUI.java: paint menu item selected only when it is armed and pressed. 2004-04-02 David Jee * gnu/java/awt/peer/gtk/GtkMenuItemPeer.java (GtkMenuItemPeer): Only connect signals if this isn't a Menu peer. * java/awt/Component.java (add): Set the parent of the popup as this component. * java/awt/PopupMenu.java (addNotify): Create popup menu when peer is null. (show): Call addNotify() if peer is null. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkPopupMenuPeer.c (Java_gnu_java_awt_peer_gtk_GtkPopupMenuPeer_show): Set the button argument for gtk_menu_popup() as zero. This causes the popup menu to respond to any mouse button. 2004-03-31 Olga Rodimina * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/JRadioButtonMenuItem.java: Implemented. * javax/swing/plaf/basic/BasicIconFactory.java: (getRadioButtonMenuItemIcon): Return radio button icon. * javax/swing/plaf/basic/BasicMenuItemUI.java: (getPreferredSize): Add size of checkIcon if it exists. (installDefaults): Don't initialize checkIcon. It's value will be set in subclasses. (uninstallDefaults): remove uninstallation of checkIcon. (paint): Moved code to paintMenuItem(). (paintMenuItem): Implemented. * javax/swing/plaf/basic/BasicRadioButtonMenuItemUI.java: UI delegate for JRadioButtonMenuItem. 2004-03-29 Olga Rodimina * javax/swing/plaf/basic/BasicMenuItemUI.java: Corrected position of the accelerator. 2004-03-29 Olga Rodimina * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/JMenuItem.java: Partly implemented. Work in progress * javax/swing/plaf/basic/BasicLookAndFeel.java: Changed default value of acceleratorDelimiter. * javax/swing/plaf/basic/BasicMenuItemUI.java: New class. Partly implemented. 2004-03-26 Mark Wielaard * native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkChoicePeer.c (item_activate): Declare label before use. * native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c (gtkSetFont): Removed unused variable label. (addExposeFilter): Declare variables before use. (removeExposeFilter): Likewise. * native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkFileDialogPeer.c (ok_clicked): Declare str_fileName before use. 2004-03-26 David Jee * gnu/java/awt/peer/gtk/GtkMenuPeer.java (addSeparator): Remove. * java/awt/Menu.java (separator): Remove static final MenuItem field. (separatorLabel): New static final String field. (addSeparator): Do not use peer method; use add(MenuItem) instead. Use separatorLabel to denote that it is a separator. (insertSeparator): Create a new MenuItem with separatorLabel, instead of reusing the static separator instance, because a MenuItem instance can't be added more than once without being cloned. * java/awt/peer/MenuPeer.java (addSeparator): Remove from interface. 2004-03-26 David Jee * gnu/java/awt/peer/gtk/GtkMenuItemPeer.java (connectSignals): New native method declaration. (GtkMenuItemPeer): Connect signals if the parent is a Menu. * java/awt/MenuItem.java (getActionCommand): Return the label if the action command is not set. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkMenuBarPeer.c (Java_gnu_java_awt_peer_gtk_GtkMenuBarPeer_addMenu): Use gtk_menu_shell_append(). * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkMenuItemPeer.c (item_activate): Fix argument type. (Java_gnu_java_awt_peer_gtk_GtkMenuItemPeer_create): Do not connect signal here. (Java_gnu_java_awt_peer_gtk_GtkMenuItemPeer_connectSignals): New method. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkMenuPeer.c (Java_gnu_java_awt_peer_gtk_GtkMenuPeer_create): Check if a label is given. Add the menu widget's top-level GtkWindow to the global window group, so it can grab the pointer. (Java_gnu_java_awt_peer_gtk_GtkMenuPeer_addItem): Use gtk_menu_shell_append(). 2004-03-23 Graydon Hoare * java/text/AttributedString.java (addAttribute): Fix off-by-one. (getIterator): Likewise. * java/text/AttributedStringIterator.java (getRunLimit): Correct logic. (getRunStart): Likewise. (getAttribute): Fix inequality. (getAttributes): Likewise. * testsuite/libjava.mauve/xfails: Remove AttributedString xfail. 2004-03-23 Kim Ho * javax/swing/plaf/basic/BasicTabbedPaneUI.java: (calculateSizes): Return real width and height. 2004-03-23 Kim Ho * javax/swing/plaf/basic/BasicTabbedPaneUI.java (calculateTabRects): Set the selectedRun before trying to rotate tabs. 2004-03-23 Kim Ho * Makefile.am: New file * Makefile.in: Regenerate * java/awt/Graphics.java: (drawRect): Draw to the correct point. * javax/swing/DefaultSingleSelectionModel.java (isSelected): Return true if the selected index is not -1. * javax/swing/JLabel.java: Do not change mnemonic index if text is null. * javax/swing/JProgressBar.java: Use JComponent's EventListenerList. * javax/swing/JScrollBar.java: Ditto. * javax/swing/JSlider.java: Ditto. * javax/swing/JTabbedPane.java: Reimplement. * javax/swing/plaf/basic/BasicLookAndFeel.java: Add defaults for TabbedPane. * javax/swing/plaf/basic/BasicArrowButton.java: Implement * javax/swing/plaf/basic/BasicProgressBarUI.java: (paintDeterminate): Don't paint String if it's empty. (paintIndeterminate): ditto. * javax/swing/plaf/basic/BasicTabbedPaneUI.java: Reimplement. 2004-03-19 Michael Koch * java/awt/image/AffineTransformOp.java (AffineTransformOp): Made public. * javax/swing/JComponent.java (listenerList): Made protected. (accessibleContext): Likewise. * javax/swing/JList.java (valueChanged): Dont use internal fields of ListSelectionEvent. * javax/swing/JViewport.java (getView): Dont use internal fields of Component. (addImpl): Likewise. * javax/swing/Timer.java (isRunning): Made public. (start): Likewise. (stop): Likewise. * javax/swing/UIDefaults.java (getInt): Made public. * javax/swing/plaf/basic/BasicListUI.java (mousePressed): Dont use internal fields of MouseEvent. (propertyChanged): Dont use internal fields of PropertyChangeEvent. * javax/swing/plaf/basic/BasicScrollBarUI.java (arrowIcon): Made static. * javax/swing/plaf/basic/BasicViewportUI.java (stateChanged): Dont use internal field on ChangeEvent. * javax/swing/text/JTextComponent.java (getUI): Call UIManager.getUI(). (updateUI): Use getUI(). 2004-03-19 Graydon Hoare * javax/swing/JComponent.java: Turn off double buffer by default. * javax/swing/plaf/basic/BasicViewportUI.java: Clear rects before painting. * jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c (Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable): Use cairo to copy areas. (Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoClip): Initialize and set clip region. 2004-03-15 Thomas Fitzsimmons * java/applet/Applet.java (preferredSize): Override deprecated variant of getPreferredSize. (minimumSize): Override deprecated variant of getMinimumSize. 2004-03-15 Olga Rodimina * gnu/java/awt/peer/gtk/GdkGraphics2D.java (drawImage(img,xform,bgcolor,obs)): New Method. Helper function that every drawImage method will use. (drawRaster): Added new parameter, bgcolor. All transparent pixels are changed to bgcolor before image is drawn. (drawRenderedImage): Fixed to use changed drawRaster(). (drawImage(image,xform,obs): Fixed to use new helper function (drawImage(image,op,x,y)): Ditto. (drawImage (img,x,y,observer)): Ditto. ((PainterThread) bgcolor): New Field. ((PainterThread) (setPixels)): Changed all transparent pixels to bgcolor. (drawImage(img,x,y,width,height,bgcolor,observer)): Fixed FIXME - all the transparent pixels are changed to the specified bgcolor. (drawImage(img, x, y, width, height, observer): Changed to use function above. (drawImage (img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,bgcolor,observer)): Fixed FIXME- changed all transparent pixels to bgcolor. (drawImage (img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer)): Changed to use function above. 2004-03-14 Thomas Fitzsimmons * java/applet/Applet.java (dimensions): New field. (getDimensions): New method. (getPreferredSize): Call getDimensions. (getMinimumSize): Likewise. 2004-03-13 Thomas Fitzsimmons * jni/classpath/jcl.c: Include stdlib.h, not malloc.h. * jni/classpath/jnilink.c: Likewise. * java/applet/Applet.java (getPreferredSize): New method. (getMinimumSize): New method. From-SVN: r80762 --- .../javax/swing/plaf/basic/BasicMenuItemUI.java | 647 +++++++++++++++++++++ 1 file changed, 647 insertions(+) create mode 100644 libjava/javax/swing/plaf/basic/BasicMenuItemUI.java (limited to 'libjava/javax/swing/plaf/basic/BasicMenuItemUI.java') diff --git a/libjava/javax/swing/plaf/basic/BasicMenuItemUI.java b/libjava/javax/swing/plaf/basic/BasicMenuItemUI.java new file mode 100644 index 0000000..fd21728 --- /dev/null +++ b/libjava/javax/swing/plaf/basic/BasicMenuItemUI.java @@ -0,0 +1,647 @@ +/* BasicMenuItemUI.java + Copyright (C) 2002, 2004 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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.AWTKeyStroke; +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Font; +import java.awt.FontMetrics; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Insets; +import java.awt.Rectangle; +import java.awt.Stroke; +import java.awt.event.FocusAdapter; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; +import java.awt.event.InputEvent; +import java.awt.event.KeyEvent; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; + +import javax.swing.AbstractButton; +import javax.swing.ButtonModel; +import javax.swing.Icon; +import javax.swing.JComponent; +import javax.swing.JCheckBoxMenuItem; +import javax.swing.JMenuItem; +import javax.swing.JRadioButtonMenuItem; +import javax.swing.KeyStroke; +import javax.swing.MenuElement; +import javax.swing.MenuSelectionManager; +import javax.swing.SwingUtilities; +import javax.swing.UIDefaults; +import javax.swing.UIManager; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; +import javax.swing.event.MenuDragMouseEvent; +import javax.swing.event.MenuDragMouseListener; +import javax.swing.event.MenuKeyEvent; +import javax.swing.event.MenuKeyListener; +import javax.swing.event.MouseInputListener; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.MenuItemUI; + + +public class BasicMenuItemUI extends MenuItemUI +{ + /** Font to be used when displaying menu item's accelerator. */ + protected Font acceleratorFont; + + /** Color to be used when displaying menu item's accelerator. */ + protected Color acceleratorForeground; + + /** Color to be used when displaying menu item's accelerator + * when menu item is selected. + */ + protected Color acceleratorSelectionForeground; + + /** + * Icon that is displayed after the text to indicated that this menu + * contains submenu. + */ + protected Icon arrowIcon; + + /** + * Icon that is displayed before the text. This icon is only used in + * JCheckBoxMenuItem or JRadioBoxMenuItem. + */ + protected Icon checkIcon; + + /** Number of spaces between icon and text. */ + protected int defaultTextIconGap = 4; + + /** Color of the text when menu item is disabled*/ + protected Color disabledForeground; + + /** The menu Drag mouse listener listening to the menu item. */ + protected MenuDragMouseListener menuDragMouseListener; + + /** The menu item itself*/ + protected JMenuItem menuItem; + + /** Menu Key listener listening to the menu item. */ + protected MenuKeyListener menuKeyListener; + + /** mouse input listener listening to menu item. */ + protected MouseInputListener mouseInputListener; + + /** Indicates if border should be painted */ + protected boolean oldBorderPainted; + + /** Color of text that is used when menu item is selected */ + protected Color selectionBackground; + + /** Color of the background that is used when menu item is selected.*/ + protected Color selectionForeground; + + /** String that separates description of the modifiers and the key*/ + private String acceleratorDelimiter; + + /** Number of spaces between accelerator and menu item's label. */ + private int defaultAcceleratorLabelGap = 4; + + // Constructor Summary + BasicMenuItemUI() + { + mouseInputListener = createMouseInputListener(menuItem); + menuDragMouseListener = createMenuDragMouseListener(menuItem); + menuKeyListener = createMenuKeyListener(menuItem); + } + + // Method Summary + protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) + { + return new MenuDragMouseHandler(); + } + + protected MenuKeyListener createMenuKeyListener(JComponent c) + { + return new MenuKeyHandler(); + } + + protected MouseInputListener createMouseInputListener(JComponent c) + { + return new MouseInputHandler(); + } + + public static ComponentUI createUI(JComponent c) + { + return new BasicMenuItemUI(); + } + + protected void doClick(MenuSelectionManager msm) + { + // TODO + } + + public Dimension getMaximumSize(JComponent c) + { + // TODO + return null; + } + + public Dimension getMinimumSize(JComponent c) + { + // TODO + return null; + } + + public MenuElement[] getPath() + { + // TODO + return null; + } + + protected Dimension getPreferredMenuItemSize(JComponent c, Icon checkIcon, + Icon arrowIcon, + int defaultTextIconGap) + { + // TODO + return null; + } + + public Dimension getPreferredSize(JComponent c) + { + AbstractButton b = (AbstractButton) c; + Dimension d = BasicGraphicsUtils.getPreferredButtonSize(b, + defaultTextIconGap); + + // if menu item has accelerator then take accelerator's size into account + // when calculating preferred size. + + KeyStroke accelerator = ((JMenuItem) c).getAccelerator(); + Rectangle rect; + if (accelerator != null) + { + rect = getAcceleratorRect(accelerator, + b.getToolkit().getFontMetrics(acceleratorFont)); + + // add width of accelerator's text + d.width = d.width + rect.width + defaultAcceleratorLabelGap; + + // adjust the heigth of the preferred size if necessary + if (d.height < rect.height) + d.height = rect.height; + } + + if (checkIcon != null) + { + d.width = d.width + checkIcon.getIconWidth() + defaultTextIconGap; + if (checkIcon.getIconHeight() > d.height) + d.height = checkIcon.getIconHeight(); + } + + return d; + } + + protected String getPropertyPrefix() + { + // TODO + return null; + } + + protected void installComponents(JMenuItem menuItem) + { + // TODO + } + + protected void installDefaults() + { + UIDefaults defaults = UIManager.getLookAndFeelDefaults(); + + menuItem.setBackground(defaults.getColor("MenuItem.background")); + menuItem.setBorder(defaults.getBorder("MenuItem.border")); + menuItem.setFont(defaults.getFont("MenuItem.font")); + menuItem.setForeground(defaults.getColor("MenuItem.foreground")); + menuItem.setMargin(defaults.getInsets("MenuItem.margin")); + acceleratorFont = defaults.getFont("MenuItem.acceleratorFont"); + acceleratorForeground = defaults.getColor("MenuItem.acceleratorForeground"); + acceleratorSelectionForeground = defaults.getColor("MenuItem.acceleratorSelectionForeground"); + arrowIcon = defaults.getIcon("MenuItem.arrowIcon"); + selectionBackground = defaults.getColor("MenuItem.selectionBackground"); + selectionForeground = defaults.getColor("MenuItem.selectionForeground"); + acceleratorDelimiter = defaults.getString("MenuItem.acceleratorDelimiter"); + } + + protected void installKeyboardActions() + { + // TODO + } + + protected void installListeners() + { + menuItem.addMouseListener(mouseInputListener); + menuItem.addMenuDragMouseListener(menuDragMouseListener); + menuItem.addMenuKeyListener(menuKeyListener); + } + + public void installUI(JComponent c) + { + super.installUI(c); + menuItem = (JMenuItem) c; + installDefaults(); + installListeners(); + } + + public void paint(Graphics g, JComponent c) + { + paintMenuItem(g, c, checkIcon, arrowIcon, c.getBackground(), + c.getForeground(), defaultTextIconGap); + } + + protected void paintBackground(Graphics g, JMenuItem menuItem, Color bgColor) + { + Dimension size = getPreferredSize(menuItem); + Color foreground = g.getColor(); + g.setColor(bgColor); + g.drawRect(0, 0, size.width, size.height); + g.setColor(foreground); + } + + protected void paintMenuItem(Graphics g, JComponent c, Icon checkIcon, + Icon arrowIcon, Color background, + Color foreground, int defaultTextIconGap) + { + AbstractButton b = (AbstractButton) c; + Rectangle tr = new Rectangle(); // text rectangle + Rectangle ir = new Rectangle(); // icon rectangle + Rectangle vr = new Rectangle(); // view rectangle + Rectangle br = new Rectangle(); // border rectangle + Rectangle ar = new Rectangle(); // accelerator rectangle + Rectangle cr = new Rectangle(); // checkIcon rectangle + + int vertAlign = b.getVerticalAlignment(); + int horAlign = b.getHorizontalAlignment(); + int vertTextPos = b.getVerticalTextPosition(); + int horTextPos = b.getHorizontalTextPosition(); + + Font f = c.getFont(); + g.setFont(f); + FontMetrics fm = g.getFontMetrics(f); + SwingUtilities.calculateInnerArea(b, br); + SwingUtilities.calculateInsetArea(br, b.getMargin(), vr); + paintBackground(g, (JMenuItem) c, c.getBackground()); + + if ((b.getModel().isArmed() && b.getModel().isPressed())) + { + if (((AbstractButton) b).isContentAreaFilled()) + { + g.setColor(b.getBackground().darker()); + g.fillRect(br.x, br.y, br.width, br.height); + } + } + else + { + if (((AbstractButton) b).isContentAreaFilled()) + { + g.setColor(b.getBackground()); + g.fillRect(br.x, br.y, br.width, br.height); + } + } + + + if (checkIcon != null) + { + SwingUtilities.layoutCompoundLabel(c, fm, null, checkIcon, vertAlign, + horAlign, vertTextPos, horTextPos, + vr, cr, tr, defaultTextIconGap); + checkIcon.paintIcon(c, g, cr.x, cr.y); + + // We need to calculate position of the menu text and position of + // user menu icon if there exists one relative to the check icon. + // So we need to adjust view rectangle s.t. its starting point is at + // checkIcon.width + defaultTextIconGap. + + vr.x = cr.x + cr.width + defaultTextIconGap; + } + + if (arrowIcon != null) + { + // FIXME: if this menu contains a submenu, we need to draw arrow icon + // here as well + } + + + // paint text and user menu icon if it exists + SwingUtilities.layoutCompoundLabel(c, fm, b.getText(), b.getIcon(), + vertAlign, horAlign, vertTextPos, + horTextPos, vr, ir, tr, + defaultTextIconGap); + + paintText(g, (JMenuItem) c, tr, b.getText()); + + // paint icon + // FIXME: should paint different icon at different button state's. + // i.e disabled icon when button is disabled.. etc. + + /* + Icon i = b.getIcon(); + if (i != null) + { + int x = ir.x; + int y = ir.y; + i.paintIcon(c, g, x, y); + } + */ + + // paint accelerator + String acceleratorText = ""; + if (((JMenuItem) c).getAccelerator() != null) + { + acceleratorText = getAcceleratorText(((JMenuItem) c).getAccelerator()); + fm = g.getFontMetrics(acceleratorFont); + ar.width = fm.stringWidth(acceleratorText); + ar.x = br.width - ar.width; + vr.x = br.width - ar.width; + + SwingUtilities.layoutCompoundLabel(c, fm, acceleratorText, null, + vertAlign, horAlign, vertTextPos, + horTextPos, vr, ir, ar, + defaultTextIconGap); + + paintAccelerator(g, (JMenuItem) c, ar, acceleratorText); + + } + + } + + protected void paintText(Graphics g, JMenuItem menuItem, Rectangle textRect, + String text) + { + Font f = menuItem.getFont(); + g.setFont(f); + FontMetrics fm = g.getFontMetrics(f); + g.setColor(menuItem.getForeground()); + + BasicGraphicsUtils.drawString(g, text, 0, textRect.x, + textRect.y + fm.getAscent()); + } + + protected void uninstallComponents(JMenuItem menuItem) + { + // TODO + } + + protected void uninstallDefaults() + { + menuItem.setForeground(null); + menuItem.setBackground(null); + menuItem.setBorder(null); + menuItem.setMargin(null); + menuItem.setBackground(null); + menuItem.setBorder(null); + menuItem.setFont(null); + menuItem.setForeground(null); + menuItem.setMargin(null); + acceleratorFont = null; + acceleratorForeground = null; + acceleratorSelectionForeground = null; + arrowIcon = null; + selectionBackground = null; + selectionForeground = null; + acceleratorDelimiter = null; + } + + protected void uninstallKeyboardActions() + { + // TODO + } + + protected void uninstallListeners() + { + menuItem.removeMouseListener(mouseInputListener); + menuItem.removeMenuDragMouseListener(menuDragMouseListener); + menuItem.removeMenuKeyListener(menuKeyListener); + } + + public void uninstallUI(JComponent c) + { + uninstallListeners(); + uninstallDefaults(); + menuItem = null; + } + + public void update(Graphics g, JComponent c) + { + // TODO + } + + private String getAcceleratorText(KeyStroke accelerator) + { + + // convert keystroke into string format + + String modifiersText = ""; + int modifiers = accelerator.getModifiers(); + char keyChar = accelerator.getKeyChar(); + int keyCode = accelerator.getKeyCode(); + + if (modifiers != 0) + modifiersText = KeyEvent.getKeyModifiersText(modifiers) + + acceleratorDelimiter; + + if (keyCode == KeyEvent.VK_UNDEFINED) + return modifiersText + keyChar; + else + return modifiersText + KeyEvent.getKeyText(keyCode); + } + + private Rectangle getAcceleratorRect(KeyStroke accelerator, FontMetrics fm) + { + int width = fm.stringWidth(getAcceleratorText(accelerator)); + int height = fm.getHeight(); + return new Rectangle(0, 0, width, height); + } + + private void paintAccelerator(Graphics g, JMenuItem menuItem, Rectangle acceleratorRect, + String acceleratorText) + { + g.setFont(acceleratorFont); + FontMetrics fm = g.getFontMetrics(acceleratorFont); + g.setColor(acceleratorForeground); + BasicGraphicsUtils.drawString(g, acceleratorText, 0, acceleratorRect.x, + acceleratorRect.y + fm.getAscent()); + } + + protected class MouseInputHandler implements MouseInputListener + { + protected MouseInputHandler() + { + } + + public void mouseClicked(MouseEvent e) + { + } + + public void mouseDragged(MouseEvent e) + { + } + + public void mouseEntered(MouseEvent e) + { + if (e.getSource() instanceof AbstractButton) + { + AbstractButton button = (AbstractButton) e.getSource(); + ButtonModel model = button.getModel(); + + if (button.isRolloverEnabled()) + { + model.setRollover(true); + } + + if (model.isPressed() && + ((e.getModifiers() & InputEvent.BUTTON1_MASK) != 0)) + { + model.setArmed(true); + } + else + { + model.setArmed(false); + } + } + } + + public void mouseExited(MouseEvent e) + { + if (e.getSource() instanceof AbstractButton) + { + AbstractButton button = (AbstractButton) e.getSource(); + ButtonModel model = button.getModel(); + + if (button.isRolloverEnabled()) + { + model.setRollover(false); + } + + model.setArmed(false); + } + } + + public void mouseMoved(MouseEvent e) + { + } + + public void mousePressed(MouseEvent e) + { + if (e.getSource() instanceof AbstractButton) + { + AbstractButton button = (AbstractButton) e.getSource(); + ButtonModel model = button.getModel(); + + if ((e.getModifiers() & InputEvent.BUTTON1_MASK) != 0) + { + // It is important that these transitions happen in this order. + model.setArmed(true); + model.setPressed(true); + } + } + } + + public void mouseReleased(MouseEvent e) + { + + if (e.getSource() instanceof AbstractButton) + { + AbstractButton button = (AbstractButton) e.getSource(); + ButtonModel model = button.getModel(); + + if ((e.getModifiers() & InputEvent.BUTTON1_MASK) != 0) + { + // It is important that these transitions happen in this order. + model.setPressed(false); + model.setArmed(false); + } + } + } + } + + protected class MenuDragMouseHandler implements MenuDragMouseListener + { + public void menuDragMouseDragged(MenuDragMouseEvent e) + { + // TODO + } + + public void menuDragMouseEntered(MenuDragMouseEvent e) + { + // TODO + } + + public void menuDragMouseExited(MenuDragMouseEvent e) + { + // TODO + } + + public void menuDragMouseReleased(MenuDragMouseEvent e) + { + // TODO + } + } + + protected class MenuKeyHandler implements MenuKeyListener + { + public void menuKeyPressed(MenuKeyEvent e) + { + // TODO + } + + public void menuKeyReleased(MenuKeyEvent e) + { + // TODO + } + + public void menuKeyTyped(MenuKeyEvent e) + { + // TODO + } + } + + protected class PropertyChangeHandler + { + public void propertyChange(PropertyChangeEvent evt) + { + // TODO + } + } +} -- cgit v1.1