File	Doc	Category	Size	Date	Package
JList.java	API Doc	Java SE 5 API	112952	Fri Aug 26 14:57:56 BST 2005	javax.swing

JList

• java.lang.Object
  • java.awt.Component
    • java.awt.Container
      • javax.swing.JComponent

// Create a JList that displays the strings in data[]

String[] data = {"one", "two", "three", "four"};
JList dataList = new JList(data);

// The value of the JList model property is an object that provides
// a read-only view of the data. It was constructed automatically.

for(int i = 0; i < dataList.getModel().getSize(); i++) {
System.out.println(dataList.getModel().getElementAt(i));
}

// Create a JList that displays the superclass of JList.class.
// We store the superclasses in a java.util.Vector.

Vector superClasses = new Vector();
Class rootClass = javax.swing.JList.class;
for(Class cls = rootClass; cls != null; cls = cls.getSuperclass()) {
superClasses.addElement(cls);
}
JList classList = new JList(superClasses);

JScrollPane scrollPane = new JScrollPane(dataList);
// Or in two steps:
JScrollPane scrollPane = new JScrollPane();
scrollPane.getViewport().setView(dataList);

String[] data = {"one", "two", "three", "four"};
JList dataList = new JList(data);

dataList.setSelectedIndex(1); // select "two"
dataList.getSelectedValue(); // returns "two"

// This list model has about 2^16 elements. Enjoy scrolling.


ListModel bigData = new AbstractListModel() {
public int getSize() { return Short.MAX_VALUE; }
public Object getElementAt(int index) { return "Index " + index; }
};

JList bigDataList = new JList(bigData);

// We don't want the JList implementation to compute the width
// or height of all of the list cells, so we give it a string
// that's as big as we'll need for any cell. It uses this to
// compute values for the fixedCellWidth and fixedCellHeight
// properties.

bigDataList.setPrototypeCellValue("Index 1234567890");

// Display an icon and a string for each object in the list.


class MyCellRenderer extends JLabel implements ListCellRenderer {
final static ImageIcon longIcon = new ImageIcon("long.gif");
final static ImageIcon shortIcon = new ImageIcon("short.gif");

// This is the only method defined by ListCellRenderer.
// We just reconfigure the JLabel each time we're called.

public Component getListCellRendererComponent(
JList list,
Object value, // value to display
int index, // cell index
boolean isSelected, // is the cell selected
boolean cellHasFocus) // the list and the cell have the focus
{
String s = value.toString();
setText(s);
setIcon((s.length() > 10) ? longIcon : shortIcon);
if (isSelected) {
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}
else {
setBackground(list.getBackground());
setForeground(list.getForeground());
}
setEnabled(list.isEnabled());
setFont(list.getFont());
setOpaque(true);
return this;
}
}

String[] data = {"one", "two", "three", "four"};
JList dataList = new JList(data);
dataList.setCellRenderer(new MyCellRenderer());

final JList list = new JList(dataModel);
MouseListener mouseListener = new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
int index = list.locationToIndex(e.getPoint());
System.out.println("Double clicked on Item " + index);
}
}
};
list.addMouseListener(mouseListener);

Fields Summary
private static final String	uiClassID
public static final int	VERTICAL Indicates the default layout: one column of cells.
public static final int	VERTICAL_WRAP Indicates "newspaper style" layout with the cells flowing vertically then horizontally.
public static final int	HORIZONTAL_WRAP Indicates "newspaper style" with the cells flowing horizontally then vertically.
private int	fixedCellWidth
private int	fixedCellHeight
private int	horizontalScrollIncrement
private Object	prototypeCellValue
private int	visibleRowCount
private Color	selectionForeground
private Color	selectionBackground
private boolean	dragEnabled
private ListSelectionModel	selectionModel
private ListModel	dataModel
private ListCellRenderer	cellRenderer
private ListSelectionListener	selectionListener
private int	layoutOrientation How to layout the cells, defaults to VERTICAL.

Constructors Summary
public JList(ListModel dataModel) Constructs a JList that displays the elements in the specified, non-null model. All JList constructors delegate to this one. param dataModel the data model for this list exception IllegalArgumentException if dataModel is null if (dataModel == null) { throw new IllegalArgumentException("dataModel must be non null"); } // Register with the ToolTipManager so that tooltips from the // renderer show through. ToolTipManager toolTipManager = ToolTipManager.sharedInstance(); toolTipManager.registerComponent(this); layoutOrientation = VERTICAL; this.dataModel = dataModel; selectionModel = createSelectionModel(); setAutoscrolls(true); setOpaque(true); updateUI();
public JList(Object[] listData) Constructs a JList that displays the elements in the specified array. This constructor just delegates to the ListModel constructor. param listData the array of Objects to be loaded into the data model this ( new AbstractListModel() { public int getSize() { return listData.length; } public Object getElementAt(int i) { return listData[i]; } } );
public JList(Vector listData) Constructs a JList that displays the elements in the specified Vector. This constructor just delegates to the ListModel constructor. param listData the Vector to be loaded into the data model this ( new AbstractListModel() { public int getSize() { return listData.size(); } public Object getElementAt(int i) { return listData.elementAt(i); } } );
public JList() Constructs a JList with an empty model. this ( new AbstractListModel() { public int getSize() { return 0; } public Object getElementAt(int i) { return "No Data Model"; } } );

