|
1
19
20 package edu.umd.cs.findbugs.gui2;
21
22 import java.awt.Color  ;
23 import java.awt.Component ;
24 import java.awt.Dimension ;
25 import java.lang.reflect.Method ;
26 import java.util.ArrayList ;
27 import java.util.Arrays ;
28 import java.util.Collections ;
29 import java.util.Enumeration ;
30 import java.util.List ;
31
32 import javax.swing.BorderFactory ;
33 import javax.swing.DefaultListSelectionModel ;
34 import javax.swing.ImageIcon ;
35 import javax.swing.JComponent ;
36 import javax.swing.JLabel ;
37 import javax.swing.JTable ;
38 import javax.swing.ListSelectionModel ;
39 import javax.swing.SwingConstants ;
40 import javax.swing.border.EtchedBorder ;
41 import javax.swing.event.ListSelectionEvent ;
42 import javax.swing.event.TableColumnModelEvent ;
43 import javax.swing.event.TableColumnModelListener ;
44 import javax.swing.table.TableCellRenderer ;
45 import javax.swing.table.JTableHeader ;
46 import javax.swing.table.TableColumn ;
47 import javax.swing.table.TableColumnModel ;
48 import javax.swing.tree.TreeModel ;
49
50
55 public class SorterTableColumnModel implements TableColumnModel {
56
57 private ArrayList <Sortables> order=new ArrayList <Sortables>();
58 private boolean[] showOrder=new boolean[Sortables.values().length];
59 private ArrayList <TableColumn > columnList=new ArrayList <TableColumn >();
60 private DefaultListSelectionModel dlsm;
61 private ArrayList <TableColumnModelListener > watchers=new ArrayList <TableColumnModelListener >();
62 private boolean frozen=false;
63
64 public SorterTableColumnModel(Sortables[] columnHeaders){
65
66 for(int x = 0; x < columnHeaders.length; x++)
67 {
68 Sortables c=columnHeaders[x];
69 for (int y=0; y<Sortables.values().length;y++)
71 {
72 if (c.equals(Sortables.values()[y]))
73 showOrder[y]=true;
74 }
75
76 TableColumn tc=new TableColumn (x);
77 FBTableCellRenderer temp = new FBTableCellRenderer();
78 tc.setHeaderRenderer(temp);
79 tc.setIdentifier(c);
80 tc.setHeaderValue(c);
81 tc.setResizable(false);
82 tc.sizeWidthToFit();
83 columnList.add(tc);
84 }
85 dlsm=new DefaultListSelectionModel ();
86 dlsm.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
87 orderUpdate();
88 }
89
90 public void createFrom(SorterTableColumnModel other)
91 {
92 if (this.getOrder().equals(other.getOrder()))
93 return;
94 columnList.clear();
95 for (int x=0; x<order.size(); x++)
96 {
97 for (TableColumnModelListener l: watchers)
98 l.columnRemoved(new TableColumnModelEvent (this,x,x));
99 }
100 for(int x = 0; x < other.order.size(); x++)
101 {
102 Sortables c=other.order.get(x);
103 for (int y=0; y<Sortables.values().length;y++)
104 {
105 if (c.equals(Sortables.values()[y]))
106 showOrder[y]=true;
107 }
108
109 TableColumn tc=new TableColumn (x);
110 tc.setHeaderRenderer(new FBTableCellRenderer());
111 tc.setIdentifier(c);
112 tc.setHeaderValue(c);
113 tc.setResizable(false);
114 tc.sizeWidthToFit();
115 columnList.add(tc);
116 for (TableColumnModelListener l: watchers)
117 l.columnAdded(new TableColumnModelEvent (this,x,x));
118 }
119 dlsm=new DefaultListSelectionModel ();
120 dlsm.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
121
122 orderUpdate();
123
124 }
125
126 public SorterTableColumnModel(ArrayList <Sortables> columnHeaders)
127 {
128 this(columnHeaders.toArray(new Sortables[columnHeaders.size()]));
129 }
130
131
132 static class FBTableCellRenderer implements TableCellRenderer {
133
134 private TableCellRenderer defaultRenderer = new JTableHeader ().getDefaultRenderer();
135
136 public Component getTableCellRendererComponent(JTable table,
137 Object value, boolean isSelected, boolean hasFocus, int row, int column){
138
139 Component comp = defaultRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
140 if (comp instanceof JLabel ) {
141 JLabel cell = (JLabel )comp;
142 cell.setFont(cell.getFont().deriveFont(Driver.getFontSize()));
143 cell.setBorder(BorderFactory.createCompoundBorder(cell.getBorder(), BorderFactory.createEmptyBorder(0, 6, 0, 6)));
144 cell.setHorizontalAlignment(SwingConstants.CENTER);
145 if (value == Sortables.DIVIDER)
146 {
147 cell.setText("");
148 cell.setIcon(new ImageIcon (MainFrame.class.getResource("arrows.png")));
149 new ImageIcon ("a");
150 }
151 }
152 return comp;
153 }
154 }
155
156 public void addColumn(TableColumn arg0)
157 {
158 throw new UnsupportedOperationException ("Can't change sorter table columns using addColumn");
159 }
160
161 public void removeColumn(TableColumn arg0)
162 {
163 throw new UnsupportedOperationException ("Can't change sorter table columns using removeColumn");
164 }
165
166 boolean[] getVisibleColumns()
167 {
168 return showOrder;
169 }
170
171 void setIndexChanged(int index)
172 {
173 showOrder[index]=!showOrder[index];
174 Sortables s=Sortables.values()[index];
175
176 boolean on=showOrder[index];
177
178 if (on)
179 {
180 TableColumn tc=new TableColumn (columnList.size());
181 tc.setHeaderRenderer(new FBTableCellRenderer());
182 tc.setIdentifier(s);
183 tc.setHeaderValue(s);
184 tc.setResizable(false);
185 tc.sizeWidthToFit();
186 columnList.add(tc);
187 for (int x=0;x<columnList.size();x++)
188 {
189 columnList.get(x).setModelIndex(x);
190 }
191 orderUpdate();
192 for (TableColumnModelListener l: watchers)
193 {
194 l.columnAdded(new TableColumnModelEvent (this,columnList.size()-1,columnList.size()-1));
195 }
196 }
197 else if (!on)
198 {
199 for (int x=0;x<columnList.size();x++)
200 {
201 columnList.get(x).setModelIndex(x);
202 }
203
204 for (int counter=0;counter<columnList.size();counter++)
205 {
206 TableColumn tc=columnList.get(counter);
207 if (tc.getIdentifier().equals(s))
208 {
209 columnList.remove(counter);
210 for (int x=counter;x<columnList.size();x++)
211 {
212 columnList.get(x).setModelIndex(x);
213 }
214
215 orderUpdate();
216 for (TableColumnModelListener l: watchers)
217 l.columnRemoved(new TableColumnModelEvent (this,counter,counter));
218
219 }
220 }
221 }
222
223 }
224
225 public void moveColumn(int fromIndex, int toIndex) {
226
227 MainFrame.getInstance().updateDesignationDisplay();
228 MainFrame.getInstance().saveComments();
229 TableColumn from=columnList.get(fromIndex);
230 TableColumn to=columnList.get(toIndex);
231
232 columnList.set(fromIndex,to);
233 to.setModelIndex(fromIndex);
234
235 columnList.set(toIndex,from);
236 from.setModelIndex(toIndex);
237
238 orderUpdate();
239
240 for (TableColumnModelListener w:(ArrayList <TableColumnModelListener >)watchers.clone())
241 {
242 w.columnMoved(new TableColumnModelEvent (this,fromIndex,toIndex));
243 }
244 }
245
246 public void setColumnMargin(int arg0) {
247 throw new UnsupportedOperationException ("NoBah");
248 }
249
250 public int getColumnCount() {
251 return columnList.size();
252 }
253
254 public Enumeration <TableColumn > getColumns() {
255 return Collections.enumeration(columnList);
256 }
257
258 public int getColumnIndex(Object columnIdentifier) {
259
260 if (columnIdentifier==null)
261 throw new IllegalArgumentException ("Dont send null to getColumnIndex, null shouldn't be in the sorting table.");
262
263 for(int x=0;x<columnList.size();x++)
264 {
265 if (columnList.get(x).getIdentifier().equals(columnIdentifier))
266 return x;
267 }
268
269 throw new IllegalArgumentException ();
270 }
271
272 public TableColumn getColumn(int x) {
273 return columnList.get(x);
274 }
275
276 public int getColumnMargin() {
277 return 0;
278 }
279
280 public int getColumnIndexAtX(int XPosition) {
281
282 for (TableColumn tc:columnList)
283 {
284 XPosition-=tc.getWidth();
285 if (XPosition < 0)
286 return tc.getModelIndex();
287 }
288 return -1;
289 }
290
291 public int getTotalColumnWidth() {
292 int total=0;
293 for (TableColumn tc: columnList)
294 {
295 total+=tc.getWidth();
296 }
297 return total;
298 }
299
300 public void setColumnSelectionAllowed(boolean arg0) {
301 throw new UnsupportedOperationException ("BAH"); }
303
304 public boolean getColumnSelectionAllowed() {
305 return true;
306 }
307
308 public int[] getSelectedColumns() {
309 int index=dlsm.getMinSelectionIndex();
310 if (index==-1)
311 return new int[]{};
312 return new int[]{index};
313 }
314
315 public int getSelectedColumnCount() {
316
317 if (dlsm.getMinSelectionIndex()==-1)
318 return 0;
319 return 1;
320 }
321
322 public void setSelectionModel(ListSelectionModel arg0) {
323 throw new UnsupportedOperationException ("No... NO NO NO NO");
324 }
325
326 public ListSelectionModel getSelectionModel() {
327 return dlsm;
328 }
329
330 public void addColumnModelListener(TableColumnModelListener listener) {
331 watchers.add(listener);
332 }
333
334 public void removeColumnModelListener(TableColumnModelListener listener) {
335 watchers.remove(listener);
336 }
337
338 public void columnSelectionChanged(ListSelectionEvent arg0) {
339 throw new UnsupportedOperationException ("columnSelectionChangedBAH");
340 }
341
342 ArrayList <Sortables> getOrder()
343 {
344 return order;
345 }
346
347 List <Sortables> getOrderBeforeDivider()
348 {
349 if (!order.contains(Sortables.DIVIDER))
350 return order;
351
352 return order.subList(0, order.indexOf(Sortables.DIVIDER));
353 }
354
355 List <Sortables> getOrderAfterDivider()
356 {
357 if (!order.contains(Sortables.DIVIDER) || order.indexOf(Sortables.DIVIDER) == order.size() - 1)
358 return new ArrayList <Sortables>();
359
360 return order.subList(order.indexOf(Sortables.DIVIDER) + 1, order.size());
361 }
362
363 private void orderUpdate()
364 {
365 if (!frozen)
367 {
368 order=new ArrayList <Sortables>();
369 for (int x=0;x<columnList.size();x++)
370 {
371 order.add((Sortables)columnList.get(x).getIdentifier());
372 }
373 }
374 }
375
376 public void freezeOrder() {
377 frozen=true;
378 }
379
380 public void thawOrder() {
381 frozen=false;
382 orderUpdate();
383 TreeModel model=MainFrame.getInstance().getTree().getModel();
384 if (model instanceof BugTreeModel)
385 {
386 ((BugTreeModel) model).checkSorter();
387 }
388 }
389 }
390 |
Popular Tags |
Java API By Example, From Geeks To Geeks.