| /* |
| * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.java.swing.plaf.windows; |
| |
| import java.beans.PropertyChangeListener; |
| import java.beans.PropertyChangeEvent; |
| import javax.swing.plaf.basic.*; |
| import javax.swing.plaf.*; |
| import javax.swing.border.*; |
| import javax.swing.*; |
| import java.awt.event.*; |
| import java.awt.*; |
| |
| import static com.sun.java.swing.plaf.windows.TMSchema.Part; |
| import static com.sun.java.swing.plaf.windows.TMSchema.State; |
| import static com.sun.java.swing.plaf.windows.XPStyle.Skin; |
| |
| import sun.swing.DefaultLookup; |
| import sun.swing.StringUIClientPropertyKey; |
| |
| |
| /** |
| * Windows combo box. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is appropriate |
| * for short term storage or RMI between applications running the same |
| * version of Swing. A future release of Swing will provide support for |
| * long term persistence. |
| * |
| * @author Tom Santos |
| * @author Igor Kushnirskiy |
| */ |
| |
| public class WindowsComboBoxUI extends BasicComboBoxUI { |
| |
| private static final MouseListener rolloverListener = |
| new MouseAdapter() { |
| private void handleRollover(MouseEvent e, boolean isRollover) { |
| JComboBox comboBox = getComboBox(e); |
| WindowsComboBoxUI comboBoxUI = getWindowsComboBoxUI(e); |
| if (comboBox == null || comboBoxUI == null) { |
| return; |
| } |
| if (! comboBox.isEditable()) { |
| //mouse over editable ComboBox does not switch rollover |
| //for the arrow button |
| ButtonModel m = null; |
| if (comboBoxUI.arrowButton != null) { |
| m = comboBoxUI.arrowButton.getModel(); |
| } |
| if (m != null ) { |
| m.setRollover(isRollover); |
| } |
| } |
| comboBoxUI.isRollover = isRollover; |
| comboBox.repaint(); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| handleRollover(e, true); |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| handleRollover(e, false); |
| } |
| |
| private JComboBox getComboBox(MouseEvent event) { |
| Object source = event.getSource(); |
| JComboBox rv = null; |
| if (source instanceof JComboBox) { |
| rv = (JComboBox) source; |
| } else if (source instanceof XPComboBoxButton) { |
| rv = ((XPComboBoxButton) source) |
| .getWindowsComboBoxUI().comboBox; |
| } |
| return rv; |
| } |
| |
| private WindowsComboBoxUI getWindowsComboBoxUI(MouseEvent event) { |
| JComboBox comboBox = getComboBox(event); |
| WindowsComboBoxUI rv = null; |
| if (comboBox != null |
| && comboBox.getUI() instanceof WindowsComboBoxUI) { |
| rv = (WindowsComboBoxUI) comboBox.getUI(); |
| } |
| return rv; |
| } |
| |
| }; |
| private boolean isRollover = false; |
| |
| private static final PropertyChangeListener componentOrientationListener = |
| new PropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent e) { |
| String propertyName = e.getPropertyName(); |
| Object source = null; |
| if ("componentOrientation" == propertyName |
| && (source = e.getSource()) instanceof JComboBox |
| && ((JComboBox) source).getUI() instanceof |
| WindowsComboBoxUI) { |
| JComboBox comboBox = (JComboBox) source; |
| WindowsComboBoxUI comboBoxUI = (WindowsComboBoxUI) comboBox.getUI(); |
| if (comboBoxUI.arrowButton instanceof XPComboBoxButton) { |
| ((XPComboBoxButton) comboBoxUI.arrowButton).setPart( |
| (comboBox.getComponentOrientation() == |
| ComponentOrientation.RIGHT_TO_LEFT) |
| ? Part.CP_DROPDOWNBUTTONLEFT |
| : Part.CP_DROPDOWNBUTTONRIGHT); |
| } |
| } |
| } |
| }; |
| |
| public static ComponentUI createUI(JComponent c) { |
| return new WindowsComboBoxUI(); |
| } |
| |
| public void installUI( JComponent c ) { |
| super.installUI( c ); |
| isRollover = false; |
| comboBox.setRequestFocusEnabled( true ); |
| if (XPStyle.getXP() != null && arrowButton != null) { |
| //we can not do it in installListeners because arrowButton |
| //is initialized after installListeners is invoked |
| comboBox.addMouseListener(rolloverListener); |
| arrowButton.addMouseListener(rolloverListener); |
| } |
| } |
| |
| public void uninstallUI(JComponent c ) { |
| comboBox.removeMouseListener(rolloverListener); |
| if(arrowButton != null) { |
| arrowButton.removeMouseListener(rolloverListener); |
| } |
| super.uninstallUI( c ); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| @Override |
| protected void installListeners() { |
| super.installListeners(); |
| XPStyle xp = XPStyle.getXP(); |
| //button glyph for LTR and RTL combobox might differ |
| if (xp != null |
| && xp.isSkinDefined(comboBox, Part.CP_DROPDOWNBUTTONRIGHT)) { |
| comboBox.addPropertyChangeListener("componentOrientation", |
| componentOrientationListener); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| @Override |
| protected void uninstallListeners() { |
| super.uninstallListeners(); |
| comboBox.removePropertyChangeListener("componentOrientation", |
| componentOrientationListener); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| protected void configureEditor() { |
| super.configureEditor(); |
| if (XPStyle.getXP() != null) { |
| editor.addMouseListener(rolloverListener); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| protected void unconfigureEditor() { |
| super.unconfigureEditor(); |
| editor.removeMouseListener(rolloverListener); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| public void paint(Graphics g, JComponent c) { |
| if (XPStyle.getXP() != null) { |
| paintXPComboBoxBackground(g, c); |
| } |
| super.paint(g, c); |
| } |
| |
| State getXPComboBoxState(JComponent c) { |
| State state = State.NORMAL; |
| if (!c.isEnabled()) { |
| state = State.DISABLED; |
| } else if (isPopupVisible(comboBox)) { |
| state = State.PRESSED; |
| } else if (isRollover) { |
| state = State.HOT; |
| } |
| return state; |
| } |
| |
| private void paintXPComboBoxBackground(Graphics g, JComponent c) { |
| XPStyle xp = XPStyle.getXP(); |
| if (xp == null) { |
| return; |
| } |
| State state = getXPComboBoxState(c); |
| Skin skin = null; |
| if (! comboBox.isEditable() |
| && xp.isSkinDefined(c, Part.CP_READONLY)) { |
| skin = xp.getSkin(c, Part.CP_READONLY); |
| } |
| if (skin == null) { |
| skin = xp.getSkin(c, Part.CP_COMBOBOX); |
| } |
| skin.paintSkin(g, 0, 0, c.getWidth(), c.getHeight(), state); |
| } |
| |
| /** |
| * If necessary paints the currently selected item. |
| * |
| * @param g Graphics to paint to |
| * @param bounds Region to paint current value to |
| * @param hasFocus whether or not the JComboBox has focus |
| * @throws NullPointerException if any of the arguments are null. |
| * @since 1.5 |
| */ |
| public void paintCurrentValue(Graphics g, Rectangle bounds, |
| boolean hasFocus) { |
| XPStyle xp = XPStyle.getXP(); |
| if ( xp != null) { |
| bounds.x += 2; |
| bounds.y += 2; |
| bounds.width -= 4; |
| bounds.height -= 4; |
| } else { |
| bounds.x += 1; |
| bounds.y += 1; |
| bounds.width -= 2; |
| bounds.height -= 2; |
| } |
| if (! comboBox.isEditable() |
| && xp != null |
| && xp.isSkinDefined(comboBox, Part.CP_READONLY)) { |
| // On vista for READNLY ComboBox |
| // color for currentValue is the same as for any other item |
| |
| // mostly copied from javax.swing.plaf.basic.BasicComboBoxUI.paintCurrentValue |
| ListCellRenderer renderer = comboBox.getRenderer(); |
| Component c; |
| if ( hasFocus && !isPopupVisible(comboBox) ) { |
| c = renderer.getListCellRendererComponent( |
| listBox, |
| comboBox.getSelectedItem(), |
| -1, |
| true, |
| false ); |
| } else { |
| c = renderer.getListCellRendererComponent( |
| listBox, |
| comboBox.getSelectedItem(), |
| -1, |
| false, |
| false ); |
| } |
| c.setFont(comboBox.getFont()); |
| if ( comboBox.isEnabled() ) { |
| c.setForeground(comboBox.getForeground()); |
| c.setBackground(comboBox.getBackground()); |
| } else { |
| c.setForeground(DefaultLookup.getColor( |
| comboBox, this, "ComboBox.disabledForeground", null)); |
| c.setBackground(DefaultLookup.getColor( |
| comboBox, this, "ComboBox.disabledBackground", null)); |
| } |
| boolean shouldValidate = false; |
| if (c instanceof JPanel) { |
| shouldValidate = true; |
| } |
| currentValuePane.paintComponent(g, c, comboBox, bounds.x, bounds.y, |
| bounds.width, bounds.height, shouldValidate); |
| |
| } else { |
| super.paintCurrentValue(g, bounds, hasFocus); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| public void paintCurrentValueBackground(Graphics g, Rectangle bounds, |
| boolean hasFocus) { |
| if (XPStyle.getXP() == null) { |
| super.paintCurrentValueBackground(g, bounds, hasFocus); |
| } |
| } |
| |
| public Dimension getMinimumSize( JComponent c ) { |
| Dimension d = super.getMinimumSize(c); |
| if (XPStyle.getXP() != null) { |
| d.width += 5; |
| } else { |
| d.width += 4; |
| } |
| d.height += 2; |
| return d; |
| } |
| |
| /** |
| * Creates a layout manager for managing the components which make up the |
| * combo box. |
| * |
| * @return an instance of a layout manager |
| */ |
| protected LayoutManager createLayoutManager() { |
| return new BasicComboBoxUI.ComboBoxLayoutManager() { |
| public void layoutContainer(Container parent) { |
| super.layoutContainer(parent); |
| |
| if (XPStyle.getXP() != null && arrowButton != null) { |
| Dimension d = parent.getSize(); |
| Insets insets = getInsets(); |
| int buttonWidth = arrowButton.getPreferredSize().width; |
| arrowButton.setBounds(WindowsGraphicsUtils.isLeftToRight((JComboBox)parent) |
| ? (d.width - insets.right - buttonWidth) |
| : insets.left, |
| insets.top, |
| buttonWidth, d.height - insets.top - insets.bottom); |
| } |
| } |
| }; |
| } |
| |
| protected void installKeyboardActions() { |
| super.installKeyboardActions(); |
| } |
| |
| protected ComboPopup createPopup() { |
| return super.createPopup(); |
| } |
| |
| /** |
| * Creates the default editor that will be used in editable combo boxes. |
| * A default editor will be used only if an editor has not been |
| * explicitly set with <code>setEditor</code>. |
| * |
| * @return a <code>ComboBoxEditor</code> used for the combo box |
| * @see javax.swing.JComboBox#setEditor |
| */ |
| protected ComboBoxEditor createEditor() { |
| return new WindowsComboBoxEditor(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| @Override |
| protected ListCellRenderer createRenderer() { |
| XPStyle xp = XPStyle.getXP(); |
| if (xp != null && xp.isSkinDefined(comboBox, Part.CP_READONLY)) { |
| return new WindowsComboBoxRenderer(); |
| } else { |
| return super.createRenderer(); |
| } |
| } |
| |
| /** |
| * Creates an button which will be used as the control to show or hide |
| * the popup portion of the combo box. |
| * |
| * @return a button which represents the popup control |
| */ |
| protected JButton createArrowButton() { |
| XPStyle xp = XPStyle.getXP(); |
| if (xp != null) { |
| return new XPComboBoxButton(xp); |
| } else { |
| return super.createArrowButton(); |
| } |
| } |
| |
| private class XPComboBoxButton extends XPStyle.GlyphButton { |
| public XPComboBoxButton(XPStyle xp) { |
| super(null, |
| (! xp.isSkinDefined(comboBox, Part.CP_DROPDOWNBUTTONRIGHT)) |
| ? Part.CP_DROPDOWNBUTTON |
| : (comboBox.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT) |
| ? Part.CP_DROPDOWNBUTTONLEFT |
| : Part.CP_DROPDOWNBUTTONRIGHT |
| ); |
| setRequestFocusEnabled(false); |
| } |
| |
| @Override |
| protected State getState() { |
| State rv; |
| rv = super.getState(); |
| XPStyle xp = XPStyle.getXP(); |
| if (rv != State.DISABLED |
| && comboBox != null && ! comboBox.isEditable() |
| && xp != null && xp.isSkinDefined(comboBox, |
| Part.CP_DROPDOWNBUTTONRIGHT)) { |
| /* |
| * for non editable ComboBoxes Vista seems to have the |
| * same glyph for all non DISABLED states |
| */ |
| rv = State.NORMAL; |
| } |
| return rv; |
| } |
| |
| public Dimension getPreferredSize() { |
| return new Dimension(17, 21); |
| } |
| |
| void setPart(Part part) { |
| setPart(comboBox, part); |
| } |
| |
| WindowsComboBoxUI getWindowsComboBoxUI() { |
| return WindowsComboBoxUI.this; |
| } |
| } |
| |
| |
| /** |
| * Subclassed to add Windows specific Key Bindings. |
| * This class is now obsolete and doesn't do anything. |
| * Only included for backwards API compatibility. |
| * Do not call or override. |
| * |
| * @deprecated As of Java 2 platform v1.4. |
| */ |
| @Deprecated |
| protected class WindowsComboPopup extends BasicComboPopup { |
| |
| public WindowsComboPopup( JComboBox cBox ) { |
| super( cBox ); |
| } |
| |
| protected KeyListener createKeyListener() { |
| return new InvocationKeyHandler(); |
| } |
| |
| protected class InvocationKeyHandler extends BasicComboPopup.InvocationKeyHandler { |
| protected InvocationKeyHandler() { |
| WindowsComboPopup.this.super(); |
| } |
| } |
| } |
| |
| |
| /** |
| * Subclassed to highlight selected item in an editable combo box. |
| */ |
| public static class WindowsComboBoxEditor |
| extends BasicComboBoxEditor.UIResource { |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.6 |
| */ |
| protected JTextField createEditorComponent() { |
| JTextField editor = super.createEditorComponent(); |
| Border border = (Border)UIManager.get("ComboBox.editorBorder"); |
| if (border != null) { |
| editor.setBorder(border); |
| } |
| editor.setOpaque(false); |
| return editor; |
| } |
| |
| public void setItem(Object item) { |
| super.setItem(item); |
| Object focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); |
| if ((focus == editor) || (focus == editor.getParent())) { |
| editor.selectAll(); |
| } |
| } |
| } |
| |
| /** |
| * Subclassed to set opacity {@code false} on the renderer |
| * and to show border for focused cells. |
| */ |
| private static class WindowsComboBoxRenderer |
| extends BasicComboBoxRenderer.UIResource { |
| private static final Object BORDER_KEY |
| = new StringUIClientPropertyKey("BORDER_KEY"); |
| private static final Border NULL_BORDER = new EmptyBorder(0, 0, 0, 0); |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public Component getListCellRendererComponent( |
| JList list, |
| Object value, |
| int index, |
| boolean isSelected, |
| boolean cellHasFocus) { |
| Component rv = |
| super.getListCellRendererComponent(list, value, index, |
| isSelected, cellHasFocus); |
| if (rv instanceof JComponent) { |
| JComponent component = (JComponent) rv; |
| if (index == -1 && isSelected) { |
| Border border = component.getBorder(); |
| Border dashedBorder = |
| new WindowsBorders.DashedBorder(list.getForeground()); |
| component.setBorder(dashedBorder); |
| //store current border in client property if needed |
| if (component.getClientProperty(BORDER_KEY) == null) { |
| component.putClientProperty(BORDER_KEY, |
| (border == null) ? NULL_BORDER : border); |
| } |
| } else { |
| if (component.getBorder() instanceof |
| WindowsBorders.DashedBorder) { |
| Object storedBorder = component.getClientProperty(BORDER_KEY); |
| if (storedBorder instanceof Border) { |
| component.setBorder( |
| (storedBorder == NULL_BORDER) ? null |
| : (Border) storedBorder); |
| } |
| component.putClientProperty(BORDER_KEY, null); |
| } |
| } |
| if (index == -1) { |
| component.setOpaque(false); |
| component.setForeground(list.getForeground()); |
| } else { |
| component.setOpaque(true); |
| } |
| } |
| return rv; |
| } |
| |
| } |
| } |
