home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / src / java / awt / list~1.jav < prev    next >
Encoding:
Text File  |  1996-01-12  |  10.1 KB  |  389 lines
  1. /*
  2.  * @(#)List.java    1.24 95/12/02 Sami Shaio
  3.  *
  4.  * Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19. package java.awt;
  20.  
  21. import java.util.Vector;
  22. import java.awt.peer.ListPeer;
  23.  
  24. /**
  25.  * A scrolling list of text items.
  26.  *
  27.  * @version     1.24, 12/02/95
  28.  * @author     Sami Shaio
  29.  */
  30. public class List extends Component {
  31.     Vector    items = new Vector();
  32.     int        rows = 0;
  33.     boolean    multipleSelections = false;
  34.     int        selected[] = new int[0];
  35.     int        visibleIndex = -1;
  36.  
  37.     /**
  38.      * Creates a new scrolling list initialized with no visible Lines
  39.      * or multiple selections.
  40.      */
  41.     public List() {
  42.     this(0, false);
  43.     }
  44.  
  45.     /**
  46.      * Creates a new scrolling list initialized with the specified 
  47.      * number of visible lines and a boolean stating whether multiple
  48.      * selections are allowed or not.
  49.      * @param rows the number of items to show.
  50.      * @param multipleSelections if true then multiple selections are allowed.
  51.      */
  52.     public List(int rows, boolean multipleSelections) {
  53.     this.rows = rows;
  54.     this.multipleSelections = multipleSelections;
  55.     }
  56.  
  57.     /**
  58.      * Creates the peer for the list.  The peer allows us to modify the
  59.      * list's appearance without changing its functionality.
  60.      */
  61.     public synchronized void addNotify() {
  62.     peer = getToolkit().createList(this);
  63.     super.addNotify();
  64.     visibleIndex = -1;
  65.     }
  66.  
  67.     /**
  68.      * Removes the peer for this list.  The peer allows us to modify the
  69.      * list's appearance without changing its functionality.
  70.      */
  71.     public synchronized void removeNotify() {
  72.     if (peer != null) {
  73.         ListPeer peer = (ListPeer)this.peer;
  74.         selected = peer.getSelectedIndexes();
  75.     }
  76.     super.removeNotify();
  77.     }
  78.     
  79.     /**
  80.      * Returns the number of items in the list.
  81.      * @see #getItem
  82.      */
  83.     public int countItems() {
  84.     return items.size();
  85.     }
  86.  
  87.     /**
  88.      * Gets the item associated with the specified index.
  89.      * @param index the position of the item
  90.      * @see #countItems
  91.      */
  92.     public String getItem(int index) {
  93.     return (String)items.elementAt(index);
  94.     }
  95.  
  96.     /**
  97.      * Adds the specified item to the end of scrolling list.
  98.      * @param item the item to be added
  99.      */
  100.     public synchronized void addItem(String item) {
  101.     addItem(item, -1);
  102.     }
  103.  
  104.     /**
  105.      * Adds the specified item to the end of scrolling list.
  106.      * @param item the item to be added
  107.      * @param index the position at which to put in the item. The
  108.      * index is zero-based. If index is -1 then the item is added to
  109.      * the end. If index is greater than the number of items in the
  110.      * list, the item gets added at the end. 
  111.      */
  112.     public synchronized void addItem(String item, int index) {
  113.     if (index < -1 || index >= items.size()) {
  114.         index = -1;
  115.     }
  116.     if (index == -1) {
  117.         items.addElement(item);
  118.     } else {
  119.         items.insertElementAt(item, index);
  120.     }
  121.     ListPeer peer = (ListPeer)this.peer;
  122.     if (peer != null) {
  123.         peer.addItem(item, index);
  124.     }
  125.     }
  126.  
  127.     /**
  128.      * Replaces the item at the given index.
  129.      * @param newValue the new value to replace the existing item
  130.      * @param index the position of the item to replace
  131.      */
  132.     public synchronized void replaceItem(String newValue, int index) {
  133.     delItem(index);
  134.     addItem(newValue, index);
  135.     }
  136.  
  137.     /**
  138.      * Clears the list.
  139.      * @see #delItem
  140.      * @see #delItems
  141.      */
  142.     public synchronized void clear() {
  143.     if (peer != null) {
  144.         ((ListPeer)peer).clear();
  145.     }
  146.     items = new Vector();
  147.     selected = new int[0];
  148.     }
  149.  
  150.     /**
  151.      * Delete an item from the list.
  152.      */
  153.     public synchronized void delItem(int position) {
  154.     delItems(position, position);
  155.     }
  156.  
  157.     /**
  158.      * Delete multiple items from the list.
  159.      */
  160.     public synchronized void delItems(int start, int end) {
  161.     for (int i=end; i >= start; i--) {
  162.         items.removeElementAt(i);
  163.     }
  164.     if (peer != null) {
  165.         ((ListPeer)peer).delItems(start, end);
  166.     }
  167.     }
  168.  
  169.     /**
  170.      * Get the selected item on the list or -1 if no item is selected.
  171.      * @see #select
  172.      * @see #deselect
  173.      * @see #isSelected
  174.      */
  175.     public synchronized int getSelectedIndex() {
  176.     int sel[] = getSelectedIndexes();
  177.     return (sel.length == 1) ? sel[0] : -1;
  178.     }
  179.  
  180.     /**
  181.      * Returns the selected indexes on the list.
  182.      * @see #select
  183.      * @see #deselect
  184.      * @see #isSelected
  185.      */
  186.     public synchronized int[] getSelectedIndexes() {
  187.     ListPeer peer = (ListPeer)this.peer;
  188.     if (peer != null) {
  189.         selected = peer.getSelectedIndexes();
  190.     }
  191.     return selected;
  192.     }
  193.  
  194.     /**
  195.      * Returns the selected item on the list or null if no item is selected.
  196.      * @see #select
  197.      * @see #deselect
  198.      * @see #isSelected
  199.      */
  200.     public synchronized String getSelectedItem() {
  201.     int index = getSelectedIndex();
  202.     return (index < 0) ? null : getItem(index);
  203.     }
  204.  
  205.     /**
  206.      * Returns the selected items on the list.
  207.      * @see #select
  208.      * @see #deselect
  209.      * @see #isSelected
  210.      */
  211.     public synchronized String[] getSelectedItems() {
  212.     int sel[] = getSelectedIndexes();
  213.     String str[] = new String[sel.length];
  214.     for (int i = 0 ; i < sel.length ; i++) {
  215.         str[i] = getItem(sel[i]);
  216.     }
  217.     return str;
  218.     }
  219.  
  220.     /**
  221.      * Selects the item at the specified index.
  222.      * @param index the position of the item to select
  223.      * @see #getSelectedItem
  224.      * @see #deselect
  225.      * @see #isSelected
  226.      */
  227.     public synchronized void select(int index) {
  228.     ListPeer peer = (ListPeer)this.peer;
  229.     if (peer != null) {
  230.         peer.select(index);
  231.         return;
  232.     }
  233.  
  234.     for (int i = 0 ; i < selected.length ; i++) {
  235.         if (selected[i] == index) {
  236.         return;
  237.         }
  238.     }
  239.     if (!multipleSelections) {
  240.         selected = new int[1];
  241.         selected[0] = index;
  242.     } else {
  243.         int newsel[] = new int[selected.length + 1];
  244.         System.arraycopy(selected, 0, newsel, 0, selected.length);
  245.         newsel[selected.length] = index;
  246.         selected = newsel;
  247.     }
  248.     }
  249.  
  250.     /**
  251.      * Deselects the item at the specified index.
  252.      * @param index the position of the item to deselect
  253.      * @see #select
  254.      * @see #getSelectedItem
  255.      * @see #isSelected
  256.      */
  257.     public synchronized void deselect(int index) {
  258.     ListPeer peer = (ListPeer)this.peer;
  259.     if (peer != null) {
  260.         peer.deselect(index);
  261.     }
  262.  
  263.     for (int i = 0 ; i < selected.length ; i++) {
  264.         if (selected[i] == index) {
  265.         int newsel[] = new int[selected.length - 1];
  266.         System.arraycopy(selected, 0, newsel, 0, i);
  267.         System.arraycopy(selected, i+1, newsel, i, selected.length - (i+1));
  268.         selected = newsel;
  269.         return;
  270.         }
  271.     }
  272.     }
  273.  
  274.     /**
  275.      * Returns true if the item at the specified index has been selected;
  276.      * false otherwise.
  277.      * @param index the item to be checked
  278.      * @see #select
  279.      * @see #deselect
  280.      * @see #isSelected
  281.      */
  282.     public synchronized boolean isSelected(int index) {
  283.     int sel[] = getSelectedIndexes();
  284.     for (int i = 0 ; i < sel.length ; i++) {
  285.         if (sel[i] == index) {
  286.         return true;
  287.         }
  288.     }
  289.     return false;
  290.     }
  291.  
  292.     /**
  293.      * Returns the number of visible lines in this list.
  294.      */
  295.     public int getRows() {
  296.     return rows;
  297.     }
  298.  
  299.     /**
  300.      * Returns true if this list allows multiple selections.
  301.      * @see #setMultipleSelections
  302.      */
  303.     public boolean allowsMultipleSelections() {
  304.     return multipleSelections;
  305.     }
  306.  
  307.     /**
  308.      * Sets whether this list should allow multiple selections or not.
  309.      * @param v the boolean to allow multiple selections
  310.      * @see #allowsMultipleSelections
  311.      */
  312.     public void setMultipleSelections(boolean v) {
  313.     if (v != multipleSelections) {
  314.         multipleSelections = v;
  315.         ListPeer peer = (ListPeer)this.peer;
  316.         if (peer != null) {
  317.         peer.setMultipleSelections(v);
  318.         }
  319.     }
  320.     }
  321.  
  322.     /**
  323.      * Gets the index of the item that was last made visible by the method
  324.      * makeVisible.
  325.      */
  326.     public int getVisibleIndex() {
  327.     return visibleIndex;
  328.     }
  329.  
  330.     /**
  331.      * Forces the item at the specified index to be visible.
  332.      * @param index the position of the item
  333.      * @see #getVisibleIndex
  334.      */
  335.     public void makeVisible(int index) {
  336.     ListPeer peer = (ListPeer)this.peer;
  337.     visibleIndex = index;
  338.     if (peer != null) {
  339.         peer.makeVisible(index);
  340.     }
  341.     }
  342.  
  343.     /**
  344.      * Returns the preferred dimensions needed for the list with the specified
  345.      * amount of rows.
  346.      * @param rows amount of rows in list.
  347.      */
  348.     public Dimension preferredSize(int rows) {
  349.     ListPeer peer = (ListPeer)this.peer;
  350.     return (peer != null) ? peer.preferredSize(rows) : super.preferredSize();
  351.     }
  352.  
  353.     /**
  354.      * Returns the preferred dimensions needed for the list.
  355.      * @return the preferred size with the specified number of rows if the 
  356.      * row size is greater than 0. 
  357.      * 
  358.      */
  359.     public Dimension preferredSize() {
  360.     return (rows > 0) ? preferredSize(rows) : super.preferredSize();
  361.     }
  362.  
  363.     /**
  364.      * Returns the minimum dimensions needed for the amount of rows in the 
  365.      * list.
  366.      * @param rows minimum amount of rows in the list
  367.      */
  368.     public Dimension minimumSize(int rows) {
  369.     ListPeer peer = (ListPeer)this.peer;
  370.     return (peer != null) ? peer.minimumSize(rows) : super.minimumSize();
  371.     }
  372.  
  373.     /**
  374.      * Returns the minimum dimensions needed for the list.
  375.      * @return the preferred size with the specified number of rows if
  376.      * the row size is greater than zero.
  377.      */
  378.     public Dimension minimumSize() {
  379.     return (rows > 0) ? minimumSize(rows) : super.minimumSize();
  380.     }
  381.  
  382.     /**
  383.      * Returns the parameter String of this list. 
  384.      */
  385.     protected String paramString() {
  386.     return super.paramString() + ",selected=" + getSelectedItem();
  387.     }
  388. }
  389.