home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava / classsrc / awt / list~1.jav < prev    next >
Encoding:
Text File  |  1995-08-11  |  5.7 KB  |  246 lines
  1. /*
  2.  * @(#)List.java    1.18 95/02/03 Sami Shaio
  3.  *
  4.  * Copyright (c) 1994 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 awt;
  20.  
  21. import java.lang.*;
  22. import java.util.*;
  23.  
  24. /**
  25.  * A scrolling list of text items.
  26.  *
  27.  * @version 1.18 03 Feb 1995
  28.  * @author Sami Shaio
  29.  */
  30. public class List extends Component implements ChoiceHandler {
  31.     private WServer        wServer;
  32.     private boolean        hFill;
  33.     private boolean        vFill;
  34.     private Vector        items;
  35.     private ChoiceHandler    handler;
  36.  
  37.     /**
  38.      * Creates a scrolling list.
  39.      * @param p is the parent window for this List.
  40.      * @param ch is the object that will handle selections for this List.
  41.      * @param visibleLines is the number of items to show.
  42.      * @param multipleSelections if true then multiple selections are allowed.
  43.      * @param resizable if true then the list will attempt to grow or
  44.      * shrink to match the width of the items it contains.
  45.      */
  46.     public List(Container p,
  47.         ChoiceHandler ch,
  48.         String pName,
  49.         int visibleLines,
  50.         boolean multipleSelections,
  51.         boolean resizable) {
  52.     super(p, pName);
  53.     if (ch == null) {
  54.         handler = this;
  55.     } else {
  56.         handler = ch;
  57.     }
  58.     Window win = Window.getWindow(p);
  59.     wServer = win.wServer;
  60.     wServer.listCreate(this,
  61.                   win,
  62.                   handler,
  63.                   visibleLines,
  64.                   multipleSelections,
  65.                   resizable);
  66.     items = new Vector();
  67.     hFill = false;
  68.     vFill = false;
  69.     }
  70.  
  71.     public List(Container p,
  72.         ChoiceHandler ch,
  73.         String pName,
  74.         int visibleLines,
  75.         boolean multipleSelections) {
  76.     this(p,ch,pName, visibleLines,multipleSelections,true);
  77.     }
  78.  
  79.     /**
  80.      * This is the callback method for a ChoiceHandler interface. It
  81.      * will be called when the use single-clicks on an item in the
  82.      * scrolling list. If pos is -1 then this indicates multiple
  83.      * selections. Override to do something useful.
  84.      */
  85.     public void selected(Component c, int pos) {
  86.     }
  87.  
  88.     /**
  89.      * This is invoked when the user double-clicks on an item in the
  90.      * list. Override to do something useful.
  91.      */
  92.     public void doubleClick(Component c, int pos) {
  93.     }
  94.  
  95.     /**
  96.      * Return true if the given item has been selected.
  97.      */
  98.     public boolean isSelected(int pos) {
  99.     if (pos >= 0 && pos < items.size()) {
  100.         return wServer.listIsSelected(this, pos);
  101.     } else {
  102.         throw new IllegalArgumentException();
  103.     }
  104.     }
  105.  
  106.     /**
  107.      * Adds an item to the scrolling list.
  108.      */
  109.     public void addItem(String item) {
  110.     wServer.listAddItem(this, item);
  111.     items.addElement(item);
  112.     }
  113.  
  114.     /**
  115.      * Gets the string associated with the given position.
  116.      */
  117.     public String itemAt(int pos) {
  118.     int itemCount = items.size();
  119.  
  120.     if (pos >= 0 && pos < itemCount) {
  121.         return (String)items.elementAt(pos);
  122.     } else {
  123.         return null;
  124.     }
  125.     }
  126.  
  127.     /**
  128.      * Clears the list.
  129.      */
  130.     public void clear() {
  131.     int itemCount = items.size();
  132.  
  133.     if (itemCount > 0) {
  134.         delItems(0, itemCount - 1);
  135.         items.removeAllElements();
  136.     }
  137.     }
  138.  
  139.     /**
  140.      * Set the number of visible lines.
  141.      */
  142.     public void setNVisible(int nLines) {
  143.     wServer.listSetNVisible(this, nLines);
  144.     }
  145.  
  146.     /**
  147.      * Deletes one item at the given position.
  148.      */
  149.     public void delItem(int pos) {
  150.     delItems(pos, pos);
  151.     }
  152.  
  153.     /**
  154.      * Deletes the items from start to end.
  155.      */
  156.     public void delItems(int start, int end) {
  157.     int i;
  158.     int itemCount = items.size();
  159.  
  160.     if (start >= 0 && start < itemCount &&
  161.         end >= 0 && end < itemCount) {
  162.         for (i=start; i <= end; i++) {
  163.         items.removeElementAt(i);
  164.         }
  165.         wServer.listDelItems(this, start, end);
  166.     } else {
  167.         throw new IllegalArgumentException();
  168.     }
  169.     }
  170.  
  171.     /** Sets whether or not this List stretches horizontally. */
  172.     public void setHFill(boolean t) {
  173.     hFill = t;
  174.     }
  175.  
  176.     /** Sets whether or not this List stretches vertically. */
  177.     public void setVFill(boolean t) {
  178.     vFill = t;
  179.     }
  180.  
  181.     public Dimension getPreferredSize() {
  182.     wServer.listDimensions(this);
  183.     return new Dimension((hFill) ? parent.width : width,
  184.                  (vFill) ? parent.height : height);
  185.     }
  186.  
  187.     public Dimension minDimension() {
  188.     Dimension dim;
  189.     wServer.listDimensions(this);
  190.     dim =  new Dimension(width, height);
  191.     return dim;
  192.     }
  193.  
  194.     public void reshape(int x, int y, int w, int h) {
  195.     super.reshape(x, y, w, h);
  196.     wServer.listReshape(this, x, y, w, h);
  197.     }
  198.  
  199.     public void move(int X, int Y) {
  200.     super.move(X,Y);
  201.     wServer.listMoveTo(this, X, Y);
  202.     }
  203.  
  204.     /**
  205.      * Select the given item.
  206.      */
  207.     public void select(int pos) {
  208.     wServer.listSelect(this, pos);
  209.     }
  210.  
  211.     /**
  212.      * Deselect the given item.
  213.      */
  214.     public void deselect(int pos) {
  215.     wServer.listDeselect(this, pos);
  216.     }
  217.  
  218.     /**
  219.      * Force the given position to be visible.
  220.      */
  221.     public void makeVisible(int pos) {
  222.     wServer.listMakeVisible(this, pos);
  223.     }
  224.  
  225.     /**
  226.      * Returns the number of items in the list.
  227.      */
  228.     public int nItems() {
  229.     return items.size();
  230.     }
  231.  
  232.     public void map() {
  233.     wServer.listShow(this);
  234.     mapped = true;
  235.     }
  236.     public void unMap() {
  237.     wServer.listHide(this);
  238.     mapped = false;
  239.     }
  240.     public void dispose() {
  241.     wServer.listDispose(this);
  242.     }
  243. }
  244.  
  245.     
  246.