| /* BasicListUI.java -- | |
| Copyright (C) 2002, 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.Component; | |
| import java.awt.Dimension; | |
| import java.awt.Graphics; | |
| import java.awt.Insets; | |
| import java.awt.Point; | |
| import java.awt.Rectangle; | |
| import java.awt.event.ActionEvent; | |
| import java.awt.event.ActionListener; | |
| import java.awt.event.FocusEvent; | |
| import java.awt.event.FocusListener; | |
| import java.awt.event.MouseEvent; | |
| import java.beans.PropertyChangeEvent; | |
| import java.beans.PropertyChangeListener; | |
| import javax.swing.AbstractAction; | |
| import javax.swing.ActionMap; | |
| import javax.swing.CellRendererPane; | |
| import javax.swing.DefaultListSelectionModel; | |
| import javax.swing.InputMap; | |
| import javax.swing.JComponent; | |
| import javax.swing.JList; | |
| import javax.swing.ListCellRenderer; | |
| import javax.swing.ListModel; | |
| import javax.swing.ListSelectionModel; | |
| import javax.swing.LookAndFeel; | |
| import javax.swing.SwingUtilities; | |
| import javax.swing.TransferHandler; | |
| import javax.swing.UIDefaults; | |
| import javax.swing.UIManager; | |
| import javax.swing.event.ListDataEvent; | |
| import javax.swing.event.ListDataListener; | |
| import javax.swing.event.ListSelectionEvent; | |
| import javax.swing.event.ListSelectionListener; | |
| import javax.swing.event.MouseInputListener; | |
| import javax.swing.plaf.ActionMapUIResource; | |
| import javax.swing.plaf.ComponentUI; | |
| import javax.swing.plaf.ListUI; | |
| import javax.swing.plaf.UIResource; | |
| /** | |
| * The Basic Look and Feel UI delegate for the | |
| * JList. | |
| */ | |
| public class BasicListUI extends ListUI | |
| { | |
| /** | |
| * A helper class which listens for {@link FocusEvent}s | |
| * from the JList. | |
| */ | |
| public class FocusHandler implements FocusListener | |
| { | |
| /** | |
| * Called when the JList acquires focus. | |
| * | |
| * @param e The FocusEvent representing focus acquisition | |
| */ | |
| public void focusGained(FocusEvent e) | |
| { | |
| repaintCellFocus(); | |
| } | |
| /** | |
| * Called when the JList loses focus. | |
| * | |
| * @param e The FocusEvent representing focus loss | |
| */ | |
| public void focusLost(FocusEvent e) | |
| { | |
| repaintCellFocus(); | |
| } | |
| /** | |
| * Helper method to repaint the focused cell's | |
| * lost or acquired focus state. | |
| */ | |
| protected void repaintCellFocus() | |
| { | |
| // TODO: Implement this properly. | |
| } | |
| } | |
| /** | |
| * A helper class which listens for {@link ListDataEvent}s generated by | |
| * the {@link JList}'s {@link ListModel}. | |
| * | |
| * @see javax.swing.JList#getModel() | |
| */ | |
| public class ListDataHandler implements ListDataListener | |
| { | |
| /** | |
| * Called when a general change has happened in the model which cannot | |
| * be represented in terms of a simple addition or deletion. | |
| * | |
| * @param e The event representing the change | |
| */ | |
| public void contentsChanged(ListDataEvent e) | |
| { | |
| updateLayoutStateNeeded |= modelChanged; | |
| list.revalidate(); | |
| } | |
| /** | |
| * Called when an interval of objects has been added to the model. | |
| * | |
| * @param e The event representing the addition | |
| */ | |
| public void intervalAdded(ListDataEvent e) | |
| { | |
| updateLayoutStateNeeded |= modelChanged; | |
| list.revalidate(); | |
| } | |
| /** | |
| * Called when an inteval of objects has been removed from the model. | |
| * | |
| * @param e The event representing the removal | |
| */ | |
| public void intervalRemoved(ListDataEvent e) | |
| { | |
| updateLayoutStateNeeded |= modelChanged; | |
| list.revalidate(); | |
| } | |
| } | |
| /** | |
| * A helper class which listens for {@link ListSelectionEvent}s | |
| * from the {@link JList}'s {@link ListSelectionModel}. | |
| */ | |
| public class ListSelectionHandler implements ListSelectionListener | |
| { | |
| /** | |
| * Called when the list selection changes. | |
| * | |
| * @param e The event representing the change | |
| */ | |
| public void valueChanged(ListSelectionEvent e) | |
| { | |
| int index1 = e.getFirstIndex(); | |
| int index2 = e.getLastIndex(); | |
| Rectangle damaged = getCellBounds(list, index1, index2); | |
| if (damaged != null) | |
| list.repaint(damaged); | |
| } | |
| } | |
| /** | |
| * This class is used to mimmic the behaviour of the JDK when registering | |
| * keyboard actions. It is the same as the private class used in JComponent | |
| * for the same reason. This class receives an action event and dispatches | |
| * it to the true receiver after altering the actionCommand property of the | |
| * event. | |
| */ | |
| private static class ActionListenerProxy | |
| extends AbstractAction | |
| { | |
| ActionListener target; | |
| String bindingCommandName; | |
| public ActionListenerProxy(ActionListener li, | |
| String cmd) | |
| { | |
| target = li; | |
| bindingCommandName = cmd; | |
| } | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| ActionEvent derivedEvent = new ActionEvent(e.getSource(), | |
| e.getID(), | |
| bindingCommandName, | |
| e.getModifiers()); | |
| target.actionPerformed(derivedEvent); | |
| } | |
| } | |
| /** | |
| * Implements the action for the JList's keyboard commands. | |
| */ | |
| private class ListAction | |
| extends AbstractAction | |
| { | |
| // TODO: Maybe make a couple of classes out of this bulk Action. | |
| // Form logical groups of Actions when doing this. | |
| /** | |
| * Creates a new ListAction for the specified command. | |
| * | |
| * @param cmd the actionCommand to set | |
| */ | |
| ListAction(String cmd) | |
| { | |
| putValue(ACTION_COMMAND_KEY, cmd); | |
| } | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| int lead = list.getLeadSelectionIndex(); | |
| int max = list.getModel().getSize() - 1; | |
| DefaultListSelectionModel selModel | |
| = (DefaultListSelectionModel) list.getSelectionModel(); | |
| String command = e.getActionCommand(); | |
| // Do nothing if list is empty | |
| if (max == -1) | |
| return; | |
| if (command.equals("selectNextRow")) | |
| { | |
| selectNextIndex(); | |
| } | |
| else if (command.equals("selectPreviousRow")) | |
| { | |
| selectPreviousIndex(); | |
| } | |
| else if (command.equals("clearSelection")) | |
| { | |
| list.clearSelection(); | |
| } | |
| else if (command.equals("selectAll")) | |
| { | |
| list.setSelectionInterval(0, max); | |
| // this next line is to restore the lead selection index to the old | |
| // position, because select-all should not change the lead index | |
| list.addSelectionInterval(lead, lead); | |
| } | |
| else if (command.equals("selectLastRow")) | |
| { | |
| list.setSelectedIndex(list.getModel().getSize() - 1); | |
| } | |
| else if (command.equals("selectLastRowChangeLead")) | |
| { | |
| selModel.moveLeadSelectionIndex(list.getModel().getSize() - 1); | |
| } | |
| else if (command.equals("scrollDownExtendSelection")) | |
| { | |
| int target; | |
| if (lead == list.getLastVisibleIndex()) | |
| { | |
| target = Math.min(max, lead + (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getLastVisibleIndex(); | |
| selModel.setLeadSelectionIndex(target); | |
| } | |
| else if (command.equals("scrollDownChangeLead")) | |
| { | |
| int target; | |
| if (lead == list.getLastVisibleIndex()) | |
| { | |
| target = Math.min(max, lead + (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getLastVisibleIndex(); | |
| selModel.moveLeadSelectionIndex(target); | |
| } | |
| else if (command.equals("scrollUpExtendSelection")) | |
| { | |
| int target; | |
| if (lead == list.getFirstVisibleIndex()) | |
| { | |
| target = Math.max(0, lead - (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getFirstVisibleIndex(); | |
| selModel.setLeadSelectionIndex(target); | |
| } | |
| else if (command.equals("scrollUpChangeLead")) | |
| { | |
| int target; | |
| if (lead == list.getFirstVisibleIndex()) | |
| { | |
| target = Math.max(0, lead - (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getFirstVisibleIndex(); | |
| selModel.moveLeadSelectionIndex(target); | |
| } | |
| else if (command.equals("selectNextRowExtendSelection")) | |
| { | |
| selModel.setLeadSelectionIndex(Math.min(lead + 1, max)); | |
| } | |
| else if (command.equals("selectFirstRow")) | |
| { | |
| list.setSelectedIndex(0); | |
| } | |
| else if (command.equals("selectFirstRowChangeLead")) | |
| { | |
| selModel.moveLeadSelectionIndex(0); | |
| } | |
| else if (command.equals("selectFirstRowExtendSelection")) | |
| { | |
| selModel.setLeadSelectionIndex(0); | |
| } | |
| else if (command.equals("selectPreviousRowExtendSelection")) | |
| { | |
| selModel.setLeadSelectionIndex(Math.max(0, lead - 1)); | |
| } | |
| else if (command.equals("scrollUp")) | |
| { | |
| int target; | |
| if (lead == list.getFirstVisibleIndex()) | |
| { | |
| target = Math.max(0, lead - (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getFirstVisibleIndex(); | |
| list.setSelectedIndex(target); | |
| } | |
| else if (command.equals("selectLastRowExtendSelection")) | |
| { | |
| selModel.setLeadSelectionIndex(list.getModel().getSize() - 1); | |
| } | |
| else if (command.equals("scrollDown")) | |
| { | |
| int target; | |
| if (lead == list.getLastVisibleIndex()) | |
| { | |
| target = Math.min(max, lead + (list.getLastVisibleIndex() | |
| - list.getFirstVisibleIndex() + 1)); | |
| } | |
| else | |
| target = list.getLastVisibleIndex(); | |
| list.setSelectedIndex(target); | |
| } | |
| else if (command.equals("selectNextRowChangeLead")) | |
| { | |
| if (selModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) | |
| selectNextIndex(); | |
| else | |
| { | |
| selModel.moveLeadSelectionIndex(Math.min(max, lead + 1)); | |
| } | |
| } | |
| else if (command.equals("selectPreviousRowChangeLead")) | |
| { | |
| if (selModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) | |
| selectPreviousIndex(); | |
| else | |
| { | |
| selModel.moveLeadSelectionIndex(Math.max(0, lead - 1)); | |
| } | |
| } | |
| else if (command.equals("addToSelection")) | |
| { | |
| list.addSelectionInterval(lead, lead); | |
| } | |
| else if (command.equals("extendTo")) | |
| { | |
| selModel.setSelectionInterval(selModel.getAnchorSelectionIndex(), | |
| lead); | |
| } | |
| else if (command.equals("toggleAndAnchor")) | |
| { | |
| if (!list.isSelectedIndex(lead)) | |
| list.addSelectionInterval(lead, lead); | |
| else | |
| list.removeSelectionInterval(lead, lead); | |
| selModel.setAnchorSelectionIndex(lead); | |
| } | |
| else | |
| { | |
| // DEBUG: uncomment the following line to print out | |
| // key bindings that aren't implemented yet | |
| // System.out.println ("not implemented: "+e.getActionCommand()); | |
| } | |
| list.ensureIndexIsVisible(list.getLeadSelectionIndex()); | |
| } | |
| } | |
| /** | |
| * A helper class which listens for {@link MouseEvent}s | |
| * from the {@link JList}. | |
| */ | |
| public class MouseInputHandler implements MouseInputListener | |
| { | |
| /** | |
| * Called when a mouse button press/release cycle completes | |
| * on the {@link JList} | |
| * | |
| * @param event The event representing the mouse click | |
| */ | |
| public void mouseClicked(MouseEvent event) | |
| { | |
| Point click = event.getPoint(); | |
| int index = locationToIndex(list, click); | |
| if (index == -1) | |
| return; | |
| if (event.isShiftDown()) | |
| { | |
| if (list.getSelectionMode() == ListSelectionModel.SINGLE_SELECTION) | |
| list.setSelectedIndex(index); | |
| else if (list.getSelectionMode() == | |
| ListSelectionModel.SINGLE_INTERVAL_SELECTION) | |
| // COMPAT: the IBM VM is compatible with the following line of code. | |
| // However, compliance with Sun's VM would correspond to replacing | |
| // getAnchorSelectionIndex() with getLeadSelectionIndex().This is | |
| // both unnatural and contradictory to the way they handle other | |
| // similar UI interactions. | |
| list.setSelectionInterval(list.getAnchorSelectionIndex(), index); | |
| else | |
| // COMPAT: both Sun and IBM are compatible instead with: | |
| // list.setSelectionInterval | |
| // (list.getLeadSelectionIndex(),index); | |
| // Note that for IBM this is contradictory to what they did in | |
| // the above situation for SINGLE_INTERVAL_SELECTION. | |
| // The most natural thing to do is the following: | |
| if (list.isSelectedIndex(list.getAnchorSelectionIndex())) | |
| list.getSelectionModel().setLeadSelectionIndex(index); | |
| else | |
| list.addSelectionInterval(list.getAnchorSelectionIndex(), index); | |
| } | |
| else if (event.isControlDown()) | |
| { | |
| if (list.getSelectionMode() == ListSelectionModel.SINGLE_SELECTION) | |
| list.setSelectedIndex(index); | |
| else if (list.isSelectedIndex(index)) | |
| list.removeSelectionInterval(index, index); | |
| else | |
| list.addSelectionInterval(index, index); | |
| } | |
| else | |
| list.setSelectedIndex(index); | |
| list.ensureIndexIsVisible(list.getLeadSelectionIndex()); | |
| } | |
| /** | |
| * Called when a mouse button is pressed down on the | |
| * {@link JList}. | |
| * | |
| * @param event The event representing the mouse press | |
| */ | |
| public void mousePressed(MouseEvent event) | |
| { | |
| // We need to explicitly request focus. | |
| list.requestFocusInWindow(); | |
| } | |
| /** | |
| * Called when a mouse button is released on | |
| * the {@link JList} | |
| * | |
| * @param event The event representing the mouse press | |
| */ | |
| public void mouseReleased(MouseEvent event) | |
| { | |
| // TODO: What should be done here, if anything? | |
| } | |
| /** | |
| * Called when the mouse pointer enters the area bounded | |
| * by the {@link JList} | |
| * | |
| * @param event The event representing the mouse entry | |
| */ | |
| public void mouseEntered(MouseEvent event) | |
| { | |
| // TODO: What should be done here, if anything? | |
| } | |
| /** | |
| * Called when the mouse pointer leaves the area bounded | |
| * by the {@link JList} | |
| * | |
| * @param event The event representing the mouse exit | |
| */ | |
| public void mouseExited(MouseEvent event) | |
| { | |
| // TODO: What should be done here, if anything? | |
| } | |
| /** | |
| * Called when the mouse pointer moves over the area bounded | |
| * by the {@link JList} while a button is held down. | |
| * | |
| * @param event The event representing the mouse drag | |
| */ | |
| public void mouseDragged(MouseEvent event) | |
| { | |
| Point click = event.getPoint(); | |
| int index = locationToIndex(list, click); | |
| if (index == -1) | |
| return; | |
| if (!event.isShiftDown() && !event.isControlDown()) | |
| list.setSelectedIndex(index); | |
| list.ensureIndexIsVisible(list.getLeadSelectionIndex()); | |
| } | |
| /** | |
| * Called when the mouse pointer moves over the area bounded | |
| * by the {@link JList}. | |
| * | |
| * @param event The event representing the mouse move | |
| */ | |
| public void mouseMoved(MouseEvent event) | |
| { | |
| // TODO: What should be done here, if anything? | |
| } | |
| } | |
| /** | |
| * Helper class which listens to {@link PropertyChangeEvent}s | |
| * from the {@link JList}. | |
| */ | |
| public class PropertyChangeHandler implements PropertyChangeListener | |
| { | |
| /** | |
| * Called when the {@link JList} changes one of its bound properties. | |
| * | |
| * @param e The event representing the property change | |
| */ | |
| public void propertyChange(PropertyChangeEvent e) | |
| { | |
| if (e.getPropertyName().equals("model")) | |
| { | |
| if (e.getOldValue() != null && e.getOldValue() instanceof ListModel) | |
| { | |
| ListModel oldModel = (ListModel) e.getOldValue(); | |
| oldModel.removeListDataListener(listDataListener); | |
| } | |
| if (e.getNewValue() != null && e.getNewValue() instanceof ListModel) | |
| { | |
| ListModel newModel = (ListModel) e.getNewValue(); | |
| newModel.addListDataListener(BasicListUI.this.listDataListener); | |
| } | |
| updateLayoutStateNeeded |= modelChanged; | |
| } | |
| else if (e.getPropertyName().equals("selectionModel")) | |
| updateLayoutStateNeeded |= selectionModelChanged; | |
| else if (e.getPropertyName().equals("font")) | |
| updateLayoutStateNeeded |= fontChanged; | |
| else if (e.getPropertyName().equals("fixedCellWidth")) | |
| updateLayoutStateNeeded |= fixedCellWidthChanged; | |
| else if (e.getPropertyName().equals("fixedCellHeight")) | |
| updateLayoutStateNeeded |= fixedCellHeightChanged; | |
| else if (e.getPropertyName().equals("prototypeCellValue")) | |
| updateLayoutStateNeeded |= prototypeCellValueChanged; | |
| else if (e.getPropertyName().equals("cellRenderer")) | |
| updateLayoutStateNeeded |= cellRendererChanged; | |
| } | |
| } | |
| /** | |
| * A constant to indicate that the model has changed. | |
| */ | |
| protected static final int modelChanged = 1; | |
| /** | |
| * A constant to indicate that the selection model has changed. | |
| */ | |
| protected static final int selectionModelChanged = 2; | |
| /** | |
| * A constant to indicate that the font has changed. | |
| */ | |
| protected static final int fontChanged = 4; | |
| /** | |
| * A constant to indicate that the fixedCellWidth has changed. | |
| */ | |
| protected static final int fixedCellWidthChanged = 8; | |
| /** | |
| * A constant to indicate that the fixedCellHeight has changed. | |
| */ | |
| protected static final int fixedCellHeightChanged = 16; | |
| /** | |
| * A constant to indicate that the prototypeCellValue has changed. | |
| */ | |
| protected static final int prototypeCellValueChanged = 32; | |
| /** | |
| * A constant to indicate that the cellRenderer has changed. | |
| */ | |
| protected static final int cellRendererChanged = 64; | |
| /** | |
| * Creates a new BasicListUI for the component. | |
| * | |
| * @param c The component to create a UI for | |
| * | |
| * @return A new UI | |
| */ | |
| public static ComponentUI createUI(final JComponent c) | |
| { | |
| return new BasicListUI(); | |
| } | |
| /** The current focus listener. */ | |
| protected FocusListener focusListener; | |
| /** The data listener listening to the model. */ | |
| protected ListDataListener listDataListener; | |
| /** The selection listener listening to the selection model. */ | |
| protected ListSelectionListener listSelectionListener; | |
| /** The mouse listener listening to the list. */ | |
| protected MouseInputListener mouseInputListener; | |
| /** The property change listener listening to the list. */ | |
| protected PropertyChangeListener propertyChangeListener; | |
| /** Saved reference to the list this UI was created for. */ | |
| protected JList list; | |
| /** | |
| * The height of a single cell in the list. This field is used when the | |
| * fixedCellHeight property of the list is set. Otherwise this field is | |
| * set to <code>-1</code> and {@link #cellHeights} is used instead. | |
| */ | |
| protected int cellHeight; | |
| /** The width of a single cell in the list. */ | |
| protected int cellWidth; | |
| /** | |
| * An array of varying heights of cells in the list, in cases where each | |
| * cell might have a different height. This field is used when the | |
| * <code>fixedCellHeight</code> property of the list is not set. Otherwise | |
| * this field is <code>null</code> and {@link #cellHeight} is used. | |
| */ | |
| protected int[] cellHeights; | |
| /** | |
| * A bitmask that indicates which properties of the JList have changed. | |
| * When nonzero, indicates that the UI class is out of | |
| * date with respect to the underlying list, and must recalculate the | |
| * list layout before painting or performing size calculations. | |
| * | |
| * @see #modelChanged | |
| * @see #selectionModelChanged | |
| * @see #fontChanged | |
| * @see #fixedCellWidthChanged | |
| * @see #fixedCellHeightChanged | |
| * @see #prototypeCellValueChanged | |
| * @see #cellRendererChanged | |
| */ | |
| protected int updateLayoutStateNeeded; | |
| /** | |
| * The {@link CellRendererPane} that is used for painting. | |
| */ | |
| protected CellRendererPane rendererPane; | |
| /** The action bound to KeyStrokes. */ | |
| ListAction action; | |
| /** | |
| * Calculate the height of a particular row. If there is a fixed {@link | |
| * #cellHeight}, return it; otherwise return the specific row height | |
| * requested from the {@link #cellHeights} array. If the requested row | |
| * is invalid, return <code>-1</code>. | |
| * | |
| * @param row The row to get the height of | |
| * | |
| * @return The height, in pixels, of the specified row | |
| */ | |
| protected int getRowHeight(int row) | |
| { | |
| int height; | |
| if (cellHeights == null) | |
| height = cellHeight; | |
| else | |
| { | |
| if (row < 0 || row >= cellHeights.length) | |
| height = -1; | |
| else | |
| height = cellHeights[row]; | |
| } | |
| return height; | |
| } | |
| /** | |
| * Calculate the bounds of a particular cell, considering the upper left | |
| * corner of the list as the origin position <code>(0,0)</code>. | |
| * | |
| * @param l Ignored; calculates over <code>this.list</code> | |
| * @param index1 The first row to include in the bounds | |
| * @param index2 The last row to incude in the bounds | |
| * | |
| * @return A rectangle encompassing the range of rows between | |
| * <code>index1</code> and <code>index2</code> inclusive, or null | |
| * such a rectangle couldn't be calculated for the given indexes. | |
| */ | |
| public Rectangle getCellBounds(JList l, int index1, int index2) | |
| { | |
| maybeUpdateLayoutState(); | |
| if (l != list || cellWidth == -1) | |
| return null; | |
| int minIndex = Math.min(index1, index2); | |
| int maxIndex = Math.max(index1, index2); | |
| Point loc = indexToLocation(list, minIndex); | |
| // When the layoutOrientation is VERTICAL, then the width == the list | |
| // width. Otherwise the cellWidth field is used. | |
| int width = cellWidth; | |
| if (l.getLayoutOrientation() == JList.VERTICAL) | |
| width = l.getWidth(); | |
| Rectangle bounds = new Rectangle(loc.x, loc.y, width, | |
| getCellHeight(minIndex)); | |
| for (int i = minIndex + 1; i <= maxIndex; i++) | |
| { | |
| Point hiLoc = indexToLocation(list, i); | |
| bounds = SwingUtilities.computeUnion(hiLoc.x, hiLoc.y, width, | |
| getCellHeight(i), bounds); | |
| } | |
| return bounds; | |
| } | |
| /** | |
| * Calculates the maximum cell height. | |
| * | |
| * @param index the index of the cell | |
| * | |
| * @return the maximum cell height | |
| */ | |
| private int getCellHeight(int index) | |
| { | |
| int height = cellHeight; | |
| if (height <= 0) | |
| { | |
| if (list.getLayoutOrientation() == JList.VERTICAL) | |
| height = getRowHeight(index); | |
| else | |
| { | |
| for (int j = 0; j < cellHeights.length; j++) | |
| height = Math.max(height, cellHeights[j]); | |
| } | |
| } | |
| return height; | |
| } | |
| /** | |
| * Calculate the Y coordinate of the upper edge of a particular row, | |
| * considering the Y coordinate <code>0</code> to occur at the top of the | |
| * list. | |
| * | |
| * @param row The row to calculate the Y coordinate of | |
| * | |
| * @return The Y coordinate of the specified row, or <code>-1</code> if | |
| * the specified row number is invalid | |
| */ | |
| protected int convertRowToY(int row) | |
| { | |
| int y = 0; | |
| for (int i = 0; i < row; ++i) | |
| { | |
| int h = getRowHeight(i); | |
| if (h == -1) | |
| return -1; | |
| y += h; | |
| } | |
| return y; | |
| } | |
| /** | |
| * Calculate the row number containing a particular Y coordinate, | |
| * considering the Y coodrinate <code>0</code> to occur at the top of the | |
| * list. | |
| * | |
| * @param y0 The Y coordinate to calculate the row number for | |
| * | |
| * @return The row number containing the specified Y value, or <code>-1</code> | |
| * if the list model is empty | |
| * | |
| * @specnote This method is specified to return -1 for an invalid Y | |
| * coordinate. However, some simple tests show that the behaviour | |
| * is to return the index of the last list element for an Y | |
| * coordinate that lies outside of the list bounds (even for | |
| * negative indices). <code>-1</code> | |
| * is only returned if the list model is empty. | |
| */ | |
| protected int convertYToRow(int y0) | |
| { | |
| if (list.getModel().getSize() == 0) | |
| return -1; | |
| // When y0 < 0, then the JDK returns the maximum row index of the list. So | |
| // do we. | |
| if (y0 < 0) | |
| return list.getModel().getSize() - 1; | |
| // Update the layout if necessary. | |
| maybeUpdateLayoutState(); | |
| int index = list.getModel().getSize() - 1; | |
| // If a fixed cell height is set, then we can work more efficient. | |
| if (cellHeight > 0) | |
| index = Math.min(y0 / cellHeight, index); | |
| // If we have no fixed cell height, we must add up each cell height up | |
| // to y0. | |
| else | |
| { | |
| int h = 0; | |
| for (int row = 0; row < cellHeights.length; ++row) | |
| { | |
| h += cellHeights[row]; | |
| if (y0 < h) | |
| { | |
| index = row; | |
| break; | |
| } | |
| } | |
| } | |
| return index; | |
| } | |
| /** | |
| * Recomputes the {@link #cellHeights}, {@link #cellHeight}, and {@link | |
| * #cellWidth} properties by examining the variouis properties of the | |
| * {@link JList}. | |
| */ | |
| protected void updateLayoutState() | |
| { | |
| int nrows = list.getModel().getSize(); | |
| cellHeight = -1; | |
| cellWidth = -1; | |
| if (cellHeights == null || cellHeights.length != nrows) | |
| cellHeights = new int[nrows]; | |
| ListCellRenderer rend = list.getCellRenderer(); | |
| // Update the cellHeight(s) fields. | |
| int fixedCellHeight = list.getFixedCellHeight(); | |
| if (fixedCellHeight > 0) | |
| { | |
| cellHeight = fixedCellHeight; | |
| cellHeights = null; | |
| } | |
| else | |
| { | |
| cellHeight = -1; | |
| for (int i = 0; i < nrows; ++i) | |
| { | |
| Component flyweight = | |
| rend.getListCellRendererComponent(list, | |
| list.getModel().getElementAt(i), | |
| i, list.isSelectedIndex(i), | |
| list.getSelectionModel().getAnchorSelectionIndex() == i); | |
| Dimension dim = flyweight.getPreferredSize(); | |
| cellHeights[i] = dim.height; | |
| } | |
| } | |
| // Update the cellWidth field. | |
| int fixedCellWidth = list.getFixedCellWidth(); | |
| if (fixedCellWidth > 0) | |
| cellWidth = fixedCellWidth; | |
| else | |
| { | |
| for (int i = 0; i < nrows; ++i) | |
| { | |
| Component flyweight = | |
| rend.getListCellRendererComponent(list, | |
| list.getModel().getElementAt(i), | |
| i, list.isSelectedIndex(i), | |
| list.getSelectionModel().getAnchorSelectionIndex() == i); | |
| Dimension dim = flyweight.getPreferredSize(); | |
| cellWidth = Math.max(cellWidth, dim.width); | |
| } | |
| } | |
| } | |
| /** | |
| * Calls {@link #updateLayoutState} if {@link #updateLayoutStateNeeded} | |
| * is nonzero, then resets {@link #updateLayoutStateNeeded} to zero. | |
| */ | |
| protected void maybeUpdateLayoutState() | |
| { | |
| if (updateLayoutStateNeeded != 0 || !list.isValid()) | |
| { | |
| updateLayoutState(); | |
| updateLayoutStateNeeded = 0; | |
| } | |
| } | |
| /** | |
| * Creates a new BasicListUI object. | |
| */ | |
| public BasicListUI() | |
| { | |
| updateLayoutStateNeeded = 1; | |
| rendererPane = new CellRendererPane(); | |
| } | |
| /** | |
| * Installs various default settings (mostly colors) from the {@link | |
| * UIDefaults} into the {@link JList} | |
| * | |
| * @see #uninstallDefaults | |
| */ | |
| protected void installDefaults() | |
| { | |
| LookAndFeel.installColorsAndFont(list, "List.background", | |
| "List.foreground", "List.font"); | |
| list.setSelectionForeground(UIManager.getColor("List.selectionForeground")); | |
| list.setSelectionBackground(UIManager.getColor("List.selectionBackground")); | |
| list.setOpaque(true); | |
| } | |
| /** | |
| * Resets to <code>null</code> those defaults which were installed in | |
| * {@link #installDefaults} | |
| */ | |
| protected void uninstallDefaults() | |
| { | |
| list.setForeground(null); | |
| list.setBackground(null); | |
| list.setSelectionForeground(null); | |
| list.setSelectionBackground(null); | |
| } | |
| /** | |
| * Attaches all the listeners we have in the UI class to the {@link | |
| * JList}, its model and its selection model. | |
| * | |
| * @see #uninstallListeners | |
| */ | |
| protected void installListeners() | |
| { | |
| if (focusListener == null) | |
| focusListener = createFocusListener(); | |
| list.addFocusListener(focusListener); | |
| if (listDataListener == null) | |
| listDataListener = createListDataListener(); | |
| list.getModel().addListDataListener(listDataListener); | |
| if (listSelectionListener == null) | |
| listSelectionListener = createListSelectionListener(); | |
| list.addListSelectionListener(listSelectionListener); | |
| if (mouseInputListener == null) | |
| mouseInputListener = createMouseInputListener(); | |
| list.addMouseListener(mouseInputListener); | |
| list.addMouseMotionListener(mouseInputListener); | |
| if (propertyChangeListener == null) | |
| propertyChangeListener = createPropertyChangeListener(); | |
| list.addPropertyChangeListener(propertyChangeListener); | |
| } | |
| /** | |
| * Detaches all the listeners we attached in {@link #installListeners}. | |
| */ | |
| protected void uninstallListeners() | |
| { | |
| list.removeFocusListener(focusListener); | |
| list.getModel().removeListDataListener(listDataListener); | |
| list.removeListSelectionListener(listSelectionListener); | |
| list.removeMouseListener(mouseInputListener); | |
| list.removeMouseMotionListener(mouseInputListener); | |
| list.removePropertyChangeListener(propertyChangeListener); | |
| } | |
| /** | |
| * Installs keyboard actions for this UI in the {@link JList}. | |
| */ | |
| protected void installKeyboardActions() | |
| { | |
| // Install UI InputMap. | |
| InputMap focusInputMap = (InputMap) UIManager.get("List.focusInputMap"); | |
| SwingUtilities.replaceUIInputMap(list, JComponent.WHEN_FOCUSED, | |
| focusInputMap); | |
| // Install UI ActionMap. | |
| ActionMap am = (ActionMap) UIManager.get("List.actionMap"); | |
| if (am == null) | |
| { | |
| // Create the actionMap once and store it in the current UIDefaults | |
| // for use in other components. | |
| am = new ActionMapUIResource(); | |
| ListAction action; | |
| action = new ListAction("selectPreviousRow"); | |
| am.put("selectPreviousRow", action); | |
| action = new ListAction("selectNextRow"); | |
| am.put("selectNextRow", action); | |
| action = new ListAction("selectPreviousRowExtendSelection"); | |
| am.put("selectPreviousRowExtendSelection", action); | |
| action = new ListAction("selectNextRowExtendSelection"); | |
| am.put("selectNextRowExtendSelection", action); | |
| action = new ListAction("selectPreviousColumn"); | |
| am.put("selectPreviousColumn", action); | |
| action = new ListAction("selectNextColumn"); | |
| am.put("selectNextColumn", action); | |
| action = new ListAction("selectPreviousColumnExtendSelection"); | |
| am.put("selectPreviousColumnExtendSelection", action); | |
| action = new ListAction("selectNextColumnExtendSelection"); | |
| am.put("selectNextColumnExtendSelection", action); | |
| action = new ListAction("selectFirstRow"); | |
| am.put("selectFirstRow", action); | |
| action = new ListAction("selectLastRow"); | |
| am.put("selectLastRow", action); | |
| action = new ListAction("selectFirstRowExtendSelection"); | |
| am.put("selectFirstRowExtendSelection", action); | |
| action = new ListAction("selectLastRowExtendSelection"); | |
| am.put("selectLastRowExtendSelection", action); | |
| action = new ListAction("scrollUp"); | |
| am.put("scrollUp", action); | |
| action = new ListAction("scrollUpExtendSelection"); | |
| am.put("scrollUpExtendSelection", action); | |
| action = new ListAction("scrollDown"); | |
| am.put("scrollDown", action); | |
| action = new ListAction("scrollDownExtendSelection"); | |
| am.put("scrollDownExtendSelection", action); | |
| action = new ListAction("selectAll"); | |
| am.put("selectAll", action); | |
| action = new ListAction("clearSelection"); | |
| am.put("clearSelection", action); | |
| am.put("copy", TransferHandler.getCopyAction()); | |
| am.put("cut", TransferHandler.getCutAction()); | |
| am.put("paste", TransferHandler.getPasteAction()); | |
| UIManager.put("List.actionMap", am); | |
| } | |
| SwingUtilities.replaceUIActionMap(list, am); | |
| } | |
| /** | |
| * Uninstalls keyboard actions for this UI in the {@link JList}. | |
| */ | |
| protected void uninstallKeyboardActions() | |
| { | |
| // Uninstall the InputMap. | |
| InputMap im = SwingUtilities.getUIInputMap(list, JComponent.WHEN_FOCUSED); | |
| if (im instanceof UIResource) | |
| SwingUtilities.replaceUIInputMap(list, JComponent.WHEN_FOCUSED, null); | |
| // Uninstall the ActionMap. | |
| if (SwingUtilities.getUIActionMap(list) instanceof UIResource) | |
| SwingUtilities.replaceUIActionMap(list, null); | |
| } | |
| /** | |
| * Installs the various aspects of the UI in the {@link JList}. In | |
| * particular, calls {@link #installDefaults}, {@link #installListeners} | |
| * and {@link #installKeyboardActions}. Also saves a reference to the | |
| * provided component, cast to a {@link JList}. | |
| * | |
| * @param c The {@link JList} to install the UI into | |
| */ | |
| public void installUI(final JComponent c) | |
| { | |
| super.installUI(c); | |
| list = (JList) c; | |
| installDefaults(); | |
| installListeners(); | |
| installKeyboardActions(); | |
| maybeUpdateLayoutState(); | |
| } | |
| /** | |
| * Uninstalls all the aspects of the UI which were installed in {@link | |
| * #installUI}. When finished uninstalling, drops the saved reference to | |
| * the {@link JList}. | |
| * | |
| * @param c Ignored; the UI is uninstalled from the {@link JList} | |
| * reference saved during the call to {@link #installUI} | |
| */ | |
| public void uninstallUI(final JComponent c) | |
| { | |
| uninstallKeyboardActions(); | |
| uninstallListeners(); | |
| uninstallDefaults(); | |
| list = null; | |
| } | |
| /** | |
| * Gets the size this list would prefer to assume. This is calculated by | |
| * calling {@link #getCellBounds} over the entire list. | |
| * | |
| * @param c Ignored; uses the saved {@link JList} reference | |
| * | |
| * @return DOCUMENT ME! | |
| */ | |
| public Dimension getPreferredSize(JComponent c) | |
| { | |
| maybeUpdateLayoutState(); | |
| int size = list.getModel().getSize(); | |
| int visibleRows = list.getVisibleRowCount(); | |
| int layoutOrientation = list.getLayoutOrientation(); | |
| int h; | |
| int w; | |
| int maxCellHeight = cellHeight; | |
| if (maxCellHeight <= 0) | |
| { | |
| for (int i = 0; i < cellHeights.length; i++) | |
| maxCellHeight = Math.max(maxCellHeight, cellHeights[i]); | |
| } | |
| if (layoutOrientation == JList.HORIZONTAL_WRAP) | |
| { | |
| if (visibleRows > 0) | |
| { | |
| // We cast to double here to force double divisions. | |
| double modelSize = size; | |
| int neededColumns = (int) Math.ceil(modelSize / visibleRows); | |
| int adjustedRows = (int) Math.ceil(modelSize / neededColumns); | |
| h = maxCellHeight * adjustedRows; | |
| w = cellWidth * neededColumns; | |
| } | |
| else | |
| { | |
| int neededColumns = Math.min(1, list.getWidth() / cellWidth); | |
| h = size / neededColumns * maxCellHeight; | |
| w = neededColumns * cellWidth; | |
| } | |
| } | |
| else if (layoutOrientation == JList.VERTICAL_WRAP) | |
| { | |
| if (visibleRows > 0) | |
| h = visibleRows * maxCellHeight; | |
| else | |
| h = Math.max(list.getHeight(), maxCellHeight); | |
| int neededColumns = h / maxCellHeight; | |
| w = cellWidth * neededColumns; | |
| } | |
| else | |
| { | |
| if (list.getFixedCellWidth() > 0) | |
| w = list.getFixedCellWidth(); | |
| else | |
| w = cellWidth; | |
| if (list.getFixedCellHeight() > 0) | |
| // FIXME: We need to add some cellVerticalMargins here, according | |
| // to the specs. | |
| h = list.getFixedCellHeight() * size; | |
| else | |
| h = maxCellHeight * size; | |
| } | |
| Insets insets = list.getInsets(); | |
| Dimension retVal = new Dimension(w + insets.left + insets.right, | |
| h + insets.top + insets.bottom); | |
| return retVal; | |
| } | |
| /** | |
| * Paints a single cell in the list. | |
| * | |
| * @param g The graphics context to paint in | |
| * @param row The row number to paint | |
| * @param bounds The bounds of the cell to paint, assuming a coordinate | |
| * system beginning at <code>(0,0)</code> in the upper left corner of the | |
| * list | |
| * @param rend A cell renderer to paint with | |
| * @param data The data to provide to the cell renderer | |
| * @param sel A selection model to provide to the cell renderer | |
| * @param lead The lead selection index of the list | |
| */ | |
| protected void paintCell(Graphics g, int row, Rectangle bounds, | |
| ListCellRenderer rend, ListModel data, | |
| ListSelectionModel sel, int lead) | |
| { | |
| boolean isSel = list.isSelectedIndex(row); | |
| boolean hasFocus = (list.getLeadSelectionIndex() == row) && BasicListUI.this.list.hasFocus(); | |
| Component comp = rend.getListCellRendererComponent(list, | |
| data.getElementAt(row), | |
| row, isSel, hasFocus); | |
| rendererPane.paintComponent(g, comp, list, bounds); | |
| } | |
| /** | |
| * Paints the list by repeatedly calling {@link #paintCell} for each visible | |
| * cell in the list. | |
| * | |
| * @param g The graphics context to paint with | |
| * @param c Ignored; uses the saved {@link JList} reference | |
| */ | |
| public void paint(Graphics g, JComponent c) | |
| { | |
| int nrows = list.getModel().getSize(); | |
| if (nrows == 0) | |
| return; | |
| maybeUpdateLayoutState(); | |
| ListCellRenderer render = list.getCellRenderer(); | |
| ListModel model = list.getModel(); | |
| ListSelectionModel sel = list.getSelectionModel(); | |
| int lead = sel.getLeadSelectionIndex(); | |
| Rectangle clip = g.getClipBounds(); | |
| int startIndex = locationToIndex(list, new Point(clip.x, clip.y)); | |
| int endIndex = locationToIndex(list, new Point(clip.x + clip.width, | |
| clip.y + clip.height)); | |
| for (int row = startIndex; row <= endIndex; ++row) | |
| { | |
| Rectangle bounds = getCellBounds(list, row, row); | |
| if (bounds != null && bounds.intersects(clip)) | |
| paintCell(g, row, bounds, render, model, sel, lead); | |
| } | |
| } | |
| /** | |
| * Computes the index of a list cell given a point within the list. If the | |
| * location lies outside the bounds of the list, the greatest index in the | |
| * list model is returned. | |
| * | |
| * @param l the list which on which the computation is based on | |
| * @param location the coordinates | |
| * | |
| * @return the index of the list item that is located at the given | |
| * coordinates or <code>-1</code> if the list model is empty | |
| */ | |
| public int locationToIndex(JList l, Point location) | |
| { | |
| int layoutOrientation = list.getLayoutOrientation(); | |
| int index = -1; | |
| switch (layoutOrientation) | |
| { | |
| case JList.VERTICAL: | |
| index = convertYToRow(location.y); | |
| break; | |
| case JList.HORIZONTAL_WRAP: | |
| // determine visible rows and cells per row | |
| int maxCellHeight = getCellHeight(0); | |
| int visibleRows = list.getHeight() / maxCellHeight; | |
| int cellsPerRow = -1; | |
| int numberOfItems = list.getModel().getSize(); | |
| cellsPerRow = numberOfItems / visibleRows + 1; | |
| // determine index for the given location | |
| int cellsPerColumn = numberOfItems / cellsPerRow + 1; | |
| int gridX = Math.min(location.x / cellWidth, cellsPerRow - 1); | |
| int gridY = Math.min(location.y / maxCellHeight, cellsPerColumn); | |
| index = gridX + gridY * cellsPerRow; | |
| break; | |
| case JList.VERTICAL_WRAP: | |
| // determine visible rows and cells per column | |
| int maxCellHeight2 = getCellHeight(0); | |
| int visibleRows2 = list.getHeight() / maxCellHeight2; | |
| int numberOfItems2 = list.getModel().getSize(); | |
| int cellsPerRow2 = numberOfItems2 / visibleRows2 + 1; | |
| int gridX2 = Math.min(location.x / cellWidth, cellsPerRow2 - 1); | |
| int gridY2 = Math.min(location.y / maxCellHeight2, visibleRows2); | |
| index = gridY2 + gridX2 * visibleRows2; | |
| break; | |
| } | |
| return index; | |
| } | |
| public Point indexToLocation(JList l, int index) | |
| { | |
| int layoutOrientation = list.getLayoutOrientation(); | |
| Point loc = null; | |
| switch (layoutOrientation) | |
| { | |
| case JList.VERTICAL: | |
| loc = new Point(0, convertRowToY(index)); | |
| break; | |
| case JList.HORIZONTAL_WRAP: | |
| // determine visible rows and cells per row | |
| int maxCellHeight = getCellHeight(0); | |
| int visibleRows = list.getHeight() / maxCellHeight; | |
| int numberOfCellsPerRow = -1; | |
| int numberOfItems = list.getModel().getSize(); | |
| numberOfCellsPerRow = numberOfItems / visibleRows + 1; | |
| // compute coordinates inside the grid | |
| int gridX = index % numberOfCellsPerRow; | |
| int gridY = index / numberOfCellsPerRow; | |
| int locX = gridX * cellWidth; | |
| int locY; | |
| locY = gridY * maxCellHeight; | |
| loc = new Point(locX, locY); | |
| break; | |
| case JList.VERTICAL_WRAP: | |
| // determine visible rows and cells per column | |
| int maxCellHeight2 = getCellHeight(0); | |
| int visibleRows2 = list.getHeight() / maxCellHeight2; | |
| // compute coordinates inside the grid | |
| if (visibleRows2 > 0) | |
| { | |
| int gridY2 = index % visibleRows2; | |
| int gridX2 = index / visibleRows2; | |
| int locX2 = gridX2 * cellWidth; | |
| int locY2 = gridY2 * maxCellHeight2; | |
| loc = new Point(locX2, locY2); | |
| } | |
| else | |
| loc = new Point(0, convertRowToY(index)); | |
| break; | |
| } | |
| return loc; | |
| } | |
| /** | |
| * Creates and returns the focus listener for this UI. | |
| * | |
| * @return the focus listener for this UI | |
| */ | |
| protected FocusListener createFocusListener() | |
| { | |
| return new FocusHandler(); | |
| } | |
| /** | |
| * Creates and returns the list data listener for this UI. | |
| * | |
| * @return the list data listener for this UI | |
| */ | |
| protected ListDataListener createListDataListener() | |
| { | |
| return new ListDataHandler(); | |
| } | |
| /** | |
| * Creates and returns the list selection listener for this UI. | |
| * | |
| * @return the list selection listener for this UI | |
| */ | |
| protected ListSelectionListener createListSelectionListener() | |
| { | |
| return new ListSelectionHandler(); | |
| } | |
| /** | |
| * Creates and returns the mouse input listener for this UI. | |
| * | |
| * @return the mouse input listener for this UI | |
| */ | |
| protected MouseInputListener createMouseInputListener() | |
| { | |
| return new MouseInputHandler(); | |
| } | |
| /** | |
| * Creates and returns the property change listener for this UI. | |
| * | |
| * @return the property change listener for this UI | |
| */ | |
| protected PropertyChangeListener createPropertyChangeListener() | |
| { | |
| return new PropertyChangeHandler(); | |
| } | |
| /** | |
| * Selects the next list item and force it to be visible. | |
| */ | |
| protected void selectNextIndex() | |
| { | |
| int index = list.getSelectionModel().getLeadSelectionIndex(); | |
| if (index < list.getModel().getSize() - 1) | |
| { | |
| index++; | |
| list.setSelectedIndex(index); | |
| } | |
| list.ensureIndexIsVisible(index); | |
| } | |
| /** | |
| * Selects the previous list item and force it to be visible. | |
| */ | |
| protected void selectPreviousIndex() | |
| { | |
| int index = list.getSelectionModel().getLeadSelectionIndex(); | |
| if (index > 0) | |
| { | |
| index--; | |
| list.setSelectedIndex(index); | |
| } | |
| list.ensureIndexIsVisible(index); | |
| } | |
| } |