swing2.html

jdbc书

     scrollSelection.addListSelectionListener(
		new ListSelectionListener() {
       public void valueChanged(ListSelectionEvent e) {
         ListSelectionModel lsm = 
		(ListSelectionModel)e.getSource();
         if (!lsm.isSelectionEmpty())  {
           setFixedRow();
         }
       }
     });

     CustomRenderer custom = new CustomRenderer();
     custom.setHorizontalAlignment(JLabel.CENTER);
     scrollColumnModel.getColumn(2).setCellRenderer(
		custom);             
     scrollColumnModel.getColumn(3).setCellRenderer(
		new CustomButtonRenderer());
   
     CustomButtonEditor customEdit=new 
			CustomButtonEditor(frame);
     scrollColumnModel.getColumn(3).setCellEditor(
		customEdit); 

     headers.add(scrollTable.getTableHeader());
 
     JPanel topPanel = new JPanel();
     topPanel.setLayout(new BoxLayout(topPanel, 
		BoxLayout.X_AXIS));
     adjustColumnWidth(
		fixedColumnModel.getColumn(0), 100);
 
     JTableHeader fixedHeader=
                    fixedTable.getTableHeader();
     fixedHeader.setAlignmentY(Component.TOP_ALIGNMENT);
     topPanel.add(fixedHeader);
     topPanel.add(Box.createRigidArea(
                        new Dimension(2, 0)));
     topPanel.setPreferredSize(new Dimension(400, 40));
 
     JPanel headerPanel = new JPanel();
     headerPanel.setAlignmentY(Component.TOP_ALIGNMENT);
     headerPanel.setLayout(new BorderLayout());
 
     JScrollPane scrollpane = new JScrollPane();
     scrollBar = scrollpane.getHorizontalScrollBar();
 
     headerPanel.add(headers, "North");
     headerPanel.add(scrollBar, "South");
     topPanel.add(headerPanel);
                                                                
     scrollTable.setPreferredScrollableViewportSize( 
		new Dimension(300,180));
     fixedTable.setPreferredScrollableViewportSize( 
		new Dimension(100,180));
     fixedTable.setPreferredSize( 
                new Dimension(100,180));
 
     innerPort = new JViewport();
     innerPort.setView(scrollTable);
     scrollpane.setViewport(innerPort);
 
     scrollBar.getModel().addChangeListener(
		new ChangeListener()  {
       public void stateChanged(ChangeEvent e) {
         Point q = headers.getViewPosition();
         Point p = innerPort.getViewPosition();
         int val = scrollBar.getModel().getValue();
         p.x = val;
         q.x = val;
         headers.setViewPosition(p);
         headers.repaint(headers.getViewRect());
         innerPort.setViewPosition(p);
         innerPort.repaint(innerPort.getViewRect());
       }
     });
 
     scrollTable.getTableHeader(
                   ).setUpdateTableInRealTime(
		   false);
 
     JPanel bottomPanel = new JPanel();
     bottomPanel.setLayout(new BoxLayout(
		bottomPanel, BoxLayout.X_AXIS));
     fixedTable.setAlignmentY(Component.TOP_ALIGNMENT);
     bottomPanel.add(fixedTable);
     bottomPanel.add(Box.createRigidArea(
                           new Dimension(2, 0)));
     innerPort.setAlignmentY(Component.TOP_ALIGNMENT);
     bottomPanel.add(innerPort);
     bottomPanel.add(Box.createRigidArea(
                           new Dimension(2, 0)));

     scrollPane= new JScrollPane(bottomPanel,
               JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,          
               JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
     JViewport outerPort = new JViewport();
     outerPort.add(bottomPanel);
     scrollPane.setColumnHeaderView(topPanel);
     scrollPane.setViewport(outerPort);
 
     scrollTable.setAutoResizeMode(
                   JTable.AUTO_RESIZE_OFF);
     frame.getContentPane().add(scrollPane);
 
     scrollTable.validate();
     frame.setSize(450,200);
  }
 
  void setFixedRow() {
    int index=scrollTable.getSelectedRow();
    fixedTable.setRowSelectionInterval(index, index);
  }
 
  void setScrollableRow() {
    int index=fixedTable.getSelectedRow();
    scrollTable.setRowSelectionInterval(index, index);
  }
 
  void adjustColumnWidth(TableColumn c, int size) {
    c.setPreferredWidth(size);
    c.setMaxWidth(size);
    c.setMinWidth(size);
  }                                          
</PRE>

<H4>JList Model</H4>

The <CODE>JList</CODE> component displays a vertical list of data elements
and uses a <CODE>ListModel</CODE> to hold and manipulate the data. It
also uses a <CODE>ListSelectionModel</CODE> object to enable selection and
subsequent retrieval of elements in the list.