Methods Summary
public void	addListSelectionListener(javax.swing.event.ListSelectionListener listener) Adds a listener to the list that's notified each time a change to the selection occurs. Listeners added directly to the JList will have their ListSelectionEvent.getSource() == this JList (instead of the ListSelectionModel). param listener the ListSelectionListener to add see #getSelectionModel see #getListSelectionListeners if (selectionListener == null) { selectionListener = new ListSelectionHandler(); getSelectionModel().addListSelectionListener(selectionListener); } listenerList.add(ListSelectionListener.class, listener);
public void	addSelectionInterval(int anchor, int lead) Sets the selection to be the union of the specified interval with current selection. Both the anchor and lead indices are included. It's not necessary for anchor to be less than lead. This is a convenience method that just delegates to the selectionModel. The DefaultListSelectionModel implementation will do nothing if either anchor or lead are -1. If anchor or lead are less than -1, IndexOutOfBoundsException is thrown. param anchor the first index to add to the selection param lead the last index to add to the selection see ListSelectionModel#addSelectionInterval see #setSelectionInterval see #removeSelectionInterval see #addListSelectionListener exception IndexOutOfBoundsException if either anchor or lead are less than -1 getSelectionModel().addSelectionInterval(anchor, lead);
private void	checkScrollableParameters(java.awt.Rectangle visibleRect, int orientation) --- The Scrollable Implementation --- if (visibleRect == null) { throw new IllegalArgumentException("visibleRect must be non-null"); } switch (orientation) { case SwingConstants.VERTICAL: case SwingConstants.HORIZONTAL: break; default: throw new IllegalArgumentException("orientation must be one of: VERTICAL, HORIZONTAL"); }
public void	clearSelection() Clears the selection - after calling this method isSelectionEmpty will return true. This is a convenience method that just delegates to the selectionModel. see ListSelectionModel#clearSelection see #isSelectionEmpty see #addListSelectionListener getSelectionModel().clearSelection();
protected javax.swing.ListSelectionModel	createSelectionModel() Returns an instance of DefaultListSelectionModel. This method is used by the constructor to initialize the selectionModel property. return the ListSelectionModel used by this JList. see #setSelectionModel see DefaultListSelectionModel return new DefaultListSelectionModel();
public void	ensureIndexIsVisible(int index) Scrolls the viewport to make the specified cell completely visible. Note, for this method to work, the JList must be displayed within a JViewport. param index the index of the cell to make visible see JComponent#scrollRectToVisible see #getVisibleRect Rectangle cellBounds = getCellBounds(index, index); if (cellBounds != null) { scrollRectToVisible(cellBounds); }
protected void	fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting) Notifies JList ListSelectionListeners that the selection model has changed. It's used to forward ListSelectionEvents from the selectionModel to the ListSelectionListeners added directly to the JList. param firstIndex the first selected index param lastIndex the last selected index param isAdjusting true if multiple changes are being made see #addListSelectionListener see #removeListSelectionListener see EventListenerList Object[] listeners = listenerList.getListenerList(); ListSelectionEvent e = null; for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ListSelectionListener.class) { if (e == null) { e = new ListSelectionEvent(this, firstIndex, lastIndex, isAdjusting); } ((ListSelectionListener)listeners[i+1]).valueChanged(e); } }
public javax.accessibility.AccessibleContext	getAccessibleContext() Gets the AccessibleContext associated with this JList. For JLists, the AccessibleContext takes the form of an AccessibleJList. A new AccessibleJList instance is created if necessary. return an AccessibleJList that serves as the AccessibleContext of this JList if (accessibleContext == null) { accessibleContext = new AccessibleJList(); } return accessibleContext;
public int	getAnchorSelectionIndex() Returns the first index argument from the most recent addSelectionModel or setSelectionInterval call. This is a convenience method that just delegates to the selectionModel. return the index that most recently anchored an interval selection see ListSelectionModel#getAnchorSelectionIndex see #addSelectionInterval see #setSelectionInterval see #addListSelectionListener return getSelectionModel().getAnchorSelectionIndex();
public java.awt.Rectangle	getCellBounds(int index0, int index1) Returns the bounds of the specified range of items in JList coordinates. Returns null if index isn't valid. param index0 the index of the first JList cell in the range param index1 the index of the last JList cell in the range return the bounds of the indexed cells in pixels ListUI ui = getUI(); return (ui != null) ? ui.getCellBounds(this, index0, index1) : null;
public javax.swing.ListCellRenderer	getCellRenderer() Returns the object that renders the list items. return the ListCellRenderer see #setCellRenderer return cellRenderer;
public boolean	getDragEnabled() Gets the dragEnabled property. return the value of the dragEnabled property see #setDragEnabled since 1.4 return dragEnabled;
public int	getFirstVisibleIndex() Returns the index of the first visible cell. The cell considered to be "first" depends on the list's componentOrientation property. If the orientation is horizontal left-to-right, then the first visible cell is in the list's upper-left corner. If the orientation is horizontal right-to-left, then the first visible cell is in the list's upper-right corner. If nothing is visible or the list is empty, a -1 is returned. Note that the returned cell may only be partially visible. return the index of the first visible cell see #getLastVisibleIndex see JComponent#getVisibleRect Rectangle r = getVisibleRect(); int first; if (this.getComponentOrientation().isLeftToRight()) { first = locationToIndex(r.getLocation()); } else { first = locationToIndex(new Point((r.x + r.width) - 1, r.y)); } if (first != -1) { Rectangle bounds = getCellBounds(first, first); if (bounds != null) { SwingUtilities.computeIntersection(r.x, r.y, r.width, r.height, bounds); if (bounds.width == 0 || bounds.height == 0) { first = -1; } } } return first;
public int	getFixedCellHeight() Returns the fixed cell height value -- the value specified by setting the fixedCellHeight property, rather than that calculated from the list elements. return the fixed cell height, in pixels see #setFixedCellHeight return fixedCellHeight;
public int	getFixedCellWidth() Returns the fixed cell width value -- the value specified by setting the fixedCellWidth property, rather than that calculated from the list elements. return the fixed cell width see #setFixedCellWidth return fixedCellWidth;
public int	getLastVisibleIndex() Returns the index of the last visible cell. The cell considered to be "last" depends on the list's componentOrientation property. If the orientation is horizontal left-to-right, then the last visible cell is in the JList's lower-right corner. If the orientation is horizontal right-to-left, then the last visible cell is in the JList's lower-left corner. If nothing is visible or the list is empty, a -1 is returned. Note that the returned cell may only be partially visible. return the index of the last visible cell see #getFirstVisibleIndex see JComponent#getVisibleRect boolean leftToRight = this.getComponentOrientation().isLeftToRight(); Rectangle r = getVisibleRect(); Point lastPoint; if (leftToRight) { lastPoint = new Point((r.x + r.width) - 1, (r.y + r.height) - 1); } else { lastPoint = new Point(r.x, (r.y + r.height) - 1); } int location = locationToIndex(lastPoint); if (location != -1) { Rectangle bounds = getCellBounds(location, location); if (bounds != null) { SwingUtilities.computeIntersection(r.x, r.y, r.width, r.height, bounds); if (bounds.width == 0 || bounds.height == 0) { // Try the lower left corner, and then go across checking // each cell. Point visibleLL = new Point(r.x, lastPoint.y); int last; int llIndex = -1; int lrIndex = location; location = -1; do { last = llIndex; llIndex = locationToIndex(visibleLL); if (llIndex != -1) { bounds = getCellBounds(llIndex, llIndex); if (llIndex != lrIndex && bounds != null && bounds.contains(visibleLL)) { location = llIndex; visibleLL.x = bounds.x + bounds.width + 1; if (visibleLL.x >= lastPoint.x) { // Past visible region, bail. last = llIndex; } } else { last = llIndex; } } } while (llIndex != -1 && last != llIndex); } } } return location;
public int	getLayoutOrientation() Returns JList.VERTICAL if the layout is a single column of cells, or JList.VERTICAL_WRAP if the layout is "newspaper style" with the content flowing vertically then horizontally or JList.HORIZONTAL_WRAP if the layout is "newspaper style" with the content flowing horizontally then vertically. return the value of the layoutOrientation property see #setLayoutOrientation since 1.4 return layoutOrientation;
public int	getLeadSelectionIndex() Returns the second index argument from the most recent addSelectionInterval or setSelectionInterval call. This is a convenience method that just delegates to the selectionModel. return the index that most recently ended a interval selection see ListSelectionModel#getLeadSelectionIndex see #addSelectionInterval see #setSelectionInterval see #addListSelectionListener beaninfo description: The lead selection index. return getSelectionModel().getLeadSelectionIndex();
public javax.swing.event.ListSelectionListener[]	getListSelectionListeners() Returns an array of all the ListSelectionListeners added to this JList with addListSelectionListener(). return all of the ListSelectionListeners added or an empty array if no listeners have been added see #addListSelectionListener since 1.4 return (ListSelectionListener[])listenerList.getListeners( ListSelectionListener.class);
public int	getMaxSelectionIndex() Returns the largest selected cell index. This is a convenience method that just delegates to the selectionModel. return the largest selected cell index see ListSelectionModel#getMaxSelectionIndex see #addListSelectionListener return getSelectionModel().getMaxSelectionIndex();
public int	getMinSelectionIndex() Returns the smallest selected cell index. This is a convenience method that just delegates to the selectionModel. return the smallest selected cell index see ListSelectionModel#getMinSelectionIndex see #addListSelectionListener return getSelectionModel().getMinSelectionIndex();
public javax.swing.ListModel	getModel() Returns the data model that holds the list of items displayed by the JList component. return the ListModel that provides the displayed list of items see #setModel return dataModel;
public int	getNextMatch(java.lang.String prefix, int startIndex, javax.swing.text.Position$Bias bias) Returns the next list element that starts with a prefix. param prefix the string to test for a match param startIndex the index for starting the search param bias the search direction, either Position.Bias.Forward or Position.Bias.Backward. return the index of the next list element that starts with the prefix; otherwise -1 exception IllegalArgumentException if prefix is null or startIndex is out of bounds since 1.4 ListModel model = getModel(); int max = model.getSize(); if (prefix == null) { throw new IllegalArgumentException(); } if (startIndex < 0 || startIndex >= max) { throw new IllegalArgumentException(); } prefix = prefix.toUpperCase(); // start search from the next element after the selected element int increment = (bias == Position.Bias.Forward) ? 1 : -1; int index = startIndex; do { Object o = model.getElementAt(index); if (o != null) { String string; if (o instanceof String) { string = ((String)o).toUpperCase(); } else { string = o.toString(); if (string != null) { string = string.toUpperCase(); } } if (string != null && string.startsWith(prefix)) { return index; } } index = (index + increment + max) % max; } while (index != startIndex); return -1;
public java.awt.Dimension	getPreferredScrollableViewportSize() Computes the size of the viewport needed to display visibleRowCount rows. This is trivial if fixedCellWidth and fixedCellHeight were specified. Note that they can be specified implicitly with the prototypeCellValue property. If fixedCellWidth wasn't specified, it's computed by finding the widest list element. If fixedCellHeight wasn't specified then we resort to heuristics: If the model isn't empty we just multiply the height of the first row by visibleRowCount. If the model is empty, (JList.getModel().getSize() == 0), then we just allocate 16 pixels per visible row, and 256 pixels for the width (unless fixedCellWidth was set), and hope for the best. If the layout orientation is not VERTICAL, than this will return the value from getPreferredSize. The current ListUI is expected to override getPreferredSize to return an appropriate value. return a dimension containing the size of the viewport needed to display visibleRowCount rows see #getPreferredScrollableViewportSize see #setPrototypeCellValue if (getLayoutOrientation() != VERTICAL) { return getPreferredSize(); } Insets insets = getInsets(); int dx = insets.left + insets.right; int dy = insets.top + insets.bottom; int visibleRowCount = getVisibleRowCount(); int fixedCellWidth = getFixedCellWidth(); int fixedCellHeight = getFixedCellHeight(); if ((fixedCellWidth > 0) && (fixedCellHeight > 0)) { int width = fixedCellWidth + dx; int height = (visibleRowCount * fixedCellHeight) + dy; return new Dimension(width, height); } else if (getModel().getSize() > 0) { int width = getPreferredSize().width; int height; Rectangle r = getCellBounds(0, 0); if (r != null) { height = (visibleRowCount * r.height) + dy; } else { // Will only happen if UI null, shouldn't matter what we return height = 1; } return new Dimension(width, height); } else { fixedCellWidth = (fixedCellWidth > 0) ? fixedCellWidth : 256; fixedCellHeight = (fixedCellHeight > 0) ? fixedCellHeight : 16; return new Dimension(fixedCellWidth, fixedCellHeight * visibleRowCount); }
public java.lang.Object	getPrototypeCellValue() Returns the cell width of the "prototypical cell" -- a cell used for the calculation of cell widths, because it has the same value as all other list items. return the value of the prototypeCellValue property see #setPrototypeCellValue return prototypeCellValue;
public int	getScrollableBlockIncrement(java.awt.Rectangle visibleRect, int orientation, int direction) Returns the distance to scroll to expose the next or previous block. For vertical scrolling we are using the follows rules: if scrolling down (direction is greater than 0), the last visible element should become the first completely visible element if scrolling up, the first visible element should become the last completely visible element visibleRect.height if the list is empty For horizontal scrolling if the list is layed out horizontally (the orientation is VERTICAL_WRAP or HORIZONTAL_WRAP): if scrolling right (direction is greater than 0), the last visible element should become the first completely visible element if scrolling left, the first visible element should become the last completely visible element visibleRect.width if the list is empty Return visibleRect.width if the list is layed out vertically. Note that the value of visibleRect must be the equal to this.getVisibleRect(). param visibleRect the visible rectangle param orientation HORIZONTAL or VERTICAL param direction if <= 0, then scroll UP; if > 0, then scroll DOWN return the block increment amount. see Scrollable#getScrollableUnitIncrement throws IllegalArgumentException if visibleRect is null, or orientation isn't one of SwingConstants.VERTICAL, SwingConstants.HORIZONTAL. checkScrollableParameters(visibleRect, orientation); if (orientation == SwingConstants.VERTICAL) { int inc = visibleRect.height; /* Scroll Down */ if (direction > 0) { // last cell is the lowest left cell int last = locationToIndex(new Point(visibleRect.x, visibleRect.y+visibleRect.height-1)); if (last != -1) { Rectangle lastRect = getCellBounds(last,last); if (lastRect != null) { inc = lastRect.y - visibleRect.y; if ( (inc == 0) && (last < getModel().getSize()-1) ) { inc = lastRect.height; } } } } /* Scroll Up */ else { int newFirst = locationToIndex(new Point(visibleRect.x, visibleRect.y-visibleRect.height)); int first = getFirstVisibleIndex(); if (newFirst != -1) { if (first == -1) { first = locationToIndex(visibleRect.getLocation()); } Rectangle newFirstRect = getCellBounds(newFirst,newFirst); Rectangle firstRect = getCellBounds(first,first); if ((newFirstRect != null) && (firstRect!=null)) { while ( (newFirstRect.y + visibleRect.height < firstRect.y + firstRect.height) && (newFirstRect.y < firstRect.y) ) { newFirst++; newFirstRect = getCellBounds(newFirst,newFirst); } inc = visibleRect.y - newFirstRect.y; if ( (inc <= 0) && (newFirstRect.y > 0)) { newFirst--; newFirstRect = getCellBounds(newFirst,newFirst); if (newFirstRect != null) { inc = visibleRect.y - newFirstRect.y; } } } } } return inc; } else if (orientation == SwingConstants.HORIZONTAL && getLayoutOrientation() != JList.VERTICAL) { int inc = visibleRect.width; /* Scroll Right */ if (direction > 0) { // last cell is an upper right cell int last = locationToIndex(new Point(visibleRect.x + visibleRect.width - 1, visibleRect.y)); if (last != -1) { Rectangle lastRect = getCellBounds(last,last); if (lastRect != null) { inc = lastRect.x - visibleRect.x; if (inc < 0) { inc += lastRect.width; } else if ( (inc == 0) && (last < getModel().getSize()-1) ) { inc = lastRect.width; } } } } /* Scroll Left */ else { // first cell is a cell at the upper left corner of the visibleRect // shifted left by the visibleRect.width int first = locationToIndex(new Point(visibleRect.x - visibleRect.width, visibleRect.y)); if (first != -1) { Rectangle firstRect = getCellBounds(first,first); if (firstRect != null) { if (firstRect.x < visibleRect.x - visibleRect.width) { if (firstRect.x + firstRect.width >= visibleRect.x) { inc = visibleRect.x - firstRect.x; } else { inc = visibleRect.x - firstRect.x - firstRect.width; } } else { inc = visibleRect.x - firstRect.x; } } } } return inc; } return visibleRect.width;
public boolean	getScrollableTracksViewportHeight() Returns true if this JList is displayed in a JViewport and the viewport is taller than JList's preferred height, or if the layout orientation is VERTICAL_WRAP and the number of visible rows is <= 0; otherwise returns false. If false, then don't track the viewport's height. This allows vertical scrolling if the JViewport is itself embedded in a JScrollPane. return true if viewport is taller than Jlist's preferred height, otherwise false see Scrollable#getScrollableTracksViewportHeight if (getLayoutOrientation() == VERTICAL_WRAP && getVisibleRowCount() <= 0) { return true; } if (getParent() instanceof JViewport) { return (((JViewport)getParent()).getHeight() > getPreferredSize().height); } return false;
public boolean	getScrollableTracksViewportWidth() Returns true if this JList is displayed in a JViewport and the viewport is wider than JList's preferred width; or if the layout orientation is HORIZONTAL_WRAP and the visible row count is <= 0; otherwise returns false. If false, then don't track the viewport's width. This allows horizontal scrolling if the JViewport is itself embedded in a JScrollPane. return true if viewport is wider than the JList's preferred width, otherwise false see Scrollable#getScrollableTracksViewportWidth if (getLayoutOrientation() == HORIZONTAL_WRAP && getVisibleRowCount() <= 0) { return true; } if (getParent() instanceof JViewport) { return (((JViewport)getParent()).getWidth() > getPreferredSize().width); } return false;
public int	getScrollableUnitIncrement(java.awt.Rectangle visibleRect, int orientation, int direction) Returns the distance to scroll to expose the next or previous row (for vertical scrolling) or column (for horizontal scrolling). For horizontal scrolling if the list is layed out vertically (the orientation is VERTICAL) than the lists font size or 1 is returned if the font is null is used. Note that the value of visibleRect must be the equal to this.getVisibleRect(). param visibleRect the visible rectangle param orientation HORIZONTAL or VERTICAL param direction if <= 0, then scroll UP; if > 0, then scroll DOWN return the distance, in pixels, to scroll to expose the next or previous unit see Scrollable#getScrollableUnitIncrement throws IllegalArgumentException if visibleRect is null, or orientation isn't one of SwingConstants.VERTICAL, SwingConstants.HORIZONTAL. checkScrollableParameters(visibleRect, orientation); if (orientation == SwingConstants.VERTICAL) { int row = getFirstVisibleIndex(); if (row == -1) { return 0; } else { /* Scroll Down */ if (direction > 0) { Rectangle r = getCellBounds(row, row); return (r == null) ? 0 : r.height - (visibleRect.y - r.y); } /* Scroll Up */ else { Rectangle r = getCellBounds(row, row); /* The first row is completely visible and it's row 0. * We're done. */ if ((r.y == visibleRect.y) && (row == 0)) { return 0; } /* The first row is completely visible, return the * height of the previous row or 0 if the first row * is the top row of the list. */ else if (r.y == visibleRect.y) { Point loc = r.getLocation(); loc.y--; int prevIndex = locationToIndex(loc); Rectangle prevR = getCellBounds(prevIndex, prevIndex); if (prevR == null || prevR.y >= r.y) { return 0; } return prevR.height; } /* The first row is partially visible, return the * height of hidden part. */ else { return visibleRect.y - r.y; } } } } else if (orientation == SwingConstants.HORIZONTAL && getLayoutOrientation() != JList.VERTICAL) { int index = locationToIndex(visibleRect.getLocation()); if (index != -1) { Rectangle cellBounds = getCellBounds(index, index); if (cellBounds != null) { if (cellBounds.x != visibleRect.x) { if (direction < 0) { return Math.abs(cellBounds.x - visibleRect.x); } return cellBounds.width + cellBounds.x - visibleRect.x; } return cellBounds.width; } } } Font f = getFont(); return (f != null) ? f.getSize() : 1;
public int	getSelectedIndex() Returns the first selected index; returns -1 if there is no selected item. return the value of getMinSelectionIndex see #getMinSelectionIndex see #addListSelectionListener return getMinSelectionIndex();
public int[]	getSelectedIndices() Returns an array of all of the selected indices in increasing order. return all of the selected indices, in increasing order see #removeSelectionInterval see #addListSelectionListener ListSelectionModel sm = getSelectionModel(); int iMin = sm.getMinSelectionIndex(); int iMax = sm.getMaxSelectionIndex(); if ((iMin < 0) || (iMax < 0)) { return new int[0]; } int[] rvTmp = new int[1+ (iMax - iMin)]; int n = 0; for(int i = iMin; i <= iMax; i++) { if (sm.isSelectedIndex(i)) { rvTmp[n++] = i; } } int[] rv = new int[n]; System.arraycopy(rvTmp, 0, rv, 0, n); return rv;
public java.lang.Object	getSelectedValue() Returns the first selected value, or null if the selection is empty. return the first selected value see #getMinSelectionIndex see #getModel see #addListSelectionListener int i = getMinSelectionIndex(); return (i == -1) ? null : getModel().getElementAt(i);
public java.lang.Object[]	getSelectedValues() Returns an array of the values for the selected cells. The returned values are sorted in increasing index order. return the selected values or an empty list if nothing is selected see #isSelectedIndex see #getModel see #addListSelectionListener ListSelectionModel sm = getSelectionModel(); ListModel dm = getModel(); int iMin = sm.getMinSelectionIndex(); int iMax = sm.getMaxSelectionIndex(); if ((iMin < 0) || (iMax < 0)) { return new Object[0]; } Object[] rvTmp = new Object[1+ (iMax - iMin)]; int n = 0; for(int i = iMin; i <= iMax; i++) { if (sm.isSelectedIndex(i)) { rvTmp[n++] = dm.getElementAt(i); } } Object[] rv = new Object[n]; System.arraycopy(rvTmp, 0, rv, 0, n); return rv;
public java.awt.Color	getSelectionBackground() Returns the background color for selected cells. return the Color used for the background of selected list items see #setSelectionBackground see #setSelectionForeground return selectionBackground;
public java.awt.Color	getSelectionForeground() Returns the selection foreground color. return the Color object for the foreground property see #setSelectionForeground see #setSelectionBackground return selectionForeground;
public int	getSelectionMode() Returns whether single-item or multiple-item selections are allowed. return the value of the selectionMode property see #setSelectionMode return getSelectionModel().getSelectionMode();
public javax.swing.ListSelectionModel	getSelectionModel() Returns the value of the current selection model. The selection model handles the task of making single selections, selections of contiguous ranges, and non-contiguous selections. return the ListSelectionModel that implements list selections see #setSelectionModel see ListSelectionModel return selectionModel;
public java.lang.String	getToolTipText(java.awt.event.MouseEvent event) Overrides JComponent's getToolTipText method in order to allow the renderer's tips to be used if it has text set. Note: For JList to properly display tooltips of its renderers JList must be a registered component with the ToolTipManager. This is done automatically in the constructor, but if at a later point JList is told setToolTipText(null) it will unregister the list component, and no tips from renderers will display anymore. see JComponent#getToolTipText if(event != null) { Point p = event.getPoint(); int index = locationToIndex(p); ListCellRenderer r = getCellRenderer(); Rectangle cellBounds; if (index != -1 && r != null && (cellBounds = getCellBounds(index, index)) != null && cellBounds.contains(p.x, p.y)) { ListSelectionModel lsm = getSelectionModel(); Component rComponent = r.getListCellRendererComponent( this, getModel().getElementAt(index), index, lsm.isSelectedIndex(index), (hasFocus() && (lsm.getLeadSelectionIndex() == index))); if(rComponent instanceof JComponent) { MouseEvent newEvent; p.translate(-cellBounds.x, -cellBounds.y); newEvent = new MouseEvent(rComponent, event.getID(), event.getWhen(), event.getModifiers(), p.x, p.y, event.getClickCount(), event.isPopupTrigger()); String tip = ((JComponent)rComponent).getToolTipText( newEvent); if (tip != null) { return tip; } } } } return super.getToolTipText();
public javax.swing.plaf.ListUI	getUI() Returns the look and feel (L&F) object that renders this component. return the ListUI object that renders this component return (ListUI)ui;
public java.lang.String	getUIClassID() Returns the suffix used to construct the name of the look and feel (L&F) class used to render this component. return the string "ListUI" see JComponent#getUIClassID see UIDefaults#getUI return uiClassID;
public boolean	getValueIsAdjusting() Returns the value of the data model's isAdjusting property. This value is true if multiple changes are being made. return true if multiple selection-changes are occurring, as when the mouse is being dragged over the list see ListSelectionModel#getValueIsAdjusting return getSelectionModel().getValueIsAdjusting();
public int	getVisibleRowCount() Returns the preferred number of visible rows. return an integer indicating the preferred number of rows to display without using a scroll bar see #setVisibleRowCount return visibleRowCount;
public java.awt.Point	indexToLocation(int index) Returns the origin of the specified item in JList coordinates. Returns null if index isn't valid. param index the index of the JList cell return the origin of the index'th cell ListUI ui = getUI(); return (ui != null) ? ui.indexToLocation(this, index) : null;
public boolean	isSelectedIndex(int index) Returns true if the specified index is selected. This is a convenience method that just delegates to the selectionModel. param index index to be queried for selection state return true if the specified index is selected see ListSelectionModel#isSelectedIndex see #setSelectedIndex see #addListSelectionListener return getSelectionModel().isSelectedIndex(index);
public boolean	isSelectionEmpty() Returns true if nothing is selected. This is a convenience method that just delegates to the selectionModel. return true if nothing is selected see ListSelectionModel#isSelectionEmpty see #clearSelection see #addListSelectionListener return getSelectionModel().isSelectionEmpty();
public int	locationToIndex(java.awt.Point location) Convert a point in JList coordinates to the closest index of the cell at that location. To determine if the cell actually contains the specified location use a combination of this method and getCellBounds. Returns -1 if the model is empty. param location the coordinates of the cell, relative to JList return an integer -- the index of the cell at the given location, or -1. ListUI ui = getUI(); return (ui != null) ? ui.locationToIndex(this, location) : -1;
protected java.lang.String	paramString() Returns a string representation of this JList. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null. return a string representation of this JList. String selectionForegroundString = (selectionForeground != null ? selectionForeground.toString() : ""); String selectionBackgroundString = (selectionBackground != null ? selectionBackground.toString() : ""); return super.paramString() + ",fixedCellHeight=" + fixedCellHeight + ",fixedCellWidth=" + fixedCellWidth + ",horizontalScrollIncrement=" + horizontalScrollIncrement + ",selectionBackground=" + selectionBackgroundString + ",selectionForeground=" + selectionForegroundString + ",visibleRowCount=" + visibleRowCount + ",layoutOrientation=" + layoutOrientation;
public void	removeListSelectionListener(javax.swing.event.ListSelectionListener listener) Removes a listener from the list that's notified each time a change to the selection occurs. param listener the ListSelectionListener to remove see #addListSelectionListener see #getSelectionModel listenerList.remove(ListSelectionListener.class, listener);
public void	removeSelectionInterval(int index0, int index1) Sets the selection to be the set difference of the specified interval and the current selection. Both the index0 and index1 indices are removed. It's not necessary for index0 to be less than index1. This is a convenience method that just delegates to the selectionModel. The DefaultListSelectionModel implementation will do nothing if either index0 or index1 are -1. If index0 or index1 are less than -1, IndexOutOfBoundsException is thrown. param index0 the first index to remove from the selection param index1 the last index to remove from the selection exception IndexOutOfBoundsException if either index0 or index1 are less than -1 see ListSelectionModel#removeSelectionInterval see #setSelectionInterval see #addSelectionInterval see #addListSelectionListener getSelectionModel().removeSelectionInterval(index0, index1);
public void	setCellRenderer(javax.swing.ListCellRenderer cellRenderer) Sets the delegate that's used to paint each cell in the list. If prototypeCellValue was set then the fixedCellWidth and fixedCellHeight properties are set as well. Only one PropertyChangeEvent is generated however - for the cellRenderer property. The default value of this property is provided by the ListUI delegate, i.e. by the look and feel implementation. To see an example which sets the cell renderer, see the class description above. This is a JavaBeans bound property. param cellRenderer the ListCellRenderer that paints list cells see #getCellRenderer beaninfo bound: true attribute: visualUpdate true description: The component used to draw the cells. ListCellRenderer oldValue = this.cellRenderer; this.cellRenderer = cellRenderer; /* If the cellRenderer has changed and prototypeCellValue * was set, then recompute fixedCellWidth and fixedCellHeight. */ if ((cellRenderer != null) && !cellRenderer.equals(oldValue)) { updateFixedCellSize(); } firePropertyChange("cellRenderer", oldValue, cellRenderer);
public void	setDragEnabled(boolean b) Sets the dragEnabled property, which must be true to enable automatic drag handling (the first part of drag and drop) on this component. The transferHandler property needs to be set to a non-null value for the drag to do anything. The default value of the dragEnabled property is false. When automatic drag handling is enabled, most look and feels begin a drag-and-drop operation whenever the user presses the mouse button over a selection and then moves the mouse a few pixels. Setting this property to true can therefore have a subtle effect on how selections behave. Some look and feels might not support automatic drag and drop; they will ignore this property. You can work around such look and feels by modifying the component to directly call the exportAsDrag method of a TransferHandler. param b the value to set the dragEnabled property to exception HeadlessException if b is true and GraphicsEnvironment.isHeadless() returns true see java.awt.GraphicsEnvironment#isHeadless see #getDragEnabled see #setTransferHandler see TransferHandler since 1.4 beaninfo description: determines whether automatic drag handling is enabled bound: false if (b && GraphicsEnvironment.isHeadless()) { throw new HeadlessException(); } dragEnabled = b;
public void	setFixedCellHeight(int height) Sets the height of every cell in the list. If height is -1, cell heights are computed by applying getPreferredSize to the cellRenderer component for each list element. The default value of this property is -1. This is a JavaBeans bound property. param height an integer giving the height, in pixels, for all cells in this list see #getPrototypeCellValue see #setFixedCellWidth see JComponent#addPropertyChangeListener beaninfo bound: true attribute: visualUpdate true description: Defines a fixed cell height when greater than zero. int oldValue = fixedCellHeight; fixedCellHeight = height; firePropertyChange("fixedCellHeight", oldValue, fixedCellHeight);
public void	setFixedCellWidth(int width) Sets the width of every cell in the list. If width is -1, cell widths are computed by applying getPreferredSize to the cellRenderer component for each list element. The default value of this property is -1. This is a JavaBeans bound property. param width the width, in pixels, for all cells in this list see #getPrototypeCellValue see #setFixedCellWidth see JComponent#addPropertyChangeListener beaninfo bound: true attribute: visualUpdate true description: Defines a fixed cell width when greater than zero. int oldValue = fixedCellWidth; fixedCellWidth = width; firePropertyChange("fixedCellWidth", oldValue, fixedCellWidth);
public void	setLayoutOrientation(int layoutOrientation) Defines the way list cells are layed out. Consider a JList with four cells, this can be layed out in one of the following ways: 0 1 2 3 0 1 2 3 0 2 1 3 These correspond to the following values: Value Description JList.VERTICAL The cells should be layed out vertically in one column. JList.HORIZONTAL_WRAP The cells should be layed out horizontally, wrapping to a new row as necessary. The number of rows to use will either be defined by getVisibleRowCount if > 0, otherwise the number of rows will be determined by the width of the JList. JList.VERTICAL_WRAP The cells should be layed out vertically, wrapping to a new column as necessary. The number of rows to use will either be defined by getVisibleRowCount if > 0, otherwise the number of rows will be determined by the height of the JList. The default value of this property is JList.VERTICAL. This will throw an IllegalArgumentException if layoutOrientation is not one of JList.HORIZONTAL_WRAP or JList.VERTICAL or JList.VERTICAL_WRAP param layoutOrientation New orientation, one of JList.HORIZONTAL_WRAP, JList.VERTICAL or JList.VERTICAL_WRAP. see #getLayoutOrientation see #setVisibleRowCount see #getScrollableTracksViewportHeight since 1.4 beaninfo bound: true attribute: visualUpdate true description: Defines the way list cells are layed out. enum: VERTICAL JList.VERTICAL HORIZONTAL_WRAP JList.HORIZONTAL_WRAP VERTICAL_WRAP JList.VERTICAL_WRAP int oldValue = this.layoutOrientation; switch (layoutOrientation) { case VERTICAL: case VERTICAL_WRAP: case HORIZONTAL_WRAP: this.layoutOrientation = layoutOrientation; firePropertyChange("layoutOrientation", oldValue, layoutOrientation); break; default: throw new IllegalArgumentException("layoutOrientation must be one of: VERTICAL, HORIZONTAL_WRAP or VERTICAL_WRAP"); }
public void	setListData(java.lang.Object[] listData) Constructs a ListModel from an array of objects and then applies setModel to it. param listData an array of Objects containing the items to display in the list see #setModel setModel ( new AbstractListModel() { public int getSize() { return listData.length; } public Object getElementAt(int i) { return listData[i]; } } );
public void	setListData(java.util.Vector listData) Constructs a ListModel from a Vector and then applies setModel to it. param listData a Vector containing the items to display in the list see #setModel setModel ( new AbstractListModel() { public int getSize() { return listData.size(); } public Object getElementAt(int i) { return listData.elementAt(i); } } );
public void	setModel(javax.swing.ListModel model) Sets the model that represents the contents or "value" of the list and clears the list selection after notifying PropertyChangeListeners. This is a JavaBeans bound property. param model the ListModel that provides the list of items for display exception IllegalArgumentException if model is null see #getModel beaninfo bound: true attribute: visualUpdate true description: The object that contains the data to be drawn by this JList. if (model == null) { throw new IllegalArgumentException("model must be non null"); } ListModel oldValue = dataModel; dataModel = model; firePropertyChange("model", oldValue, dataModel); clearSelection();
public void	setPrototypeCellValue(java.lang.Object prototypeCellValue) Computes the fixedCellWidth and fixedCellHeight properties by configuring the cellRenderer to index equals zero for the specified value and then computing the renderer component's preferred size. These properties are useful when the list is too long to allow JList to compute the width/height of each cell and there is a single cell value that is known to occupy as much space as any of the others. Note that we do set the fixedCellWidth and fixedCellHeight properties here but only a prototypeCellValue PropertyChangeEvent is fired. To see an example which sets this property, see the class description above. The default value of this property is null. This is a JavaBeans bound property. param prototypeCellValue the value on which to base fixedCellWidth and fixedCellHeight see #getPrototypeCellValue see #setFixedCellWidth see #setFixedCellHeight see JComponent#addPropertyChangeListener beaninfo bound: true attribute: visualUpdate true description: The cell prototype value, used to compute cell width and height. Object oldValue = this.prototypeCellValue; this.prototypeCellValue = prototypeCellValue; /* If the cellRenderer has changed and prototypeCellValue * was set, then recompute fixedCellWidth and fixedCellHeight. */ if ((prototypeCellValue != null) && !prototypeCellValue.equals(oldValue)) { updateFixedCellSize(); } firePropertyChange("prototypeCellValue", oldValue, prototypeCellValue);
public void	setSelectedIndex(int index) Selects a single cell. param index the index of the one cell to select see ListSelectionModel#setSelectionInterval see #isSelectedIndex see #addListSelectionListener beaninfo description: The index of the selected cell. if (index >= getModel().getSize()) { return; } getSelectionModel().setSelectionInterval(index, index);
public void	setSelectedIndices(int[] indices) Selects a set of cells. param indices an array of the indices of the cells to select see ListSelectionModel#addSelectionInterval see #isSelectedIndex see #addListSelectionListener ListSelectionModel sm = getSelectionModel(); sm.clearSelection(); int size = getModel().getSize(); for(int i = 0; i < indices.length; i++) { if (indices[i] < size) { sm.addSelectionInterval(indices[i], indices[i]); } }
public void	setSelectedValue(java.lang.Object anObject, boolean shouldScroll) Selects the specified object from the list. param anObject the object to select param shouldScroll true if the list should scroll to display the selected object, if one exists; otherwise false if(anObject == null) setSelectedIndex(-1); else if(!anObject.equals(getSelectedValue())) { int i,c; ListModel dm = getModel(); for(i=0,c=dm.getSize();i<c;i++) if(anObject.equals(dm.getElementAt(i))){ setSelectedIndex(i); if(shouldScroll) ensureIndexIsVisible(i); repaint(); /** FIX-ME setSelectedIndex does not redraw all the time with the basic l&f**/ return; } setSelectedIndex(-1); } repaint(); /** FIX-ME setSelectedIndex does not redraw all the time with the basic l&f**/
public void	setSelectionBackground(java.awt.Color selectionBackground) Sets the background color for selected cells. Cell renderers can use this color to the fill selected cells. The default value of this property is defined by the look and feel implementation. This is a JavaBeans bound property. param selectionBackground the Color to use for the background of selected cells see #getSelectionBackground see #setSelectionForeground see #setForeground see #setBackground see #setFont beaninfo bound: true attribute: visualUpdate true description: The background color of selected cells. Color oldValue = this.selectionBackground; this.selectionBackground = selectionBackground; firePropertyChange("selectionBackground", oldValue, selectionBackground);
public void	setSelectionForeground(java.awt.Color selectionForeground) Sets the foreground color for selected cells. Cell renderers can use this color to render text and graphics for selected cells. The default value of this property is defined by the look and feel implementation. This is a JavaBeans bound property. param selectionForeground the Color to use in the foreground for selected list items see #getSelectionForeground see #setSelectionBackground see #setForeground see #setBackground see #setFont beaninfo bound: true attribute: visualUpdate true description: The foreground color of selected cells. Color oldValue = this.selectionForeground; this.selectionForeground = selectionForeground; firePropertyChange("selectionForeground", oldValue, selectionForeground);
public void	setSelectionInterval(int anchor, int lead) Selects the specified interval. Both the anchor and lead indices are included. It's not necessary for anchor to be less than lead. This is a convenience method that just delegates to the selectionModel. The DefaultListSelectionModel implementation will do nothing if either anchor or lead are -1. If anchor or lead are less than -1, IndexOutOfBoundsException is thrown. param anchor the first index to select param lead the last index to select exception IndexOutOfBoundsException if either anchor or lead are less than -1 see ListSelectionModel#setSelectionInterval see #addSelectionInterval see #removeSelectionInterval see #addListSelectionListener getSelectionModel().setSelectionInterval(anchor, lead);
public void	setSelectionMode(int selectionMode) Determines whether single-item or multiple-item selections are allowed. The following selectionMode values are allowed: ListSelectionModel.SINGLE_SELECTION Only one list index can be selected at a time. In this mode the setSelectionInterval and addSelectionInterval methods are equivalent, and only the second index argument is used. ListSelectionModel.SINGLE_INTERVAL_SELECTION One contiguous index interval can be selected at a time. In this mode setSelectionInterval and addSelectionInterval are equivalent. ListSelectionModel.MULTIPLE_INTERVAL_SELECTION In this mode, there's no restriction on what can be selected. This is the default. param selectionMode an integer specifying the type of selections that are permissible see #getSelectionMode beaninfo description: The selection mode. enum: SINGLE_SELECTION ListSelectionModel.SINGLE_SELECTION SINGLE_INTERVAL_SELECTION ListSelectionModel.SINGLE_INTERVAL_SELECTION MULTIPLE_INTERVAL_SELECTION ListSelectionModel.MULTIPLE_INTERVAL_SELECTION getSelectionModel().setSelectionMode(selectionMode);
public void	setSelectionModel(javax.swing.ListSelectionModel selectionModel) Sets the selectionModel for the list to a non-null ListSelectionModel implementation. The selection model handles the task of making single selections, selections of contiguous ranges, and non-contiguous selections. This is a JavaBeans bound property. param selectionModel the ListSelectionModel that implements the selections exception IllegalArgumentException if selectionModel is null see #getSelectionModel beaninfo bound: true description: The selection model, recording which cells are selected. if (selectionModel == null) { throw new IllegalArgumentException("selectionModel must be non null"); } /* Remove the forwarding ListSelectionListener from the old * selectionModel, and add it to the new one, if necessary. */ if (selectionListener != null) { this.selectionModel.removeListSelectionListener(selectionListener); selectionModel.addListSelectionListener(selectionListener); } ListSelectionModel oldValue = this.selectionModel; this.selectionModel = selectionModel; firePropertyChange("selectionModel", oldValue, selectionModel);
public void	setUI(javax.swing.plaf.ListUI ui) Sets the look and feel (L&F) object that renders this component. param ui the ListUI L&F object see UIDefaults#getUI beaninfo bound: true hidden: true attribute: visualUpdate true description: The UI object that implements the Component's LookAndFeel. super.setUI(ui);
public void	setValueIsAdjusting(boolean b) Sets the data model's isAdjusting property to true, so that a single event will be generated when all of the selection events have finished (for example, when the mouse is being dragged over the list in selection mode). param b the boolean value for the property value see ListSelectionModel#setValueIsAdjusting getSelectionModel().setValueIsAdjusting(b);
public void	setVisibleRowCount(int visibleRowCount) Sets the preferred number of rows in the list that can be displayed without a scrollbar, as determined by the nearest JViewport ancestor, if any. The value of this property only affects the value of the JList's preferredScrollableViewportSize. The default value of this property is 8. This is a JavaBeans bound property. param visibleRowCount an integer specifying the preferred number of visible rows see #getVisibleRowCount see JComponent#getVisibleRect see JViewport beaninfo bound: true attribute: visualUpdate true description: The preferred number of cells that can be displayed without a scroll bar. int oldValue = this.visibleRowCount; this.visibleRowCount = Math.max(0, visibleRowCount); firePropertyChange("visibleRowCount", oldValue, visibleRowCount);
private void	updateFixedCellSize() ListCellRenderer cr = getCellRenderer(); Object value = getPrototypeCellValue(); if ((cr != null) && (value != null)) { Component c = cr.getListCellRendererComponent(this, value, 0, false, false); /* The ListUI implementation will add Component c to its private * CellRendererPane however we can't assume that's already * been done here. So we temporarily set the one "inherited" * property that may affect the renderer components preferred size: * its font. */ Font f = c.getFont(); c.setFont(getFont()); Dimension d = c.getPreferredSize(); fixedCellWidth = d.width; fixedCellHeight = d.height; c.setFont(f); }
public void	updateUI() Resets the UI property with the value from the current look and feel. see UIManager#getUI setUI((ListUI)UIManager.getUI(this)); invalidate();
private void	writeObject(java.io.ObjectOutputStream s) s.defaultWriteObject(); if (getUIClassID().equals(uiClassID)) { byte count = JComponent.getWriteObjCounter(this); JComponent.setWriteObjCounter(this, --count); if (count == 0 && ui != null) { ui.installUI(this); } }