1 /*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.swing.plaf.basic;
27
28 import sun.swing.DefaultLookup;
29 import sun.swing.UIAction;
30
31 import javax.swing.*;
32 import javax.swing.event.*;
33 import javax.swing.plaf.*;
34 import javax.swing.text.Position;
35
36 import java.awt.*;
37 import java.awt.event.*;
38 import java.awt.datatransfer.Transferable;
39 import java.awt.geom.Point2D;
40
41 import java.beans.PropertyChangeListener;
42 import java.beans.PropertyChangeEvent;
43
44 import sun.swing.SwingUtilities2;
45 import javax.swing.plaf.basic.DragRecognitionSupport.BeforeDrag;
46
47 /**
48 * An extensible implementation of {@code ListUI}.
49 * <p>
50 * {@code BasicListUI} instances cannot be shared between multiple
51 * lists.
52 *
53 * @author Hans Muller
54 * @author Philip Milne
55 * @author Shannon Hickey (drag and drop)
56 */
57 public class BasicListUI extends ListUI
58 {
59 private static final StringBuilder BASELINE_COMPONENT_KEY =
60 new StringBuilder("List.baselineComponent");
61
62 /**
63 * The instance of {@code JList}.
64 */
65 protected JList<Object> list = null;
66 /**
67 * The instance of {@code CellRendererPane}.
68 */
69 protected CellRendererPane rendererPane;
70
71 // Listeners that this UI attaches to the JList
72 /**
73 * {@code FocusListener} that attached to {@code JList}.
74 */
75 protected FocusListener focusListener;
76 /**
77 * {@code MouseInputListener} that attached to {@code JList}.
78 */
79 protected MouseInputListener mouseInputListener;
80 /**
81 * {@code ListSelectionListener} that attached to {@code JList}.
82 */
83 protected ListSelectionListener listSelectionListener;
84 /**
85 * {@code ListDataListener} that attached to {@code JList}.
86 */
87 protected ListDataListener listDataListener;
88 /**
89 * {@code PropertyChangeListener} that attached to {@code JList}.
90 */
91 protected PropertyChangeListener propertyChangeListener;
92 private Handler handler;
93
94 /**
95 * The array of cells' height
96 */
97 protected int[] cellHeights = null;
98 /**
99 * The height of cell.
100 */
101 protected int cellHeight = -1;
102 /**
103 * The width of cell.
104 */
105 protected int cellWidth = -1;
106 /**
107 * The value represents changes to {@code JList} model.
108 */
109 protected int updateLayoutStateNeeded = modelChanged;
110 /**
111 * Height of the list. When asked to paint, if the current size of
112 * the list differs, this will update the layout state.
113 */
114 private int listHeight;
115
116 /**
117 * Width of the list. When asked to paint, if the current size of
118 * the list differs, this will update the layout state.
119 */
120 private int listWidth;
121
122 /**
123 * The layout orientation of the list.
124 */
125 private int layoutOrientation;
126
127 // Following ivars are used if the list is laying out horizontally
128
129 /**
130 * Number of columns to create.
131 */
132 private int columnCount;
133 /**
134 * Preferred height to make the list, this is only used if the
135 * the list is layed out horizontally.
136 */
137 private int preferredHeight;
138 /**
139 * Number of rows per column. This is only used if the row height is
140 * fixed.
141 */
142 private int rowsPerColumn;
143
144 /**
145 * The time factor to treate the series of typed alphanumeric key
146 * as prefix for first letter navigation.
147 */
148 private long timeFactor = 1000L;
149
150 /**
151 * Local cache of JList's client property "List.isFileList"
152 */
153 private boolean isFileList = false;
154
155 /**
156 * Local cache of JList's component orientation property
157 */
158 private boolean isLeftToRight = true;
159
160 /* The bits below define JList property changes that affect layout.
161 * When one of these properties changes we set a bit in
162 * updateLayoutStateNeeded. The change is dealt with lazily, see
163 * maybeUpdateLayoutState. Changes to the JLists model, e.g. the
164 * models length changed, are handled similarly, see DataListener.
165 */
166
167 /**
168 * The bit relates to model changed property.
169 */
170 protected static final int modelChanged = 1 << 0;
171 /**
172 * The bit relates to selection model changed property.
173 */
174 protected static final int selectionModelChanged = 1 << 1;
175 /**
176 * The bit relates to font changed property.
177 */
178 protected static final int fontChanged = 1 << 2;
179 /**
180 * The bit relates to fixed cell width changed property.
181 */
182 protected static final int fixedCellWidthChanged = 1 << 3;
183 /**
184 * The bit relates to fixed cell height changed property.
185 */
186 protected static final int fixedCellHeightChanged = 1 << 4;
187 /**
188 * The bit relates to prototype cell value changed property.
189 */
190 protected static final int prototypeCellValueChanged = 1 << 5;
191 /**
192 * The bit relates to cell renderer changed property.
193 */
194 protected static final int cellRendererChanged = 1 << 6;
195 private static final int layoutOrientationChanged = 1 << 7;
196 private static final int heightChanged = 1 << 8;
197 private static final int widthChanged = 1 << 9;
198 private static final int componentOrientationChanged = 1 << 10;
199
200 private static final int DROP_LINE_THICKNESS = 2;
201
202 static void loadActionMap(LazyActionMap map) {
203 map.put(new Actions(Actions.SELECT_PREVIOUS_COLUMN));
204 map.put(new Actions(Actions.SELECT_PREVIOUS_COLUMN_EXTEND));
205 map.put(new Actions(Actions.SELECT_PREVIOUS_COLUMN_CHANGE_LEAD));
206 map.put(new Actions(Actions.SELECT_NEXT_COLUMN));
207 map.put(new Actions(Actions.SELECT_NEXT_COLUMN_EXTEND));
208 map.put(new Actions(Actions.SELECT_NEXT_COLUMN_CHANGE_LEAD));
209 map.put(new Actions(Actions.SELECT_PREVIOUS_ROW));
210 map.put(new Actions(Actions.SELECT_PREVIOUS_ROW_EXTEND));
211 map.put(new Actions(Actions.SELECT_PREVIOUS_ROW_CHANGE_LEAD));
212 map.put(new Actions(Actions.SELECT_NEXT_ROW));
213 map.put(new Actions(Actions.SELECT_NEXT_ROW_EXTEND));
214 map.put(new Actions(Actions.SELECT_NEXT_ROW_CHANGE_LEAD));
215 map.put(new Actions(Actions.SELECT_FIRST_ROW));
216 map.put(new Actions(Actions.SELECT_FIRST_ROW_EXTEND));
217 map.put(new Actions(Actions.SELECT_FIRST_ROW_CHANGE_LEAD));
218 map.put(new Actions(Actions.SELECT_LAST_ROW));
219 map.put(new Actions(Actions.SELECT_LAST_ROW_EXTEND));
220 map.put(new Actions(Actions.SELECT_LAST_ROW_CHANGE_LEAD));
221 map.put(new Actions(Actions.SCROLL_UP));
222 map.put(new Actions(Actions.SCROLL_UP_EXTEND));
223 map.put(new Actions(Actions.SCROLL_UP_CHANGE_LEAD));
224 map.put(new Actions(Actions.SCROLL_DOWN));
225 map.put(new Actions(Actions.SCROLL_DOWN_EXTEND));
226 map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_LEAD));
227 map.put(new Actions(Actions.SELECT_ALL));
228 map.put(new Actions(Actions.CLEAR_SELECTION));
229 map.put(new Actions(Actions.ADD_TO_SELECTION));
230 map.put(new Actions(Actions.TOGGLE_AND_ANCHOR));
231 map.put(new Actions(Actions.EXTEND_TO));
232 map.put(new Actions(Actions.MOVE_SELECTION_TO));
233
234 map.put(TransferHandler.getCutAction().getValue(Action.NAME),
235 TransferHandler.getCutAction());
236 map.put(TransferHandler.getCopyAction().getValue(Action.NAME),
237 TransferHandler.getCopyAction());
238 map.put(TransferHandler.getPasteAction().getValue(Action.NAME),
239 TransferHandler.getPasteAction());
240 }
241
242 /**
243 * Paint one List cell: compute the relevant state, get the "rubber stamp"
244 * cell renderer component, and then use the {@code CellRendererPane} to paint it.
245 * Subclasses may want to override this method rather than {@code paint()}.
246 *
247 * @param g an instance of {@code Graphics}
248 * @param row a row
249 * @param rowBounds a bounding rectangle to render to
250 * @param cellRenderer a list of {@code ListCellRenderer}
251 * @param dataModel a list model
252 * @param selModel a selection model
253 * @param leadIndex a lead index
254 * @see #paint
255 */
256 protected void paintCell(
257 Graphics g,
258 int row,
259 Rectangle rowBounds,
260 ListCellRenderer<Object> cellRenderer,
261 ListModel<Object> dataModel,
262 ListSelectionModel selModel,
263 int leadIndex)
264 {
265 Object value = dataModel.getElementAt(row);
266 boolean cellHasFocus = list.hasFocus() && (row == leadIndex);
267 boolean isSelected = selModel.isSelectedIndex(row);
268
269 Component rendererComponent =
270 cellRenderer.getListCellRendererComponent(list, value, row, isSelected, cellHasFocus);
271
272 int cx = rowBounds.x;
273 int cy = rowBounds.y;
274 int cw = rowBounds.width;
275 int ch = rowBounds.height;
276
277 if (isFileList) {
278 // Shrink renderer to preferred size. This is mostly used on Windows
279 // where selection is only shown around the file name, instead of
280 // across the whole list cell.
281 int w = Math.min(cw, rendererComponent.getPreferredSize().width + 4);
282 if (!isLeftToRight) {
283 cx += (cw - w);
284 }
285 cw = w;
286 }
287
288 rendererPane.paintComponent(g, rendererComponent, list, cx, cy, cw, ch, true);
289 }
290
291
292 /**
293 * Paint the rows that intersect the Graphics objects clipRect. This
294 * method calls paintCell as necessary. Subclasses
295 * may want to override these methods.
296 *
297 * @see #paintCell
298 */
299 public void paint(Graphics g, JComponent c) {
300 Shape clip = g.getClip();
301 paintImpl(g, c);
302 g.setClip(clip);
303
304 paintDropLine(g);
305 }
306
307 private void paintImpl(Graphics g, JComponent c)
308 {
309 switch (layoutOrientation) {
310 case JList.VERTICAL_WRAP:
311 if (list.getHeight() != listHeight) {
312 updateLayoutStateNeeded |= heightChanged;
313 redrawList();
314 }
315 break;
316 case JList.HORIZONTAL_WRAP:
317 if (list.getWidth() != listWidth) {
318 updateLayoutStateNeeded |= widthChanged;
319 redrawList();
320 }
321 break;
322 default:
323 break;
324 }
325 maybeUpdateLayoutState();
326
327 ListCellRenderer<Object> renderer = list.getCellRenderer();
328 ListModel<Object> dataModel = list.getModel();
329 ListSelectionModel selModel = list.getSelectionModel();
330 int size;
331
332 if ((renderer == null) || (size = dataModel.getSize()) == 0) {
333 return;
334 }
335
336 // Determine how many columns we need to paint
337 Rectangle paintBounds = g.getClipBounds();
338
339 int startColumn, endColumn;
340 if (c.getComponentOrientation().isLeftToRight()) {
341 startColumn = convertLocationToColumn(paintBounds.x,
342 paintBounds.y);
343 endColumn = convertLocationToColumn(paintBounds.x +
344 paintBounds.width,
345 paintBounds.y);
346 } else {
347 startColumn = convertLocationToColumn(paintBounds.x +
348 paintBounds.width,
349 paintBounds.y);
350 endColumn = convertLocationToColumn(paintBounds.x,
351 paintBounds.y);
352 }
353 int maxY = paintBounds.y + paintBounds.height;
354 int leadIndex = adjustIndex(list.getLeadSelectionIndex(), list);
355 int rowIncrement = (layoutOrientation == JList.HORIZONTAL_WRAP) ?
356 columnCount : 1;
357
358
359 for (int colCounter = startColumn; colCounter <= endColumn;
360 colCounter++) {
361 // And then how many rows in this columnn
362 int row = convertLocationToRowInColumn(paintBounds.y, colCounter);
363 int rowCount = getRowCount(colCounter);
364 int index = getModelIndex(colCounter, row);
365 Rectangle rowBounds = getCellBounds(list, index, index);
366
367 if (rowBounds == null) {
368 // Not valid, bail!
369 return;
370 }
371 while (row < rowCount && rowBounds.y < maxY &&
372 index < size) {
373 rowBounds.height = getHeight(colCounter, row);
374 g.setClip(rowBounds.x, rowBounds.y, rowBounds.width,
375 rowBounds.height);
376 g.clipRect(paintBounds.x, paintBounds.y, paintBounds.width,
377 paintBounds.height);
378 paintCell(g, index, rowBounds, renderer, dataModel, selModel,
379 leadIndex);
380 rowBounds.y += rowBounds.height;
381 index += rowIncrement;
382 row++;
383 }
384 }
385 // Empty out the renderer pane, allowing renderers to be gc'ed.
386 rendererPane.removeAll();
387 }
388
389 private void paintDropLine(Graphics g) {
390 JList.DropLocation loc = list.getDropLocation();
391 if (loc == null || !loc.isInsert()) {
392 return;
393 }
394
395 Color c = DefaultLookup.getColor(list, this, "List.dropLineColor", null);
396 if (c != null) {
397 g.setColor(c);
398 Rectangle rect = getDropLineRect(loc);
399 g.fillRect(rect.x, rect.y, rect.width, rect.height);
400 }
401 }
402
403 private Rectangle getDropLineRect(JList.DropLocation loc) {
404 int size = list.getModel().getSize();
405
406 if (size == 0) {
407 Insets insets = list.getInsets();
408 if (layoutOrientation == JList.HORIZONTAL_WRAP) {
409 if (isLeftToRight) {
410 return new Rectangle(insets.left, insets.top, DROP_LINE_THICKNESS, 20);
411 } else {
412 return new Rectangle(list.getWidth() - DROP_LINE_THICKNESS - insets.right,
413 insets.top, DROP_LINE_THICKNESS, 20);
414 }
415 } else {
416 return new Rectangle(insets.left, insets.top,
417 list.getWidth() - insets.left - insets.right,
418 DROP_LINE_THICKNESS);
419 }
420 }
421
422 Rectangle rect = null;
423 int index = loc.getIndex();
424 boolean decr = false;
425
426 if (layoutOrientation == JList.HORIZONTAL_WRAP) {
427 if (index == size) {
428 decr = true;
429 } else if (index != 0 && convertModelToRow(index)
430 != convertModelToRow(index - 1)) {
431
432 Rectangle prev = getCellBounds(list, index - 1);
433 Rectangle me = getCellBounds(list, index);
434 Point p = loc.getDropPoint();
435
436 if (isLeftToRight) {
437 decr = Point2D.distance(prev.x + prev.width,
438 prev.y + (int)(prev.height / 2.0),
439 p.x, p.y)
440 < Point2D.distance(me.x,
441 me.y + (int)(me.height / 2.0),
442 p.x, p.y);
443 } else {
444 decr = Point2D.distance(prev.x,
445 prev.y + (int)(prev.height / 2.0),
446 p.x, p.y)
447 < Point2D.distance(me.x + me.width,
448 me.y + (int)(prev.height / 2.0),
449 p.x, p.y);
450 }
451 }
452
453 if (decr) {
454 index--;
455 rect = getCellBounds(list, index);
456 if (isLeftToRight) {
457 rect.x += rect.width;
458 } else {
459 rect.x -= DROP_LINE_THICKNESS;
460 }
461 } else {
462 rect = getCellBounds(list, index);
463 if (!isLeftToRight) {
464 rect.x += rect.width - DROP_LINE_THICKNESS;
465 }
466 }
467
468 if (rect.x >= list.getWidth()) {
469 rect.x = list.getWidth() - DROP_LINE_THICKNESS;
470 } else if (rect.x < 0) {
471 rect.x = 0;
472 }
473
474 rect.width = DROP_LINE_THICKNESS;
475 } else if (layoutOrientation == JList.VERTICAL_WRAP) {
476 if (index == size) {
477 index--;
478 rect = getCellBounds(list, index);
479 rect.y += rect.height;
480 } else if (index != 0 && convertModelToColumn(index)
481 != convertModelToColumn(index - 1)) {
482
483 Rectangle prev = getCellBounds(list, index - 1);
484 Rectangle me = getCellBounds(list, index);
485 Point p = loc.getDropPoint();
486 if (Point2D.distance(prev.x + (int)(prev.width / 2.0),
487 prev.y + prev.height,
488 p.x, p.y)
489 < Point2D.distance(me.x + (int)(me.width / 2.0),
490 me.y,
491 p.x, p.y)) {
492
493 index--;
494 rect = getCellBounds(list, index);
495 rect.y += rect.height;
496 } else {
497 rect = getCellBounds(list, index);
498 }
499 } else {
500 rect = getCellBounds(list, index);
501 }
502
503 if (rect.y >= list.getHeight()) {
504 rect.y = list.getHeight() - DROP_LINE_THICKNESS;
505 }
506
507 rect.height = DROP_LINE_THICKNESS;
508 } else {
509 if (index == size) {
510 index--;
511 rect = getCellBounds(list, index);
512 rect.y += rect.height;
513 } else {
514 rect = getCellBounds(list, index);
515 }
516
517 if (rect.y >= list.getHeight()) {
518 rect.y = list.getHeight() - DROP_LINE_THICKNESS;
519 }
520
521 rect.height = DROP_LINE_THICKNESS;
522 }
523
524 return rect;
525 }
526
527 /**
528 * Returns the baseline.
529 *
530 * @throws NullPointerException {@inheritDoc}
531 * @throws IllegalArgumentException {@inheritDoc}
532 * @see javax.swing.JComponent#getBaseline(int, int)
533 * @since 1.6
534 */
535 public int getBaseline(JComponent c, int width, int height) {
536 super.getBaseline(c, width, height);
537 int rowHeight = list.getFixedCellHeight();
538 UIDefaults lafDefaults = UIManager.getLookAndFeelDefaults();
539 Component renderer = (Component)lafDefaults.get(
540 BASELINE_COMPONENT_KEY);
541 if (renderer == null) {
542 @SuppressWarnings("unchecked")
543 ListCellRenderer<Object> lcr = (ListCellRenderer)UIManager.get(
544 "List.cellRenderer");
545
546 // fix for 6711072 some LAFs like Nimbus do not provide this
547 // UIManager key and we should not through a NPE here because of it
548 if (lcr == null) {
549 lcr = new DefaultListCellRenderer();
550 }
551 renderer = lcr.getListCellRendererComponent(
552 list, "a", -1, false, false);
553 lafDefaults.put(BASELINE_COMPONENT_KEY, renderer);
554 }
555 renderer.setFont(list.getFont());
556 // JList actually has much more complex behavior here.
557 // If rowHeight != -1 the rowHeight is either the max of all cell
558 // heights (layout orientation != VERTICAL), or is variable depending
559 // upon the cell. We assume a default size.
560 // We could theoretically query the real renderer, but that would
561 // not work for an empty model and the results may vary with
562 // the content.
563 if (rowHeight == -1) {
564 rowHeight = renderer.getPreferredSize().height;
565 }
566 return renderer.getBaseline(Integer.MAX_VALUE, rowHeight) +
567 list.getInsets().top;
568 }
569
570 /**
571 * Returns an enum indicating how the baseline of the component
572 * changes as the size changes.
573 *
574 * @throws NullPointerException {@inheritDoc}
575 * @see javax.swing.JComponent#getBaseline(int, int)
576 * @since 1.6
577 */
578 public Component.BaselineResizeBehavior getBaselineResizeBehavior(
579 JComponent c) {
580 super.getBaselineResizeBehavior(c);
581 return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
582 }
583
584 /**
585 * The preferredSize of the list depends upon the layout orientation.
586 * <table summary="Describes the preferred size for each layout orientation">
587 * <tr><th>Layout Orientation</th><th>Preferred Size</th></tr>
588 * <tr>
589 * <td>JList.VERTICAL
590 * <td>The preferredSize of the list is total height of the rows
591 * and the maximum width of the cells. If JList.fixedCellHeight
592 * is specified then the total height of the rows is just
593 * (cellVerticalMargins + fixedCellHeight) * model.getSize() where
594 * rowVerticalMargins is the space we allocate for drawing
595 * the yellow focus outline. Similarly if fixedCellWidth is
596 * specified then we just use that.
597 * </td>
598 * <tr>
599 * <td>JList.VERTICAL_WRAP
600 * <td>If the visible row count is greater than zero, the preferredHeight
601 * is the maximum cell height * visibleRowCount. If the visible row
602 * count is <= 0, the preferred height is either the current height
603 * of the list, or the maximum cell height, whichever is
604 * bigger. The preferred width is than the maximum cell width *
605 * number of columns needed. Where the number of columns needs is
606 * list.height / max cell height. Max cell height is either the fixed
607 * cell height, or is determined by iterating through all the cells
608 * to find the maximum height from the ListCellRenderer.
609 * <tr>
610 * <td>JList.HORIZONTAL_WRAP
611 * <td>If the visible row count is greater than zero, the preferredHeight
612 * is the maximum cell height * adjustedRowCount. Where
613 * visibleRowCount is used to determine the number of columns.
614 * Because this lays out horizontally the number of rows is
615 * then determined from the column count. For example, lets say
616 * you have a model with 10 items and the visible row count is 8.
617 * The number of columns needed to display this is 2, but you no
618 * longer need 8 rows to display this, you only need 5, thus
619 * the adjustedRowCount is 5.
620 * <p>If the visible row
621 * count is <= 0, the preferred height is dictated by the
622 * number of columns, which will be as many as can fit in the width
623 * of the <code>JList</code> (width / max cell width), with at
624 * least one column. The preferred height then becomes the
625 * model size / number of columns * maximum cell height.
626 * Max cell height is either the fixed
627 * cell height, or is determined by iterating through all the cells
628 * to find the maximum height from the ListCellRenderer.
629 * </table>
630 * The above specifies the raw preferred width and height. The resulting
631 * preferred width is the above width + insets.left + insets.right and
632 * the resulting preferred height is the above height + insets.top +
633 * insets.bottom. Where the <code>Insets</code> are determined from
634 * <code>list.getInsets()</code>.
635 *
636 * @param c The JList component.
637 * @return The total size of the list.
638 */
639 public Dimension getPreferredSize(JComponent c) {
640 maybeUpdateLayoutState();
641
642 int lastRow = list.getModel().getSize() - 1;
643 if (lastRow < 0) {
644 return new Dimension(0, 0);
645 }
646
647 Insets insets = list.getInsets();
648 int width = cellWidth * columnCount + insets.left + insets.right;
649 int height;
650
651 if (layoutOrientation != JList.VERTICAL) {
652 height = preferredHeight;
653 }
654 else {
655 Rectangle bounds = getCellBounds(list, lastRow);
656
657 if (bounds != null) {
658 height = bounds.y + bounds.height + insets.bottom;
659 }
660 else {
661 height = 0;
662 }
663 }
664 return new Dimension(width, height);
665 }
666
667
668 /**
669 * Selected the previous row and force it to be visible.
670 *
671 * @see JList#ensureIndexIsVisible
672 */
673 protected void selectPreviousIndex() {
674 int s = list.getSelectedIndex();
675 if(s > 0) {
676 s -= 1;
677 list.setSelectedIndex(s);
678 list.ensureIndexIsVisible(s);
679 }
680 }
681
682
683 /**
684 * Selected the previous row and force it to be visible.
685 *
686 * @see JList#ensureIndexIsVisible
687 */
688 protected void selectNextIndex()
689 {
690 int s = list.getSelectedIndex();
691 if((s + 1) < list.getModel().getSize()) {
692 s += 1;
693 list.setSelectedIndex(s);
694 list.ensureIndexIsVisible(s);
695 }
696 }
697
698
699 /**
700 * Registers the keyboard bindings on the <code>JList</code> that the
701 * <code>BasicListUI</code> is associated with. This method is called at
702 * installUI() time.
703 *
704 * @see #installUI
705 */
706 protected void installKeyboardActions() {
707 InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
708
709 SwingUtilities.replaceUIInputMap(list, JComponent.WHEN_FOCUSED,
710 inputMap);
711
712 LazyActionMap.installLazyActionMap(list, BasicListUI.class,
713 "List.actionMap");
714 }
715
716 InputMap getInputMap(int condition) {
717 if (condition == JComponent.WHEN_FOCUSED) {
718 InputMap keyMap = (InputMap)DefaultLookup.get(
719 list, this, "List.focusInputMap");
720 InputMap rtlKeyMap;
721
722 if (isLeftToRight ||
723 ((rtlKeyMap = (InputMap)DefaultLookup.get(list, this,
724 "List.focusInputMap.RightToLeft")) == null)) {
725 return keyMap;
726 } else {
727 rtlKeyMap.setParent(keyMap);
728 return rtlKeyMap;
729 }
730 }
731 return null;
732 }
733
734 /**
735 * Unregisters keyboard actions installed from
736 * <code>installKeyboardActions</code>.
737 * This method is called at uninstallUI() time - subclassess should
738 * ensure that all of the keyboard actions registered at installUI
739 * time are removed here.
740 *
741 * @see #installUI
742 */
743 protected void uninstallKeyboardActions() {
744 SwingUtilities.replaceUIActionMap(list, null);
745 SwingUtilities.replaceUIInputMap(list, JComponent.WHEN_FOCUSED, null);
746 }
747
748
749 /**
750 * Creates and installs the listeners for the JList, its model, and its
751 * selectionModel. This method is called at installUI() time.
752 *
753 * @see #installUI
754 * @see #uninstallListeners
755 */
756 protected void installListeners()
757 {
758 TransferHandler th = list.getTransferHandler();
759 if (th == null || th instanceof UIResource) {
760 list.setTransferHandler(defaultTransferHandler);
761 // default TransferHandler doesn't support drop
762 // so we don't want drop handling
763 if (list.getDropTarget() instanceof UIResource) {
764 list.setDropTarget(null);
765 }
766 }
767
768 focusListener = createFocusListener();
769 mouseInputListener = createMouseInputListener();
770 propertyChangeListener = createPropertyChangeListener();
771 listSelectionListener = createListSelectionListener();
772 listDataListener = createListDataListener();
773
774 list.addFocusListener(focusListener);
775 list.addMouseListener(mouseInputListener);
776 list.addMouseMotionListener(mouseInputListener);
777 list.addPropertyChangeListener(propertyChangeListener);
778 list.addKeyListener(getHandler());
779
780 ListModel<Object> model = list.getModel();
781 if (model != null) {
782 model.addListDataListener(listDataListener);
783 }
784
785 ListSelectionModel selectionModel = list.getSelectionModel();
786 if (selectionModel != null) {
787 selectionModel.addListSelectionListener(listSelectionListener);
788 }
789 }
790
791
792 /**
793 * Removes the listeners from the JList, its model, and its
794 * selectionModel. All of the listener fields, are reset to
795 * null here. This method is called at uninstallUI() time,
796 * it should be kept in sync with installListeners.
797 *
798 * @see #uninstallUI
799 * @see #installListeners
800 */
801 protected void uninstallListeners()
802 {
803 list.removeFocusListener(focusListener);
804 list.removeMouseListener(mouseInputListener);
805 list.removeMouseMotionListener(mouseInputListener);
806 list.removePropertyChangeListener(propertyChangeListener);
807 list.removeKeyListener(getHandler());
808
809 ListModel<Object> model = list.getModel();
810 if (model != null) {
811 model.removeListDataListener(listDataListener);
812 }
813
814 ListSelectionModel selectionModel = list.getSelectionModel();
815 if (selectionModel != null) {
816 selectionModel.removeListSelectionListener(listSelectionListener);
817 }
818
819 focusListener = null;
820 mouseInputListener = null;
821 listSelectionListener = null;
822 listDataListener = null;
823 propertyChangeListener = null;
824 handler = null;
825 }
826
827
828 /**
829 * Initializes list properties such as font, foreground, and background,
830 * and adds the CellRendererPane. The font, foreground, and background
831 * properties are only set if their current value is either null
832 * or a UIResource, other properties are set if the current
833 * value is null.
834 *
835 * @see #uninstallDefaults
836 * @see #installUI
837 * @see CellRendererPane
838 */
839 protected void installDefaults()
840 {
841 list.setLayout(null);
842
843 LookAndFeel.installBorder(list, "List.border");
844
845 LookAndFeel.installColorsAndFont(list, "List.background", "List.foreground", "List.font");
846
847 LookAndFeel.installProperty(list, "opaque", Boolean.TRUE);
848
849 if (list.getCellRenderer() == null) {
850 @SuppressWarnings("unchecked")
851 ListCellRenderer<Object> tmp = (ListCellRenderer)(UIManager.get("List.cellRenderer"));
852 list.setCellRenderer(tmp);
853 }
854
855 Color sbg = list.getSelectionBackground();
856 if (sbg == null || sbg instanceof UIResource) {
857 list.setSelectionBackground(UIManager.getColor("List.selectionBackground"));
858 }
859
860 Color sfg = list.getSelectionForeground();
861 if (sfg == null || sfg instanceof UIResource) {
862 list.setSelectionForeground(UIManager.getColor("List.selectionForeground"));
863 }
864
865 Long l = (Long)UIManager.get("List.timeFactor");
866 timeFactor = (l!=null) ? l.longValue() : 1000L;
867
868 updateIsFileList();
869 }
870
871 private void updateIsFileList() {
872 boolean b = Boolean.TRUE.equals(list.getClientProperty("List.isFileList"));
873 if (b != isFileList) {
874 isFileList = b;
875 Font oldFont = list.getFont();
876 if (oldFont == null || oldFont instanceof UIResource) {
877 Font newFont = UIManager.getFont(b ? "FileChooser.listFont" : "List.font");
878 if (newFont != null && newFont != oldFont) {
879 list.setFont(newFont);
880 }
881 }
882 }
883 }
884
885
886 /**
887 * Sets the list properties that have not been explicitly overridden to
888 * {@code null}. A property is considered overridden if its current value
889 * is not a {@code UIResource}.
890 *
891 * @see #installDefaults
892 * @see #uninstallUI
893 * @see CellRendererPane
894 */
895 protected void uninstallDefaults()
896 {
897 LookAndFeel.uninstallBorder(list);
898 if (list.getFont() instanceof UIResource) {
899 list.setFont(null);
900 }
901 if (list.getForeground() instanceof UIResource) {
902 list.setForeground(null);
903 }
904 if (list.getBackground() instanceof UIResource) {
905 list.setBackground(null);
906 }
907 if (list.getSelectionBackground() instanceof UIResource) {
908 list.setSelectionBackground(null);
909 }
910 if (list.getSelectionForeground() instanceof UIResource) {
911 list.setSelectionForeground(null);
912 }
913 if (list.getCellRenderer() instanceof UIResource) {
914 list.setCellRenderer(null);
915 }
916 if (list.getTransferHandler() instanceof UIResource) {
917 list.setTransferHandler(null);
918 }
919 }
920
921
922 /**
923 * Initializes <code>this.list</code> by calling <code>installDefaults()</code>,
924 * <code>installListeners()</code>, and <code>installKeyboardActions()</code>
925 * in order.
926 *
927 * @see #installDefaults
928 * @see #installListeners
929 * @see #installKeyboardActions
930 */
931 public void installUI(JComponent c)
932 {
933 @SuppressWarnings("unchecked")
934 JList<Object> tmp = (JList)c;
935 list = tmp;
936
937 layoutOrientation = list.getLayoutOrientation();
938
939 rendererPane = new CellRendererPane();
940 list.add(rendererPane);
941
942 columnCount = 1;
943
944 updateLayoutStateNeeded = modelChanged;
945 isLeftToRight = list.getComponentOrientation().isLeftToRight();
946
947 installDefaults();
948 installListeners();
949 installKeyboardActions();
950 }
951
952
953 /**
954 * Uninitializes <code>this.list</code> by calling <code>uninstallListeners()</code>,
955 * <code>uninstallKeyboardActions()</code>, and <code>uninstallDefaults()</code>
956 * in order. Sets this.list to null.
957 *
958 * @see #uninstallListeners
959 * @see #uninstallKeyboardActions
960 * @see #uninstallDefaults
961 */
962 public void uninstallUI(JComponent c)
963 {
964 uninstallListeners();
965 uninstallDefaults();
966 uninstallKeyboardActions();
967
968 cellWidth = cellHeight = -1;
969 cellHeights = null;
970
971 listWidth = listHeight = -1;
972
973 list.remove(rendererPane);
974 rendererPane = null;
975 list = null;
976 }
977
978
979 /**
980 * Returns a new instance of {@code BasicListUI}.
981 * {@code BasicListUI} delegates are allocated one per {@code JList}.
982 *
983 * @param list a component
984 * @return a new {@code ListUI} implementation for the Windows look and feel.
985 */
986 public static ComponentUI createUI(JComponent list) {
987 return new BasicListUI();
988 }
989
990
991 /**
992 * {@inheritDoc}
993 * @throws NullPointerException {@inheritDoc}
994 */
995 public int locationToIndex(JList<?> list, Point location) {
996 maybeUpdateLayoutState();
997 return convertLocationToModel(location.x, location.y);
998 }
999
1000
1001 /**
1002 * {@inheritDoc}
1003 */
1004 public Point indexToLocation(JList<?> list, int index) {
1005 maybeUpdateLayoutState();
1006 Rectangle rect = getCellBounds(list, index, index);
1007
1008 if (rect != null) {
1009 return new Point(rect.x, rect.y);
1010 }
1011 return null;
1012 }
1013
1014
1015 /**
1016 * {@inheritDoc}
1017 */
1018 public Rectangle getCellBounds(JList<?> list, int index1, int index2) {
1019 maybeUpdateLayoutState();
1020
1021 int minIndex = Math.min(index1, index2);
1022 int maxIndex = Math.max(index1, index2);
1023
1024 if (minIndex >= list.getModel().getSize()) {
1025 return null;
1026 }
1027
1028 Rectangle minBounds = getCellBounds(list, minIndex);
1029
1030 if (minBounds == null) {
1031 return null;
1032 }
1033 if (minIndex == maxIndex) {
1034 return minBounds;
1035 }
1036 Rectangle maxBounds = getCellBounds(list, maxIndex);
1037
1038 if (maxBounds != null) {
1039 if (layoutOrientation == JList.HORIZONTAL_WRAP) {
1040 int minRow = convertModelToRow(minIndex);
1041 int maxRow = convertModelToRow(maxIndex);
1042
1043 if (minRow != maxRow) {
1044 minBounds.x = 0;
1045 minBounds.width = list.getWidth();
1046 }
1047 }
1048 else if (minBounds.x != maxBounds.x) {
1049 // Different columns
1050 minBounds.y = 0;
1051 minBounds.height = list.getHeight();
1052 }
1053 minBounds.add(maxBounds);
1054 }
1055 return minBounds;
1056 }
1057
1058 /**
1059 * Gets the bounds of the specified model index, returning the resulting
1060 * bounds, or null if <code>index</code> is not valid.
1061 */
1062 private Rectangle getCellBounds(JList<?> list, int index) {
1063 maybeUpdateLayoutState();
1064
1065 int row = convertModelToRow(index);
1066 int column = convertModelToColumn(index);
1067
1068 if (row == -1 || column == -1) {
1069 return null;
1070 }
1071
1072 Insets insets = list.getInsets();
1073 int x;
1074 int w = cellWidth;
1075 int y = insets.top;
1076 int h;
1077 switch (layoutOrientation) {
1078 case JList.VERTICAL_WRAP:
1079 case JList.HORIZONTAL_WRAP:
1080 if (isLeftToRight) {
1081 x = insets.left + column * cellWidth;
1082 } else {
1083 x = list.getWidth() - insets.right - (column+1) * cellWidth;
1084 }
1085 y += cellHeight * row;
1086 h = cellHeight;
1087 break;
1088 default:
1089 x = insets.left;
1090 if (cellHeights == null) {
1091 y += (cellHeight * row);
1092 }
1093 else if (row >= cellHeights.length) {
1094 y = 0;
1095 }
1096 else {
1097 for(int i = 0; i < row; i++) {
1098 y += cellHeights[i];
1099 }
1100 }
1101 w = list.getWidth() - (insets.left + insets.right);
1102 h = getRowHeight(index);
1103 break;
1104 }
1105 return new Rectangle(x, y, w, h);
1106 }
1107
1108 /**
1109 * Returns the height of the specified row based on the current layout.
1110 *
1111 * @param row a row
1112 * @return the specified row height or -1 if row isn't valid
1113 * @see #convertYToRow
1114 * @see #convertRowToY
1115 * @see #updateLayoutState
1116 */
1117 protected int getRowHeight(int row)
1118 {
1119 return getHeight(0, row);
1120 }
1121
1122
1123 /**
1124 * Convert the {@code JList} relative coordinate to the row that contains it,
1125 * based on the current layout. If {@code y0} doesn't fall within any row,
1126 * return -1.
1127 *
1128 * @param y0 a relative Y coordinate
1129 * @return the row that contains y0, or -1
1130 * @see #getRowHeight
1131 * @see #updateLayoutState
1132 */
1133 protected int convertYToRow(int y0)
1134 {
1135 return convertLocationToRow(0, y0, false);
1136 }
1137
1138
1139 /**
1140 * Return the {@code JList} relative Y coordinate of the origin of the specified
1141 * row or -1 if row isn't valid.
1142 *
1143 * @param row a row
1144 * @return the Y coordinate of the origin of row, or -1
1145 * @see #getRowHeight
1146 * @see #updateLayoutState
1147 */
1148 protected int convertRowToY(int row)
1149 {
1150 if (row >= getRowCount(0) || row < 0) {
1151 return -1;
1152 }
1153 Rectangle bounds = getCellBounds(list, row, row);
1154 return bounds.y;
1155 }
1156
1157 /**
1158 * Returns the height of the cell at the passed in location.
1159 */
1160 private int getHeight(int column, int row) {
1161 if (column < 0 || column > columnCount || row < 0) {
1162 return -1;
1163 }
1164 if (layoutOrientation != JList.VERTICAL) {
1165 return cellHeight;
1166 }
1167 if (row >= list.getModel().getSize()) {
1168 return -1;
1169 }
1170 return (cellHeights == null) ? cellHeight :
1171 ((row < cellHeights.length) ? cellHeights[row] : -1);
1172 }
1173
1174 /**
1175 * Returns the row at location x/y.
1176 *
1177 * @param closest If true and the location doesn't exactly match a
1178 * particular location, this will return the closest row.
1179 */
1180 private int convertLocationToRow(int x, int y0, boolean closest) {
1181 int size = list.getModel().getSize();
1182
1183 if (size <= 0) {
1184 return -1;
1185 }
1186 Insets insets = list.getInsets();
1187 if (cellHeights == null) {
1188 int row = (cellHeight == 0) ? 0 :
1189 ((y0 - insets.top) / cellHeight);
1190 if (closest) {
1191 if (row < 0) {
1192 row = 0;
1193 }
1194 else if (row >= size) {
1195 row = size - 1;
1196 }
1197 }
1198 return row;
1199 }
1200 else if (size > cellHeights.length) {
1201 return -1;
1202 }
1203 else {
1204 int y = insets.top;
1205 int row = 0;
1206
1207 if (closest && y0 < y) {
1208 return 0;
1209 }
1210 int i;
1211 for (i = 0; i < size; i++) {
1212 if ((y0 >= y) && (y0 < y + cellHeights[i])) {
1213 return row;
1214 }
1215 y += cellHeights[i];
1216 row += 1;
1217 }
1218 return i - 1;
1219 }
1220 }
1221
1222 /**
1223 * Returns the closest row that starts at the specified y-location
1224 * in the passed in column.
1225 */
1226 private int convertLocationToRowInColumn(int y, int column) {
1227 int x = 0;
1228
1229 if (layoutOrientation != JList.VERTICAL) {
1230 if (isLeftToRight) {
1231 x = column * cellWidth;
1232 } else {
1233 x = list.getWidth() - (column+1)*cellWidth - list.getInsets().right;
1234 }
1235 }
1236 return convertLocationToRow(x, y, true);
1237 }
1238
1239 /**
1240 * Returns the closest location to the model index of the passed in
1241 * location.
1242 */
1243 private int convertLocationToModel(int x, int y) {
1244 int row = convertLocationToRow(x, y, true);
1245 int column = convertLocationToColumn(x, y);
1246
1247 if (row >= 0 && column >= 0) {
1248 return getModelIndex(column, row);
1249 }
1250 return -1;
1251 }
1252
1253 /**
1254 * Returns the number of rows in the given column.
1255 */
1256 private int getRowCount(int column) {
1257 if (column < 0 || column >= columnCount) {
1258 return -1;
1259 }
1260 if (layoutOrientation == JList.VERTICAL ||
1261 (column == 0 && columnCount == 1)) {
1262 return list.getModel().getSize();
1263 }
1264 if (column >= columnCount) {
1265 return -1;
1266 }
1267 if (layoutOrientation == JList.VERTICAL_WRAP) {
1268 if (column < (columnCount - 1)) {
1269 return rowsPerColumn;
1270 }
1271 return list.getModel().getSize() - (columnCount - 1) *
1272 rowsPerColumn;
1273 }
1274 // JList.HORIZONTAL_WRAP
1275 int diff = columnCount - (columnCount * rowsPerColumn -
1276 list.getModel().getSize());
1277
1278 if (column >= diff) {
1279 return Math.max(0, rowsPerColumn - 1);
1280 }
1281 return rowsPerColumn;
1282 }
1283
1284 /**
1285 * Returns the model index for the specified display location.
1286 * If <code>column</code>x<code>row</code> is beyond the length of the
1287 * model, this will return the model size - 1.
1288 */
1289 private int getModelIndex(int column, int row) {
1290 switch (layoutOrientation) {
1291 case JList.VERTICAL_WRAP:
1292 return Math.min(list.getModel().getSize() - 1, rowsPerColumn *
1293 column + Math.min(row, rowsPerColumn-1));
1294 case JList.HORIZONTAL_WRAP:
1295 return Math.min(list.getModel().getSize() - 1, row * columnCount +
1296 column);
1297 default:
1298 return row;
1299 }
1300 }
1301
1302 /**
1303 * Returns the closest column to the passed in location.
1304 */
1305 private int convertLocationToColumn(int x, int y) {
1306 if (cellWidth > 0) {
1307 if (layoutOrientation == JList.VERTICAL) {
1308 return 0;
1309 }
1310 Insets insets = list.getInsets();
1311 int col;
1312 if (isLeftToRight) {
1313 col = (x - insets.left) / cellWidth;
1314 } else {
1315 col = (list.getWidth() - x - insets.right - 1) / cellWidth;
1316 }
1317 if (col < 0) {
1318 return 0;
1319 }
1320 else if (col >= columnCount) {
1321 return columnCount - 1;
1322 }
1323 return col;
1324 }
1325 return 0;
1326 }
1327
1328 /**
1329 * Returns the row that the model index <code>index</code> will be
1330 * displayed in..
1331 */
1332 private int convertModelToRow(int index) {
1333 int size = list.getModel().getSize();
1334
1335 if ((index < 0) || (index >= size)) {
1336 return -1;
1337 }
1338
1339 if (layoutOrientation != JList.VERTICAL && columnCount > 1 &&
1340 rowsPerColumn > 0) {
1341 if (layoutOrientation == JList.VERTICAL_WRAP) {
1342 return index % rowsPerColumn;
1343 }
1344 return index / columnCount;
1345 }
1346 return index;
1347 }
1348
1349 /**
1350 * Returns the column that the model index <code>index</code> will be
1351 * displayed in.
1352 */
1353 private int convertModelToColumn(int index) {
1354 int size = list.getModel().getSize();
1355
1356 if ((index < 0) || (index >= size)) {
1357 return -1;
1358 }
1359
1360 if (layoutOrientation != JList.VERTICAL && rowsPerColumn > 0 &&
1361 columnCount > 1) {
1362 if (layoutOrientation == JList.VERTICAL_WRAP) {
1363 return index / rowsPerColumn;
1364 }
1365 return index % columnCount;
1366 }
1367 return 0;
1368 }
1369
1370 /**
1371 * If updateLayoutStateNeeded is non zero, call updateLayoutState() and reset
1372 * updateLayoutStateNeeded. This method should be called by methods
1373 * before doing any computation based on the geometry of the list.
1374 * For example it's the first call in paint() and getPreferredSize().
1375 *
1376 * @see #updateLayoutState
1377 */
1378 protected void maybeUpdateLayoutState()
1379 {
1380 if (updateLayoutStateNeeded != 0) {
1381 updateLayoutState();
1382 updateLayoutStateNeeded = 0;
1383 }
1384 }
1385
1386
1387 /**
1388 * Recompute the value of cellHeight or cellHeights based
1389 * and cellWidth, based on the current font and the current
1390 * values of fixedCellWidth, fixedCellHeight, and prototypeCellValue.
1391 *
1392 * @see #maybeUpdateLayoutState
1393 */
1394 protected void updateLayoutState()
1395 {
1396 /* If both JList fixedCellWidth and fixedCellHeight have been
1397 * set, then initialize cellWidth and cellHeight, and set
1398 * cellHeights to null.
1399 */
1400
1401 int fixedCellHeight = list.getFixedCellHeight();
1402 int fixedCellWidth = list.getFixedCellWidth();
1403
1404 cellWidth = (fixedCellWidth != -1) ? fixedCellWidth : -1;
1405
1406 if (fixedCellHeight != -1) {
1407 cellHeight = fixedCellHeight;
1408 cellHeights = null;
1409 }
1410 else {
1411 cellHeight = -1;
1412 cellHeights = new int[list.getModel().getSize()];
1413 }
1414
1415 /* If either of JList fixedCellWidth and fixedCellHeight haven't
1416 * been set, then initialize cellWidth and cellHeights by
1417 * scanning through the entire model. Note: if the renderer is
1418 * null, we just set cellWidth and cellHeights[*] to zero,
1419 * if they're not set already.
1420 */
1421
1422 if ((fixedCellWidth == -1) || (fixedCellHeight == -1)) {
1423
1424 ListModel<Object> dataModel = list.getModel();
1425 int dataModelSize = dataModel.getSize();
1426 ListCellRenderer<Object> renderer = list.getCellRenderer();
1427
1428 if (renderer != null) {
1429 for(int index = 0; index < dataModelSize; index++) {
1430 Object value = dataModel.getElementAt(index);
1431 Component c = renderer.getListCellRendererComponent(list, value, index, false, false);
1432 rendererPane.add(c);
1433 Dimension cellSize = c.getPreferredSize();
1434 if (fixedCellWidth == -1) {
1435 cellWidth = Math.max(cellSize.width, cellWidth);
1436 }
1437 if (fixedCellHeight == -1) {
1438 cellHeights[index] = cellSize.height;
1439 }
1440 }
1441 }
1442 else {
1443 if (cellWidth == -1) {
1444 cellWidth = 0;
1445 }
1446 if (cellHeights == null) {
1447 cellHeights = new int[dataModelSize];
1448 }
1449 for(int index = 0; index < dataModelSize; index++) {
1450 cellHeights[index] = 0;
1451 }
1452 }
1453 }
1454
1455 columnCount = 1;
1456 if (layoutOrientation != JList.VERTICAL) {
1457 updateHorizontalLayoutState(fixedCellWidth, fixedCellHeight);
1458 }
1459 }
1460
1461 /**
1462 * Invoked when the list is layed out horizontally to determine how
1463 * many columns to create.
1464 * <p>
1465 * This updates the <code>rowsPerColumn, </code><code>columnCount</code>,
1466 * <code>preferredHeight</code> and potentially <code>cellHeight</code>
1467 * instance variables.
1468 */
1469 private void updateHorizontalLayoutState(int fixedCellWidth,
1470 int fixedCellHeight) {
1471 int visRows = list.getVisibleRowCount();
1472 int dataModelSize = list.getModel().getSize();
1473 Insets insets = list.getInsets();
1474
1475 listHeight = list.getHeight();
1476 listWidth = list.getWidth();
1477
1478 if (dataModelSize == 0) {
1479 rowsPerColumn = columnCount = 0;
1480 preferredHeight = insets.top + insets.bottom;
1481 return;
1482 }
1483
1484 int height;
1485
1486 if (fixedCellHeight != -1) {
1487 height = fixedCellHeight;
1488 }
1489 else {
1490 // Determine the max of the renderer heights.
1491 int maxHeight = 0;
1492 if (cellHeights.length > 0) {
1493 maxHeight = cellHeights[cellHeights.length - 1];
1494 for (int counter = cellHeights.length - 2;
1495 counter >= 0; counter--) {
1496 maxHeight = Math.max(maxHeight, cellHeights[counter]);
1497 }
1498 }
1499 height = cellHeight = maxHeight;
1500 cellHeights = null;
1501 }
1502 // The number of rows is either determined by the visible row
1503 // count, or by the height of the list.
1504 rowsPerColumn = dataModelSize;
1505 if (visRows > 0) {
1506 rowsPerColumn = visRows;
1507 columnCount = Math.max(1, dataModelSize / rowsPerColumn);
1508 if (dataModelSize > 0 && dataModelSize > rowsPerColumn &&
1509 dataModelSize % rowsPerColumn != 0) {
1510 columnCount++;
1511 }
1512 if (layoutOrientation == JList.HORIZONTAL_WRAP) {
1513 // Because HORIZONTAL_WRAP flows differently, the
1514 // rowsPerColumn needs to be adjusted.
1515 rowsPerColumn = (dataModelSize / columnCount);
1516 if (dataModelSize % columnCount > 0) {
1517 rowsPerColumn++;
1518 }
1519 }
1520 }
1521 else if (layoutOrientation == JList.VERTICAL_WRAP && height != 0) {
1522 rowsPerColumn = Math.max(1, (listHeight - insets.top -
1523 insets.bottom) / height);
1524 columnCount = Math.max(1, dataModelSize / rowsPerColumn);
1525 if (dataModelSize > 0 && dataModelSize > rowsPerColumn &&
1526 dataModelSize % rowsPerColumn != 0) {
1527 columnCount++;
1528 }
1529 }
1530 else if (layoutOrientation == JList.HORIZONTAL_WRAP && cellWidth > 0 &&
1531 listWidth > 0) {
1532 columnCount = Math.max(1, (listWidth - insets.left -
1533 insets.right) / cellWidth);
1534 rowsPerColumn = dataModelSize / columnCount;
1535 if (dataModelSize % columnCount > 0) {
1536 rowsPerColumn++;
1537 }
1538 }
1539 preferredHeight = rowsPerColumn * cellHeight + insets.top +
1540 insets.bottom;
1541 }
1542
1543 private Handler getHandler() {
1544 if (handler == null) {
1545 handler = new Handler();
1546 }
1547 return handler;
1548 }
1549
1550 /**
1551 * Mouse input, and focus handling for JList. An instance of this
1552 * class is added to the appropriate java.awt.Component lists
1553 * at installUI() time. Note keyboard input is handled with JComponent
1554 * KeyboardActions, see installKeyboardActions().
1555 * <p>
1556 * <strong>Warning:</strong>
1557 * Serialized objects of this class will not be compatible with
1558 * future Swing releases. The current serialization support is
1559 * appropriate for short term storage or RMI between applications running
1560 * the same version of Swing. As of 1.4, support for long term storage
1561 * of all JavaBeans™
1562 * has been added to the <code>java.beans</code> package.
1563 * Please see {@link java.beans.XMLEncoder}.
1564 *
1565 * @see #createMouseInputListener
1566 * @see #installKeyboardActions
1567 * @see #installUI
1568 */
1569 @SuppressWarnings("serial") // Same-version serialization only
1570 public class MouseInputHandler implements MouseInputListener
1571 {
1572 public void mouseClicked(MouseEvent e) {
1573 getHandler().mouseClicked(e);
1574 }
1575
1576 public void mouseEntered(MouseEvent e) {
1577 getHandler().mouseEntered(e);
1578 }
1579
1580 public void mouseExited(MouseEvent e) {
1581 getHandler().mouseExited(e);
1582 }
1583
1584 public void mousePressed(MouseEvent e) {
1585 getHandler().mousePressed(e);
1586 }
1587
1588 public void mouseDragged(MouseEvent e) {
1589 getHandler().mouseDragged(e);
1590 }
1591
1592 public void mouseMoved(MouseEvent e) {
1593 getHandler().mouseMoved(e);
1594 }
1595
1596 public void mouseReleased(MouseEvent e) {
1597 getHandler().mouseReleased(e);
1598 }
1599 }
1600
1601
1602 /**
1603 * Creates a delegate that implements {@code MouseInputListener}.
1604 * The delegate is added to the corresponding {@code java.awt.Component} listener
1605 * lists at {@code installUI()} time. Subclasses can override this method to return
1606 * a custom {@code MouseInputListener}, e.g.
1607 * <pre>
1608 * class MyListUI extends BasicListUI {
1609 * protected MouseInputListener <b>createMouseInputListener</b>() {
1610 * return new MyMouseInputHandler();
1611 * }
1612 * public class MyMouseInputHandler extends MouseInputHandler {
1613 * public void mouseMoved(MouseEvent e) {
1614 * // do some extra work when the mouse moves
1615 * super.mouseMoved(e);
1616 * }
1617 * }
1618 * }
1619 * </pre>
1620 *
1621 * @return an instance of {@code MouseInputListener}
1622 * @see MouseInputHandler
1623 * @see #installUI
1624 */
1625 protected MouseInputListener createMouseInputListener() {
1626 return getHandler();
1627 }
1628
1629 /**
1630 * This class should be treated as a "protected" inner class.
1631 * Instantiate it only within subclasses of {@code BasicListUI}.
1632 */
1633 public class FocusHandler implements FocusListener
1634 {
1635 /**
1636 * Repaints focused cells.
1637 */
1638 protected void repaintCellFocus()
1639 {
1640 getHandler().repaintCellFocus();
1641 }
1642
1643 /* The focusGained() focusLost() methods run when the JList
1644 * focus changes.
1645 */
1646
1647 public void focusGained(FocusEvent e) {
1648 getHandler().focusGained(e);
1649 }
1650
1651 public void focusLost(FocusEvent e) {
1652 getHandler().focusLost(e);
1653 }
1654 }
1655
1656 /**
1657 * Returns an instance of {@code FocusListener}.
1658 *
1659 * @return an instance of {@code FocusListener}
1660 */
1661 protected FocusListener createFocusListener() {
1662 return getHandler();
1663 }
1664
1665 /**
1666 * The ListSelectionListener that's added to the JLists selection
1667 * model at installUI time, and whenever the JList.selectionModel property
1668 * changes. When the selection changes we repaint the affected rows.
1669 * <p>
1670 * <strong>Warning:</strong>
1671 * Serialized objects of this class will not be compatible with
1672 * future Swing releases. The current serialization support is
1673 * appropriate for short term storage or RMI between applications running
1674 * the same version of Swing. As of 1.4, support for long term storage
1675 * of all JavaBeans™
1676 * has been added to the <code>java.beans</code> package.
1677 * Please see {@link java.beans.XMLEncoder}.
1678 *
1679 * @see #createListSelectionListener
1680 * @see #getCellBounds
1681 * @see #installUI
1682 */
1683 @SuppressWarnings("serial") // Same-version serialization only
1684 public class ListSelectionHandler implements ListSelectionListener
1685 {
1686 public void valueChanged(ListSelectionEvent e)
1687 {
1688 getHandler().valueChanged(e);
1689 }
1690 }
1691
1692
1693 /**
1694 * Creates an instance of {@code ListSelectionHandler} that's added to
1695 * the {@code JLists} by selectionModel as needed. Subclasses can override
1696 * this method to return a custom {@code ListSelectionListener}, e.g.
1697 * <pre>
1698 * class MyListUI extends BasicListUI {
1699 * protected ListSelectionListener <b>createListSelectionListener</b>() {
1700 * return new MySelectionListener();
1701 * }
1702 * public class MySelectionListener extends ListSelectionHandler {
1703 * public void valueChanged(ListSelectionEvent e) {
1704 * // do some extra work when the selection changes
1705 * super.valueChange(e);
1706 * }
1707 * }
1708 * }
1709 * </pre>
1710 *
1711 * @return an instance of {@code ListSelectionHandler}
1712 * @see ListSelectionHandler
1713 * @see #installUI
1714 */
1715 protected ListSelectionListener createListSelectionListener() {
1716 return getHandler();
1717 }
1718
1719
1720 private void redrawList() {
1721 list.revalidate();
1722 list.repaint();
1723 }
1724
1725
1726 /**
1727 * The {@code ListDataListener} that's added to the {@code JLists} model at
1728 * {@code installUI time}, and whenever the JList.model property changes.
1729 * <p>
1730 * <strong>Warning:</strong>
1731 * Serialized objects of this class will not be compatible with
1732 * future Swing releases. The current serialization support is
1733 * appropriate for short term storage or RMI between applications running
1734 * the same version of Swing. As of 1.4, support for long term storage
1735 * of all JavaBeans™
1736 * has been added to the <code>java.beans</code> package.
1737 * Please see {@link java.beans.XMLEncoder}.
1738 *
1739 * @see JList#getModel
1740 * @see #maybeUpdateLayoutState
1741 * @see #createListDataListener
1742 * @see #installUI
1743 */
1744 @SuppressWarnings("serial") // Same-version serialization only
1745 public class ListDataHandler implements ListDataListener
1746 {
1747 public void intervalAdded(ListDataEvent e) {
1748 getHandler().intervalAdded(e);
1749 }
1750
1751
1752 public void intervalRemoved(ListDataEvent e)
1753 {
1754 getHandler().intervalRemoved(e);
1755 }
1756
1757
1758 public void contentsChanged(ListDataEvent e) {
1759 getHandler().contentsChanged(e);
1760 }
1761 }
1762
1763
1764 /**
1765 * Creates an instance of {@code ListDataListener} that's added to
1766 * the {@code JLists} by model as needed. Subclasses can override
1767 * this method to return a custom {@code ListDataListener}, e.g.
1768 * <pre>
1769 * class MyListUI extends BasicListUI {
1770 * protected ListDataListener <b>createListDataListener</b>() {
1771 * return new MyListDataListener();
1772 * }
1773 * public class MyListDataListener extends ListDataHandler {
1774 * public void contentsChanged(ListDataEvent e) {
1775 * // do some extra work when the models contents change
1776 * super.contentsChange(e);
1777 * }
1778 * }
1779 * }
1780 * </pre>
1781 *
1782 * @return an instance of {@code ListDataListener}
1783 * @see ListDataListener
1784 * @see JList#getModel
1785 * @see #installUI
1786 */
1787 protected ListDataListener createListDataListener() {
1788 return getHandler();
1789 }
1790
1791
1792 /**
1793 * The PropertyChangeListener that's added to the JList at
1794 * installUI time. When the value of a JList property that
1795 * affects layout changes, we set a bit in updateLayoutStateNeeded.
1796 * If the JLists model changes we additionally remove our listeners
1797 * from the old model. Likewise for the JList selectionModel.
1798 * <p>
1799 * <strong>Warning:</strong>
1800 * Serialized objects of this class will not be compatible with
1801 * future Swing releases. The current serialization support is
1802 * appropriate for short term storage or RMI between applications running
1803 * the same version of Swing. As of 1.4, support for long term storage
1804 * of all JavaBeans™
1805 * has been added to the <code>java.beans</code> package.
1806 * Please see {@link java.beans.XMLEncoder}.
1807 *
1808 * @see #maybeUpdateLayoutState
1809 * @see #createPropertyChangeListener
1810 * @see #installUI
1811 */
1812 @SuppressWarnings("serial") // Same-version serialization only
1813 public class PropertyChangeHandler implements PropertyChangeListener
1814 {
1815 public void propertyChange(PropertyChangeEvent e)
1816 {
1817 getHandler().propertyChange(e);
1818 }
1819 }
1820
1821
1822 /**
1823 * Creates an instance of {@code PropertyChangeHandler} that's added to
1824 * the {@code JList} by {@code installUI()}. Subclasses can override this method
1825 * to return a custom {@code PropertyChangeListener}, e.g.
1826 * <pre>
1827 * class MyListUI extends BasicListUI {
1828 * protected PropertyChangeListener <b>createPropertyChangeListener</b>() {
1829 * return new MyPropertyChangeListener();
1830 * }
1831 * public class MyPropertyChangeListener extends PropertyChangeHandler {
1832 * public void propertyChange(PropertyChangeEvent e) {
1833 * if (e.getPropertyName().equals("model")) {
1834 * // do some extra work when the model changes
1835 * }
1836 * super.propertyChange(e);
1837 * }
1838 * }
1839 * }
1840 * </pre>
1841 *
1842 * @return an instance of {@code PropertyChangeHandler}
1843 * @see PropertyChangeListener
1844 * @see #installUI
1845 */
1846 protected PropertyChangeListener createPropertyChangeListener() {
1847 return getHandler();
1848 }
1849
1850 /** Used by IncrementLeadSelectionAction. Indicates the action should
1851 * change the lead, and not select it. */
1852 private static final int CHANGE_LEAD = 0;
1853 /** Used by IncrementLeadSelectionAction. Indicates the action should
1854 * change the selection and lead. */
1855 private static final int CHANGE_SELECTION = 1;
1856 /** Used by IncrementLeadSelectionAction. Indicates the action should
1857 * extend the selection from the anchor to the next index. */
1858 private static final int EXTEND_SELECTION = 2;
1859
1860
1861 private static class Actions extends UIAction {
1862 private static final String SELECT_PREVIOUS_COLUMN =
1863 "selectPreviousColumn";
1864 private static final String SELECT_PREVIOUS_COLUMN_EXTEND =
1865 "selectPreviousColumnExtendSelection";
1866 private static final String SELECT_PREVIOUS_COLUMN_CHANGE_LEAD =
1867 "selectPreviousColumnChangeLead";
1868 private static final String SELECT_NEXT_COLUMN = "selectNextColumn";
1869 private static final String SELECT_NEXT_COLUMN_EXTEND =
1870 "selectNextColumnExtendSelection";
1871 private static final String SELECT_NEXT_COLUMN_CHANGE_LEAD =
1872 "selectNextColumnChangeLead";
1873 private static final String SELECT_PREVIOUS_ROW = "selectPreviousRow";
1874 private static final String SELECT_PREVIOUS_ROW_EXTEND =
1875 "selectPreviousRowExtendSelection";
1876 private static final String SELECT_PREVIOUS_ROW_CHANGE_LEAD =
1877 "selectPreviousRowChangeLead";
1878 private static final String SELECT_NEXT_ROW = "selectNextRow";
1879 private static final String SELECT_NEXT_ROW_EXTEND =
1880 "selectNextRowExtendSelection";
1881 private static final String SELECT_NEXT_ROW_CHANGE_LEAD =
1882 "selectNextRowChangeLead";
1883 private static final String SELECT_FIRST_ROW = "selectFirstRow";
1884 private static final String SELECT_FIRST_ROW_EXTEND =
1885 "selectFirstRowExtendSelection";
1886 private static final String SELECT_FIRST_ROW_CHANGE_LEAD =
1887 "selectFirstRowChangeLead";
1888 private static final String SELECT_LAST_ROW = "selectLastRow";
1889 private static final String SELECT_LAST_ROW_EXTEND =
1890 "selectLastRowExtendSelection";
1891 private static final String SELECT_LAST_ROW_CHANGE_LEAD =
1892 "selectLastRowChangeLead";
1893 private static final String SCROLL_UP = "scrollUp";
1894 private static final String SCROLL_UP_EXTEND =
1895 "scrollUpExtendSelection";
1896 private static final String SCROLL_UP_CHANGE_LEAD =
1897 "scrollUpChangeLead";
1898 private static final String SCROLL_DOWN = "scrollDown";
1899 private static final String SCROLL_DOWN_EXTEND =
1900 "scrollDownExtendSelection";
1901 private static final String SCROLL_DOWN_CHANGE_LEAD =
1902 "scrollDownChangeLead";
1903 private static final String SELECT_ALL = "selectAll";
1904 private static final String CLEAR_SELECTION = "clearSelection";
1905
1906 // add the lead item to the selection without changing lead or anchor
1907 private static final String ADD_TO_SELECTION = "addToSelection";
1908
1909 // toggle the selected state of the lead item and move the anchor to it
1910 private static final String TOGGLE_AND_ANCHOR = "toggleAndAnchor";
1911
1912 // extend the selection to the lead item
1913 private static final String EXTEND_TO = "extendTo";
1914
1915 // move the anchor to the lead and ensure only that item is selected
1916 private static final String MOVE_SELECTION_TO = "moveSelectionTo";
1917
1918 Actions(String name) {
1919 super(name);
1920 }
1921 public void actionPerformed(ActionEvent e) {
1922 String name = getName();
1923 @SuppressWarnings("unchecked")
1924 JList<Object> list = (JList)e.getSource();
1925 BasicListUI ui = (BasicListUI)BasicLookAndFeel.getUIOfType(
1926 list.getUI(), BasicListUI.class);
1927
1928 if (name == SELECT_PREVIOUS_COLUMN) {
1929 changeSelection(list, CHANGE_SELECTION,
1930 getNextColumnIndex(list, ui, -1), -1);
1931 }
1932 else if (name == SELECT_PREVIOUS_COLUMN_EXTEND) {
1933 changeSelection(list, EXTEND_SELECTION,
1934 getNextColumnIndex(list, ui, -1), -1);
1935 }
1936 else if (name == SELECT_PREVIOUS_COLUMN_CHANGE_LEAD) {
1937 changeSelection(list, CHANGE_LEAD,
1938 getNextColumnIndex(list, ui, -1), -1);
1939 }
1940 else if (name == SELECT_NEXT_COLUMN) {
1941 changeSelection(list, CHANGE_SELECTION,
1942 getNextColumnIndex(list, ui, 1), 1);
1943 }
1944 else if (name == SELECT_NEXT_COLUMN_EXTEND) {
1945 changeSelection(list, EXTEND_SELECTION,
1946 getNextColumnIndex(list, ui, 1), 1);
1947 }
1948 else if (name == SELECT_NEXT_COLUMN_CHANGE_LEAD) {
1949 changeSelection(list, CHANGE_LEAD,
1950 getNextColumnIndex(list, ui, 1), 1);
1951 }
1952 else if (name == SELECT_PREVIOUS_ROW) {
1953 changeSelection(list, CHANGE_SELECTION,
1954 getNextIndex(list, ui, -1), -1);
1955 }
1956 else if (name == SELECT_PREVIOUS_ROW_EXTEND) {
1957 changeSelection(list, EXTEND_SELECTION,
1958 getNextIndex(list, ui, -1), -1);
1959 }
1960 else if (name == SELECT_PREVIOUS_ROW_CHANGE_LEAD) {
1961 changeSelection(list, CHANGE_LEAD,
1962 getNextIndex(list, ui, -1), -1);
1963 }
1964 else if (name == SELECT_NEXT_ROW) {
1965 changeSelection(list, CHANGE_SELECTION,
1966 getNextIndex(list, ui, 1), 1);
1967 }
1968 else if (name == SELECT_NEXT_ROW_EXTEND) {
1969 changeSelection(list, EXTEND_SELECTION,
1970 getNextIndex(list, ui, 1), 1);
1971 }
1972 else if (name == SELECT_NEXT_ROW_CHANGE_LEAD) {
1973 changeSelection(list, CHANGE_LEAD,
1974 getNextIndex(list, ui, 1), 1);
1975 }
1976 else if (name == SELECT_FIRST_ROW) {
1977 changeSelection(list, CHANGE_SELECTION, 0, -1);
1978 }
1979 else if (name == SELECT_FIRST_ROW_EXTEND) {
1980 changeSelection(list, EXTEND_SELECTION, 0, -1);
1981 }
1982 else if (name == SELECT_FIRST_ROW_CHANGE_LEAD) {
1983 changeSelection(list, CHANGE_LEAD, 0, -1);
1984 }
1985 else if (name == SELECT_LAST_ROW) {
1986 changeSelection(list, CHANGE_SELECTION,
1987 list.getModel().getSize() - 1, 1);
1988 }
1989 else if (name == SELECT_LAST_ROW_EXTEND) {
1990 changeSelection(list, EXTEND_SELECTION,
1991 list.getModel().getSize() - 1, 1);
1992 }
1993 else if (name == SELECT_LAST_ROW_CHANGE_LEAD) {
1994 changeSelection(list, CHANGE_LEAD,
1995 list.getModel().getSize() - 1, 1);
1996 }
1997 else if (name == SCROLL_UP) {
1998 changeSelection(list, CHANGE_SELECTION,
1999 getNextPageIndex(list, -1), -1);
2000 }
2001 else if (name == SCROLL_UP_EXTEND) {
2002 changeSelection(list, EXTEND_SELECTION,
2003 getNextPageIndex(list, -1), -1);
2004 }
2005 else if (name == SCROLL_UP_CHANGE_LEAD) {
2006 changeSelection(list, CHANGE_LEAD,
2007 getNextPageIndex(list, -1), -1);
2008 }
2009 else if (name == SCROLL_DOWN) {
2010 changeSelection(list, CHANGE_SELECTION,
2011 getNextPageIndex(list, 1), 1);
2012 }
2013 else if (name == SCROLL_DOWN_EXTEND) {
2014 changeSelection(list, EXTEND_SELECTION,
2015 getNextPageIndex(list, 1), 1);
2016 }
2017 else if (name == SCROLL_DOWN_CHANGE_LEAD) {
2018 changeSelection(list, CHANGE_LEAD,
2019 getNextPageIndex(list, 1), 1);
2020 }
2021 else if (name == SELECT_ALL) {
2022 selectAll(list);
2023 }
2024 else if (name == CLEAR_SELECTION) {
2025 clearSelection(list);
2026 }
2027 else if (name == ADD_TO_SELECTION) {
2028 int index = adjustIndex(
2029 list.getSelectionModel().getLeadSelectionIndex(), list);
2030
2031 if (!list.isSelectedIndex(index)) {
2032 int oldAnchor = list.getSelectionModel().getAnchorSelectionIndex();
2033 list.setValueIsAdjusting(true);
2034 list.addSelectionInterval(index, index);
2035 list.getSelectionModel().setAnchorSelectionIndex(oldAnchor);
2036 list.setValueIsAdjusting(false);
2037 }
2038 }
2039 else if (name == TOGGLE_AND_ANCHOR) {
2040 int index = adjustIndex(
2041 list.getSelectionModel().getLeadSelectionIndex(), list);
2042
2043 if (list.isSelectedIndex(index)) {
2044 list.removeSelectionInterval(index, index);
2045 } else {
2046 list.addSelectionInterval(index, index);
2047 }
2048 }
2049 else if (name == EXTEND_TO) {
2050 changeSelection(
2051 list, EXTEND_SELECTION,
2052 adjustIndex(list.getSelectionModel().getLeadSelectionIndex(), list),
2053 0);
2054 }
2055 else if (name == MOVE_SELECTION_TO) {
2056 changeSelection(
2057 list, CHANGE_SELECTION,
2058 adjustIndex(list.getSelectionModel().getLeadSelectionIndex(), list),
2059 0);
2060 }
2061 }
2062
2063 public boolean isEnabled(Object c) {
2064 Object name = getName();
2065 if (name == SELECT_PREVIOUS_COLUMN_CHANGE_LEAD ||
2066 name == SELECT_NEXT_COLUMN_CHANGE_LEAD ||
2067 name == SELECT_PREVIOUS_ROW_CHANGE_LEAD ||
2068 name == SELECT_NEXT_ROW_CHANGE_LEAD ||
2069 name == SELECT_FIRST_ROW_CHANGE_LEAD ||
2070 name == SELECT_LAST_ROW_CHANGE_LEAD ||
2071 name == SCROLL_UP_CHANGE_LEAD ||
2072 name == SCROLL_DOWN_CHANGE_LEAD) {
2073
2074 // discontinuous selection actions are only enabled for
2075 // DefaultListSelectionModel
2076 return c != null && ((JList)c).getSelectionModel()
2077 instanceof DefaultListSelectionModel;
2078 }
2079
2080 return true;
2081 }
2082
2083 private void clearSelection(JList<?> list) {
2084 list.clearSelection();
2085 }
2086
2087 private void selectAll(JList<?> list) {
2088 int size = list.getModel().getSize();
2089 if (size > 0) {
2090 ListSelectionModel lsm = list.getSelectionModel();
2091 int lead = adjustIndex(lsm.getLeadSelectionIndex(), list);
2092
2093 if (lsm.getSelectionMode() == ListSelectionModel.SINGLE_SELECTION) {
2094 if (lead == -1) {
2095 int min = adjustIndex(list.getMinSelectionIndex(), list);
2096 lead = (min == -1 ? 0 : min);
2097 }
2098
2099 list.setSelectionInterval(lead, lead);
2100 list.ensureIndexIsVisible(lead);
2101 } else {
2102 list.setValueIsAdjusting(true);
2103
2104 int anchor = adjustIndex(lsm.getAnchorSelectionIndex(), list);
2105
2106 list.setSelectionInterval(0, size - 1);
2107
2108 // this is done to restore the anchor and lead
2109 SwingUtilities2.setLeadAnchorWithoutSelection(lsm, anchor, lead);
2110
2111 list.setValueIsAdjusting(false);
2112 }
2113 }
2114 }
2115
2116 private int getNextPageIndex(JList<?> list, int direction) {
2117 if (list.getModel().getSize() == 0) {
2118 return -1;
2119 }
2120
2121 int index = -1;
2122 Rectangle visRect = list.getVisibleRect();
2123 ListSelectionModel lsm = list.getSelectionModel();
2124 int lead = adjustIndex(lsm.getLeadSelectionIndex(), list);
2125 Rectangle leadRect =
2126 (lead==-1) ? new Rectangle() : list.getCellBounds(lead, lead);
2127
2128 if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2129 list.getVisibleRowCount() <= 0) {
2130 if (!list.getComponentOrientation().isLeftToRight()) {
2131 direction = -direction;
2132 }
2133 // apply for horizontal scrolling: the step for next
2134 // page index is number of visible columns
2135 if (direction < 0) {
2136 // left
2137 visRect.x = leadRect.x + leadRect.width - visRect.width;
2138 Point p = new Point(visRect.x - 1, leadRect.y);
2139 index = list.locationToIndex(p);
2140 Rectangle cellBounds = list.getCellBounds(index, index);
2141 if (visRect.intersects(cellBounds)) {
2142 p.x = cellBounds.x - 1;
2143 index = list.locationToIndex(p);
2144 cellBounds = list.getCellBounds(index, index);
2145 }
2146 // this is necessary for right-to-left orientation only
2147 if (cellBounds.y != leadRect.y) {
2148 p.x = cellBounds.x + cellBounds.width;
2149 index = list.locationToIndex(p);
2150 }
2151 }
2152 else {
2153 // right
2154 visRect.x = leadRect.x;
2155 Point p = new Point(visRect.x + visRect.width, leadRect.y);
2156 index = list.locationToIndex(p);
2157 Rectangle cellBounds = list.getCellBounds(index, index);
2158 if (visRect.intersects(cellBounds)) {
2159 p.x = cellBounds.x + cellBounds.width;
2160 index = list.locationToIndex(p);
2161 cellBounds = list.getCellBounds(index, index);
2162 }
2163 if (cellBounds.y != leadRect.y) {
2164 p.x = cellBounds.x - 1;
2165 index = list.locationToIndex(p);
2166 }
2167 }
2168 }
2169 else {
2170 if (direction < 0) {
2171 // up
2172 // go to the first visible cell
2173 Point p = new Point(leadRect.x, visRect.y);
2174 index = list.locationToIndex(p);
2175 if (lead <= index) {
2176 // if lead is the first visible cell (or above it)
2177 // adjust the visible rect up
2178 visRect.y = leadRect.y + leadRect.height - visRect.height;
2179 p.y = visRect.y;
2180 index = list.locationToIndex(p);
2181 Rectangle cellBounds = list.getCellBounds(index, index);
2182 // go one cell down if first visible cell doesn't fit
2183 // into adjasted visible rectangle
2184 if (cellBounds.y < visRect.y) {
2185 p.y = cellBounds.y + cellBounds.height;
2186 index = list.locationToIndex(p);
2187 cellBounds = list.getCellBounds(index, index);
2188 }
2189 // if index isn't less then lead
2190 // try to go to cell previous to lead
2191 if (cellBounds.y >= leadRect.y) {
2192 p.y = leadRect.y - 1;
2193 index = list.locationToIndex(p);
2194 }
2195 }
2196 }
2197 else {
2198 // down
2199 // go to the last completely visible cell
2200 Point p = new Point(leadRect.x,
2201 visRect.y + visRect.height - 1);
2202 index = list.locationToIndex(p);
2203 Rectangle cellBounds = list.getCellBounds(index, index);
2204 // go up one cell if last visible cell doesn't fit
2205 // into visible rectangle
2206 if (cellBounds.y + cellBounds.height >
2207 visRect.y + visRect.height) {
2208 p.y = cellBounds.y - 1;
2209 index = list.locationToIndex(p);
2210 cellBounds = list.getCellBounds(index, index);
2211 index = Math.max(index, lead);
2212 }
2213
2214 if (lead >= index) {
2215 // if lead is the last completely visible index
2216 // (or below it) adjust the visible rect down
2217 visRect.y = leadRect.y;
2218 p.y = visRect.y + visRect.height - 1;
2219 index = list.locationToIndex(p);
2220 cellBounds = list.getCellBounds(index, index);
2221 // go one cell up if last visible cell doesn't fit
2222 // into adjasted visible rectangle
2223 if (cellBounds.y + cellBounds.height >
2224 visRect.y + visRect.height) {
2225 p.y = cellBounds.y - 1;
2226 index = list.locationToIndex(p);
2227 cellBounds = list.getCellBounds(index, index);
2228 }
2229 // if index isn't greater then lead
2230 // try to go to cell next after lead
2231 if (cellBounds.y <= leadRect.y) {
2232 p.y = leadRect.y + leadRect.height;
2233 index = list.locationToIndex(p);
2234 }
2235 }
2236 }
2237 }
2238 return index;
2239 }
2240
2241 private void changeSelection(JList<?> list, int type,
2242 int index, int direction) {
2243 if (index >= 0 && index < list.getModel().getSize()) {
2244 ListSelectionModel lsm = list.getSelectionModel();
2245
2246 // CHANGE_LEAD is only valid with multiple interval selection
2247 if (type == CHANGE_LEAD &&
2248 list.getSelectionMode()
2249 != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) {
2250
2251 type = CHANGE_SELECTION;
2252 }
2253
2254 // IMPORTANT - This needs to happen before the index is changed.
2255 // This is because JFileChooser, which uses JList, also scrolls
2256 // the selected item into view. If that happens first, then
2257 // this method becomes a no-op.
2258 adjustScrollPositionIfNecessary(list, index, direction);
2259
2260 if (type == EXTEND_SELECTION) {
2261 int anchor = adjustIndex(lsm.getAnchorSelectionIndex(), list);
2262 if (anchor == -1) {
2263 anchor = 0;
2264 }
2265
2266 list.setSelectionInterval(anchor, index);
2267 }
2268 else if (type == CHANGE_SELECTION) {
2269 list.setSelectedIndex(index);
2270 }
2271 else {
2272 // casting should be safe since the action is only enabled
2273 // for DefaultListSelectionModel
2274 ((DefaultListSelectionModel)lsm).moveLeadSelectionIndex(index);
2275 }
2276 }
2277 }
2278
2279 /**
2280 * When scroll down makes selected index the last completely visible
2281 * index. When scroll up makes selected index the first visible index.
2282 * Adjust visible rectangle respect to list's component orientation.
2283 */
2284 private void adjustScrollPositionIfNecessary(JList<?> list, int index,
2285 int direction) {
2286 if (direction == 0) {
2287 return;
2288 }
2289 Rectangle cellBounds = list.getCellBounds(index, index);
2290 Rectangle visRect = list.getVisibleRect();
2291 if (cellBounds != null && !visRect.contains(cellBounds)) {
2292 if (list.getLayoutOrientation() == JList.VERTICAL_WRAP &&
2293 list.getVisibleRowCount() <= 0) {
2294 // horizontal
2295 if (list.getComponentOrientation().isLeftToRight()) {
2296 if (direction > 0) {
2297 // right for left-to-right
2298 int x =Math.max(0,
2299 cellBounds.x + cellBounds.width - visRect.width);
2300 int startIndex =
2301 list.locationToIndex(new Point(x, cellBounds.y));
2302 Rectangle startRect = list.getCellBounds(startIndex,
2303 startIndex);
2304 if (startRect.x < x && startRect.x < cellBounds.x) {
2305 startRect.x += startRect.width;
2306 startIndex =
2307 list.locationToIndex(startRect.getLocation());
2308 startRect = list.getCellBounds(startIndex,
2309 startIndex);
2310 }
2311 cellBounds = startRect;
2312 }
2313 cellBounds.width = visRect.width;
2314 }
2315 else {
2316 if (direction > 0) {
2317 // left for right-to-left
2318 int x = cellBounds.x + visRect.width;
2319 int rightIndex =
2320 list.locationToIndex(new Point(x, cellBounds.y));
2321 Rectangle rightRect = list.getCellBounds(rightIndex,
2322 rightIndex);
2323 if (rightRect.x + rightRect.width > x &&
2324 rightRect.x > cellBounds.x) {
2325 rightRect.width = 0;
2326 }
2327 cellBounds.x = Math.max(0,
2328 rightRect.x + rightRect.width - visRect.width);
2329 cellBounds.width = visRect.width;
2330 }
2331 else {
2332 cellBounds.x += Math.max(0,
2333 cellBounds.width - visRect.width);
2334 // adjust width to fit into visible rectangle
2335 cellBounds.width = Math.min(cellBounds.width,
2336 visRect.width);
2337 }
2338 }
2339 }
2340 else {
2341 // vertical
2342 if (direction > 0 &&
2343 (cellBounds.y < visRect.y ||
2344 cellBounds.y + cellBounds.height
2345 > visRect.y + visRect.height)) {
2346 //down
2347 int y = Math.max(0,
2348 cellBounds.y + cellBounds.height - visRect.height);
2349 int startIndex =
2350 list.locationToIndex(new Point(cellBounds.x, y));
2351 Rectangle startRect = list.getCellBounds(startIndex,
2352 startIndex);
2353 if (startRect.y < y && startRect.y < cellBounds.y) {
2354 startRect.y += startRect.height;
2355 startIndex =
2356 list.locationToIndex(startRect.getLocation());
2357 startRect =
2358 list.getCellBounds(startIndex, startIndex);
2359 }
2360 cellBounds = startRect;
2361 cellBounds.height = visRect.height;
2362 }
2363 else {
2364 // adjust height to fit into visible rectangle
2365 cellBounds.height = Math.min(cellBounds.height, visRect.height);
2366 }
2367 }
2368 list.scrollRectToVisible(cellBounds);
2369 }
2370 }
2371
2372 private int getNextColumnIndex(JList<?> list, BasicListUI ui,
2373 int amount) {
2374 if (list.getLayoutOrientation() != JList.VERTICAL) {
2375 int index = adjustIndex(list.getLeadSelectionIndex(), list);
2376 int size = list.getModel().getSize();
2377
2378 if (index == -1) {
2379 return 0;
2380 } else if (size == 1) {
2381 // there's only one item so we should select it
2382 return 0;
2383 } else if (ui == null || ui.columnCount <= 1) {
2384 return -1;
2385 }
2386
2387 int column = ui.convertModelToColumn(index);
2388 int row = ui.convertModelToRow(index);
2389
2390 column += amount;
2391 if (column >= ui.columnCount || column < 0) {
2392 // No wrapping.
2393 return -1;
2394 }
2395 int maxRowCount = ui.getRowCount(column);
2396 if (row >= maxRowCount) {
2397 return -1;
2398 }
2399 return ui.getModelIndex(column, row);
2400 }
2401 // Won't change the selection.
2402 return -1;
2403 }
2404
2405 private int getNextIndex(JList<?> list, BasicListUI ui, int amount) {
2406 int index = adjustIndex(list.getLeadSelectionIndex(), list);
2407 int size = list.getModel().getSize();
2408
2409 if (index == -1) {
2410 if (size > 0) {
2411 if (amount > 0) {
2412 index = 0;
2413 }
2414 else {
2415 index = size - 1;
2416 }
2417 }
2418 } else if (size == 1) {
2419 // there's only one item so we should select it
2420 index = 0;
2421 } else if (list.getLayoutOrientation() == JList.HORIZONTAL_WRAP) {
2422 if (ui != null) {
2423 index += ui.columnCount * amount;
2424 }
2425 } else {
2426 index += amount;
2427 }
2428
2429 return index;
2430 }
2431 }
2432
2433
2434 private class Handler implements FocusListener, KeyListener,
2435 ListDataListener, ListSelectionListener,
2436 MouseInputListener, PropertyChangeListener,
2437 BeforeDrag {
2438 //
2439 // KeyListener
2440 //
2441 private String prefix = "";
2442 private String typedString = "";
2443 private long lastTime = 0L;
2444
2445 /**
2446 * Invoked when a key has been typed.
2447 *
2448 * Moves the keyboard focus to the first element whose prefix matches the
2449 * sequence of alphanumeric keys pressed by the user with delay less
2450 * than value of <code>timeFactor</code> property (or 1000 milliseconds
2451 * if it is not defined). Subsequent same key presses move the keyboard
2452 * focus to the next object that starts with the same letter until another
2453 * key is pressed, then it is treated as the prefix with appropriate number
2454 * of the same letters followed by first typed another letter.
2455 */
2456 public void keyTyped(KeyEvent e) {
2457 JList<?> src = (JList)e.getSource();
2458 ListModel<?> model = src.getModel();
2459
2460 if (model.getSize() == 0 || e.isAltDown() ||
2461 BasicGraphicsUtils.isMenuShortcutKeyDown(e) ||
2462 isNavigationKey(e)) {
2463 // Nothing to select
2464 return;
2465 }
2466 boolean startingFromSelection = true;
2467
2468 char c = e.getKeyChar();
2469
2470 long time = e.getWhen();
2471 int startIndex = adjustIndex(src.getLeadSelectionIndex(), list);
2472 if (time - lastTime < timeFactor) {
2473 typedString += c;
2474 if((prefix.length() == 1) && (c == prefix.charAt(0))) {
2475 // Subsequent same key presses move the keyboard focus to the next
2476 // object that starts with the same letter.
2477 startIndex++;
2478 } else {
2479 prefix = typedString;
2480 }
2481 } else {
2482 startIndex++;
2483 typedString = "" + c;
2484 prefix = typedString;
2485 }
2486 lastTime = time;
2487
2488 if (startIndex < 0 || startIndex >= model.getSize()) {
2489 startingFromSelection = false;
2490 startIndex = 0;
2491 }
2492 int index = src.getNextMatch(prefix, startIndex,
2493 Position.Bias.Forward);
2494 if (index >= 0) {
2495 src.setSelectedIndex(index);
2496 src.ensureIndexIsVisible(index);
2497 } else if (startingFromSelection) { // wrap
2498 index = src.getNextMatch(prefix, 0,
2499 Position.Bias.Forward);
2500 if (index >= 0) {
2501 src.setSelectedIndex(index);
2502 src.ensureIndexIsVisible(index);
2503 }
2504 }
2505 }
2506
2507 /**
2508 * Invoked when a key has been pressed.
2509 *
2510 * Checks to see if the key event is a navigation key to prevent
2511 * dispatching these keys for the first letter navigation.
2512 */
2513 public void keyPressed(KeyEvent e) {
2514 if ( isNavigationKey(e) ) {
2515 prefix = "";
2516 typedString = "";
2517 lastTime = 0L;
2518 }
2519 }
2520
2521 /**
2522 * Invoked when a key has been released.
2523 * See the class description for {@link KeyEvent} for a definition of
2524 * a key released event.
2525 */
2526 public void keyReleased(KeyEvent e) {
2527 }
2528
2529 /**
2530 * Returns whether or not the supplied key event maps to a key that is used for
2531 * navigation. This is used for optimizing key input by only passing non-
2532 * navigation keys to the first letter navigation mechanism.
2533 */
2534 private boolean isNavigationKey(KeyEvent event) {
2535 InputMap inputMap = list.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
2536 KeyStroke key = KeyStroke.getKeyStrokeForEvent(event);
2537
2538 if (inputMap != null && inputMap.get(key) != null) {
2539 return true;
2540 }
2541 return false;
2542 }
2543
2544 //
2545 // PropertyChangeListener
2546 //
2547 public void propertyChange(PropertyChangeEvent e) {
2548 String propertyName = e.getPropertyName();
2549
2550 /* If the JList.model property changes, remove our listener,
2551 * listDataListener from the old model and add it to the new one.
2552 */
2553 if (propertyName == "model") {
2554 @SuppressWarnings("unchecked")
2555 ListModel<?> oldModel = (ListModel)e.getOldValue();
2556 @SuppressWarnings("unchecked")
2557 ListModel<?> newModel = (ListModel)e.getNewValue();
2558 if (oldModel != null) {
2559 oldModel.removeListDataListener(listDataListener);
2560 }
2561 if (newModel != null) {
2562 newModel.addListDataListener(listDataListener);
2563 }
2564 updateLayoutStateNeeded |= modelChanged;
2565 redrawList();
2566 }
2567
2568 /* If the JList.selectionModel property changes, remove our listener,
2569 * listSelectionListener from the old selectionModel and add it to the new one.
2570 */
2571 else if (propertyName == "selectionModel") {
2572 ListSelectionModel oldModel = (ListSelectionModel)e.getOldValue();
2573 ListSelectionModel newModel = (ListSelectionModel)e.getNewValue();
2574 if (oldModel != null) {
2575 oldModel.removeListSelectionListener(listSelectionListener);
2576 }
2577 if (newModel != null) {
2578 newModel.addListSelectionListener(listSelectionListener);
2579 }
2580 updateLayoutStateNeeded |= modelChanged;
2581 redrawList();
2582 }
2583 else if (propertyName == "cellRenderer") {
2584 updateLayoutStateNeeded |= cellRendererChanged;
2585 redrawList();
2586 }
2587 else if (propertyName == "font") {
2588 updateLayoutStateNeeded |= fontChanged;
2589 redrawList();
2590 }
2591 else if (propertyName == "prototypeCellValue") {
2592 updateLayoutStateNeeded |= prototypeCellValueChanged;
2593 redrawList();
2594 }
2595 else if (propertyName == "fixedCellHeight") {
2596 updateLayoutStateNeeded |= fixedCellHeightChanged;
2597 redrawList();
2598 }
2599 else if (propertyName == "fixedCellWidth") {
2600 updateLayoutStateNeeded |= fixedCellWidthChanged;
2601 redrawList();
2602 }
2603 else if (propertyName == "selectionForeground") {
2604 list.repaint();
2605 }
2606 else if (propertyName == "selectionBackground") {
2607 list.repaint();
2608 }
2609 else if ("layoutOrientation" == propertyName) {
2610 updateLayoutStateNeeded |= layoutOrientationChanged;
2611 layoutOrientation = list.getLayoutOrientation();
2612 redrawList();
2613 }
2614 else if ("visibleRowCount" == propertyName) {
2615 if (layoutOrientation != JList.VERTICAL) {
2616 updateLayoutStateNeeded |= layoutOrientationChanged;
2617 redrawList();
2618 }
2619 }
2620 else if ("componentOrientation" == propertyName) {
2621 isLeftToRight = list.getComponentOrientation().isLeftToRight();
2622 updateLayoutStateNeeded |= componentOrientationChanged;
2623 redrawList();
2624
2625 InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
2626 SwingUtilities.replaceUIInputMap(list, JComponent.WHEN_FOCUSED,
2627 inputMap);
2628 } else if ("List.isFileList" == propertyName) {
2629 updateIsFileList();
2630 redrawList();
2631 } else if ("dropLocation" == propertyName) {
2632 JList.DropLocation oldValue = (JList.DropLocation)e.getOldValue();
2633 repaintDropLocation(oldValue);
2634 repaintDropLocation(list.getDropLocation());
2635 }
2636 }
2637
2638 private void repaintDropLocation(JList.DropLocation loc) {
2639 if (loc == null) {
2640 return;
2641 }
2642
2643 Rectangle r;
2644
2645 if (loc.isInsert()) {
2646 r = getDropLineRect(loc);
2647 } else {
2648 r = getCellBounds(list, loc.getIndex());
2649 }
2650
2651 if (r != null) {
2652 list.repaint(r);
2653 }
2654 }
2655
2656 //
2657 // ListDataListener
2658 //
2659 public void intervalAdded(ListDataEvent e) {
2660 updateLayoutStateNeeded = modelChanged;
2661
2662 int minIndex = Math.min(e.getIndex0(), e.getIndex1());
2663 int maxIndex = Math.max(e.getIndex0(), e.getIndex1());
2664
2665 /* Sync the SelectionModel with the DataModel.
2666 */
2667
2668 ListSelectionModel sm = list.getSelectionModel();
2669 if (sm != null) {
2670 sm.insertIndexInterval(minIndex, maxIndex - minIndex+1, true);
2671 }
2672
2673 /* Repaint the entire list, from the origin of
2674 * the first added cell, to the bottom of the
2675 * component.
2676 */
2677 redrawList();
2678 }
2679
2680
2681 public void intervalRemoved(ListDataEvent e)
2682 {
2683 updateLayoutStateNeeded = modelChanged;
2684
2685 /* Sync the SelectionModel with the DataModel.
2686 */
2687
2688 ListSelectionModel sm = list.getSelectionModel();
2689 if (sm != null) {
2690 sm.removeIndexInterval(e.getIndex0(), e.getIndex1());
2691 }
2692
2693 /* Repaint the entire list, from the origin of
2694 * the first removed cell, to the bottom of the
2695 * component.
2696 */
2697
2698 redrawList();
2699 }
2700
2701
2702 public void contentsChanged(ListDataEvent e) {
2703 updateLayoutStateNeeded = modelChanged;
2704 redrawList();
2705 }
2706
2707
2708 //
2709 // ListSelectionListener
2710 //
2711 public void valueChanged(ListSelectionEvent e) {
2712 maybeUpdateLayoutState();
2713
2714 int size = list.getModel().getSize();
2715 int firstIndex = Math.min(size - 1, Math.max(e.getFirstIndex(), 0));
2716 int lastIndex = Math.min(size - 1, Math.max(e.getLastIndex(), 0));
2717
2718 Rectangle bounds = getCellBounds(list, firstIndex, lastIndex);
2719
2720 if (bounds != null) {
2721 list.repaint(bounds.x, bounds.y, bounds.width, bounds.height);
2722 }
2723 }
2724
2725 //
2726 // MouseListener
2727 //
2728 public void mouseClicked(MouseEvent e) {
2729 }
2730
2731 public void mouseEntered(MouseEvent e) {
2732 }
2733
2734 public void mouseExited(MouseEvent e) {
2735 }
2736
2737 // Whether or not the mouse press (which is being considered as part
2738 // of a drag sequence) also caused the selection change to be fully
2739 // processed.
2740 private boolean dragPressDidSelection;
2741
2742 public void mousePressed(MouseEvent e) {
2743 if (SwingUtilities2.shouldIgnore(e, list)) {
2744 return;
2745 }
2746
2747 boolean dragEnabled = list.getDragEnabled();
2748 boolean grabFocus = true;
2749
2750 // different behavior if drag is enabled
2751 if (dragEnabled) {
2752 int row = SwingUtilities2.loc2IndexFileList(list, e.getPoint());
2753 // if we have a valid row and this is a drag initiating event
2754 if (row != -1 && DragRecognitionSupport.mousePressed(e)) {
2755 dragPressDidSelection = false;
2756
2757 if (BasicGraphicsUtils.isMenuShortcutKeyDown(e)) {
2758 // do nothing for control - will be handled on release
2759 // or when drag starts
2760 return;
2761 } else if (!e.isShiftDown() && list.isSelectedIndex(row)) {
2762 // clicking on something that's already selected
2763 // and need to make it the lead now
2764 list.addSelectionInterval(row, row);
2765 return;
2766 }
2767
2768 // could be a drag initiating event - don't grab focus
2769 grabFocus = false;
2770
2771 dragPressDidSelection = true;
2772 }
2773 } else {
2774 // When drag is enabled mouse drags won't change the selection
2775 // in the list, so we only set the isAdjusting flag when it's
2776 // not enabled
2777 list.setValueIsAdjusting(true);
2778 }
2779
2780 if (grabFocus) {
2781 SwingUtilities2.adjustFocus(list);
2782 }
2783
2784 adjustSelection(e);
2785 }
2786
2787 private void adjustSelection(MouseEvent e) {
2788 int row = SwingUtilities2.loc2IndexFileList(list, e.getPoint());
2789 if (row < 0) {
2790 // If shift is down in multi-select, we should do nothing.
2791 // For single select or non-shift-click, clear the selection
2792 if (isFileList &&
2793 e.getID() == MouseEvent.MOUSE_PRESSED &&
2794 (!e.isShiftDown() ||
2795 list.getSelectionMode() == ListSelectionModel.SINGLE_SELECTION)) {
2796 list.clearSelection();
2797 }
2798 }
2799 else {
2800 int anchorIndex = adjustIndex(list.getAnchorSelectionIndex(), list);
2801 boolean anchorSelected;
2802 if (anchorIndex == -1) {
2803 anchorIndex = 0;
2804 anchorSelected = false;
2805 } else {
2806 anchorSelected = list.isSelectedIndex(anchorIndex);
2807 }
2808
2809 if (BasicGraphicsUtils.isMenuShortcutKeyDown(e)) {
2810 if (e.isShiftDown()) {
2811 if (anchorSelected) {
2812 list.addSelectionInterval(anchorIndex, row);
2813 } else {
2814 list.removeSelectionInterval(anchorIndex, row);
2815 if (isFileList) {
2816 list.addSelectionInterval(row, row);
2817 list.getSelectionModel().setAnchorSelectionIndex(anchorIndex);
2818 }
2819 }
2820 } else if (list.isSelectedIndex(row)) {
2821 list.removeSelectionInterval(row, row);
2822 } else {
2823 list.addSelectionInterval(row, row);
2824 }
2825 } else if (e.isShiftDown()) {
2826 list.setSelectionInterval(anchorIndex, row);
2827 } else {
2828 list.setSelectionInterval(row, row);
2829 }
2830 }
2831 }
2832
2833 public void dragStarting(MouseEvent me) {
2834 if (BasicGraphicsUtils.isMenuShortcutKeyDown(me)) {
2835 int row = SwingUtilities2.loc2IndexFileList(list, me.getPoint());
2836 list.addSelectionInterval(row, row);
2837 }
2838 }
2839
2840 public void mouseDragged(MouseEvent e) {
2841 if (SwingUtilities2.shouldIgnore(e, list)) {
2842 return;
2843 }
2844
2845 if (list.getDragEnabled()) {
2846 DragRecognitionSupport.mouseDragged(e, this);
2847 return;
2848 }
2849
2850 if (e.isShiftDown() || BasicGraphicsUtils.isMenuShortcutKeyDown(e)) {
2851 return;
2852 }
2853
2854 int row = locationToIndex(list, e.getPoint());
2855 if (row != -1) {
2856 // 4835633. Dragging onto a File should not select it.
2857 if (isFileList) {
2858 return;
2859 }
2860 Rectangle cellBounds = getCellBounds(list, row, row);
2861 if (cellBounds != null) {
2862 list.scrollRectToVisible(cellBounds);
2863 list.setSelectionInterval(row, row);
2864 }
2865 }
2866 }
2867
2868 public void mouseMoved(MouseEvent e) {
2869 }
2870
2871 public void mouseReleased(MouseEvent e) {
2872 if (SwingUtilities2.shouldIgnore(e, list)) {
2873 return;
2874 }
2875
2876 if (list.getDragEnabled()) {
2877 MouseEvent me = DragRecognitionSupport.mouseReleased(e);
2878 if (me != null) {
2879 SwingUtilities2.adjustFocus(list);
2880 if (!dragPressDidSelection) {
2881 adjustSelection(me);
2882 }
2883 }
2884 } else {
2885 list.setValueIsAdjusting(false);
2886 }
2887 }
2888
2889 //
2890 // FocusListener
2891 //
2892 protected void repaintCellFocus()
2893 {
2894 int leadIndex = adjustIndex(list.getLeadSelectionIndex(), list);
2895 if (leadIndex != -1) {
2896 Rectangle r = getCellBounds(list, leadIndex, leadIndex);
2897 if (r != null) {
2898 list.repaint(r.x, r.y, r.width, r.height);
2899 }
2900 }
2901 }
2902
2903 /* The focusGained() focusLost() methods run when the JList
2904 * focus changes.
2905 */
2906
2907 public void focusGained(FocusEvent e) {
2908 repaintCellFocus();
2909 }
2910
2911 public void focusLost(FocusEvent e) {
2912 repaintCellFocus();
2913 }
2914 }
2915
2916 private static int adjustIndex(int index, JList<?> list) {
2917 return index < list.getModel().getSize() ? index : -1;
2918 }
2919
2920 private static final TransferHandler defaultTransferHandler = new ListTransferHandler();
2921
2922 @SuppressWarnings("serial") // Superclass is a JDK-implementation class
2923 static class ListTransferHandler extends TransferHandler implements UIResource {
2924
2925 /**
2926 * Create a Transferable to use as the source for a data transfer.
2927 *
2928 * @param c The component holding the data to be transfered. This
2929 * argument is provided to enable sharing of TransferHandlers by
2930 * multiple components.
2931 * @return The representation of the data to be transfered.
2932 *
2933 */
2934 @SuppressWarnings("deprecation")
2935 protected Transferable createTransferable(JComponent c) {
2936 if (c instanceof JList) {
2937 JList<?> list = (JList) c;
2938 Object[] values = list.getSelectedValues();
2939
2940 if (values == null || values.length == 0) {
2941 return null;
2942 }
2943
2944 StringBuilder plainStr = new StringBuilder();
2945 StringBuilder htmlStr = new StringBuilder();
2946
2947 htmlStr.append("<html>\n<body>\n<ul>\n");
2948
2949 for (int i = 0; i < values.length; i++) {
2950 Object obj = values[i];
2951 String val = ((obj == null) ? "" : obj.toString());
2952 plainStr.append(val).append('\n');
2953 htmlStr.append(" <li>").append(val).append('\n');
2954 }
2955
2956 // remove the last newline
2957 plainStr.deleteCharAt(plainStr.length() - 1);
2958 htmlStr.append("</ul>\n</body>\n</html>");
2959
2960 return new BasicTransferable(plainStr.toString(), htmlStr.toString());
2961 }
2962
2963 return null;
2964 }
2965
2966 public int getSourceActions(JComponent c) {
2967 return COPY;
2968 }
2969
2970 }
2971 }