<P>
Default implementations of the <CODE>AbstractListModel</CODE> and 
<CODE>AbstractListSelectionModel</CODE> classes are provided in the Project 
Swing API in the form of the <CODE>DefaultListModel</CODE> and
<CODE>DefaultListSelectionModel</CODE> classes. If you use these two default 
models and the default cell renderer, 
you get a list that displays model elements by calling the 
<CODE>toString</CODE> method on each object. The list uses the 
<CODE>MULTIPLE_INTERVAL_SELECTION</CODE> list selection model to select 
each element from the list.

<P>
Three selection modes are available to <CODE>DefaultListSelectionModel</CODE>: 
<CODE>SINGLE_SELECTION</CODE>, where only one item is selected at a 
time; <CODE>SINGLE_INTERVAL_SELECTION</CODE> in which a range of sequential 
items can be selected; and <CODE>MULTIPLE_INTERVAL_SELECTION</CODE>, which
allows any or all elements to be selected. The
selection mode can be changed by calling the <CODE>setSelectionMode</CODE>
method in the <CODE>JList</CODE> class.

<PRE>
    public SimpleList() {
       JList list;
       DefaultListModel deflist;
       deflist= new DefaultListModel();
       deflist.addElement("element 1");
       deflist.addElement("element 2");
       list = new JList(deflist);
 
       JScrollPane scroll = new JScrollPane(list);
       getContentPane().add(scroll, BorderLayout.CENTER);
     }                                                     
</PRE>

<H4>JTree Model</H4>

The <CODE>JTree</CODE> class models and displays a vertical list 
of elements or nodes arranged in a tree-based hierarchy.

<P>
<IMG SRC="./Art/tree.gif" ALIGN="LEFT">
A <CODE>JTree</CODE> object has one root node and one or more child nodes,
which can contain further child nodes. Each parent node can be expanded
to show all its children similiar to directory trees familiar to Windows
users.

<P>
Like the <CODE>JList</CODE> and <CODE>JTable</CODE> components, 
the <CODE>JTree</CODE> consists of more than one model. The selection model
is similiar to the one detailed for the <CODE>JList</CODE> model. The
selection modes have the following slightly different names: 
<CODE>SINGLE_TREE_SELECTION</CODE>, <CODE>DISCONTIGUOUS_TREE_SELECTION</CODE>, 
and <CODE>CONTIGUOUS_TREE_SELECTION</CODE>.

<P>
While <CODE>DefaultTreeModel</CODE> maintains the data in the tree and
is responsible for adding and removing nodes, it is the
<CODE>DefaultTreeMutableTreeNode</CODE> class that defines the methods
used for node traversal. The <CODE>DefaultTreeModel</CODE> 
is often used to implement custom models because there is no 
<CODE>AbstractTreeModel</CODE> in the <CODE>JTree</CODE> package. However,
if you use custom objects, you must implement <CODE>TreeModel</CODE>. 
This code example creates a <CODE>JTree</CODE> using the 
<CODE>DefaultTreeModel</CODE>.

<PRE>
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

public class SimpleTree extends JFrame {
  public SimpleTree() {
    String[] treelabels =   { 
			     "All Auctions", 
			     "Closed Auction", 
			     "Open Auctions"};
    Integer[] closedItems = { new Integer(500144), 
			      new Integer(500146), 
			      new Integer(500147)};

    Integer[] openItems = { new Integer(500148), 
			    new Integer(500149)};
                                             
    DefaultMutableTreeNode[] nodes = new 
        DefaultMutableTreeNode[treelabels.length];
    DefaultMutableTreeNode[] closednodes = new 
	DefaultMutableTreeNode[closedItems.length];
    DefaultMutableTreeNode[] opennodes = new 
	DefaultMutableTreeNode[openItems.length];

    for (int i=0; i &lt; treelabels.length; i++) {
      nodes[i] = new 
        DefaultMutableTreeNode(treelabels[i]); 
    }
    nodes[0].add(nodes[1]);
    nodes[0].add(nodes[2]);

    for (int i=0; i &lt; closedItems.length; i++) {
       closednodes[i] = new 
		DefaultMutableTreeNode(closedItems[i]); 
       nodes[1].add(closednodes[i]);
    }

    for (int i=0; i &lt; openItems.length; i++) {
       opennodes[i] = new 
		DefaultMutableTreeNode(openItems[i]); 
       nodes[2].add(opennodes[i]);
    }
    DefaultTreeModel model=new 
                DefaultTreeModel(nodes[0]);

    JTree tree = new JTree(model);

    JScrollPane scroll = new JScrollPane(tree);
    getContentPane().add(scroll, BorderLayout.CENTER);
  }                                                               

