/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.gui;import java.awt.*;import javax.swing.*;import javax.swing.table.*;   // TableModel and other JTable-related classesimport java.beans.*;          // For JavaBean introspectionimport java.util.*;           // For array sorting /** * This class is a JTable subclass that displays a table of the JavaBeans * properties of any specified class. **/public class PropertyTable extends JTable {    /** This main method allows the class to be demonstrated  standalone */    public static void main(String[] args) {	// Specify the name of the class as a command-line argument	Class beanClass = null; 	try {	    // Use reflection to get the Class from the classname	    beanClass = Class.forName(args[0]);	}	catch (Exception e) {  // Report errors	    System.out.println("Can't find specified class: "+e.getMessage());	    System.out.println("Usage: java TableDemo <JavaBean class name>");	    System.exit(0);	}		// Create a table to display the properties of the specified class	JTable table = new PropertyTable(beanClass);		// Then put the table in a scrolling window, put the scrolling 	// window into a frame, and pop it all up on to the screen	JScrollPane scrollpane = new JScrollPane(table);	JFrame frame = new JFrame("Properties of JavaBean: " + args[0]);	frame.getContentPane().add(scrollpane);	frame.setSize(500, 400);	frame.setVisible(true);    }    /**     * This constructor method specifies what data the table will display     * (the table model) and uses the TableColumnModel to customize the     * way that the table displays it.  The hard work is done by the     * TableModel implementation below.     **/    public PropertyTable(Class beanClass) {	// Set the data model for this table	try {	    setModel(new JavaBeanPropertyTableModel(beanClass));	}	catch (IntrospectionException e) {	    System.err.println("WARNING: can't introspect: " + beanClass);	}		// Tweak the appearance of the table by manipulating its column model	TableColumnModel colmodel = getColumnModel();		// Set column widths	colmodel.getColumn(0).setPreferredWidth(125);	colmodel.getColumn(1).setPreferredWidth(200);	colmodel.getColumn(2).setPreferredWidth(75);	colmodel.getColumn(3).setPreferredWidth(50);		// Right justify the text in the first column	TableColumn namecol = colmodel.getColumn(0);	DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();	renderer.setHorizontalAlignment(SwingConstants.RIGHT);	namecol.setCellRenderer(renderer);    }    /**     * This class implements TableModel and represents JavaBeans property data     * in a way that the JTable component can display.  If you've got some     * type of tabular data to display, implement a TableModel class to     * describe that data, and the JTable component will be able to display it.     **/    static class JavaBeanPropertyTableModel extends AbstractTableModel {	PropertyDescriptor[] properties;  // The properties to display	/**	 * The constructor: use the JavaBeans introspector mechanism to get 	 * information about all the properties of a bean.  Once we've got	 * this information, the other methods will interpret it for JTable.	 **/	public JavaBeanPropertyTableModel(Class beanClass)	    throws java.beans.IntrospectionException	{	    // Use the introspector class to get "bean info" about the class.	    BeanInfo beaninfo = Introspector.getBeanInfo(beanClass);	    // Get the property descriptors from that BeanInfo class	    properties = beaninfo.getPropertyDescriptors();	    // Now do a case-insensitive sort by property name	    // The anonymous Comparator implementation specifies how to 	    // sort PropertyDescriptor objects by name	    Arrays.sort(properties, new Comparator() {		    public int compare(Object p, Object q) {			PropertyDescriptor a = (PropertyDescriptor) p;			PropertyDescriptor b = (PropertyDescriptor) q;			return a.getName().compareToIgnoreCase(b.getName());		    }		    public boolean equals(Object o) { return o == this; }		});	}	// These are the names of the columns represented by this TableModel	static final String[] columnNames = new String[] {	    "Name", "Type", "Access", "Bound"	};	// These are the types of the columns represented by this TableModel	static final Class[] columnTypes = new Class[] {	    String.class, Class.class, String.class, Boolean.class	};	// These simple methods return basic information about the table	public int getColumnCount() { return columnNames.length; }	public int getRowCount() { return properties.length; }	public String getColumnName(int column) { return columnNames[column]; }	public Class getColumnClass(int column) { return columnTypes[column]; }	/**	 * This method returns the value that appears at the specified row and	 * column of the table	 **/	public Object getValueAt(int row, int column) {	    PropertyDescriptor prop = properties[row];	    switch(column) {	    case 0: return prop.getName();	    case 1: return prop.getPropertyType();	    case 2: return getAccessType(prop);	    case 3: return new Boolean(prop.isBound());	    default: return null;	    }	}	// A helper method called from getValueAt() above	String getAccessType(PropertyDescriptor prop) {	    java.lang.reflect.Method reader = prop.getReadMethod();	    java.lang.reflect.Method writer = prop.getWriteMethod();	    if ((reader != null) && (writer != null)) return "Read/Write";	    else if (reader != null) return "Read-Only";	    else if (writer != null) return "Write-Only";	    else return "No Access";  // should never happen	}    }}