Debian Codegraph @

src/java/org/astrogrid/samp/gui/TransmissionTableModel.java

raw
1 package org.astrogrid.samp.gui;
2
3 import java.awt.Component;
4 import java.awt.Graphics2D;
5 import java.awt.event.ActionEvent;
6 import java.awt.event.ActionListener;
7 import java.util.ArrayList;
8 import java.util.Iterator;
9 import java.util.LinkedList;
10 import java.util.List;
11 import javax.swing.JLabel;
12 import javax.swing.JTable;
13 import javax.swing.SwingUtilities;
14 import javax.swing.Timer;
15 import javax.swing.event.ChangeEvent;
16 import javax.swing.event.ChangeListener;
17 import javax.swing.event.TableModelEvent;
18 import javax.swing.event.TableModelListener;
19 import javax.swing.table.DefaultTableCellRenderer;
20 import javax.swing.table.TableCellRenderer;
21 import javax.swing.table.TableColumn;
22 import javax.swing.table.TableModel;
23 import org.astrogrid.samp.Client;
24
25 /**
26 * TableModel implementation which displays Transmission objects.
27 *
28 * @author Mark Taylor
29 * @since 5 Dec 2008
30 */
31 class TransmissionTableModel implements TableModel {
32
33 private final List transList_;
34 private final List tableListenerList_;
35 private final ChangeListener changeListener_;
36 private final Column[] columns_;
37 private int maxRows_;
38 private int removeDelay_;
39
40 /** Cell renderer for Transmission.Status objects. */
41 public static final TableCellRenderer STATUS_RENDERER =
42 createStatusCellRenderer();
43
44 /** Cell renderer for Client objects. */
45 private static final TableCellRenderer CLIENT_RENDERER =
46 createClientCellRenderer();
47
48 /**
49 * Constructor.
50 *
51 * @param showSender true if a Sender column is required
52 * @param showReceiver true if a Receiver column is required
53 * @param removeDelay time in milliseconds after transmission resolution
54 * that it will stay in the table - after this it will be
55 * removed automatically
56 * @param maxRows maximum row count for table - if not set to a finite
57 * value, Swing can get overloaded in very high message traffic
58 */
59 public TransmissionTableModel( final boolean showSender,
60 final boolean showReceiver,
61 int removeDelay, int maxRows ) {
62 removeDelay_ = removeDelay;
63 maxRows_ = maxRows;
64 transList_ = new LinkedList();
65 tableListenerList_ = new ArrayList();
66
67 // Set up table columns.
68 List colList = new ArrayList();
69 int charWidth = 8;
70 int icol = 0;
71 colList.add( new Column( "MType", String.class,
72 new TableColumn( icol++, 30 * charWidth ) ) {
73 Object getValue( Transmission trans ) {
74 return trans.getMessage().getMType();
75 }
76 } );
77 if ( showSender ) {
78 colList.add( new Column( "Sender", Object.class,
79 new TableColumn( icol++, 20 * charWidth,
80 CLIENT_RENDERER,
81 null ) ) {
82 Object getValue( Transmission trans ) {
83 return trans.getSender();
84 }
85 } );
86 }
87 if ( showReceiver ) {
88 colList.add( new Column( "Receiver", Object.class,
89 new TableColumn( icol++, 20 * charWidth,
90 CLIENT_RENDERER,
91 null ) ) {
92 Object getValue( Transmission trans ) {
93 return trans.getReceiver();
94 }
95 } );
96 }
97 colList.add( new Column( "Status", Object.class,
98 new TableColumn( icol++, 16 * charWidth,
99 STATUS_RENDERER, null ) ) {
100 Object getValue( Transmission trans ) {
101 return trans.getStatus();
102 }
103 } );
104 columns_ = (Column[]) colList.toArray( new Column[ 0 ] );
105
106 // Set up listener to monitor changes of transmissions.
107 changeListener_ = new ChangeListener() {
108 public void stateChanged( ChangeEvent evt ) {
109 Object src = evt.getSource();
110 assert src instanceof Transmission;
111 if ( src instanceof Transmission ) {
112 transmissionChanged( (Transmission) src );
113 }
114 }
115 };
116 }
117
118 /**
119 * Returns the transmission corresponding to a given table row.
120 *
121 * @param irow row index
122 * @param transmission displayed in row irow
123 */
124 public Transmission getTransmission( int irow ) {
125 return (Transmission) transList_.get( irow );
126 }
127
128 /**
129 * Adds a transmission (row) to this model. It will appear at the top.
130 *
131 * @param trans transmission to add
132 */
133 public void addTransmission( Transmission trans ) {
134 while ( transList_.size() > maxRows_ ) {
135 transList_.remove( maxRows_ );
136 fireTableChanged( new TableModelEvent( this, maxRows_, maxRows_,
137 TableModelEvent.ALL_COLUMNS,
138 TableModelEvent.DELETE ) );
139 }
140 transList_.add( 0, trans );
141 trans.addChangeListener( changeListener_ );
142 fireTableChanged( new TableModelEvent( this, 0, 0,
143 TableModelEvent.ALL_COLUMNS,
144 TableModelEvent.INSERT ) );
145 }
146
147 /**
148 * Removes a transmission from this model.
149 *
150 * @param trans transmission to remove
151 */
152 public void removeTransmission( final Transmission trans ) {
153 int index = transList_.indexOf( trans );
154 if ( index >= 0 ) {
155 transList_.remove( index );
156 fireTableChanged( new TableModelEvent( this, index, index,
157 TableModelEvent.ALL_COLUMNS,
158 TableModelEvent.DELETE ) );
159 }
160
161 // Defer listener removal to avoid concurrency problems
162 // (trying to remove a listener which generated this event).
163 SwingUtilities.invokeLater( new Runnable() {
164 public void run() {
165 trans.removeChangeListener( changeListener_ );
166 }
167 } );
168 }
169
170 public int getColumnCount() {
171 return columns_.length;
172 }
173
174 public int getRowCount() {
175 return transList_.size();
176 }
177
178 public Object getValueAt( int irow, int icol ) {
179 return columns_[ icol ].getValue( getTransmission( irow ) );
180 }
181
182 public String getColumnName( int icol ) {
183 return columns_[ icol ].name_;
184 }
185
186 public Class getColumnClass( int icol ) {
187 return columns_[ icol ].clazz_;
188 }
189
190 public boolean isCellEditable( int irow, int icol ) {
191 return false;
192 }
193
194 public void setValueAt( Object value, int irow, int icol ) {
195 throw new UnsupportedOperationException();
196 }
197
198 public void addTableModelListener( TableModelListener listener ) {
199 tableListenerList_.add( listener );
200 }
201
202 public void removeTableModelListener( TableModelListener listener ) {
203 tableListenerList_.remove( listener );
204 }
205
206 /**
207 * Returns a TableColumn suitable for a given column of this table.
208 * Can be used for more customised presentation.
209 *
210 * @param icol column index
211 * @return table column
212 */
213 public TableColumn getTableColumn( int icol ) {
214 return columns_[ icol ].tcol_;
215 }
216
217 /**
218 * Called whenever a transmission which is in this list has changed
219 * state.
220 *
221 * @param trans transmission
222 */
223 private void transmissionChanged( final Transmission trans ) {
224 int index = transList_.indexOf( trans );
225 if ( index >= 0 ) {
226 fireTableChanged( new TableModelEvent( this, index ) );
227 if ( trans.isDone() && removeDelay_ >= 0 ) {
228 long sinceDone =
229 System.currentTimeMillis() - trans.getDoneTime();
230 long delay = removeDelay_ - sinceDone;
231 if ( delay <= 0 ) {
232 removeTransmission( trans );
233 }
234 else {
235 ActionListener remover = new ActionListener() {
236 public void actionPerformed( ActionEvent evt ) {
237 removeTransmission( trans );
238 }
239 };
240 new Timer( (int) delay + 1, remover ).start();
241 }
242 }
243 }
244 }
245
246 /**
247 * Passes a table event to all registered listeners.
248 *
249 * @param evt event to forward
250 */
251 private void fireTableChanged( TableModelEvent evt ) {
252 for ( Iterator it = tableListenerList_.iterator(); it.hasNext(); ) {
253 ((TableModelListener) it.next()).tableChanged( evt );
254 }
255 }
256
257 /**
258 * Describes metadata and data for a table column.
259 */
260 private abstract class Column {
261 final String name_;
262 final Class clazz_;
263 final TableColumn tcol_;
264
265 /**
266 * Constructor.
267 *
268 * @param name column name
269 * @param clazz column content class
270 */
271 Column( String name, Class clazz, TableColumn tcol ) {
272 name_ = name;
273 clazz_ = clazz;
274 tcol_ = tcol;
275 tcol_.setHeaderValue( name );
276 }
277
278 /**
279 * Returns the item in this column for a given transmission.
280 *
281 * @param trans transmission
282 * @return cell value
283 */
284 abstract Object getValue( Transmission trans );
285 }
286
287 /**
288 * Template custom TableCellRenderer for subclassing.
289 */
290 private static abstract class CustomTableCellRenderer
291 extends DefaultTableCellRenderer {
292 public Component getTableCellRendererComponent( JTable table,
293 Object value,
294 boolean isSel,
295 boolean hasFocus,
296 int irow, int icol ) {
297 int size;
298 try {
299 size =
300 (int) Math.ceil( getFont()
301 .getMaxCharBounds( ((Graphics2D)
302 table.getGraphics())
303 .getFontRenderContext() )
304 .getHeight() );
305 }
306 catch ( NullPointerException e ) {
307 size = 16;
308 }
309 Component comp =
310 super.getTableCellRendererComponent( table, value, isSel,
311 hasFocus, irow, icol );
312 if ( comp instanceof JLabel ) {
313 configureLabel( (JLabel) comp, value, size - 2 );
314 }
315 return comp;
316 }
317
318 /**
319 * Configures a JLabel given the value to render and the
320 * component size.
321 *
322 * @param label renderer component to configure
323 * @param value object to render
324 * @param height component height in pixels
325 */
326 abstract void configureLabel( JLabel label, Object value, int height );
327 }
328
329 /**
330 * Returns a cell renderer for Transmission.Status objects.
331 *
332 * @return table cell renderer
333 */
334 private static TableCellRenderer createStatusCellRenderer() {
335 return new CustomTableCellRenderer() {
336 void configureLabel( JLabel label, Object value, int height ) {
337 if ( value instanceof Transmission.Status ) {
338 Transmission.Status status = (Transmission.Status) value;
339 label.setText( status.getText() );
340 label.setIcon( status.getIcon( height ) );
341 }
342 }
343 };
344 }
345
346 /**
347 * Returns a cell renderer for Client objects.
348 *
349 * @return table cell renderer
350 */
351 private static TableCellRenderer createClientCellRenderer() {
352 final IconStore iconStore =
353 new IconStore( IconStore.createEmptyIcon( 16 ) );
354 return new CustomTableCellRenderer() {
355 void configureLabel( JLabel label, Object value, int height ) {
356 if ( value instanceof Client ) {
357 Client client = (Client) value;
358 label.setText( client.toString() );
359 label.setIcon( ClientListCellRenderer
360 .reshapeIcon( iconStore.getIcon( client ),
361 height ) );
362 }
363 }
364 };
365 }
366 }