  public static void main(String[] args) {
    SimpleTree frame = new SimpleTree();
    frame.addWindowListener( new WindowAdapter() {
      public void windowClosing( WindowEvent e ) {
        System.exit(0);
      }
    });
    frame.setVisible(true);
    frame.pack();
    frame.setSize(150,150);
  }                          
}
</PRE>

The <CODE>toString</CODE> method is used to retrieve the value for the 
<CODE>Integer</CODE> objects in the tree. And although the 
<CODE>DefaultTreeModel</CODE> is used to maintain the data
in the tree and to add or remove nodes, the <CODE>DefaultMutableTreeNode</CODE> 
class defines the methods used to traverse through the nodes in the tree. 

<P>
A primitive search of the nodes in a <CODE>JTree</CODE> is accomplished
with the <CODE>depthFirstEnumeration</CODE> method, which is the same as
the <CODE>postorderEnumeration</CODE> method and works its
way from the end points of the tree first. Or you can call the 
<CODE>preorderEnumeration</CODE> method, the reverse of the
<CODE>postorderEnumeration</CODE> method, which starts from the root and descends 
each tree in turn. Or you can call the <CODE>breadthFirstEnumeration</CODE>
method, which starts from the root and visits all the child nodes in one level 
before visiting the child nodes at a lower depth. 

<P>
The following code expands the parent node if it contains a child node that 
matches the search field entered. It uses a call to 
<CODE>Enumeration e = nodes[0].depthFirstEnumeration();</CODE> to return a 
list of all the nodes in the tree. Once it has found a match, it builds the 
<CODE>TreePath</CODE> from the root node to the node that matched the search to 
pass to the <CODE>makeVisible</CODE> method in the <CODE>JTree</CODE> class 
that ensures the node is expanded in the tree. 

<PRE>
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

public class SimpleSearchTree extends JFrame {
  JPanel findPanel;
  JTextField findField;
  JTree tree;
  JButton findButton;
  DefaultMutableTreeNode[] nodes;

  public SimpleSearchTree() {
    String[] treelabels =  { "All Auctions", 
			     "Closed Auction", 
			     "Open Auctions" };
    Integer[] closedItems = { new Integer(500144), 
			      new Integer(500146), 
			      new Integer(500147) };

    Integer[] openItems ={ new Integer(500148), 
			   new Integer(500149)};
                                             
    nodes = new 
      DefaultMutableTreeNode[treelabels.length];
    DefaultMutableTreeNode[] closednodes = new 
	    DefaultMutableTreeNode[closedItems.length];
    DefaultMutableTreeNode[] opennodes = new 
	    DefaultMutableTreeNode[openItems.length];
    for (int i=0; i &lt; treelabels.length; i++) {
       nodes[i] = new 
         DefaultMutableTreeNode(treelabels[i]); 
    }
    nodes[0].add(nodes[1]);
    nodes[0].add(nodes[2]);

    for (int i=0; i &lt; closedItems.length; i++) {
       closednodes[i] = new 
		DefaultMutableTreeNode(closedItems[i]); 
       nodes[1].add(closednodes[i]);
    }

    for (int i=0; i &lt; openItems.length; i++) {
       opennodes[i] = new DefaultMutableTreeNode(
                            openItems[i]); 
       nodes[2].add(opennodes[i]);
    }

    DefaultTreeModel model=new 
                       DefaultTreeModel(nodes[0]);
    tree = new JTree(model);

    JScrollPane scroll = new JScrollPane(tree);
    getContentPane().add(scroll, BorderLayout.CENTER);
    findPanel= new JPanel();
    findField= new JTextField(10);
    findButton= new JButton("find");
    findButton.addActionListener (new ActionListener() {
      public void actionPerformed (ActionEvent e) {
        String field=findField.getText(); 
        if (field != null) {
          findNode(findField.getText());
        } else {
          return;
        } 
      }
    });
    findPanel.add(findField);
    findPanel.add(findButton);
    getContentPane().add(findPanel, BorderLayout.SOUTH);
  }                                                               
  public void findNode(String field) {
    Enumeration e = nodes[0].depthFirstEnumeration(); 
    Object currNode; 
    while (e.hasMoreElements()) {
      currNode = e.nextElement(); 
      if (currNode.toString().equals(field)) { 
        TreePath path=new TreePath(((
	     DefaultMutableTreeNode)currNode).getPath());
        tree.makeVisible(path);
        tree.setSelectionRow(tree.getRowForPath(path));  
        return;
      } 
    } 
  }

  public static void main(String[] args) {
    SimpleSearchTree frame = new SimpleSearchTree();
    frame.addWindowListener( new WindowAdapter() {
      public void windowClosing( WindowEvent e ) {
        System.exit(0);
      }
    });
    frame.setVisible(true);
    frame.pack();
    frame.setSize(300,150);
  }