mirror of git://gcc.gnu.org/git/gcc.git
1411 lines
40 KiB
Java
1411 lines
40 KiB
Java
/* BasicComboBoxUI.java --
|
|
Copyright (C) 2004, 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.basic;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Dimension;
|
|
import java.awt.Font;
|
|
import java.awt.Graphics;
|
|
import java.awt.Insets;
|
|
import java.awt.LayoutManager;
|
|
import java.awt.Rectangle;
|
|
import java.awt.event.FocusEvent;
|
|
import java.awt.event.FocusListener;
|
|
import java.awt.event.ItemEvent;
|
|
import java.awt.event.ItemListener;
|
|
import java.awt.event.KeyAdapter;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.KeyListener;
|
|
import java.awt.event.MouseListener;
|
|
import java.awt.event.MouseMotionListener;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
|
|
import javax.accessibility.Accessible;
|
|
import javax.accessibility.AccessibleContext;
|
|
import javax.swing.CellRendererPane;
|
|
import javax.swing.ComboBoxEditor;
|
|
import javax.swing.ComboBoxModel;
|
|
import javax.swing.DefaultListCellRenderer;
|
|
import javax.swing.InputMap;
|
|
import javax.swing.JButton;
|
|
import javax.swing.JComboBox;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JList;
|
|
import javax.swing.ListCellRenderer;
|
|
import javax.swing.LookAndFeel;
|
|
import javax.swing.SwingUtilities;
|
|
import javax.swing.UIManager;
|
|
import javax.swing.event.ListDataEvent;
|
|
import javax.swing.event.ListDataListener;
|
|
import javax.swing.plaf.ComboBoxUI;
|
|
import javax.swing.plaf.ComponentUI;
|
|
import javax.swing.plaf.UIResource;
|
|
|
|
/**
|
|
* A UI delegate for the {@link JComboBox} component.
|
|
*
|
|
* @author Olga Rodimina
|
|
* @author Robert Schuster
|
|
*/
|
|
public class BasicComboBoxUI extends ComboBoxUI
|
|
{
|
|
/**
|
|
* The arrow button that is displayed in the right side of JComboBox. This
|
|
* button is used to hide and show combo box's list of items.
|
|
*/
|
|
protected JButton arrowButton;
|
|
|
|
/**
|
|
* The combo box represented by this UI delegate.
|
|
*/
|
|
protected JComboBox comboBox;
|
|
|
|
/**
|
|
* The component that is responsible for displaying/editing the selected
|
|
* item of the combo box.
|
|
*
|
|
* @see BasicComboBoxEditor#getEditorComponent()
|
|
*/
|
|
protected Component editor;
|
|
|
|
/**
|
|
* A listener listening to focus events occurring in the {@link JComboBox}.
|
|
*/
|
|
protected FocusListener focusListener;
|
|
|
|
/**
|
|
* A flag indicating whether JComboBox currently has the focus.
|
|
*/
|
|
protected boolean hasFocus;
|
|
|
|
/**
|
|
* A listener listening to item events fired by the {@link JComboBox}.
|
|
*/
|
|
protected ItemListener itemListener;
|
|
|
|
/**
|
|
* A listener listening to key events that occur while {@link JComboBox} has
|
|
* the focus.
|
|
*/
|
|
protected KeyListener keyListener;
|
|
|
|
/**
|
|
* List used when rendering selected item of the combo box. The selection
|
|
* and foreground colors for combo box renderer are configured from this
|
|
* list.
|
|
*/
|
|
protected JList listBox;
|
|
|
|
/**
|
|
* ListDataListener listening to JComboBox model
|
|
*/
|
|
protected ListDataListener listDataListener;
|
|
|
|
/**
|
|
* Popup list containing the combo box's menu items.
|
|
*/
|
|
protected ComboPopup popup;
|
|
|
|
protected KeyListener popupKeyListener;
|
|
|
|
protected MouseListener popupMouseListener;
|
|
|
|
protected MouseMotionListener popupMouseMotionListener;
|
|
|
|
/**
|
|
* Listener listening to changes in the bound properties of JComboBox
|
|
*/
|
|
protected PropertyChangeListener propertyChangeListener;
|
|
|
|
/* Size of the largest item in the comboBox
|
|
* This is package-private to avoid an accessor method.
|
|
*/
|
|
Dimension displaySize = new Dimension();
|
|
|
|
/**
|
|
* Used to render the combo box values.
|
|
*/
|
|
protected CellRendererPane currentValuePane;
|
|
|
|
/**
|
|
* The current minimum size if isMinimumSizeDirty is false.
|
|
* Setup by getMinimumSize() and invalidated by the various listeners.
|
|
*/
|
|
protected Dimension cachedMinimumSize;
|
|
|
|
/**
|
|
* Indicates whether or not the cachedMinimumSize field is valid or not.
|
|
*/
|
|
protected boolean isMinimumSizeDirty = true;
|
|
|
|
/**
|
|
* Creates a new <code>BasicComboBoxUI</code> object.
|
|
*/
|
|
public BasicComboBoxUI()
|
|
{
|
|
currentValuePane = new CellRendererPane();
|
|
cachedMinimumSize = new Dimension();
|
|
}
|
|
|
|
/**
|
|
* A factory method to create a UI delegate for the given
|
|
* {@link JComponent}, which should be a {@link JComboBox}.
|
|
*
|
|
* @param c The {@link JComponent} a UI is being created for.
|
|
*
|
|
* @return A UI delegate for the {@link JComponent}.
|
|
*/
|
|
public static ComponentUI createUI(JComponent c)
|
|
{
|
|
return new BasicComboBoxUI();
|
|
}
|
|
|
|
/**
|
|
* Installs the UI for the given {@link JComponent}.
|
|
*
|
|
* @param c the JComponent to install a UI for.
|
|
*
|
|
* @see #uninstallUI(JComponent)
|
|
*/
|
|
public void installUI(JComponent c)
|
|
{
|
|
super.installUI(c);
|
|
|
|
if (c instanceof JComboBox)
|
|
{
|
|
isMinimumSizeDirty = true;
|
|
comboBox = (JComboBox) c;
|
|
installDefaults();
|
|
popup = createPopup();
|
|
listBox = popup.getList();
|
|
|
|
// Set editor and renderer for the combo box. Editor is used
|
|
// only if combo box becomes editable, otherwise renderer is used
|
|
// to paint the selected item; combobox is not editable by default.
|
|
ListCellRenderer renderer = comboBox.getRenderer();
|
|
if (renderer == null || renderer instanceof UIResource)
|
|
comboBox.setRenderer(createRenderer());
|
|
|
|
ComboBoxEditor currentEditor = comboBox.getEditor();
|
|
if (currentEditor == null || currentEditor instanceof UIResource)
|
|
{
|
|
currentEditor = createEditor();
|
|
comboBox.setEditor(currentEditor);
|
|
}
|
|
|
|
installComponents();
|
|
installListeners();
|
|
comboBox.setLayout(createLayoutManager());
|
|
comboBox.setFocusable(true);
|
|
installKeyboardActions();
|
|
comboBox.putClientProperty(BasicLookAndFeel.DONT_CANCEL_POPUP,
|
|
Boolean.TRUE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uninstalls the UI for the given {@link JComponent}.
|
|
*
|
|
* @param c The JComponent that is having this UI removed.
|
|
*
|
|
* @see #installUI(JComponent)
|
|
*/
|
|
public void uninstallUI(JComponent c)
|
|
{
|
|
setPopupVisible(comboBox, false);
|
|
popup.uninstallingUI();
|
|
uninstallKeyboardActions();
|
|
comboBox.setLayout(null);
|
|
uninstallComponents();
|
|
uninstallListeners();
|
|
uninstallDefaults();
|
|
comboBox = null;
|
|
}
|
|
|
|
/**
|
|
* Installs the defaults that are defined in the {@link BasicLookAndFeel}
|
|
* for this {@link JComboBox}.
|
|
*
|
|
* @see #uninstallDefaults()
|
|
*/
|
|
protected void installDefaults()
|
|
{
|
|
LookAndFeel.installColorsAndFont(comboBox, "ComboBox.background",
|
|
"ComboBox.foreground", "ComboBox.font");
|
|
LookAndFeel.installBorder(comboBox, "ComboBox.border");
|
|
}
|
|
|
|
/**
|
|
* Creates and installs the listeners for this UI.
|
|
*
|
|
* @see #uninstallListeners()
|
|
*/
|
|
protected void installListeners()
|
|
{
|
|
// install combo box's listeners
|
|
propertyChangeListener = createPropertyChangeListener();
|
|
comboBox.addPropertyChangeListener(propertyChangeListener);
|
|
|
|
focusListener = createFocusListener();
|
|
comboBox.addFocusListener(focusListener);
|
|
|
|
itemListener = createItemListener();
|
|
comboBox.addItemListener(itemListener);
|
|
|
|
keyListener = createKeyListener();
|
|
comboBox.addKeyListener(keyListener);
|
|
|
|
// install listeners that listen to combo box model
|
|
listDataListener = createListDataListener();
|
|
comboBox.getModel().addListDataListener(listDataListener);
|
|
|
|
// Install mouse and key listeners from the popup.
|
|
popupMouseListener = popup.getMouseListener();
|
|
comboBox.addMouseListener(popupMouseListener);
|
|
|
|
popupMouseMotionListener = popup.getMouseMotionListener();
|
|
comboBox.addMouseMotionListener(popupMouseMotionListener);
|
|
|
|
popupKeyListener = popup.getKeyListener();
|
|
comboBox.addKeyListener(popupKeyListener);
|
|
}
|
|
|
|
/**
|
|
* Uninstalls the defaults and sets any objects created during
|
|
* install to <code>null</code>.
|
|
*
|
|
* @see #installDefaults()
|
|
*/
|
|
protected void uninstallDefaults()
|
|
{
|
|
if (comboBox.getFont() instanceof UIResource)
|
|
comboBox.setFont(null);
|
|
|
|
if (comboBox.getForeground() instanceof UIResource)
|
|
comboBox.setForeground(null);
|
|
|
|
if (comboBox.getBackground() instanceof UIResource)
|
|
comboBox.setBackground(null);
|
|
|
|
LookAndFeel.uninstallBorder(comboBox);
|
|
}
|
|
|
|
/**
|
|
* Detaches all the listeners we attached in {@link #installListeners}.
|
|
*
|
|
* @see #installListeners()
|
|
*/
|
|
protected void uninstallListeners()
|
|
{
|
|
comboBox.removePropertyChangeListener(propertyChangeListener);
|
|
propertyChangeListener = null;
|
|
|
|
comboBox.removeFocusListener(focusListener);
|
|
listBox.removeFocusListener(focusListener);
|
|
focusListener = null;
|
|
|
|
comboBox.removeItemListener(itemListener);
|
|
itemListener = null;
|
|
|
|
comboBox.removeKeyListener(keyListener);
|
|
keyListener = null;
|
|
|
|
comboBox.getModel().removeListDataListener(listDataListener);
|
|
listDataListener = null;
|
|
|
|
if (popupMouseListener != null)
|
|
comboBox.removeMouseListener(popupMouseListener);
|
|
popupMouseListener = null;
|
|
|
|
if (popupMouseMotionListener != null)
|
|
comboBox.removeMouseMotionListener(popupMouseMotionListener);
|
|
popupMouseMotionListener = null;
|
|
|
|
if (popupKeyListener != null)
|
|
comboBox.removeKeyListener(popupKeyListener);
|
|
popupKeyListener = null;
|
|
}
|
|
|
|
/**
|
|
* Creates the popup that will contain list of combo box's items.
|
|
*
|
|
* @return popup containing list of combo box's items
|
|
*/
|
|
protected ComboPopup createPopup()
|
|
{
|
|
return new BasicComboPopup(comboBox);
|
|
}
|
|
|
|
/**
|
|
* Creates a {@link KeyListener} to listen to key events.
|
|
*
|
|
* @return KeyListener that listens to key events.
|
|
*/
|
|
protected KeyListener createKeyListener()
|
|
{
|
|
return new KeyHandler();
|
|
}
|
|
|
|
/**
|
|
* Creates the {@link FocusListener} that will listen to changes in this
|
|
* JComboBox's focus.
|
|
*
|
|
* @return the FocusListener.
|
|
*/
|
|
protected FocusListener createFocusListener()
|
|
{
|
|
return new FocusHandler();
|
|
}
|
|
|
|
/**
|
|
* Creates a {@link ListDataListener} to listen to the combo box's data model.
|
|
*
|
|
* @return The new listener.
|
|
*/
|
|
protected ListDataListener createListDataListener()
|
|
{
|
|
return new ListDataHandler();
|
|
}
|
|
|
|
/**
|
|
* Creates an {@link ItemListener} that will listen to the changes in
|
|
* the JComboBox's selection.
|
|
*
|
|
* @return The ItemListener
|
|
*/
|
|
protected ItemListener createItemListener()
|
|
{
|
|
return new ItemHandler();
|
|
}
|
|
|
|
/**
|
|
* Creates a {@link PropertyChangeListener} to listen to the changes in
|
|
* the JComboBox's bound properties.
|
|
*
|
|
* @return The PropertyChangeListener
|
|
*/
|
|
protected PropertyChangeListener createPropertyChangeListener()
|
|
{
|
|
return new PropertyChangeHandler();
|
|
}
|
|
|
|
/**
|
|
* Creates and returns a layout manager for the combo box. Subclasses can
|
|
* override this method to provide a different layout.
|
|
*
|
|
* @return a layout manager for the combo box.
|
|
*/
|
|
protected LayoutManager createLayoutManager()
|
|
{
|
|
return new ComboBoxLayoutManager();
|
|
}
|
|
|
|
/**
|
|
* Creates a component that will be responsible for rendering the
|
|
* selected component in the combo box.
|
|
*
|
|
* @return A renderer for the combo box.
|
|
*/
|
|
protected ListCellRenderer createRenderer()
|
|
{
|
|
return new BasicComboBoxRenderer.UIResource();
|
|
}
|
|
|
|
/**
|
|
* Creates the component that will be responsible for displaying/editing
|
|
* the selected item in the combo box. This editor is used only when combo
|
|
* box is editable.
|
|
*
|
|
* @return A new component that will be responsible for displaying/editing
|
|
* the selected item in the combo box.
|
|
*/
|
|
protected ComboBoxEditor createEditor()
|
|
{
|
|
return new BasicComboBoxEditor.UIResource();
|
|
}
|
|
|
|
/**
|
|
* Installs the components for this JComboBox. ArrowButton, main
|
|
* part of combo box (upper part) and popup list of items are created and
|
|
* configured here.
|
|
*/
|
|
protected void installComponents()
|
|
{
|
|
// create and install arrow button
|
|
arrowButton = createArrowButton();
|
|
comboBox.add(arrowButton);
|
|
if (arrowButton != null)
|
|
configureArrowButton();
|
|
|
|
if (comboBox.isEditable())
|
|
addEditor();
|
|
|
|
comboBox.add(currentValuePane);
|
|
}
|
|
|
|
/**
|
|
* Uninstalls components from this {@link JComboBox}.
|
|
*
|
|
* @see #installComponents()
|
|
*/
|
|
protected void uninstallComponents()
|
|
{
|
|
// Unconfigure arrow button.
|
|
if (arrowButton != null)
|
|
{
|
|
unconfigureArrowButton();
|
|
}
|
|
|
|
// Unconfigure editor.
|
|
if (editor != null)
|
|
{
|
|
unconfigureEditor();
|
|
}
|
|
|
|
comboBox.removeAll();
|
|
arrowButton = null;
|
|
}
|
|
|
|
/**
|
|
* Adds the current editor to the combo box.
|
|
*/
|
|
public void addEditor()
|
|
{
|
|
removeEditor();
|
|
editor = comboBox.getEditor().getEditorComponent();
|
|
if (editor != null)
|
|
{
|
|
configureEditor();
|
|
comboBox.add(editor);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the current editor from the combo box.
|
|
*/
|
|
public void removeEditor()
|
|
{
|
|
if (editor != null)
|
|
{
|
|
unconfigureEditor();
|
|
comboBox.remove(editor);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Configures the editor for this combo box.
|
|
*/
|
|
protected void configureEditor()
|
|
{
|
|
editor.setFont(comboBox.getFont());
|
|
if (popupKeyListener != null)
|
|
editor.addKeyListener(popupKeyListener);
|
|
if (keyListener != null)
|
|
editor.addKeyListener(keyListener);
|
|
comboBox.configureEditor(comboBox.getEditor(),
|
|
comboBox.getSelectedItem());
|
|
}
|
|
|
|
/**
|
|
* Unconfigures the editor for this combo box.
|
|
*/
|
|
protected void unconfigureEditor()
|
|
{
|
|
if (popupKeyListener != null)
|
|
editor.removeKeyListener(popupKeyListener);
|
|
if (keyListener != null)
|
|
editor.removeKeyListener(keyListener);
|
|
}
|
|
|
|
/**
|
|
* Configures the arrow button.
|
|
*
|
|
* @see #configureArrowButton()
|
|
*/
|
|
public void configureArrowButton()
|
|
{
|
|
if (arrowButton != null)
|
|
{
|
|
arrowButton.setEnabled(comboBox.isEnabled());
|
|
arrowButton.setFocusable(false);
|
|
arrowButton.addMouseListener(popup.getMouseListener());
|
|
arrowButton.addMouseMotionListener(popup.getMouseMotionListener());
|
|
|
|
// Mark the button as not closing the popup, we handle this ourselves.
|
|
arrowButton.putClientProperty(BasicLookAndFeel.DONT_CANCEL_POPUP,
|
|
Boolean.TRUE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unconfigures the arrow button.
|
|
*
|
|
* @see #configureArrowButton()
|
|
*
|
|
* @specnote The specification says this method is implementation specific
|
|
* and should not be used or overridden.
|
|
*/
|
|
public void unconfigureArrowButton()
|
|
{
|
|
if (arrowButton != null)
|
|
{
|
|
if (popupMouseListener != null)
|
|
arrowButton.removeMouseListener(popupMouseListener);
|
|
if (popupMouseMotionListener != null)
|
|
arrowButton.removeMouseMotionListener(popupMouseMotionListener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an arrow button for this {@link JComboBox}. The arrow button is
|
|
* displayed at the right end of the combo box and is used to display/hide
|
|
* the drop down list of items.
|
|
*
|
|
* @return A new button.
|
|
*/
|
|
protected JButton createArrowButton()
|
|
{
|
|
return new BasicArrowButton(BasicArrowButton.SOUTH);
|
|
}
|
|
|
|
/**
|
|
* Returns <code>true</code> if the popup is visible, and <code>false</code>
|
|
* otherwise.
|
|
*
|
|
* @param c The JComboBox to check
|
|
*
|
|
* @return <code>true</code> if popup part of the JComboBox is visible and
|
|
* <code>false</code> otherwise.
|
|
*/
|
|
public boolean isPopupVisible(JComboBox c)
|
|
{
|
|
return popup.isVisible();
|
|
}
|
|
|
|
/**
|
|
* Displays/hides the {@link JComboBox}'s list of items on the screen.
|
|
*
|
|
* @param c The combo box, for which list of items should be
|
|
* displayed/hidden
|
|
* @param v true if show popup part of the jcomboBox and false to hide.
|
|
*/
|
|
public void setPopupVisible(JComboBox c, boolean v)
|
|
{
|
|
if (v)
|
|
popup.show();
|
|
else
|
|
popup.hide();
|
|
}
|
|
|
|
/**
|
|
* JComboBox is focus traversable if it is editable and not otherwise.
|
|
*
|
|
* @param c combo box for which to check whether it is focus traversable
|
|
*
|
|
* @return true if focus tranversable and false otherwise
|
|
*/
|
|
public boolean isFocusTraversable(JComboBox c)
|
|
{
|
|
if (!comboBox.isEditable())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Paints given menu item using specified graphics context
|
|
*
|
|
* @param g The graphics context used to paint this combo box
|
|
* @param c comboBox which needs to be painted.
|
|
*/
|
|
public void paint(Graphics g, JComponent c)
|
|
{
|
|
hasFocus = comboBox.hasFocus();
|
|
if (! comboBox.isEditable())
|
|
{
|
|
Rectangle rect = rectangleForCurrentValue();
|
|
paintCurrentValueBackground(g, rect, hasFocus);
|
|
paintCurrentValue(g, rect, hasFocus);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns preferred size for the combo box.
|
|
*
|
|
* @param c comboBox for which to get preferred size
|
|
*
|
|
* @return The preferred size for the given combo box
|
|
*/
|
|
public Dimension getPreferredSize(JComponent c)
|
|
{
|
|
return getMinimumSize(c);
|
|
}
|
|
|
|
/**
|
|
* Returns the minimum size for this {@link JComboBox} for this
|
|
* look and feel. Also makes sure cachedMinimimSize is setup correctly.
|
|
*
|
|
* @param c The {@link JComponent} to find the minimum size for.
|
|
*
|
|
* @return The dimensions of the minimum size.
|
|
*/
|
|
public Dimension getMinimumSize(JComponent c)
|
|
{
|
|
if (isMinimumSizeDirty)
|
|
{
|
|
Insets i = getInsets();
|
|
Dimension d = getDisplaySize();
|
|
d.width += i.left + i.right + d.height;
|
|
cachedMinimumSize = new Dimension(d.width, d.height + i.top + i.bottom);
|
|
isMinimumSizeDirty = false;
|
|
}
|
|
return new Dimension(cachedMinimumSize);
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum size for this {@link JComboBox} for this
|
|
* look and feel.
|
|
*
|
|
* @param c The {@link JComponent} to find the maximum size for
|
|
*
|
|
* @return The maximum size (<code>Dimension(32767, 32767)</code>).
|
|
*/
|
|
public Dimension getMaximumSize(JComponent c)
|
|
{
|
|
return new Dimension(32767, 32767);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of accessible children of the combobox.
|
|
*
|
|
* @param c the component (combobox) to check, ignored
|
|
*
|
|
* @return the number of accessible children of the combobox
|
|
*/
|
|
public int getAccessibleChildrenCount(JComponent c)
|
|
{
|
|
int count = 1;
|
|
if (comboBox.isEditable())
|
|
count = 2;
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Returns the accessible child with the specified index.
|
|
*
|
|
* @param c the component, this is ignored
|
|
* @param i the index of the accessible child to return
|
|
*/
|
|
public Accessible getAccessibleChild(JComponent c, int i)
|
|
{
|
|
Accessible child = null;
|
|
switch (i)
|
|
{
|
|
case 0: // The popup.
|
|
if (popup instanceof Accessible)
|
|
{
|
|
AccessibleContext ctx = ((Accessible) popup).getAccessibleContext();
|
|
ctx.setAccessibleParent(comboBox);
|
|
child = (Accessible) popup;
|
|
}
|
|
break;
|
|
case 1: // The editor, if any.
|
|
if (comboBox.isEditable() && editor instanceof Accessible)
|
|
{
|
|
AccessibleContext ctx =
|
|
((Accessible) editor).getAccessibleContext();
|
|
ctx.setAccessibleParent(comboBox);
|
|
child = (Accessible) editor;
|
|
}
|
|
break;
|
|
}
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the specified key is a navigation key and false otherwise
|
|
*
|
|
* @param keyCode a key for which to check whether it is navigation key or
|
|
* not.
|
|
*
|
|
* @return true if the specified key is a navigation key and false otherwis
|
|
*/
|
|
protected boolean isNavigationKey(int keyCode)
|
|
{
|
|
return keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN
|
|
|| keyCode == KeyEvent.VK_LEFT || keyCode == KeyEvent.VK_RIGHT
|
|
|| keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_ESCAPE
|
|
|| keyCode == KeyEvent.VK_TAB;
|
|
}
|
|
|
|
/**
|
|
* Selects next possible item relative to the current selection
|
|
* to be next selected item in the combo box.
|
|
*/
|
|
protected void selectNextPossibleValue()
|
|
{
|
|
int index = comboBox.getSelectedIndex();
|
|
if (index != comboBox.getItemCount() - 1)
|
|
comboBox.setSelectedIndex(index + 1);
|
|
}
|
|
|
|
/**
|
|
* Selects previous item relative to current selection to be
|
|
* next selected item.
|
|
*/
|
|
protected void selectPreviousPossibleValue()
|
|
{
|
|
int index = comboBox.getSelectedIndex();
|
|
if (index > 0)
|
|
comboBox.setSelectedIndex(index - 1);
|
|
}
|
|
|
|
/**
|
|
* Displays combo box popup if the popup is not currently shown
|
|
* on the screen and hides it if it is currently shown
|
|
*/
|
|
protected void toggleOpenClose()
|
|
{
|
|
setPopupVisible(comboBox, ! isPopupVisible(comboBox));
|
|
}
|
|
|
|
/**
|
|
* Returns the bounds in which comboBox's selected item will be
|
|
* displayed.
|
|
*
|
|
* @return rectangle bounds in which comboBox's selected Item will be
|
|
* displayed
|
|
*/
|
|
protected Rectangle rectangleForCurrentValue()
|
|
{
|
|
int w = comboBox.getWidth();
|
|
int h = comboBox.getHeight();
|
|
Insets i = comboBox.getInsets();
|
|
int arrowSize = h - (i.top + i.bottom);
|
|
if (arrowButton != null)
|
|
arrowSize = arrowButton.getWidth();
|
|
return new Rectangle(i.left, i.top, w - (i.left + i.right + arrowSize),
|
|
h - (i.top + i.left));
|
|
}
|
|
|
|
/**
|
|
* Returns the insets of the current border.
|
|
*
|
|
* @return Insets representing space between combo box and its border
|
|
*/
|
|
protected Insets getInsets()
|
|
{
|
|
return comboBox.getInsets();
|
|
}
|
|
|
|
/**
|
|
* Paints currently selected value in the main part of the combo
|
|
* box (part without popup).
|
|
*
|
|
* @param g graphics context
|
|
* @param bounds Rectangle representing the size of the area in which
|
|
* selected item should be drawn
|
|
* @param hasFocus true if combo box has focus and false otherwise
|
|
*/
|
|
public void paintCurrentValue(Graphics g, Rectangle bounds, boolean hasFocus)
|
|
{
|
|
/* Gets the component to be drawn for the current value.
|
|
* If there is currently no selected item we will take an empty
|
|
* String as replacement.
|
|
*/
|
|
ListCellRenderer renderer = comboBox.getRenderer();
|
|
if (comboBox.getSelectedIndex() != -1)
|
|
{
|
|
Component comp;
|
|
if (hasFocus && ! isPopupVisible(comboBox))
|
|
{
|
|
comp = renderer.getListCellRendererComponent(listBox,
|
|
comboBox.getSelectedItem(), -1, true, false);
|
|
}
|
|
else
|
|
{
|
|
comp = renderer.getListCellRendererComponent(listBox,
|
|
comboBox.getSelectedItem(), -1, false, false);
|
|
Color bg = UIManager.getColor("ComboBox.disabledForeground");
|
|
comp.setBackground(bg);
|
|
}
|
|
comp.setFont(comboBox.getFont());
|
|
if (hasFocus && ! isPopupVisible(comboBox))
|
|
{
|
|
comp.setForeground(listBox.getSelectionForeground());
|
|
comp.setBackground(listBox.getSelectionBackground());
|
|
}
|
|
else if (comboBox.isEnabled())
|
|
{
|
|
comp.setForeground(comboBox.getForeground());
|
|
comp.setBackground(comboBox.getBackground());
|
|
}
|
|
else
|
|
{
|
|
Color fg = UIManager.getColor("ComboBox.disabledForeground");
|
|
comp.setForeground(fg);
|
|
Color bg = UIManager.getColor("ComboBox.disabledBackground");
|
|
comp.setBackground(bg);
|
|
}
|
|
currentValuePane.paintComponent(g, comp, comboBox, bounds.x, bounds.y,
|
|
bounds.width, bounds.height);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Paints the background of part of the combo box, where currently
|
|
* selected value is displayed. If the combo box has focus this method
|
|
* should also paint focus rectangle around the combo box.
|
|
*
|
|
* @param g graphics context
|
|
* @param bounds Rectangle representing the size of the largest item in the
|
|
* comboBox
|
|
* @param hasFocus true if combo box has fox and false otherwise
|
|
*/
|
|
public void paintCurrentValueBackground(Graphics g, Rectangle bounds,
|
|
boolean hasFocus)
|
|
{
|
|
Color saved = g.getColor();
|
|
if (comboBox.isEnabled())
|
|
g.setColor(UIManager.getColor("UIManager.background"));
|
|
else
|
|
g.setColor(UIManager.getColor("UIManager.disabledBackground"));
|
|
g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height);
|
|
g.setColor(saved);
|
|
}
|
|
|
|
private static final ListCellRenderer DEFAULT_RENDERER
|
|
= new DefaultListCellRenderer();
|
|
|
|
/**
|
|
* Returns the default size for the display area of a combo box that does
|
|
* not contain any elements. This method returns the width and height of
|
|
* a single space in the current font, plus a margin of 1 pixel.
|
|
*
|
|
* @return The default display size.
|
|
*
|
|
* @see #getDisplaySize()
|
|
*/
|
|
protected Dimension getDefaultSize()
|
|
{
|
|
Component comp = DEFAULT_RENDERER.getListCellRendererComponent(listBox,
|
|
" ", -1, false, false);
|
|
currentValuePane.add(comp);
|
|
comp.setFont(comboBox.getFont());
|
|
Dimension d = comp.getPreferredSize();
|
|
currentValuePane.remove(comp);
|
|
return d;
|
|
}
|
|
|
|
/**
|
|
* Returns the size of the display area for the combo box. This size will be
|
|
* the size of the combo box, not including the arrowButton.
|
|
*
|
|
* @return The size of the display area for the combo box.
|
|
*/
|
|
protected Dimension getDisplaySize()
|
|
{
|
|
Dimension dim = new Dimension();
|
|
ListCellRenderer renderer = comboBox.getRenderer();
|
|
if (renderer == null)
|
|
{
|
|
renderer = DEFAULT_RENDERER;
|
|
}
|
|
|
|
Object prototype = comboBox.getPrototypeDisplayValue();
|
|
if (prototype != null)
|
|
{
|
|
Component comp = renderer.getListCellRendererComponent(listBox,
|
|
prototype, -1, false, false);
|
|
currentValuePane.add(comp);
|
|
comp.setFont(comboBox.getFont());
|
|
Dimension renderSize = comp.getPreferredSize();
|
|
currentValuePane.remove(comp);
|
|
dim.height = renderSize.height;
|
|
dim.width = renderSize.width;
|
|
}
|
|
else
|
|
{
|
|
ComboBoxModel model = comboBox.getModel();
|
|
int size = model.getSize();
|
|
if (size > 0)
|
|
{
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
Component comp = renderer.getListCellRendererComponent(listBox,
|
|
model.getElementAt(i), -1, false, false);
|
|
currentValuePane.add(comp);
|
|
comp.setFont(comboBox.getFont());
|
|
Dimension renderSize = comp.getPreferredSize();
|
|
currentValuePane.remove(comp);
|
|
dim.width = Math.max(dim.width, renderSize.width);
|
|
dim.height = Math.max(dim.height, renderSize.height);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dim = getDefaultSize();
|
|
if (comboBox.isEditable())
|
|
dim.width = 100;
|
|
}
|
|
}
|
|
if (comboBox.isEditable())
|
|
{
|
|
Dimension editSize = editor.getPreferredSize();
|
|
dim.width = Math.max(dim.width, editSize.width);
|
|
dim.height = Math.max(dim.height, editSize.height);
|
|
}
|
|
displaySize.setSize(dim.width, dim.height);
|
|
return dim;
|
|
}
|
|
|
|
/**
|
|
* Installs the keyboard actions for the {@link JComboBox} as specified
|
|
* by the look and feel.
|
|
*/
|
|
protected void installKeyboardActions()
|
|
{
|
|
SwingUtilities.replaceUIInputMap(comboBox,
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
|
|
(InputMap) UIManager.get("ComboBox.ancestorInputMap"));
|
|
// Install any action maps here.
|
|
}
|
|
|
|
/**
|
|
* Uninstalls the keyboard actions for the {@link JComboBox} there were
|
|
* installed by in {@link #installListeners}.
|
|
*/
|
|
protected void uninstallKeyboardActions()
|
|
{
|
|
SwingUtilities.replaceUIInputMap(comboBox,
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
|
|
// Uninstall any action maps here.
|
|
}
|
|
|
|
/**
|
|
* A {@link LayoutManager} used to position the sub-components of the
|
|
* {@link JComboBox}.
|
|
*
|
|
* @see BasicComboBoxUI#createLayoutManager()
|
|
*/
|
|
public class ComboBoxLayoutManager implements LayoutManager
|
|
{
|
|
/**
|
|
* Creates a new ComboBoxLayoutManager object.
|
|
*/
|
|
public ComboBoxLayoutManager()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Adds a component to the layout. This method does nothing, since the
|
|
* layout manager doesn't need to track the components.
|
|
*
|
|
* @param name the name to associate the component with (ignored).
|
|
* @param comp the component (ignored).
|
|
*/
|
|
public void addLayoutComponent(String name, Component comp)
|
|
{
|
|
// Do nothing
|
|
}
|
|
|
|
/**
|
|
* Removes a component from the layout. This method does nothing, since
|
|
* the layout manager doesn't need to track the components.
|
|
*
|
|
* @param comp the component.
|
|
*/
|
|
public void removeLayoutComponent(Component comp)
|
|
{
|
|
// Do nothing
|
|
}
|
|
|
|
/**
|
|
* Returns preferred layout size of the JComboBox.
|
|
*
|
|
* @param parent the Container for which the preferred size should be
|
|
* calculated.
|
|
*
|
|
* @return The preferred size for the given container
|
|
*/
|
|
public Dimension preferredLayoutSize(Container parent)
|
|
{
|
|
return parent.getPreferredSize();
|
|
}
|
|
|
|
/**
|
|
* Returns the minimum layout size.
|
|
*
|
|
* @param parent the container.
|
|
*
|
|
* @return The minimum size.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container parent)
|
|
{
|
|
return parent.getMinimumSize();
|
|
}
|
|
|
|
/**
|
|
* Arranges the components in the container. It puts arrow
|
|
* button right end part of the comboBox. If the comboBox is editable
|
|
* then editor is placed to the left of arrow button, starting from the
|
|
* beginning.
|
|
*
|
|
* @param parent Container that should be layed out.
|
|
*/
|
|
public void layoutContainer(Container parent)
|
|
{
|
|
// Position editor component to the left of arrow button if combo box is
|
|
// editable
|
|
Insets i = getInsets();
|
|
int arrowSize = comboBox.getHeight() - (i.top + i.bottom);
|
|
|
|
if (arrowButton != null)
|
|
arrowButton.setBounds(comboBox.getWidth() - (i.right + arrowSize),
|
|
i.top, arrowSize, arrowSize);
|
|
if (editor != null)
|
|
editor.setBounds(rectangleForCurrentValue());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles focus changes occuring in the combo box. This class is
|
|
* responsible for repainting combo box whenever focus is gained or lost
|
|
* and also for hiding popup list of items whenever combo box loses its
|
|
* focus.
|
|
*/
|
|
public class FocusHandler extends Object implements FocusListener
|
|
{
|
|
/**
|
|
* Creates a new FocusHandler object.
|
|
*/
|
|
public FocusHandler()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Invoked when combo box gains focus. It repaints main
|
|
* part of combo box accordingly.
|
|
*
|
|
* @param e the FocusEvent
|
|
*/
|
|
public void focusGained(FocusEvent e)
|
|
{
|
|
hasFocus = true;
|
|
comboBox.repaint();
|
|
}
|
|
|
|
/**
|
|
* Invoked when the combo box loses focus. It repaints the main part
|
|
* of the combo box accordingly and hides the popup list of items.
|
|
*
|
|
* @param e the FocusEvent
|
|
*/
|
|
public void focusLost(FocusEvent e)
|
|
{
|
|
hasFocus = false;
|
|
if (! e.isTemporary() && comboBox.isLightWeightPopupEnabled())
|
|
setPopupVisible(comboBox, false);
|
|
comboBox.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles {@link ItemEvent}s fired by the {@link JComboBox} when its
|
|
* selected item changes.
|
|
*/
|
|
public class ItemHandler extends Object implements ItemListener
|
|
{
|
|
/**
|
|
* Creates a new ItemHandler object.
|
|
*/
|
|
public ItemHandler()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Invoked when selected item becomes deselected or when
|
|
* new item becomes selected.
|
|
*
|
|
* @param e the ItemEvent representing item's state change.
|
|
*/
|
|
public void itemStateChanged(ItemEvent e)
|
|
{
|
|
ComboBoxModel model = comboBox.getModel();
|
|
Object v = model.getSelectedItem();
|
|
if (editor != null)
|
|
comboBox.configureEditor(comboBox.getEditor(), v);
|
|
comboBox.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* KeyHandler handles key events occuring while JComboBox has focus.
|
|
*/
|
|
public class KeyHandler extends KeyAdapter
|
|
{
|
|
public KeyHandler()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Invoked whenever key is pressed while JComboBox is in focus.
|
|
*/
|
|
public void keyPressed(KeyEvent e)
|
|
{
|
|
if (comboBox.getModel().getSize() != 0 && comboBox.isEnabled())
|
|
{
|
|
if (! isNavigationKey(e.getKeyCode()))
|
|
{
|
|
if (! comboBox.isEditable())
|
|
if (comboBox.selectWithKeyChar(e.getKeyChar()))
|
|
e.consume();
|
|
}
|
|
else
|
|
{
|
|
if (e.getKeyCode() == KeyEvent.VK_UP && comboBox.isPopupVisible())
|
|
selectPreviousPossibleValue();
|
|
else if (e.getKeyCode() == KeyEvent.VK_DOWN)
|
|
{
|
|
if (comboBox.isPopupVisible())
|
|
selectNextPossibleValue();
|
|
else
|
|
comboBox.showPopup();
|
|
}
|
|
else if (e.getKeyCode() == KeyEvent.VK_ENTER
|
|
|| e.getKeyCode() == KeyEvent.VK_ESCAPE)
|
|
popup.hide();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles the changes occurring in the JComboBox's data model.
|
|
*/
|
|
public class ListDataHandler extends Object implements ListDataListener
|
|
{
|
|
/**
|
|
* Creates a new ListDataHandler object.
|
|
*/
|
|
public ListDataHandler()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Invoked if the content's of JComboBox's data model are changed.
|
|
*
|
|
* @param e ListDataEvent describing the change.
|
|
*/
|
|
public void contentsChanged(ListDataEvent e)
|
|
{
|
|
if (e.getIndex0() != -1 || e.getIndex1() != -1)
|
|
{
|
|
isMinimumSizeDirty = true;
|
|
comboBox.revalidate();
|
|
}
|
|
if (editor != null)
|
|
comboBox.configureEditor(comboBox.getEditor(),
|
|
comboBox.getSelectedItem());
|
|
comboBox.repaint();
|
|
}
|
|
|
|
/**
|
|
* Invoked when items are added to the JComboBox's data model.
|
|
*
|
|
* @param e ListDataEvent describing the change.
|
|
*/
|
|
public void intervalAdded(ListDataEvent e)
|
|
{
|
|
int start = e.getIndex0();
|
|
int end = e.getIndex1();
|
|
if (start == 0 && comboBox.getItemCount() - (end - start + 1) == 0)
|
|
contentsChanged(e);
|
|
else if (start != -1 || end != -1)
|
|
{
|
|
ListCellRenderer renderer = comboBox.getRenderer();
|
|
ComboBoxModel model = comboBox.getModel();
|
|
int w = displaySize.width;
|
|
int h = displaySize.height;
|
|
// TODO: Optimize using prototype here.
|
|
for (int i = start; i <= end; ++i)
|
|
{
|
|
Component comp = renderer.getListCellRendererComponent(listBox,
|
|
model.getElementAt(i), -1, false, false);
|
|
currentValuePane.add(comp);
|
|
comp.setFont(comboBox.getFont());
|
|
Dimension dim = comp.getPreferredSize();
|
|
w = Math.max(w, dim.width);
|
|
h = Math.max(h, dim.height);
|
|
currentValuePane.remove(comp);
|
|
}
|
|
if (displaySize.width < w || displaySize.height < h)
|
|
{
|
|
if (displaySize.width < w)
|
|
displaySize.width = w;
|
|
if (displaySize.height < h)
|
|
displaySize.height = h;
|
|
comboBox.revalidate();
|
|
if (editor != null)
|
|
{
|
|
comboBox.configureEditor(comboBox.getEditor(),
|
|
comboBox.getSelectedItem());
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Invoked when items are removed from the JComboBox's
|
|
* data model.
|
|
*
|
|
* @param e ListDataEvent describing the change.
|
|
*/
|
|
public void intervalRemoved(ListDataEvent e)
|
|
{
|
|
contentsChanged(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles {@link PropertyChangeEvent}s fired by the {@link JComboBox}.
|
|
*/
|
|
public class PropertyChangeHandler extends Object
|
|
implements PropertyChangeListener
|
|
{
|
|
/**
|
|
* Creates a new instance.
|
|
*/
|
|
public PropertyChangeHandler()
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* Invoked whenever bound property of JComboBox changes.
|
|
*
|
|
* @param e the event.
|
|
*/
|
|
public void propertyChange(PropertyChangeEvent e)
|
|
{
|
|
// Lets assume every change invalidates the minimumsize.
|
|
String propName = e.getPropertyName();
|
|
if (propName.equals("enabled"))
|
|
{
|
|
boolean enabled = comboBox.isEnabled();
|
|
if (editor != null)
|
|
editor.setEnabled(enabled);
|
|
if (arrowButton != null)
|
|
arrowButton.setEnabled(enabled);
|
|
|
|
comboBox.repaint();
|
|
}
|
|
else if (propName.equals("editor") && comboBox.isEditable())
|
|
{
|
|
addEditor();
|
|
comboBox.revalidate();
|
|
}
|
|
else if (e.getPropertyName().equals("editable"))
|
|
{
|
|
if (comboBox.isEditable())
|
|
{
|
|
addEditor();
|
|
}
|
|
else
|
|
{
|
|
removeEditor();
|
|
}
|
|
|
|
comboBox.revalidate();
|
|
}
|
|
else if (propName.equals("model"))
|
|
{
|
|
// remove ListDataListener from old model and add it to new model
|
|
ComboBoxModel oldModel = (ComboBoxModel) e.getOldValue();
|
|
if (oldModel != null && listDataListener != null)
|
|
oldModel.removeListDataListener(listDataListener);
|
|
|
|
ComboBoxModel newModel = (ComboBoxModel) e.getNewValue();
|
|
if (newModel != null && listDataListener != null)
|
|
comboBox.getModel().addListDataListener(listDataListener);
|
|
|
|
if (editor != null)
|
|
{
|
|
comboBox.configureEditor(comboBox.getEditor(),
|
|
comboBox.getSelectedItem());
|
|
}
|
|
isMinimumSizeDirty = true;
|
|
comboBox.revalidate();
|
|
comboBox.repaint();
|
|
}
|
|
else if (propName.equals("font"))
|
|
{
|
|
Font font = (Font) e.getNewValue();
|
|
if (editor != null)
|
|
{
|
|
editor.setFont(font);
|
|
}
|
|
listBox.setFont(font);
|
|
isMinimumSizeDirty = true;
|
|
comboBox.revalidate();
|
|
}
|
|
else if (propName.equals("prototypeDisplayValue"))
|
|
{
|
|
isMinimumSizeDirty = true;
|
|
comboBox.revalidate();
|
|
}
|
|
else if (propName.equals("renderer"))
|
|
{
|
|
isMinimumSizeDirty = true;
|
|
comboBox.revalidate();
|
|
}
|
|
// FIXME: Need to handle changes in other bound properties.
|
|
}
|
|
}
|
|
}
|