GNU Classpath (0.19) | ||
Frames | No Frames |
1: /* JList.java -- 2: Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.swing; 40: 41: import java.awt.Color; 42: import java.awt.Component; 43: import java.awt.ComponentOrientation; 44: import java.awt.Cursor; 45: import java.awt.Dimension; 46: import java.awt.Font; 47: import java.awt.FontMetrics; 48: import java.awt.Point; 49: import java.awt.Rectangle; 50: import java.awt.event.FocusListener; 51: import java.beans.PropertyChangeEvent; 52: import java.beans.PropertyChangeListener; 53: import java.util.Locale; 54: import java.util.Vector; 55: 56: import javax.accessibility.Accessible; 57: import javax.accessibility.AccessibleComponent; 58: import javax.accessibility.AccessibleContext; 59: import javax.accessibility.AccessibleRole; 60: import javax.accessibility.AccessibleSelection; 61: import javax.accessibility.AccessibleState; 62: import javax.accessibility.AccessibleStateSet; 63: import javax.swing.event.ListDataEvent; 64: import javax.swing.event.ListDataListener; 65: import javax.swing.event.ListSelectionEvent; 66: import javax.swing.event.ListSelectionListener; 67: import javax.swing.plaf.ListUI; 68: import javax.swing.text.Position; 69: 70: /** 71: * <p>This class is a facade over three separate objects: {@link 72: * javax.swing.ListModel}, {@link javax.swing.ListSelectionModel} and 73: * {@link javax.swing.plaf.ListUI}. The facade represents a unified "list" 74: * concept, with independently replacable (possibly client-provided) models 75: * for its contents and its current selection. In addition, each element in 76: * the list is rendered via a strategy class {@link 77: * javax.swing.ListCellRenderer}.</p> 78: * 79: * <p>Lists have many properties, some of which are stored in this class 80: * while others are delegated to the list's model or selection. The 81: * following properties are available:</p> 82: * 83: * <table> 84: * <tr><th>Property </th><th>Stored in</th><th>Bound?</th></tr> 85: * <tr><td>accessibleContext </td><td>list </td><td>no </td></tr> 86: * <tr><td>anchorSelectionIndex </td><td>selection</td><td>no </td></tr> 87: * <tr><td>cellRenderer </td><td>list </td><td>yes </td></tr> 88: * <tr><td>dragEnabled </td><td>list </td><td>no </td></tr> 89: * <tr><td>firstVisibleIndex </td><td>list </td><td>no </td></tr> 90: * <tr><td>fixedCellHeight </td><td>list </td><td>yes </td></tr> 91: * <tr><td>fixedCellWidth </td><td>list </td><td>yes </td></tr> 92: * <tr><td>lastVisibleIndex </td><td>list </td><td>no </td></tr> 93: * <tr><td>layoutOrientation </td><td>list </td><td>yes </td></tr> 94: * <tr><td>leadSelectionIndex </td><td>selection</td><td>no </td></tr> 95: * <tr><td>maxSelectionIndex </td><td>selection</td><td>no </td></tr> 96: * <tr><td>minSelectionIndex </td><td>selection</td><td>no </td></tr> 97: * <tr><td>model </td><td>list </td><td>yes </td></tr> 98: * <tr><td>opaque </td><td>list </td><td>no </td></tr> 99: * <tr><td>preferredScrollableViewportSize</td><td>list </td><td>no </td></tr> 100: * <tr><td>prototypeCellValue </td><td>list </td><td>yes </td></tr> 101: * <tr><td>scrollableTracksViewportHeight </td><td>list </td><td>no </td></tr> 102: * <tr><td>scrollableTracksViewportWidth </td><td>list </td><td>no </td></tr> 103: * <tr><td>selectedIndex </td><td>selection</td><td>no </td></tr> 104: * <tr><td>selectedIndices </td><td>selection</td><td>no </td></tr> 105: * <tr><td>selectedValue </td><td>model </td><td>no </td></tr> 106: * <tr><td>selectedValues </td><td>model </td><td>no </td></tr> 107: * <tr><td>selectionBackground </td><td>list </td><td>yes </td></tr> 108: * <tr><td>selectionEmpty </td><td>selection</td><td>no </td></tr> 109: * <tr><td>selectionForeground </td><td>list </td><td>yes </td></tr> 110: * <tr><td>selectionMode </td><td>selection</td><td>no </td></tr> 111: * <tr><td>selectionModel </td><td>list </td><td>yes </td></tr> 112: * <tr><td>UI </td><td>list </td><td>yes </td></tr> 113: * <tr><td>UIClassID </td><td>list </td><td>no </td></tr> 114: * <tr><td>valueIsAdjusting </td><td>list </td><td>no </td></tr> 115: * <tr><td>visibleRowCount </td><td>list </td><td>no </td></tr> 116: * </table> 117: * 118: * @author Graydon Hoare (graydon@redhat.com) 119: */ 120: 121: public class JList extends JComponent implements Accessible, Scrollable 122: { 123: 124: /** 125: * Provides accessibility support for <code>JList</code>. 126: */ 127: protected class AccessibleJList extends AccessibleJComponent 128: implements AccessibleSelection, PropertyChangeListener, 129: ListSelectionListener, ListDataListener 130: { 131: 132: /** 133: * Provides accessibility support for list elements in <code>JList</code>s. 134: */ 135: protected class AccessibleJListChild extends AccessibleContext 136: implements Accessible, AccessibleComponent 137: { 138: 139: /** 140: * The parent list. 141: */ 142: JList parent; 143: 144: /** 145: * The index in the list for that child. 146: */ 147: int listIndex; 148: 149: /** 150: * The cursor for this list child. 151: */ 152: // TODO: Testcases show that this class somehow stores state about the 153: // cursor. I cannot make up though how that could affect 154: // the actual list. 155: Cursor cursor = Cursor.getDefaultCursor(); 156: 157: /** 158: * Creates a new instance of <code>AccessibleJListChild</code>. 159: * 160: * @param list the list of which this is an accessible child 161: * @param index the list index for this child 162: */ 163: public AccessibleJListChild(JList list, int index) 164: { 165: parent = list; 166: listIndex = index; 167: } 168: 169: /** 170: * Returns the accessible context of this object. Returns 171: * <code>this</code> since <code>AccessibleJListChild</code>s are their 172: * own accessible contexts. 173: * 174: * @return the accessible context of this object, <code>this</code> 175: */ 176: public AccessibleContext getAccessibleContext() 177: { 178: return this; 179: } 180: 181: /** 182: * Returns the background color for this list child. This returns the 183: * background of the <code>JList</code> itself since the background 184: * cannot be set on list children individually 185: * 186: * @return the background color for this list child 187: */ 188: public Color getBackground() 189: { 190: return parent.getBackground(); 191: } 192: 193: /** 194: * Calling this method has no effect, since the background color cannot be 195: * set on list children individually. 196: * 197: * @param color not used here. 198: */ 199: public void setBackground(Color color) 200: { 201: // Calling this method has no effect, since the background color cannot 202: // be set on list children individually. 203: } 204: 205: /** 206: * Returns the foreground color for this list child. This returns the 207: * background of the <code>JList</code> itself since the foreground 208: * cannot be set on list children individually. 209: * 210: * @return the background color for this list child 211: */ 212: public Color getForeground() 213: { 214: return parent.getForeground(); 215: } 216: 217: /** 218: * Calling this method has no effect, since the foreground color cannot be 219: * set on list children individually. 220: * 221: * @param color not used here. 222: */ 223: public void setForeground(Color color) 224: { 225: // Calling this method has no effect, since the foreground color cannot 226: // be set on list children individually. 227: } 228: 229: /** 230: * Returns the cursor for this list child. 231: * 232: * @return the cursor for this list child 233: */ 234: public Cursor getCursor() 235: { 236: // TODO: Testcases show that this method returns the cursor that has 237: // been set by setCursor. I cannot make up though how that could affect 238: // the actual list. 239: return cursor; 240: } 241: 242: /** 243: * Sets the cursor for this list child. 244: */ 245: public void setCursor(Cursor cursor) 246: { 247: this.cursor = cursor; 248: // TODO: Testcases show that this method returns the cursor that has 249: // been set by setCursor. I cannot make up though how that could affect 250: // the actual list. 251: } 252: 253: /** 254: * Returns the font of the <code>JList</code> since it is not possible to 255: * set fonts for list children individually. 256: * 257: * @return the font of the <code>JList</code> 258: */ 259: public Font getFont() 260: { 261: return parent.getFont(); 262: } 263: 264: /** 265: * Does nothing since it is not possible to set the font on list children 266: * individually. 267: * 268: * @param font not used here 269: */ 270: public void setFont(Font font) 271: { 272: // Does nothing since it is not possible to set the font on list 273: // children individually. 274: } 275: 276: /** 277: * Returns the font metrics for the specified font. This method forwards 278: * to the parent <code>JList</code>. 279: * 280: * @param font the font for which the font metrics is queried 281: * 282: * @return the font metrics for the specified font 283: */ 284: public FontMetrics getFontMetrics(Font font) 285: { 286: return parent.getFontMetrics(font); 287: } 288: 289: /** 290: * Returns <code>true</code> if the parent <code>JList</code> is enabled, 291: * <code>false</code> otherwise. The list children cannot have an enabled 292: * flag set individually. 293: * 294: * @return <code>true</code> if the parent <code>JList</code> is enabled, 295: * <code>false</code> otherwise 296: */ 297: public boolean isEnabled() 298: { 299: return parent.isEnabled(); 300: } 301: 302: /** 303: * Does nothing since the enabled flag cannot be set for list children 304: * individually. 305: * 306: * @param b not used here 307: */ 308: public void setEnabled(boolean b) 309: { 310: // Does nothing since the enabled flag cannot be set for list children 311: // individually. 312: } 313: 314: /** 315: * Returns <code>true</code> if this list child is visible, 316: * <code>false</code> otherwise. The value of this property depends 317: * on {@link JList#getFirstVisibleIndex()} and 318: * {@link JList#getLastVisibleIndex()}. 319: * 320: * @return <code>true</code> if this list child is visible, 321: * <code>false</code> otherwise 322: */ 323: public boolean isVisible() 324: { 325: return listIndex >= parent.getFirstVisibleIndex() 326: && listIndex <= parent.getLastVisibleIndex(); 327: } 328: 329: /** 330: * The value of the visible property cannot be modified, so this method 331: * does nothing. 332: * 333: * @param b not used here 334: */ 335: public void setVisible(boolean b) 336: { 337: // The value of the visible property cannot be modified, so this method 338: // does nothing. 339: } 340: 341: /** 342: * Returns <code>true</code> if this list child is currently showing on 343: * screen and <code>false</code> otherwise. The list child is showing if 344: * it is visible and if it's parent JList is currently showing. 345: * 346: * @return <code>true</code> if this list child is currently showing on 347: * screen and <code>false</code> otherwise 348: */ 349: public boolean isShowing() 350: { 351: return isVisible() && parent.isShowing(); 352: } 353: 354: /** 355: * Returns <code>true</code> if this list child covers the screen location 356: * <code>point</code> (relative to the <code>JList</code> coordinate 357: * system, <code>false</code> otherwise. 358: * 359: * @return <code>true</code> if this list child covers the screen location 360: * <code>point</code> , <code>false</code> otherwise 361: */ 362: public boolean contains(Point point) 363: { 364: return getBounds().contains(point); 365: } 366: 367: /** 368: * Returns the absolute screen location of this list child. 369: * 370: * @return the absolute screen location of this list child 371: */ 372: public Point getLocationOnScreen() 373: { 374: Point loc = getLocation(); 375: SwingUtilities.convertPointToScreen(loc, parent); 376: return loc; 377: } 378: 379: /** 380: * Returns the screen location of this list child relative to it's parent. 381: * 382: * @return the location of this list child relative to it's parent 383: * 384: * @see JList#indexToLocation(int) 385: */ 386: public Point getLocation() 387: { 388: return parent.indexToLocation(listIndex); 389: } 390: 391: /** 392: * Does nothing since the screen location cannot be set on list children 393: * explictitly. 394: * 395: * @param point not used here 396: */ 397: public void setLocation(Point point) 398: { 399: // Does nothing since the screen location cannot be set on list children 400: // explictitly. 401: } 402: 403: /** 404: * Returns the bounds of this list child. 405: * 406: * @return the bounds of this list child 407: * 408: * @see JList#getCellBounds(int, int) 409: */ 410: public Rectangle getBounds() 411: { 412: return parent.getCellBounds(listIndex, listIndex); 413: } 414: 415: /** 416: * Does nothing since the bounds cannot be set on list children 417: * individually. 418: * 419: * @param rectangle not used here 420: */ 421: public void setBounds(Rectangle rectangle) 422: { 423: // Does nothing since the bounds cannot be set on list children 424: // individually. 425: } 426: 427: /** 428: * Returns the size of this list child. 429: * 430: * @return the size of this list child 431: */ 432: public Dimension getSize() 433: { 434: Rectangle b = getBounds(); 435: return b.getSize(); 436: } 437: 438: /** 439: * Does nothing since the size cannot be set on list children 440: * individually. 441: * 442: * @param dimension not used here 443: */ 444: public void setSize(Dimension dimension) 445: { 446: // Does nothing since the size cannot be set on list children 447: // individually. 448: } 449: 450: /** 451: * Returns <code>null</code> because list children do not have children 452: * themselves 453: * 454: * @return <code>null</code> 455: */ 456: public Accessible getAccessibleAt(Point point) 457: { 458: return null; 459: } 460: 461: /** 462: * Returns <code>true</code> since list children are focus traversable. 463: * 464: * @return true 465: */ 466: public boolean isFocusTraversable() 467: { 468: // TODO: Is this 100% ok? 469: return true; 470: } 471: 472: /** 473: * Requests focus on the parent list. List children cannot request focus 474: * individually. 475: */ 476: public void requestFocus() 477: { 478: // TODO: Is this 100% ok? 479: parent.requestFocus(); 480: } 481: 482: /** 483: * Adds a focus listener to the parent list. List children do not have 484: * their own focus management. 485: * 486: * @param listener the focus listener to add 487: */ 488: public void addFocusListener(FocusListener listener) 489: { 490: // TODO: Is this 100% ok? 491: parent.addFocusListener(listener); 492: } 493: 494: /** 495: * Removes a focus listener from the parent list. List children do not 496: * have their own focus management. 497: * 498: * @param listener the focus listener to remove 499: */ 500: public void removeFocusListener(FocusListener listener) 501: { 502: // TODO: Is this 100% 503: parent.removeFocusListener(listener); 504: } 505: 506: /** 507: * Returns the accessible role of this list item, which is 508: * {@link AccessibleRole#LABEL}. 509: * 510: * @return {@link AccessibleRole#LABEL} 511: */ 512: public AccessibleRole getAccessibleRole() 513: { 514: return AccessibleRole.LABEL; 515: } 516: 517: /** 518: * Returns the accessible state set of this list item. 519: * 520: * @return the accessible state set of this list item 521: */ 522: public AccessibleStateSet getAccessibleStateSet() 523: { 524: AccessibleStateSet states = new AccessibleStateSet(); 525: if (isVisible()) 526: states.add(AccessibleState.VISIBLE); 527: if (isShowing()) 528: states.add(AccessibleState.SHOWING); 529: if (isFocusTraversable()) 530: states.add(AccessibleState.FOCUSABLE); 531: // TODO: How should the active state be handled? The API docs 532: // suggest that this state is set on the activated list child, 533: // that is the one that is drawn with a box. However, I don't know how 534: // to implement this. 535: 536: // TODO: We set the selectable state here because list children are 537: // selectable. Is there a way to disable single children? 538: if (parent.isEnabled()) 539: states.add(AccessibleState.SELECTABLE); 540: 541: if (parent.isSelectedIndex(listIndex)) 542: states.add(AccessibleState.SELECTED); 543: 544: // TODO: Handle more states here? 545: return states; 546: } 547: 548: /** 549: * Returns the index of this list child within it's parent list. 550: * 551: * @return the index of this list child within it's parent list 552: */ 553: public int getAccessibleIndexInParent() 554: { 555: return listIndex; 556: } 557: 558: /** 559: * Returns <code>0</code> since list children don't have children 560: * themselves. 561: * 562: * @return <code>0</code> 563: */ 564: public int getAccessibleChildrenCount() 565: { 566: return 0; 567: } 568: 569: /** 570: * Returns <code>null</code> since list children don't have children 571: * themselves. 572: * 573: * @return <code>null</code> 574: */ 575: public Accessible getAccessibleChild(int i) 576: { 577: return null; 578: } 579: 580: /** 581: * Returns the locale of this component. This call is forwarded to the 582: * parent list since list children don't have a separate locale setting. 583: * 584: * @return the locale of this component 585: */ 586: public Locale getLocale() 587: { 588: return parent.getLocale(); 589: } 590: 591: /** 592: * This method does 593: * nothing, list children are transient accessible objects which means 594: * that they don't fire property change events. 595: * 596: * @param l not used here 597: */ 598: public void addPropertyChangeListener(PropertyChangeListener l) 599: { 600: // Do nothing here. 601: } 602: 603: /** 604: * This method does 605: * nothing, list children are transient accessible objects which means 606: * that they don't fire property change events. 607: * 608: * @param l not used here 609: */ 610: public void removePropertyChangeListener(PropertyChangeListener l) 611: { 612: // Do nothing here. 613: } 614: 615: // TODO: Implement the remaining methods of this class. 616: } 617: 618: /** 619: * Create a new AccessibleJList. 620: */ 621: public AccessibleJList() 622: { 623: // Nothing to do here. 624: } 625: 626: /** 627: * Returns the number of selected accessible children. 628: * 629: * @return the number of selected accessible children 630: */ 631: public int getAccessibleSelectionCount() 632: { 633: return getSelectedIndices().length; 634: } 635: 636: /** 637: * Returns the n-th selected accessible child. 638: * 639: * @param n the index of the selected child to return 640: * 641: * @return the n-th selected accessible child 642: */ 643: public Accessible getAccessibleSelection(int n) 644: { 645: return new AccessibleJListChild(JList.this, getSelectedIndices()[n]); 646: } 647: 648: /** 649: * Returns <code>true</code> if the n-th child is selected, 650: * <code>false</code> otherwise. 651: * 652: * @param n the index of the child of which the selected state is queried 653: * 654: * @return <code>true</code> if the n-th child is selected, 655: * <code>false</code> otherwise 656: */ 657: public boolean isAccessibleChildSelected(int n) 658: { 659: return isSelectedIndex(n); 660: } 661: 662: /** 663: * Adds the accessible item with the specified index to the selected items. 664: * If multiple selections are supported, the item is added to the selection, 665: * otherwise the item replaces the current selection. 666: * 667: * @param i the index of the item to add to the selection 668: */ 669: public void addAccessibleSelection(int i) 670: { 671: addSelectionInterval(i, i); 672: } 673: 674: /** 675: * Removes the accessible item with the specified index to the selection. 676: * 677: * @param i the index of the item to be removed from the selection 678: */ 679: public void removeAccessibleSelection(int i) 680: { 681: removeSelectionInterval(i, i); 682: } 683: 684: /** 685: * Remove all selection items from the selection. 686: */ 687: public void clearAccessibleSelection() 688: { 689: clearSelection(); 690: } 691: 692: /** 693: * Selects all items if multiple selections are supported. 694: * Otherwise do nothing. 695: */ 696: public void selectAllAccessibleSelection() 697: { 698: addSelectionInterval(0, getModel().getSize()); 699: } 700: 701: /** 702: * Receices notification when the list selection is changed. This method 703: * fires two property change events, the first with 704: * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY} and the second 705: * with {@link AccessibleContext#ACCESSIBLE_SELECTION_PROPERTY}. 706: * 707: * @param event the list selection event 708: */ 709: public void valueChanged(ListSelectionEvent event) 710: { 711: firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE, 712: Boolean.TRUE); 713: firePropertyChange(ACCESSIBLE_SELECTION_PROPERTY, Boolean.FALSE, 714: Boolean.TRUE); 715: } 716: 717: /** 718: * Receives notification when items have changed in the 719: * <code>JList</code>. This method fires a property change event with 720: * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}. 721: * 722: * @param event the list data event 723: */ 724: public void contentsChanged(ListDataEvent event) 725: { 726: firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE, 727: Boolean.TRUE); 728: } 729: 730: /** 731: * Receives notification when items are inserted into the 732: * <code>JList</code>. This method fires a property change event with 733: * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}. 734: * 735: * @param event the list data event 736: */ 737: public void intervalAdded(ListDataEvent event) 738: { 739: firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE, 740: Boolean.TRUE); 741: } 742: 743: /** 744: * Receives notification when items are removed from the 745: * <code>JList</code>. This method fires a property change event with 746: * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}. 747: * 748: * @param event the list data event 749: */ 750: public void intervalRemoved(ListDataEvent event) 751: { 752: firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE, 753: Boolean.TRUE); 754: } 755: 756: 757: /** 758: * Receives notification about changes of the <code>JList</code>'s 759: * properties. This is used to re-register this object as listener to 760: * the data model and selection model when the data model or selection model 761: * changes. 762: * 763: * @param e the property change event 764: */ 765: public void propertyChange(PropertyChangeEvent e) 766: { 767: String propertyName = e.getPropertyName(); 768: if (propertyName.equals("model")) 769: { 770: ListModel oldModel = (ListModel) e.getOldValue(); 771: oldModel.removeListDataListener(this); 772: ListModel newModel = (ListModel) e.getNewValue(); 773: newModel.addListDataListener(this); 774: } 775: else if (propertyName.equals("selectionModel")) 776: { 777: ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue(); 778: oldModel.removeListSelectionListener(this); 779: ListSelectionModel newModel = (ListSelectionModel) e.getNewValue(); 780: oldModel.addListSelectionListener(this); 781: } 782: } 783: 784: /** 785: * Return the state set of the <code>JList</code>. 786: * 787: * @return the state set of the <code>JList</code> 788: */ 789: public AccessibleStateSet getAccessibleStateSet() 790: { 791: // TODO: Figure out if there is possibly more state that must be 792: // handled here. 793: AccessibleStateSet s = super.getAccessibleStateSet(); 794: if (getSelectionMode() != ListSelectionModel.SINGLE_SELECTION) 795: s.add(AccessibleState.MULTISELECTABLE); 796: return s; 797: } 798: 799: /** 800: * Returns the accessible role for <code>JList</code>, 801: * {@link AccessibleRole#LIST}. 802: * 803: * @return the accessible role for <code>JList</code> 804: */ 805: public AccessibleRole getAccessibleRole() 806: { 807: return AccessibleRole.LIST; 808: } 809: 810: /** 811: * Returns the accessible child at the visual location <code>p</code> 812: * (relative to the upper left corner of the <code>JList</code>). If there 813: * is no child at that location, this returns <code>null</code>. 814: * 815: * @param p the screen location for which to return the accessible child 816: * 817: * @return the accessible child at the specified location, or 818: * <code>null</code> if there is no child at that location 819: */ 820: public Accessible getAccessibleAt(Point p) 821: { 822: int childIndex = locationToIndex(p); 823: return getAccessibleChild(childIndex); 824: } 825: 826: /** 827: * Returns the number of accessible children in the <code>JList</code>. 828: * 829: * @return the number of accessible children in the <code>JList</code> 830: */ 831: public int getAccessibleChildrenCount() 832: { 833: return getModel().getSize(); 834: } 835: 836: /** 837: * Returns the n-th accessible child of this <code>JList</code>. This will 838: * be an instance of {@link AccessibleJListChild}. If there is no child 839: * at that index, <code>null</code> is returned. 840: * 841: * @param n the index of the child to return 842: * 843: * @return the n-th accessible child of this <code>JList</code> 844: */ 845: public Accessible getAccessibleChild(int n) 846: { 847: if (getModel().getSize() <= n) 848: return null; 849: return new AccessibleJListChild(JList.this, n); 850: } 851: } 852: 853: private static final long serialVersionUID = 4406629526391098046L; 854: 855: /** 856: * Constant value used in "layoutOrientation" property. This value means 857: * that cells are laid out in a single vertical column. This is the default. 858: */ 859: public static final int VERTICAL = 0; 860: 861: /** 862: * Constant value used in "layoutOrientation" property. This value means 863: * that cells are laid out in multiple columns "newspaper style", filling 864: * vertically first, then horizontally. 865: */ 866: public static final int VERTICAL_WRAP = 1; 867: 868: /** 869: * Constant value used in "layoutOrientation" property. This value means 870: * that cells are laid out in multiple columns "newspaper style", 871: * filling horizontally first, then vertically. 872: */ 873: public static final int HORIZONTAL_WRAP = 2; 874: 875: /** 876: * This property indicates whether "drag and drop" functions are enabled 877: * on the list. 878: */ 879: boolean dragEnabled; 880: 881: /** This property provides a strategy for rendering cells in the list. */ 882: ListCellRenderer cellRenderer; 883: 884: /** 885: * This property indicates an fixed width to assign to all cells in the 886: * list. If its value is <code>-1</code>, no width has been 887: * assigned. This value can be set explicitly, or implicitly by setting 888: * the {@link #prototypeCellValue} property. 889: */ 890: int fixedCellWidth; 891: 892: /** 893: * This property indicates an fixed height to assign to all cells in the 894: * list. If its value is <code>-1</code>, no height has been 895: * assigned. This value can be set explicitly, or implicitly by setting 896: * the {@link #prototypeCellValue} property. 897: */ 898: int fixedCellHeight; 899: 900: /** 901: * This property holds the current layout orientation of the list, which 902: * is one of the integer constants {@link #VERTICAL}, {@link 903: * #VERTICAL_WRAP}, or {@link #HORIZONTAL_WRAP}. 904: */ 905: int layoutOrientation; 906: 907: /** This property holds the data elements displayed by the list. */ 908: ListModel model; 909: 910: /** 911: * <p>This property holds a reference to a "prototype" data value -- 912: * typically a String -- which is used to calculate the {@link 913: * #fixedCellWidth} and {@link #fixedCellHeight} properties, using the 914: * {@link #cellRenderer} property to acquire a component to render the 915: * prototype.</p> 916: * 917: * <p>It is important that you <em>not</em> set this value to a 918: * component. It has to be a <em>data value</em> such as the objects you 919: * would find in the list's model. Setting it to a component will have 920: * undefined (and undesirable) affects. </p> 921: */ 922: Object prototypeCellValue; 923: 924: /** 925: * This property specifies a foreground color for the selected cells in 926: * the list. When {@link ListCellRenderer#getListCellRendererComponent} 927: * is called with a selected cell object, the component returned will 928: * have its "foreground" set to this color. 929: */ 930: Color selectionBackground; 931: 932: /** 933: * This property specifies a background color for the selected cells in 934: * the list. When {@link ListCellRenderer#getListCellRendererComponent} 935: * is called with a selected cell object, the component returned will 936: * have its "background" property set to this color. 937: */ 938: Color selectionForeground; 939: 940: /** 941: * This property holds a description of which data elements in the {@link 942: * #model} property should be considered "selected", when displaying and 943: * interacting with the list. 944: */ 945: ListSelectionModel selectionModel; 946: 947: 948: /** 949: * This property indicates that the list's selection is currently 950: * "adjusting" -- perhaps due to a user actively dragging the mouse over 951: * multiple list elements -- and is therefore likely to change again in 952: * the near future. A {@link ListSelectionListener} might choose to delay 953: * updating its view of the list's selection until this property is 954: * false, meaning that the adjustment has completed. 955: */ 956: boolean valueIsAdjusting; 957: 958: /** 959: * This property indicates a <em>preference</em> for the number of rows 960: * displayed in the list, and will scale the 961: * {@link #getPreferredScrollableViewportSize} property accordingly. The actual 962: * number of displayed rows, when the list is placed in a real {@link 963: * JViewport} or other component, may be greater or less than this number. 964: */ 965: int visibleRowCount; 966: 967: /** 968: * Fire a {@link ListSelectionEvent} to all the registered ListSelectionListeners. 969: */ 970: protected void fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting) 971: { 972: ListSelectionEvent evt = new ListSelectionEvent(this, firstIndex, lastIndex, isAdjusting); 973: ListSelectionListener listeners[] = getListSelectionListeners(); 974: for (int i = 0; i < listeners.length; ++i) 975: { 976: listeners[i].valueChanged(evt); 977: } 978: } 979: 980: /** 981: * This private listener propagates {@link ListSelectionEvent} events 982: * from the list's "selectionModel" property to the list's {@link 983: * ListSelectionListener} listeners. It also listens to {@link 984: * ListDataEvent} events from the list's {@link #model} property. If this 985: * class receives either type of event, it triggers repainting of the 986: * list. 987: */ 988: private class ListListener 989: implements ListSelectionListener, ListDataListener 990: { 991: // ListDataListener events 992: public void contentsChanged(ListDataEvent event) 993: { 994: JList.this.revalidate(); 995: JList.this.repaint(); 996: } 997: public void intervalAdded(ListDataEvent event) 998: { 999: JList.this.revalidate(); 1000: JList.this.repaint(); 1001: } 1002: public void intervalRemoved(ListDataEvent event) 1003: { 1004: JList.this.revalidate(); 1005: JList.this.repaint(); 1006: } 1007: // ListSelectionListener events 1008: public void valueChanged(ListSelectionEvent event) 1009: { 1010: JList.this.fireSelectionValueChanged(event.getFirstIndex(), 1011: event.getLastIndex(), 1012: event.getValueIsAdjusting()); 1013: JList.this.repaint(); 1014: } 1015: } 1016: 1017: /** 1018: * Shared ListListener instance, subscribed to both the current {@link 1019: * #model} and {@link #selectionModel} properties of the list. 1020: */ 1021: ListListener listListener; 1022: 1023: 1024: /** 1025: * Creates a new JList object. 1026: */ 1027: public JList() 1028: { 1029: init(); 1030: } 1031: 1032: /** 1033: * Creates a new JList object. 1034: * 1035: * @param listData Initial data to populate the list with 1036: */ 1037: public JList(Object[] listData) 1038: { 1039: init(); 1040: setListData(listData); 1041: } 1042: 1043: /** 1044: * Creates a new JList object. 1045: * 1046: * @param listData Initial data to populate the list with 1047: */ 1048: public JList(Vector listData) 1049: { 1050: init(); 1051: setListData(listData); 1052: } 1053: 1054: /** 1055: * Creates a new JList object. 1056: * 1057: * @param listData Initial data to populate the list with 1058: */ 1059: public JList(ListModel listData) 1060: { 1061: init(); 1062: setModel(listData); 1063: } 1064: 1065: void init() 1066: { 1067: dragEnabled = false; 1068: fixedCellHeight = -1; 1069: fixedCellWidth = -1; 1070: layoutOrientation = VERTICAL; 1071: opaque = true; 1072: valueIsAdjusting = false; 1073: visibleRowCount = 8; 1074: 1075: cellRenderer = new DefaultListCellRenderer(); 1076: listListener = new ListListener(); 1077: 1078: setModel(new DefaultListModel()); 1079: setSelectionModel(createSelectionModel()); 1080: 1081: updateUI(); 1082: } 1083: 1084: /** 1085: * Creates the default <code>ListSelectionModel</code>. 1086: * 1087: * @return the <code>ListSelectionModel</code> 1088: */ 1089: protected ListSelectionModel createSelectionModel() 1090: { 1091: return new DefaultListSelectionModel(); 1092: } 1093: 1094: /** 1095: * Gets the value of the {@link #fixedCellHeight} property. This property 1096: * may be <code>-1</code> to indicate that no cell height has been 1097: * set. This property is also set implicitly when the 1098: * {@link #prototypeCellValue} property is set. 1099: * 1100: * @return The current value of the property 1101: * 1102: * @see #fixedCellHeight 1103: * @see #setFixedCellHeight 1104: * @see #setPrototypeCellValue 1105: */ 1106: public int getFixedCellHeight() 1107: { 1108: return fixedCellHeight; 1109: } 1110: 1111: /** 1112: * Sets the value of the {@link #fixedCellHeight} property. This property 1113: * may be <code>-1</code> to indicate that no cell height has been 1114: * set. This property is also set implicitly when the {@link 1115: * #prototypeCellValue} property is set, but setting it explicitly 1116: * overrides the height computed from {@link #prototypeCellValue}. 1117: * 1118: * @see #getFixedCellHeight 1119: * @see #getPrototypeCellValue 1120: */ 1121: public void setFixedCellHeight(int h) 1122: { 1123: if (fixedCellHeight == h) 1124: return; 1125: 1126: int old = fixedCellHeight; 1127: fixedCellHeight = h; 1128: firePropertyChange("fixedCellWidth", old, h); 1129: } 1130: 1131: 1132: /** 1133: * Gets the value of the {@link #fixedCellWidth} property. This property 1134: * may be <code>-1</code> to indicate that no cell width has been 1135: * set. This property is also set implicitly when the {@link 1136: * #prototypeCellValue} property is set. 1137: * 1138: * @return The current value of the property 1139: * 1140: * @see #setFixedCellWidth 1141: * @see #setPrototypeCellValue 1142: */ 1143: public int getFixedCellWidth() 1144: { 1145: return fixedCellWidth; 1146: } 1147: 1148: /** 1149: * Sets the value of the {@link #fixedCellWidth} property. This property 1150: * may be <code>-1</code> to indicate that no cell width has been 1151: * set. This property is also set implicitly when the {@link 1152: * #prototypeCellValue} property is set, but setting it explicitly 1153: * overrides the width computed from {@link #prototypeCellValue}. 1154: * 1155: * @see #getFixedCellHeight 1156: * @see #getPrototypeCellValue 1157: */ 1158: public void setFixedCellWidth(int w) 1159: { 1160: if (fixedCellWidth == w) 1161: return; 1162: 1163: int old = fixedCellWidth; 1164: fixedCellWidth = w; 1165: firePropertyChange("fixedCellWidth", old, w); 1166: } 1167: 1168: /** 1169: * Gets the value of the {@link #visibleRowCount} property. 1170: * 1171: * @return the current value of the property. 1172: */ 1173: 1174: public int getVisibleRowCount() 1175: { 1176: return visibleRowCount; 1177: } 1178: 1179: /** 1180: * Sets the value of the {@link #visibleRowCount} property. 1181: * 1182: * @param vc The new property value 1183: */ 1184: public void setVisibleRowCount(int vc) 1185: { 1186: visibleRowCount = vc; 1187: revalidate(); 1188: repaint(); 1189: } 1190: 1191: /** 1192: * Adds a {@link ListSelectionListener} to the listener list for this 1193: * list. The listener will be called back with a {@link 1194: * ListSelectionEvent} any time the list's {@link #selectionModel} 1195: * property changes. The source of such events will be the JList, 1196: * not the selection model. 1197: * 1198: * @param listener The new listener to add 1199: */ 1200: public void addListSelectionListener(ListSelectionListener listener) 1201: { 1202: listenerList.add (ListSelectionListener.class, listener); 1203: } 1204: 1205: /** 1206: * Removes a {@link ListSelectionListener} from the listener list for 1207: * this list. The listener will no longer be called when the list's 1208: * {@link #selectionModel} changes. 1209: * 1210: * @param listener The listener to remove 1211: */ 1212: public void removeListSelectionListener(ListSelectionListener listener) 1213: { 1214: listenerList.remove(ListSelectionListener.class, listener); 1215: } 1216: 1217: /** 1218: * Returns an array of all ListSelectionListeners subscribed to this 1219: * list. 1220: * 1221: * @return The current subscribed listeners 1222: * 1223: * @since 1.4 1224: */ 1225: public ListSelectionListener[] getListSelectionListeners() 1226: { 1227: return (ListSelectionListener[]) getListeners(ListSelectionListener.class); 1228: } 1229: 1230: public int getSelectionMode() 1231: { 1232: return selectionModel.getSelectionMode(); 1233: } 1234: 1235: /** 1236: * Sets the list's "selectionMode" property, which simply mirrors the 1237: * same property on the list's {@link #selectionModel} property. This 1238: * property should be one of the integer constants 1239: * <code>SINGLE_SELECTION</code>, <code>SINGLE_INTERVAL_SELECTION</code>, 1240: * or <code>MULTIPLE_INTERVAL_SELECTION</code> from the {@link 1241: * ListSelectionModel} interface. 1242: * 1243: * @param a The new selection mode 1244: */ 1245: public void setSelectionMode(int a) 1246: { 1247: selectionModel.setSelectionMode(a); 1248: } 1249: 1250: /** 1251: * Adds the interval <code>[a,a]</code> to the set of selections managed 1252: * by this list's {@link #selectionModel} property. Depending on the 1253: * selection mode, this may cause existing selections to become invalid, 1254: * or may simply expand the set of selections. 1255: * 1256: * @param a A number in the half-open range <code>[0, x)</code> where 1257: * <code>x = getModel.getSize()</code>, indicating the index of an 1258: * element in the list to select. 1259: * 1260: * @see #setSelectionMode 1261: * @see #selectionModel 1262: */ 1263: public void setSelectedIndex(int a) 1264: { 1265: selectionModel.setSelectionInterval(a, a); 1266: } 1267: 1268: /** 1269: * For each element <code>a[i]</code> of the provided array 1270: * <code>a</code>, calls {@link #setSelectedIndex} on <code>a[i]</code>. 1271: * 1272: * @see #setSelectionMode 1273: * @see #selectionModel 1274: */ 1275: public void setSelectedIndices(int [] a) 1276: { 1277: for (int i = 0; i < a.length; ++i) 1278: setSelectedIndex(a[i]); 1279: } 1280: 1281: /** 1282: * Returns the minimum index of an element in the list which is currently 1283: * selected. 1284: * 1285: * @return A number in the half-open range <code>[0, x)</code> where 1286: * <code>x = getModel.getSize()</code>, indicating the minimum index of 1287: * an element in the list for which the element is selected, or 1288: * <code>-1</code> if no elements are selected 1289: */ 1290: public int getSelectedIndex() 1291: { 1292: return selectionModel.getMinSelectionIndex(); 1293: } 1294: 1295: /** 1296: * Returns <code>true</code> if the model's selection is empty, otherwise 1297: * <code>false</code>. 1298: * 1299: * @return The return value of {@link ListSelectionModel#isSelectionEmpty} 1300: */ 1301: public boolean isSelectionEmpty() 1302: { 1303: return selectionModel.isSelectionEmpty(); 1304: } 1305: 1306: /** 1307: * Returns the list index of the upper left or upper right corner of the 1308: * visible rectangle of this list, depending on the {@link 1309: * Component#getComponentOrientation} property. 1310: * 1311: * @return The index of the first visible list cell, or <code>-1</code> 1312: * if none is visible. 1313: */ 1314: public int getFirstVisibleIndex() 1315: { 1316: ComponentOrientation or = getComponentOrientation(); 1317: Rectangle r = getVisibleRect(); 1318: if (or == ComponentOrientation.RIGHT_TO_LEFT) 1319: r.translate((int) r.getWidth() - 1, 0); 1320: return getUI().locationToIndex(this, r.getLocation()); 1321: } 1322: 1323: 1324: /** 1325: * Returns index of the cell to which specified location is closest to 1326: * @param location for which to look for in the list 1327: * 1328: * @return index of the cell to which specified location is closest to. 1329: */ 1330: public int locationToIndex(Point location) 1331: { 1332: return getUI().locationToIndex(this, location); 1333: } 1334: 1335: /** 1336: * Returns location of the cell located at the specified index in the list. 1337: * @param index of the cell for which location will be determined 1338: * 1339: * @return location of the cell located at the specified index in the list. 1340: */ 1341: public Point indexToLocation(int index) 1342: { 1343: return getUI().indexToLocation(this, index); 1344: } 1345: 1346: /** 1347: * Returns the list index of the lower right or lower left corner of the 1348: * visible rectangle of this list, depending on the {@link 1349: * Component#getComponentOrientation} property. 1350: * 1351: * @return The index of the last visible list cell, or <code>-1</code> 1352: * if none is visible. 1353: */ 1354: public int getLastVisibleIndex() 1355: { 1356: ComponentOrientation or = getComponentOrientation(); 1357: Rectangle r = getVisibleRect(); 1358: r.translate(0, (int) r.getHeight() - 1); 1359: if (or == ComponentOrientation.LEFT_TO_RIGHT) 1360: r.translate((int) r.getWidth() - 1, 0); 1361: if (getUI().locationToIndex(this, r.getLocation()) == -1 1362: && indexToLocation(getModel().getSize() - 1).y < r.y) 1363: return getModel().getSize() - 1; 1364: return getUI().locationToIndex(this, r.getLocation()); 1365: } 1366: 1367: /** 1368: * Returns the indices of values in the {@link #model} property which are 1369: * selected. 1370: * 1371: * @return An array of model indices, each of which is selected according 1372: * to the {@link #getSelectedValues} property 1373: */ 1374: public int[] getSelectedIndices() 1375: { 1376: int lo, hi, n, i, j; 1377: if (selectionModel.isSelectionEmpty()) 1378: return new int[0]; 1379: lo = selectionModel.getMinSelectionIndex(); 1380: hi = selectionModel.getMaxSelectionIndex(); 1381: n = 0; 1382: for (i = lo; i <= hi; ++i) 1383: if (selectionModel.isSelectedIndex(i)) 1384: n++; 1385: int [] v = new int[n]; 1386: j = 0; 1387: for (i = lo; i <= hi; ++i) 1388: if (selectionModel.isSelectedIndex(i)) 1389: v[j++] = i; 1390: return v; 1391: } 1392: 1393: /** 1394: * Indicates whether the list element at a given index value is 1395: * currently selected. 1396: * 1397: * @param a The index to check 1398: * @return <code>true</code> if <code>a</code> is the index of a selected 1399: * list element 1400: */ 1401: public boolean isSelectedIndex(int a) 1402: { 1403: return selectionModel.isSelectedIndex(a); 1404: } 1405: 1406: /** 1407: * Returns the first value in the list's {@link #model} property which is 1408: * selected, according to the list's {@link #selectionModel} property. 1409: * This is equivalent to calling 1410: * <code>getModel()getElementAt(getSelectedIndex())</code>, with a check 1411: * for the special index value of <code>-1</code> which returns null 1412: * <code>null</code>. 1413: * 1414: * @return The first selected element, or <code>null</code> if no element 1415: * is selected. 1416: * 1417: * @see #getSelectedValues 1418: */ 1419: public Object getSelectedValue() 1420: { 1421: int index = getSelectedIndex(); 1422: if (index == -1) 1423: return null; 1424: return getModel().getElementAt(index); 1425: } 1426: 1427: /** 1428: * Returns all the values in the list's {@link #model} property which 1429: * are selected, according to the list's {@link #selectionModel} property. 1430: * 1431: * @return An array containing all the selected values 1432: * 1433: * @see #setSelectedValue 1434: */ 1435: public Object[] getSelectedValues() 1436: { 1437: int [] idx = getSelectedIndices(); 1438: Object [] v = new Object[idx.length]; 1439: for (int i = 0; i < idx.length; ++i) 1440: v[i] = getModel().getElementAt(i); 1441: return v; 1442: } 1443: 1444: /** 1445: * Gets the value of the {@link #selectionBackground} property. 1446: * 1447: * @return The current value of the property 1448: */ 1449: public Color getSelectionBackground() 1450: { 1451: return selectionBackground; 1452: } 1453: 1454: /** 1455: * Sets the value of the {@link #selectionBackground} property. 1456: * 1457: * @param c The new value of the property 1458: */ 1459: public void setSelectionBackground(Color c) 1460: { 1461: if (selectionBackground == c) 1462: return; 1463: 1464: Color old = selectionBackground; 1465: selectionBackground = c; 1466: firePropertyChange("selectionBackground", old, c); 1467: repaint(); 1468: } 1469: 1470: /** 1471: * Gets the value of the {@link #selectionForeground} property. 1472: * 1473: * @return The current value of the property 1474: */ 1475: public Color getSelectionForeground() 1476: { 1477: return selectionForeground; 1478: } 1479: 1480: /** 1481: * Sets the value of the {@link #selectionForeground} property. 1482: * 1483: * @param c The new value of the property 1484: */ 1485: public void setSelectionForeground(Color c) 1486: { 1487: if (selectionForeground == c) 1488: return; 1489: 1490: Color old = selectionForeground; 1491: selectionForeground = c; 1492: firePropertyChange("selectionForeground", old, c); 1493: } 1494: 1495: /** 1496: * Sets the selection to cover only the specified value, if it 1497: * exists in the model. 1498: * 1499: * @param obj The object to select 1500: * @param scroll Whether to scroll the list to make the newly selected 1501: * value visible 1502: * 1503: * @see #ensureIndexIsVisible 1504: */ 1505: 1506: public void setSelectedValue(Object obj, boolean scroll) 1507: { 1508: for (int i = 0; i < model.getSize(); ++i) 1509: { 1510: if (model.getElementAt(i).equals(obj)) 1511: { 1512: setSelectedIndex(i); 1513: if (scroll) 1514: ensureIndexIsVisible(i); 1515: break; 1516: } 1517: } 1518: } 1519: 1520: /** 1521: * Scrolls this list to make the specified cell visible. This 1522: * only works if the list is contained within a viewport. 1523: * 1524: * @param i The list index to make visible 1525: * 1526: * @see JComponent#scrollRectToVisible 1527: */ 1528: public void ensureIndexIsVisible(int i) 1529: { 1530: scrollRectToVisible(getUI().getCellBounds(this, i, i)); 1531: } 1532: 1533: /** 1534: * Sets the {@link #model} property of the list to a new anonymous 1535: * {@link AbstractListModel} subclass which accesses the provided Object 1536: * array directly. 1537: * 1538: * @param listData The object array to build a new list model on 1539: * @see #setModel 1540: */ 1541: public void setListData(final Object[] listData) 1542: { 1543: setModel(new AbstractListModel() 1544: { 1545: public int getSize() 1546: { 1547: return listData.length; 1548: } 1549: 1550: public Object getElementAt(int i) 1551: { 1552: return listData[i]; 1553: } 1554: }); 1555: } 1556: 1557: /** 1558: * Sets the {@link #model} property of the list to a new anonymous {@link 1559: * AbstractListModel} subclass which accesses the provided vector 1560: * directly. 1561: * 1562: * @param listData The object array to build a new list model on 1563: * @see #setModel 1564: */ 1565: public void setListData(final Vector listData) 1566: { 1567: setModel(new AbstractListModel() 1568: { 1569: public int getSize() 1570: { 1571: return listData.size(); 1572: } 1573: 1574: public Object getElementAt(int i) 1575: { 1576: return listData.elementAt(i); 1577: } 1578: }); 1579: } 1580: 1581: /** 1582: * Gets the value of the {@link #cellRenderer} property. 1583: * 1584: * @return The current value of the property 1585: */ 1586: public ListCellRenderer getCellRenderer() 1587: { 1588: return cellRenderer; 1589: } 1590: 1591: /** 1592: * Sets the value of the {@link #getCellRenderer} property. 1593: * 1594: * @param renderer The new property value 1595: */ 1596: public void setCellRenderer(ListCellRenderer renderer) 1597: { 1598: if (cellRenderer == renderer) 1599: return; 1600: 1601: ListCellRenderer old = cellRenderer; 1602: cellRenderer = renderer; 1603: firePropertyChange("cellRenderer", old, renderer); 1604: revalidate(); 1605: repaint(); 1606: } 1607: 1608: /** 1609: * Gets the value of the {@link #model} property. 1610: * 1611: * @return The current value of the property 1612: */ 1613: public ListModel getModel() 1614: { 1615: return model; 1616: } 1617: 1618: /** 1619: * Sets the value of the {@link #model} property. The list's {@link 1620: * #listListener} is unsubscribed from the existing model, if it exists, 1621: * and re-subscribed to the new model. 1622: * 1623: * @param model The new property value 1624: */ 1625: public void setModel(ListModel model) 1626: { 1627: if (this.model == model) 1628: return; 1629: 1630: if (this.model != null) 1631: this.model.removeListDataListener(listListener); 1632: 1633: ListModel old = this.model; 1634: this.model = model; 1635: 1636: if (this.model != null) 1637: this.model.addListDataListener(listListener); 1638: 1639: firePropertyChange("model", old, model); 1640: revalidate(); 1641: repaint(); 1642: } 1643: 1644: 1645: public ListSelectionModel getSelectionModel() 1646: { 1647: return selectionModel; 1648: } 1649: 1650: /** 1651: * Sets the value of the {@link #selectionModel} property. The list's 1652: * {@link #listListener} is unsubscribed from the existing selection 1653: * model, if it exists, and re-subscribed to the new selection model. 1654: * 1655: * @param model The new property value 1656: */ 1657: public void setSelectionModel(ListSelectionModel model) 1658: { 1659: if (selectionModel == model) 1660: return; 1661: 1662: if (selectionModel != null) 1663: selectionModel.removeListSelectionListener(listListener); 1664: 1665: ListSelectionModel old = selectionModel; 1666: selectionModel = model; 1667: 1668: if (selectionModel != null) 1669: selectionModel.addListSelectionListener(listListener); 1670: 1671: firePropertyChange("selectionModel", old, model); 1672: revalidate(); 1673: repaint(); 1674: } 1675: 1676: /** 1677: * Gets the value of the UI property. 1678: * 1679: * @return The current property value 1680: */ 1681: public ListUI getUI() 1682: { 1683: return (ListUI) ui; 1684: } 1685: 1686: /** 1687: * Sets the value of the UI property. 1688: * 1689: * @param ui The new property value 1690: */ 1691: public void setUI(ListUI ui) 1692: { 1693: super.setUI(ui); 1694: } 1695: 1696: /** 1697: * Calls {@link #setUI} with the {@link ListUI} subclass 1698: * returned from calling {@link UIManager#getUI}. 1699: */ 1700: public void updateUI() 1701: { 1702: setUI((ListUI) UIManager.getUI(this)); 1703: } 1704: 1705: /** 1706: * Return the class identifier for the list's UI property. This should 1707: * be the constant string <code>"ListUI"</code>, and map to an 1708: * appropriate UI class in the {@link UIManager}. 1709: * 1710: * @return The class identifier 1711: */ 1712: public String getUIClassID() 1713: { 1714: return "ListUI"; 1715: } 1716: 1717: 1718: /** 1719: * Returns the current value of the {@link #prototypeCellValue} 1720: * property. This property holds a reference to a "prototype" data value 1721: * -- typically a String -- which is used to calculate the {@link 1722: * #fixedCellWidth} and {@link #fixedCellHeight} properties, using the 1723: * {@link #cellRenderer} property to acquire a component to render the 1724: * prototype. 1725: * 1726: * @return The current prototype cell value 1727: * @see #setPrototypeCellValue 1728: */ 1729: public Object getPrototypeCellValue() 1730: { 1731: return prototypeCellValue; 1732: } 1733: 1734: /** 1735: * <p>Set the {@link #prototypeCellValue} property. This property holds a 1736: * reference to a "prototype" data value -- typically a String -- which 1737: * is used to calculate the {@link #fixedCellWidth} and {@link 1738: * #fixedCellHeight} properties, using the {@link #cellRenderer} property 1739: * to acquire a component to render the prototype.</p> 1740: * 1741: * <p>It is important that you <em>not</em> set this value to a 1742: * component. It has to be a <em>data value</em> such as the objects you 1743: * would find in the list's model. Setting it to a component will have 1744: * undefined (and undesirable) affects. </p> 1745: * 1746: * @param obj The new prototype cell value 1747: * @see #getPrototypeCellValue 1748: */ 1749: public void setPrototypeCellValue(Object obj) 1750: { 1751: if (prototypeCellValue == obj) 1752: return; 1753: 1754: Object old = prototypeCellValue; 1755: Component comp = getCellRenderer() 1756: .getListCellRendererComponent(this, obj, 0, false, false); 1757: Dimension d = comp.getPreferredSize(); 1758: fixedCellWidth = d.width; 1759: fixedCellHeight = d.height; 1760: prototypeCellValue = obj; 1761: firePropertyChange("prototypeCellValue", old, obj); 1762: } 1763: 1764: public AccessibleContext getAccessibleContext() 1765: { 1766: return new AccessibleJList(); 1767: } 1768: 1769: /** 1770: * Returns a size indicating how much space this list would like to 1771: * consume, when contained in a scrollable viewport. This is part of the 1772: * {@link Scrollable} interface, which interacts with {@link 1773: * ScrollPaneLayout} and {@link JViewport} to define scrollable objects. 1774: * 1775: * @return The preferred size 1776: */ 1777: public Dimension getPreferredScrollableViewportSize() 1778: { 1779: //If the layout orientation is not VERTICAL, then this will 1780: //return the value from getPreferredSize. The current ListUI is 1781: //expected to override getPreferredSize to return an appropriate value. 1782: if (getLayoutOrientation() != VERTICAL) 1783: return getPreferredSize(); 1784: 1785: int size = getModel().getSize(); 1786: 1787: // Trivial case: if fixedCellWidth and fixedCellHeight were set 1788: // just use them 1789: if (fixedCellHeight != -1 && fixedCellWidth != -1) 1790: return new Dimension(fixedCellWidth, size * fixedCellHeight); 1791: 1792: // If the model is empty we use 16 * the number of visible rows 1793: // for the height and either fixedCellWidth (if set) or 256 1794: // for the width 1795: if (size == 0) 1796: { 1797: if (fixedCellWidth == -1) 1798: return new Dimension(256, 16 * getVisibleRowCount()); 1799: else 1800: return new Dimension(fixedCellWidth, 16 * getVisibleRowCount()); 1801: } 1802: 1803: // Calculate the width: if fixedCellWidth was set use that, otherwise 1804: // use the preferredWidth 1805: int prefWidth; 1806: if (fixedCellWidth != -1) 1807: prefWidth = fixedCellWidth; 1808: else 1809: prefWidth = getPreferredSize().width; 1810: 1811: // Calculate the height: if fixedCellHeight was set use that, otherwise 1812: // use the height of the first row multiplied by the number of visible 1813: // rows 1814: int prefHeight; 1815: if (fixedCellHeight != -1) 1816: prefHeight = fixedCellHeight; 1817: else 1818: prefHeight = getVisibleRowCount() * getCellBounds(0, 0).height; 1819: 1820: return new Dimension (prefWidth, prefHeight); 1821: } 1822: 1823: /** 1824: * <p>Return the number of pixels the list must scroll in order to move a 1825: * "unit" of the list into the provided visible rectangle. When the 1826: * provided direction is positive, the call describes a "downwards" 1827: * scroll, which will be exposing a cell at a <em>greater</em> index in 1828: * the list than those elements currently showing. Then the provided 1829: * direction is negative, the call describes an "upwards" scroll, which 1830: * will be exposing a cell at a <em>lesser</em> index in the list than 1831: * those elements currently showing.</p> 1832: * 1833: * <p>If the provided orientation is <code>HORIZONTAL</code>, the above 1834: * comments refer to "rightwards" for positive direction, and "leftwards" 1835: * for negative.</p> 1836: * 1837: * 1838: * @param visibleRect The rectangle to scroll an element into 1839: * @param orientation One of the numeric consants <code>VERTICAL</code> 1840: * or <code>HORIZONTAL</code> 1841: * @param direction An integer indicating the scroll direction: positive means 1842: * forwards (down, right), negative means backwards (up, left) 1843: * 1844: * @return The scrollable unit increment, in pixels 1845: */ 1846: public int getScrollableUnitIncrement(Rectangle visibleRect, 1847: int orientation, int direction) 1848: { 1849: ListUI lui = this.getUI(); 1850: if (orientation == SwingConstants.VERTICAL) 1851: { 1852: if (direction > 0) 1853: { 1854: // Scrolling down 1855: Point bottomLeft = new Point(visibleRect.x, 1856: visibleRect.y + visibleRect.height); 1857: int curIdx = lui.locationToIndex(this, bottomLeft); 1858: Rectangle curBounds = lui.getCellBounds(this, curIdx, curIdx); 1859: if (curBounds.y + curBounds.height == bottomLeft.y) 1860: { 1861: // we are at the exact bottom of the current cell, so we 1862: // are being asked to scroll to the end of the next one 1863: if (curIdx + 1 < model.getSize()) 1864: { 1865: // there *is* a next item in the list 1866: Rectangle nxtBounds = lui.getCellBounds(this, curIdx + 1, curIdx + 1); 1867: return nxtBounds.height; 1868: } 1869: else 1870: { 1871: // no next item, no advance possible 1872: return 0; 1873: } 1874: } 1875: else 1876: { 1877: // we are part way through an existing cell, so we are being 1878: // asked to scroll to the bottom of it 1879: return (curBounds.y + curBounds.height) - bottomLeft.y; 1880: } 1881: } 1882: else 1883: { 1884: // scrolling up 1885: Point topLeft = new Point(visibleRect.x, visibleRect.y); 1886: int curIdx = lui.locationToIndex(this, topLeft); 1887: Rectangle curBounds = lui.getCellBounds(this, curIdx, curIdx); 1888: if (curBounds.y == topLeft.y) 1889: { 1890: // we are at the exact top of the current cell, so we 1891: // are being asked to scroll to the top of the previous one 1892: if (curIdx > 0) 1893: { 1894: // there *is* a previous item in the list 1895: Rectangle nxtBounds = lui.getCellBounds(this, curIdx - 1, curIdx - 1); 1896: return -nxtBounds.height; 1897: } 1898: else 1899: { 1900: // no previous item, no advance possible 1901: return 0; 1902: } 1903: } 1904: else 1905: { 1906: // we are part way through an existing cell, so we are being 1907: // asked to scroll to the top of it 1908: return curBounds.y - topLeft.y; 1909: } 1910: } 1911: } 1912: 1913: // FIXME: handle horizontal scrolling (also wrapping?) 1914: return 1; 1915: } 1916: 1917: /** 1918: * <p>Return the number of pixels the list must scroll in order to move a 1919: * "block" of the list into the provided visible rectangle. When the 1920: * provided direction is positive, the call describes a "downwards" 1921: * scroll, which will be exposing a cell at a <em>greater</em> index in 1922: * the list than those elements currently showing. Then the provided 1923: * direction is negative, the call describes an "upwards" scroll, which 1924: * will be exposing a cell at a <em>lesser</em> index in the list than 1925: * those elements currently showing.</p> 1926: * 1927: * <p>If the provided orientation is <code>HORIZONTAL</code>, the above 1928: * comments refer to "rightwards" for positive direction, and "leftwards" 1929: * for negative.</p> 1930: * 1931: * 1932: * @param visibleRect The rectangle to scroll an element into 1933: * @param orientation One of the numeric consants <code>VERTICAL</code> 1934: * or <code>HORIZONTAL</code> 1935: * @param direction An integer indicating the scroll direction: positive means 1936: * forwards (down, right), negative means backwards (up, left) 1937: * 1938: * @return The scrollable unit increment, in pixels 1939: */ 1940: public int getScrollableBlockIncrement(Rectangle visibleRect, 1941: int orientation, int direction) 1942: { 1943: if (orientation == VERTICAL) 1944: return visibleRect.height * direction; 1945: else 1946: return visibleRect.width * direction; 1947: } 1948: 1949: /** 1950: * Gets the value of the <code>scrollableTracksViewportWidth</code> property. 1951: * 1952: * @return <code>true</code> if the viewport is larger (horizontally) 1953: * than the list and the list should be expanded to fit the viewport; 1954: * <code>false</code> if the viewport is smaller than the list and the 1955: * list should scroll (horizontally) within the viewport 1956: */ 1957: public boolean getScrollableTracksViewportWidth() 1958: { 1959: Component parent = getParent(); 1960: boolean retVal = false; 1961: if (parent instanceof JViewport) 1962: { 1963: JViewport viewport = (JViewport) parent; 1964: Dimension pref = getPreferredSize(); 1965: if (viewport.getSize().width > pref.width) 1966: retVal = true; 1967: if ((getLayoutOrientation() == HORIZONTAL_WRAP) 1968: && (getVisibleRowCount() <= 0)) 1969: retVal = true; 1970: } 1971: return retVal; 1972: } 1973: 1974: /** 1975: * Gets the value of the </code>scrollableTracksViewportWidth</code> property. 1976: * 1977: * @return <code>true</code> if the viewport is larger (vertically) 1978: * than the list and the list should be expanded to fit the viewport; 1979: * <code>false</code> if the viewport is smaller than the list and the 1980: * list should scroll (vertically) within the viewport 1981: */ 1982: public boolean getScrollableTracksViewportHeight() 1983: { 1984: Component parent = getParent(); 1985: boolean retVal = false; 1986: if (parent instanceof JViewport) 1987: { 1988: JViewport viewport = (JViewport) parent; 1989: Dimension pref = getPreferredSize(); 1990: if (viewport.getSize().height > pref.height) 1991: retVal = true; 1992: if ((getLayoutOrientation() == VERTICAL_WRAP) 1993: && (getVisibleRowCount() <= 0)) 1994: retVal = true; 1995: } 1996: return retVal; 1997: } 1998: 1999: public int getAnchorSelectionIndex() 2000: { 2001: return selectionModel.getAnchorSelectionIndex(); 2002: } 2003: 2004: public int getLeadSelectionIndex() 2005: { 2006: return selectionModel.getLeadSelectionIndex(); 2007: } 2008: 2009: public int getMinSelectionIndex() 2010: { 2011: return selectionModel.getMaxSelectionIndex(); 2012: } 2013: 2014: public int getMaxSelectionIndex() 2015: { 2016: return selectionModel.getMaxSelectionIndex(); 2017: } 2018: 2019: public void clearSelection() 2020: { 2021: selectionModel.clearSelection(); 2022: } 2023: 2024: public void setSelectionInterval(int anchor, int lead) 2025: { 2026: selectionModel.setSelectionInterval(anchor, lead); 2027: } 2028: 2029: public void addSelectionInterval(int anchor, int lead) 2030: { 2031: selectionModel.addSelectionInterval(anchor, lead); 2032: } 2033: 2034: public void removeSelectionInterval(int index0, int index1) 2035: { 2036: selectionModel.removeSelectionInterval(index0, index1); 2037: } 2038: 2039: /** 2040: * Returns the value of the <code>valueIsAdjusting</code> property. 2041: * 2042: * @return the value 2043: */ 2044: public boolean getValueIsAdjusting() 2045: { 2046: return valueIsAdjusting; 2047: } 2048: 2049: /** 2050: * Sets the <code>valueIsAdjusting</code> property. 2051: * 2052: * @param isAdjusting the new value 2053: */ 2054: public void setValueIsAdjusting(boolean isAdjusting) 2055: { 2056: valueIsAdjusting = isAdjusting; 2057: } 2058: 2059: /** 2060: * Return the value of the <code>dragEnabled</code> property. 2061: * 2062: * @return the value 2063: * 2064: * @since 1.4 2065: */ 2066: public boolean getDragEnabled() 2067: { 2068: return dragEnabled; 2069: } 2070: 2071: /** 2072: * Set the <code>dragEnabled</code> property. 2073: * 2074: * @param enabled new value 2075: * 2076: * @since 1.4 2077: */ 2078: public void setDragEnabled(boolean enabled) 2079: { 2080: dragEnabled = enabled; 2081: } 2082: 2083: /** 2084: * Returns the layout orientation. 2085: * 2086: * @return the orientation, one of <code>JList.VERTICAL</code>, 2087: * <code>JList.VERTICAL_WRAP</code> and <code>JList.HORIZONTAL_WRAP</code> 2088: * 2089: * @since 1.4 2090: */ 2091: public int getLayoutOrientation() 2092: { 2093: return layoutOrientation; 2094: } 2095: 2096: /** 2097: * Sets the layout orientation. 2098: * 2099: * @param orientation the orientation to set, one of <code>JList.VERTICAL</code>, 2100: * <code>JList.VERTICAL_WRAP</code> and <code>JList.HORIZONTAL_WRAP</code> 2101: * 2102: * @since 1.4 2103: */ 2104: public void setLayoutOrientation(int orientation) 2105: { 2106: if (layoutOrientation == orientation) 2107: return; 2108: 2109: int old = layoutOrientation; 2110: layoutOrientation = orientation; 2111: firePropertyChange("layoutOrientation", old, orientation); 2112: } 2113: 2114: /** 2115: * Returns the bounds of the rectangle that encloses both list cells 2116: * with index0 and index1. 2117: * 2118: * @param index0 the index of the first cell 2119: * @param index1 the index of the second cell 2120: * 2121: * @return the bounds of the rectangle that encloses both list cells 2122: * with index0 and index1, <code>null</code> if one of the indices is 2123: * not valid 2124: */ 2125: public Rectangle getCellBounds(int index0, int index1) 2126: { 2127: return getUI().getCellBounds(this, index0, index1); 2128: } 2129: 2130: /** 2131: * Returns the next list element (beginning from <code>startIndex</code> 2132: * that starts with <code>prefix</code>. Searching is done in the direction 2133: * specified by <code>bias</code>. 2134: * 2135: * @param prefix the prefix to search for in the cell values 2136: * @param startIndex the index where to start searching from 2137: * @param bias the search direction, either {@link Position.Bias#Forward} 2138: * or {@link Position.Bias#Backward} 2139: * 2140: * @return the index of the found element or -1 if no such element has 2141: * been found 2142: * 2143: * @throws IllegalArgumentException if prefix is <code>null</code> or 2144: * startIndex is not valid 2145: * 2146: * @since 1.4 2147: */ 2148: public int getNextMatch(String prefix, int startIndex, Position.Bias bias) 2149: { 2150: if (prefix == null) 2151: throw new IllegalArgumentException("The argument 'prefix' must not be" 2152: + " null."); 2153: if (startIndex < 0) 2154: throw new IllegalArgumentException("The argument 'startIndex' must not" 2155: + " be less than zero."); 2156: 2157: int size = model.getSize(); 2158: if (startIndex > model.getSize()) 2159: throw new IllegalArgumentException("The argument 'startIndex' must not" 2160: + " be greater than the number of" 2161: + " elements in the ListModel."); 2162: 2163: int index = -1; 2164: if (bias == Position.Bias.Forward) 2165: { 2166: for (int i = startIndex; i < size; i++) 2167: { 2168: String item = model.getElementAt(i).toString(); 2169: if (item.startsWith(prefix)) 2170: { 2171: index = i; 2172: break; 2173: } 2174: } 2175: } 2176: else 2177: { 2178: for (int i = startIndex; i >= 0; i--) 2179: { 2180: String item = model.getElementAt(i).toString(); 2181: if (item.startsWith(prefix)) 2182: { 2183: index = i; 2184: break; 2185: } 2186: } 2187: } 2188: return index; 2189: } 2190: }
GNU Classpath (0.19) |