KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > prefuse > util > ui > JPrefuseTable


1 package prefuse.util.ui;
2
3 import javax.swing.JFrame JavaDoc;
4 import javax.swing.JScrollPane JavaDoc;
5 import javax.swing.JTable JavaDoc;
6 import javax.swing.event.TableModelEvent JavaDoc;
7 import javax.swing.event.TableModelListener JavaDoc;
8 import javax.swing.table.DefaultTableCellRenderer JavaDoc;
9 import javax.swing.table.TableCellRenderer JavaDoc;
10 import javax.swing.table.TableModel JavaDoc;
11
12 import prefuse.data.Table;
13 import prefuse.data.event.EventConstants;
14 import prefuse.data.event.TableListener;
15 import prefuse.util.StringLib;
16 import prefuse.util.collections.CopyOnWriteArrayList;
17 import prefuse.util.collections.IntIterator;
18 import prefuse.visual.VisualTable;
19
20 /**
21  * Swing component that displays a prefuse Table instance in a Swing
22  * JTable component.
23  *
24  * @author <a HREF="http://jheer.org">jeffrey heer</a>
25  */

26 public class JPrefuseTable extends JTable JavaDoc {
27
28     private Table JavaDoc m_table;
29     private TableCellRenderer JavaDoc m_tcr = new DefaultTableCellRenderer JavaDoc();
30     
31     /**
32      * Create a new JPrefuseTable.
33      * @param t the Table to display.
34      */

35     public JPrefuseTable(Table JavaDoc t) {
36         super();
37         m_table = t;
38         
39         PrefuseTableModel model = new PrefuseTableModel();
40         super.setModel(model);
41         m_table.addTableListener(model);
42     }
43     
44     /**
45      * Get the table backing this component.
46      * @return a prefuse Table instance
47      */

48     public Table JavaDoc getTable() {
49         return m_table;
50     }
51     
52     /**
53      * Get the cell renderer to use for drawing table cells.
54      * @see javax.swing.JTable#getCellRenderer(int, int)
55      */

56     public TableCellRenderer JavaDoc getCellRenderer(int r, int c) {
57         return m_tcr;
58     }
59     
60     // ------------------------------------------------------------------------
61

62     /**
63      * TableModel implementation that serves as an adapter between a prefuse
64      * Table instance and a JTable component.
65      */

66     public class PrefuseTableModel implements TableModel JavaDoc, TableListener {
67         
68         private CopyOnWriteArrayList m_listeners = new CopyOnWriteArrayList();
69         private int[] m_rowmap;
70         
71         /**
72          * Initialize mapping between prefuse table rows and the rows reported
73          * by this model.
74          */

75         private void initRowMap() {
76             m_rowmap = new int[m_table.getRowCount()];
77             IntIterator rows = m_table.rows();
78             for ( int i=0; rows.hasNext(); ++i ) {
79                 m_rowmap[i] = rows.nextInt();
80             }
81         }
82         
83         /**
84          * Get the prefuse table row for a row index into this table model.
85          * @param rowIndex the row index in this table model
86          * @return the corresponding prefuse table row
87          */

88         private int getRow(int rowIndex) {
89             if ( m_rowmap == null )
90                 initRowMap();
91             return m_rowmap[rowIndex];
92         }
93         
94         // --------------------------------------------------------------------
95

96         /**
97          * @see javax.swing.table.TableModel#getColumnCount()
98          */

99         public int getColumnCount() {
100             return m_table.getColumnCount();
101         }
102         /**
103          * @see javax.swing.table.TableModel#getRowCount()
104          */

105         public int getRowCount() {
106             return m_table.getRowCount();
107         }
108         /**
109          * @see javax.swing.table.TableModel#isCellEditable(int, int)
110          */

111         public boolean isCellEditable(int rowIndex, int columnIndex) {
112             return m_table.isCellEditable(rowIndex, columnIndex);
113         }
114         /**
115          * @see javax.swing.table.TableModel#getColumnClass(int)
116          */

117         public Class JavaDoc getColumnClass(int columnIndex) {
118             return m_table.getColumnType(columnIndex);
119         }
120         /**
121          * @see javax.swing.table.TableModel#getValueAt(int, int)
122          */

123         public Object JavaDoc getValueAt(int rowIndex, int columnIndex) {
124             Object JavaDoc o = m_table.get(getRow(rowIndex), columnIndex);
125             if ( o != null && o.getClass().isArray() ) {
126                 return StringLib.getArrayString(o);
127             } else {
128                 return o;
129             }
130         }
131         /**
132          * @see javax.swing.table.TableModel#setValueAt(java.lang.Object, int, int)
133          */

134         public void setValueAt(Object JavaDoc aValue, int rowIndex, int columnIndex) {
135             m_table.set(getRow(rowIndex), columnIndex, aValue);
136         }
137         /**
138          * @see javax.swing.table.TableModel#getColumnName(int)
139          */

140         public String JavaDoc getColumnName(int columnIndex) {
141             return m_table.getColumnName(columnIndex);
142         }
143         
144         // --------------------------------------------------------------------
145

146         /**
147          * @see javax.swing.table.TableModel#addTableModelListener(javax.swing.event.TableModelListener)
148          */

149         public void addTableModelListener(TableModelListener JavaDoc l) {
150             m_listeners.add(l);
151         }
152         /**
153          * @see javax.swing.table.TableModel#removeTableModelListener(javax.swing.event.TableModelListener)
154          */

155         public void removeTableModelListener(TableModelListener JavaDoc l) {
156             m_listeners.remove(l);
157         }
158
159         /**
160          * @see prefuse.data.event.TableListener#tableChanged(prefuse.data.Table, int, int, int, int)
161          */

162         public void tableChanged(Table JavaDoc t, int start, int end, int col, int type) {
163             if ( type == EventConstants.INSERT || type == EventConstants.DELETE )
164                 m_rowmap = null; // invalidate row map
165

166             Object JavaDoc[] lstnrs = m_listeners.getArray();
167             if ( lstnrs.length == 0 )
168                 return;
169             
170             TableModelEvent JavaDoc evt
171                 = new TableModelEvent JavaDoc(this, start, end, col, type);
172             for ( int i=0; i<lstnrs.length; ++i ) {
173                 ((TableModelListener JavaDoc)lstnrs[i]).tableChanged(evt);
174             }
175         }
176         
177     } // end of inner class PrefuseTableModel
178

179     // ------------------------------------------------------------------------
180

181     /**
182      * Create a new window displaying the contents of the input Table as
183      * a Swing JTable.
184      * @param t the Table instance to display
185      * @return a reference to the JFrame holding the table view
186      */

187     public static JFrame JavaDoc showTableWindow(Table JavaDoc t) {
188         JPrefuseTable table = new JPrefuseTable(t);
189         String JavaDoc title = t.toString();
190         if ( t instanceof VisualTable ) {
191             title = ((VisualTable)t).getGroup() + " " + title;
192         }
193         JFrame JavaDoc frame = new JFrame JavaDoc(title);
194         frame.getContentPane().add(new JScrollPane JavaDoc(table));
195         frame.pack();
196         frame.setVisible(true);
197         return frame;
198     }
199     
200 } // end of class JPrefuseTable
201
Popular Tags