1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56:
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66: import ;
67: import ;
68: import ;
69: import ;
70: import ;
71: import ;
72: import ;
73: import ;
74: import ;
75: import ;
76: import ;
77: import ;
78:
79: public class JTable extends JComponent
80: implements TableModelListener, Scrollable, TableColumnModelListener,
81: ListSelectionListener, CellEditorListener, Accessible
82: {
83:
84:
87: private class BooleanCellRenderer
88: extends DefaultTableCellRenderer
89: {
90:
91:
94: private JCheckBox checkBox = new JCheckBox();
95:
96:
108: public Component getTableCellRendererComponent(JTable table, Object value,
109: boolean isSelected,
110: boolean hasFocus, int row,
111: int column)
112: {
113: Boolean boolValue = (Boolean) value;
114: checkBox.setSelected(boolValue.booleanValue());
115: return checkBox;
116: }
117: }
118:
119:
122: private class DateCellRenderer
123: extends DefaultTableCellRenderer
124: {
125:
137: public Component getTableCellRendererComponent(JTable table, Object value,
138: boolean isSelected,
139: boolean hasFocus, int row,
140: int column)
141: {
142: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
143: row, column);
144: if (value instanceof Date)
145: {
146: Date dateValue = (Date) value;
147: DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
148: setText(df.format(dateValue));
149: }
150: return this;
151: }
152: }
153:
154:
157: private class DoubleCellRenderer
158: extends DefaultTableCellRenderer
159: {
160:
163: public DoubleCellRenderer()
164: {
165: setHorizontalAlignment(JLabel.RIGHT);
166: }
167:
168:
180: public Component getTableCellRendererComponent(JTable table, Object value,
181: boolean isSelected,
182: boolean hasFocus, int row,
183: int column)
184: {
185: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
186: row, column);
187: if (value instanceof Double)
188: {
189: Double doubleValue = (Double) value;
190: NumberFormat nf = NumberFormat.getInstance();
191: setText(nf.format(doubleValue.doubleValue()));
192: }
193: return this;
194: }
195: }
196:
197:
200: private class FloatCellRenderer
201: extends DefaultTableCellRenderer
202: {
203:
206: public FloatCellRenderer()
207: {
208: setHorizontalAlignment(JLabel.RIGHT);
209: }
210:
211:
223: public Component getTableCellRendererComponent(JTable table, Object value,
224: boolean isSelected,
225: boolean hasFocus, int row,
226: int column)
227: {
228: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
229: row, column);
230: if (value instanceof Float)
231: {
232: Float floatValue = (Float) value;
233: NumberFormat nf = NumberFormat.getInstance();
234: setText(nf.format(floatValue.floatValue()));
235: }
236: return this;
237: }
238: }
239:
240:
243: private class NumberCellRenderer
244: extends DefaultTableCellRenderer
245: {
246:
249: public NumberCellRenderer()
250: {
251: setHorizontalAlignment(JLabel.RIGHT);
252: }
253: }
254:
255:
258: private class IconCellRenderer
259: extends DefaultTableCellRenderer
260: {
261:
273: public Component getTableCellRendererComponent(JTable table, Object value,
274: boolean isSelected,
275: boolean hasFocus, int row,
276: int column)
277: {
278: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
279: row, column);
280: if (value instanceof Icon)
281: {
282: Icon iconValue = (Icon) value;
283: setIcon(iconValue);
284: }
285: return this;
286: }
287: }
288:
289: private static final long serialVersionUID = 3876025080382781659L;
290:
291:
292:
297: public static final int AUTO_RESIZE_OFF = 0;
298:
299:
304: public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
305:
306:
311: public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
312:
313:
319: public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
320:
321:
326: public static final int AUTO_RESIZE_LAST_COLUMN = 3;
327:
328:
329:
334: protected Hashtable defaultEditorsByColumnClass;
335:
336:
341: protected Hashtable defaultRenderersByColumnClass;
342:
343:
346: protected int editingColumn;
347:
348:
351: protected int editingRow;
352:
353:
358: protected transient Component editorComp;
359:
360:
361:
372: protected boolean autoCreateColumnsFromModel;
373:
374:
384: protected int autoResizeMode;
385:
386:
397: protected int rowHeight;
398:
399:
409: protected int rowMargin;
410:
411:
424: protected boolean rowSelectionAllowed;
425:
426:
431: protected boolean cellSelectionEnabled;
432:
433:
442: protected TableModel dataModel;
443:
444:
466: protected TableColumnModel columnModel;
467:
468:
480: protected ListSelectionModel selectionModel;
481:
482:
485: protected AccessibleContext accessibleContext;
486:
487:
490: protected TableCellEditor cellEditor;
491:
492:
498: private boolean dragEnabled;
499:
500:
507: protected Color gridColor;
508:
509:
516: protected Dimension preferredViewportSize;
517:
518:
526: protected Color selectionBackground;
527:
528:
532: private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
533:
534:
542: protected Color selectionForeground;
543:
544:
548: private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
549:
550:
553: protected boolean showHorizontalLines;
554:
555:
558: protected boolean showVerticalLines;
559:
560:
563: protected JTableHeader tableHeader;
564:
565:
568: int rowBeingEdited = -1;
569:
570:
573: int columnBeingEdited = -1;
574:
575:
578: Timer editorTimer = new EditorUpdateTimer();
579:
580:
584: Object oldCellValue;
585:
586:
589: public JTable ()
590: {
591: this(null, null, null);
592: }
593:
594:
600: public JTable (int numRows, int numColumns)
601: {
602: this(new DefaultTableModel(numRows, numColumns));
603: }
604:
605:
611: public JTable(Object[][] data, Object[] columnNames)
612: {
613: this(new DefaultTableModel(data, columnNames));
614: }
615:
616:
621: public JTable (TableModel dm)
622: {
623: this(dm, null, null);
624: }
625:
626:
632: public JTable (TableModel dm, TableColumnModel cm)
633: {
634: this(dm, cm, null);
635: }
636:
637:
644: public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
645: {
646: setModel(dm == null ? createDefaultDataModel() : dm);
647: setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
648:
649: this.columnModel = cm;
650: initializeLocalVars();
651:
652:
653:
654: selectionModel.setLeadSelectionIndex(0);
655: columnModel.getSelectionModel().setLeadSelectionIndex(0);
656: updateUI();
657: }
658:
659: protected void initializeLocalVars()
660: {
661: setTableHeader(createDefaultTableHeader());
662: this.autoCreateColumnsFromModel = false;
663: if (columnModel == null)
664: {
665: this.autoCreateColumnsFromModel = true;
666: createColumnsFromModel();
667: }
668: this.columnModel.addColumnModelListener(this);
669:
670: this.defaultRenderersByColumnClass = new Hashtable();
671: createDefaultRenderers();
672:
673: this.defaultEditorsByColumnClass = new Hashtable();
674: createDefaultEditors();
675:
676: this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
677: this.rowHeight = 16;
678: this.rowMargin = 1;
679: this.rowSelectionAllowed = true;
680:
681: this.cellEditor = null;
682:
683: this.dragEnabled = true;
684: this.preferredViewportSize = new Dimension(450,400);
685: this.showHorizontalLines = true;
686: this.showVerticalLines = true;
687: this.editingColumn = -1;
688: this.editingRow = -1;
689: setIntercellSpacing(new Dimension(1,1));
690: }
691:
692:
698: public JTable(Vector data, Vector columnNames)
699: {
700: this(new DefaultTableModel(data, columnNames));
701: }
702:
703:
706: private class EditorUpdateTimer
707: extends Timer
708: implements ActionListener
709: {
710:
713: public EditorUpdateTimer()
714: {
715: super(500, null);
716: addActionListener(this);
717: }
718:
719:
722: public void actionPerformed(ActionEvent ev)
723: {
724: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
725: if (c != null)
726: c.setVisible(!c.isVisible());
727: JTable.this.repaint();
728: }
729:
730:
733: public void update()
734: {
735: stop();
736: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
737: if (c != null)
738: {
739: setDelay(c.getBlinkRate());
740: if (((JTextField)JTable.this.editorComp).isEditable())
741: start();
742: else
743: c.setVisible(false);
744: }
745: }
746: }
747:
748: public void addColumn(TableColumn column)
749: {
750: if (column.getHeaderValue() == null)
751: {
752: String name = dataModel.getColumnName(column.getModelIndex());
753: column.setHeaderValue(name);
754: }
755:
756: columnModel.addColumn(column);
757: }
758:
759: protected void createDefaultEditors()
760: {
761:
762: }
763:
764: protected void createDefaultRenderers()
765: {
766: setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
767: setDefaultRenderer(Number.class, new NumberCellRenderer());
768: setDefaultRenderer(Double.class, new DoubleCellRenderer());
769: setDefaultRenderer(Double.class, new FloatCellRenderer());
770: setDefaultRenderer(Date.class, new DateCellRenderer());
771: setDefaultRenderer(Icon.class, new IconCellRenderer());
772: }
773:
774:
777: public static JScrollPane createScrollPaneForTable(JTable table)
778: {
779: return new JScrollPane(table);
780: }
781:
782: protected TableColumnModel createDefaultColumnModel()
783: {
784: return new DefaultTableColumnModel();
785: }
786:
787: protected TableModel createDefaultDataModel()
788: {
789: return new DefaultTableModel();
790: }
791:
792: protected ListSelectionModel createDefaultSelectionModel()
793: {
794: return new DefaultListSelectionModel();
795: }
796:
797: protected JTableHeader createDefaultTableHeader()
798: {
799: return new JTableHeader(columnModel);
800: }
801:
802: private void createColumnsFromModel()
803: {
804: if (dataModel == null)
805: return;
806:
807: TableColumnModel cm = createDefaultColumnModel();
808:
809: for (int i = 0; i < dataModel.getColumnCount(); ++i)
810: {
811: cm.addColumn(new TableColumn(i));
812: }
813: this.setColumnModel(cm);
814: }
815:
816:
817:
818: public void columnAdded (TableColumnModelEvent event)
819: {
820: revalidate();
821: repaint();
822: }
823:
824: public void columnMarginChanged (ChangeEvent event)
825: {
826: revalidate();
827: repaint();
828: }
829:
830: public void columnMoved (TableColumnModelEvent event)
831: {
832: revalidate();
833: repaint();
834: }
835:
836: public void columnRemoved (TableColumnModelEvent event)
837: {
838: revalidate();
839: repaint();
840: }
841:
842: public void columnSelectionChanged (ListSelectionEvent event)
843: {
844: repaint();
845: }
846:
847: public void editingCanceled (ChangeEvent event)
848: {
849: if (rowBeingEdited > -1 && columnBeingEdited > -1)
850: {
851: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
852: {
853: remove ((Component)getValueAt(rowBeingEdited, columnBeingEdited));
854: setValueAt(oldCellValue, rowBeingEdited, columnBeingEdited);
855: }
856: rowBeingEdited = -1;
857: columnBeingEdited = -1;
858: }
859: editorTimer.stop();
860: editorComp = null;
861: cellEditor = null;
862: requestFocusInWindow(false);
863: repaint();
864: }
865:
866: public void editingStopped (ChangeEvent event)
867: {
868: if (rowBeingEdited > -1 && columnBeingEdited > -1)
869: {
870: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
871: {
872: remove((Component)getValueAt(rowBeingEdited, columnBeingEdited));
873: setValueAt(((JTextField)editorComp).getText(),
874: rowBeingEdited, columnBeingEdited);
875: }
876: rowBeingEdited = -1;
877: columnBeingEdited = -1;
878: }
879: editorTimer.stop();
880: editorComp = null;
881: cellEditor = null;
882: requestFocusInWindow(false);
883: repaint();
884: }
885:
886: public void tableChanged (TableModelEvent event)
887: {
888:
889:
890: if ((event.getFirstRow() ==TableModelEvent.HEADER_ROW)
891: && autoCreateColumnsFromModel)
892:
893: createColumnsFromModel();
894:
895: repaint();
896: }
897:
898: public void valueChanged (ListSelectionEvent event)
899: {
900: repaint();
901: }
902:
903:
911: public int columnAtPoint(Point point)
912: {
913: if (point != null)
914: {
915: int x0 = getLocation().x;
916: int ncols = getColumnCount();
917: Dimension gap = getIntercellSpacing();
918: TableColumnModel cols = getColumnModel();
919: int x = point.x;
920:
921: for (int i = 0; i < ncols; ++i)
922: {
923: int width = cols.getColumn(i).getWidth()
924: + (gap == null ? 0 : gap.width);
925: if (0 <= x && x < width)
926: return i;
927: x -= width;
928: }
929: }
930: return -1;
931: }
932:
933:
941: public int rowAtPoint(Point point)
942: {
943: if (point != null)
944: {
945: int y0 = getLocation().y;
946: int nrows = getRowCount();
947: Dimension gap = getIntercellSpacing();
948: int height = getRowHeight() + (gap == null ? 0 : gap.height);
949: int y = point.y;
950:
951: for (int i = 0; i < nrows; ++i)
952: {
953: if (0 <= y && y < height)
954: return i;
955: y -= height;
956: }
957: }
958: return -1;
959: }
960:
961:
977: public Rectangle getCellRect(int row,
978: int column,
979: boolean includeSpacing)
980: {
981: int height = getRowHeight(row);
982: int width = columnModel.getColumn(column).getWidth();
983: int x_gap = columnModel.getColumnMargin();
984: int y_gap = rowMargin;
985:
986: column = Math.max(0, Math.min(column, getColumnCount() - 1));
987: row = Math.max(0, Math.min(row, getRowCount() - 1));
988:
989: int x = 0;
990: int y = (height + y_gap) * row;
991:
992: for (int i = 0; i < column; ++i)
993: {
994: x += columnModel.getColumn(i).getWidth();
995: x += x_gap;
996: }
997:
998: if (includeSpacing)
999: return new Rectangle(x, y, width, height);
1000: else
1001: return new Rectangle(x, y, width - x_gap, height - y_gap);
1002: }
1003:
1004: public void clearSelection()
1005: {
1006: selectionModel.clearSelection();
1007: getColumnModel().getSelectionModel().clearSelection();
1008: }
1009:
1010:
1017: public int getSelectedRow ()
1018: {
1019: return selectionModel.getMinSelectionIndex();
1020: }
1021:
1022:
1027: public ListSelectionModel getSelectionModel()
1028: {
1029:
1030: return selectionModel;
1031: }
1032:
1033: public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
1034: {
1035: if (orientation == SwingConstants.VERTICAL)
1036: return visibleRect.height * direction;
1037: else
1038: return visibleRect.width * direction;
1039: }
1040:
1041:
1046: public boolean getScrollableTracksViewportHeight()
1047: {
1048: return false;
1049: }
1050:
1051:
1057: public boolean getScrollableTracksViewportWidth()
1058: {
1059: if (autoResizeMode == AUTO_RESIZE_OFF)
1060: return false;
1061: else
1062: return true;
1063: }
1064:
1065: public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)
1066: {
1067:
1068:
1069:
1070:
1071: if (orientation == SwingConstants.VERTICAL)
1072: return rowHeight;
1073: else
1074: {
1075: int sum = 0;
1076: for (int i = 0; i < getColumnCount(); ++i)
1077: sum += columnModel.getColumn(0).getWidth();
1078: return getColumnCount() == 0 ? 10 : sum / getColumnCount();
1079: }
1080: }
1081:
1082:
1083: public TableCellEditor getCellEditor(int row, int column)
1084: {
1085: TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
1086:
1087: if (editor == null)
1088: editor = getDefaultEditor(dataModel.getColumnClass(column));
1089:
1090: return editor;
1091: }
1092:
1093: public TableCellEditor getDefaultEditor(Class columnClass)
1094: {
1095: if (defaultEditorsByColumnClass.containsKey(columnClass))
1096: return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
1097: else
1098: {
1099:
1100: TableCellEditor r = new DefaultCellEditor(new JTextField());
1101: defaultEditorsByColumnClass.put(columnClass, r);
1102: return r;
1103: }
1104: }
1105:
1106:
1107:
1108: public TableCellRenderer getCellRenderer(int row, int column)
1109: {
1110: TableCellRenderer renderer =
1111: columnModel.getColumn(column).getCellRenderer();
1112:
1113: if (renderer == null)
1114: renderer = getDefaultRenderer(dataModel.getColumnClass(column));
1115:
1116: return renderer;
1117: }
1118:
1119: public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
1120: {
1121: defaultRenderersByColumnClass.put(columnClass, rend);
1122: }
1123:
1124: public TableCellRenderer getDefaultRenderer(Class columnClass)
1125: {
1126: if (defaultRenderersByColumnClass.containsKey(columnClass))
1127: return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
1128: else
1129: {
1130: TableCellRenderer r = new DefaultTableCellRenderer();
1131: defaultRenderersByColumnClass.put(columnClass, r);
1132: return r;
1133: }
1134: }
1135:
1136: public int convertColumnIndexToModel(int vc)
1137: {
1138: if (vc < 0)
1139: return vc;
1140: else
1141: return columnModel.getColumn(vc).getModelIndex();
1142: }
1143:
1144: public int convertColumnIndexToView(int mc)
1145: {
1146: if (mc < 0)
1147: return mc;
1148: int ncols = getColumnCount();
1149: for (int vc = 0; vc < ncols; ++vc)
1150: {
1151: if (columnModel.getColumn(vc).getModelIndex() == mc)
1152: return vc;
1153: }
1154: return -1;
1155: }
1156:
1157: public Component prepareRenderer(TableCellRenderer renderer,
1158: int row,
1159: int column)
1160: {
1161: boolean rsa = getRowSelectionAllowed();
1162: boolean csa = getColumnSelectionAllowed();
1163: boolean rs = rsa ? getSelectionModel().isSelectedIndex(row) : false;
1164: boolean cs = csa ? columnModel.getSelectionModel().isSelectedIndex(column) : false;
1165: boolean isSelected = ((rsa && csa && rs && cs)
1166: || (rsa && !csa && rs)
1167: || (!rsa && csa && cs));
1168:
1169: return renderer.getTableCellRendererComponent(this,
1170: dataModel.getValueAt(row,
1171: convertColumnIndexToModel(column)),
1172: isSelected,
1173: false,
1174: row, column);
1175: }
1176:
1177:
1178:
1183: public boolean getAutoCreateColumnsFromModel()
1184: {
1185: return autoCreateColumnsFromModel;
1186: }
1187:
1188:
1193: public int getAutoResizeMode()
1194: {
1195: return autoResizeMode;
1196: }
1197:
1198:
1203: public int getRowHeight()
1204: {
1205: return rowHeight;
1206: }
1207:
1208:
1213: public int getRowHeight(int row)
1214: {
1215:
1216:
1217: return rowHeight;
1218: }
1219:
1220:
1221:
1226: public int getRowMargin()
1227: {
1228: return rowMargin;
1229: }
1230:
1231:
1236: public boolean getRowSelectionAllowed()
1237: {
1238: return rowSelectionAllowed;
1239: }
1240:
1241:
1246: public boolean getCellSelectionEnabled()
1247: {
1248: return getColumnSelectionAllowed() && getRowSelectionAllowed();
1249: }
1250:
1251:
1256: public TableModel getModel()
1257: {
1258: return dataModel;
1259: }
1260:
1261:
1267: public int getColumnCount()
1268: {
1269: return columnModel.getColumnCount();
1270: }
1271:
1272:
1278: public int getRowCount()
1279: {
1280: return dataModel.getRowCount();
1281: }
1282:
1283:
1288: public TableColumnModel getColumnModel()
1289: {
1290: return columnModel;
1291: }
1292:
1293:
1299: public int getSelectedColumn()
1300: {
1301: return columnModel.getSelectionModel().getMinSelectionIndex();
1302: }
1303:
1304: private static int countSelections(ListSelectionModel lsm)
1305: {
1306: int lo = lsm.getMinSelectionIndex();
1307: int hi = lsm.getMaxSelectionIndex();
1308: int sum = 0;
1309: if (lo != -1 && hi != -1)
1310: {
1311: switch (lsm.getSelectionMode())
1312: {
1313: case ListSelectionModel.SINGLE_SELECTION:
1314: sum = 1;
1315: break;
1316:
1317: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
1318: sum = hi - lo + 1;
1319: break;
1320:
1321: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
1322: for (int i = lo; i <= hi; ++i)
1323: if (lsm.isSelectedIndex(i))
1324: ++sum;
1325: break;
1326: }
1327: }
1328: return sum;
1329: }
1330:
1331: private static int[] getSelections(ListSelectionModel lsm)
1332: {
1333: int sz = countSelections(lsm);
1334: int [] ret = new int[sz];
1335:
1336: int lo = lsm.getMinSelectionIndex();
1337: int hi = lsm.getMaxSelectionIndex();
1338: int j = 0;
1339: java.util.ArrayList ls = new java.util.ArrayList();
1340: if (lo != -1 && hi != -1)
1341: {
1342: switch (lsm.getSelectionMode())
1343: {
1344: case ListSelectionModel.SINGLE_SELECTION:
1345: ret[0] = lo;
1346: break;
1347:
1348: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
1349: for (int i = lo; i <= hi; ++i)
1350: ret[j++] = i;
1351: break;
1352:
1353: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
1354: for (int i = lo; i <= hi; ++i)
1355: if (lsm.isSelectedIndex(i))
1356: ret[j++] = i;
1357: break;
1358: }
1359: }
1360: return ret;
1361: }
1362:
1363:
1369: public int getSelectedColumnCount()
1370: {
1371: return countSelections(columnModel.getSelectionModel());
1372: }
1373:
1374:
1380: public int[] getSelectedColumns()
1381: {
1382: return getSelections(columnModel.getSelectionModel());
1383: }
1384:
1385:
1390: public boolean getColumnSelectionAllowed()
1391: {
1392: return getColumnModel().getColumnSelectionAllowed();
1393: }
1394:
1395:
1401: public int getSelectedRowCount()
1402: {
1403: return countSelections(selectionModel);
1404: }
1405:
1406:
1412: public int[] getSelectedRows()
1413: {
1414: return getSelections(selectionModel);
1415: }
1416:
1417:
1422: public AccessibleContext getAccessibleContext()
1423: {
1424: return accessibleContext;
1425: }
1426:
1427:
1432: public TableCellEditor getCellEditor()
1433: {
1434: return cellEditor;
1435: }
1436:
1437:
1442: public boolean getDragEnabled()
1443: {
1444: return dragEnabled;
1445: }
1446:
1447:
1452: public Color getGridColor()
1453: {
1454: return gridColor;
1455: }
1456:
1457:
1462: public Dimension getIntercellSpacing()
1463: {
1464: return new Dimension(columnModel.getColumnMargin(), rowMargin);
1465: }
1466:
1467:
1472: public Dimension getPreferredScrollableViewportSize()
1473: {
1474: return preferredViewportSize;
1475: }
1476:
1477:
1482: public Color getSelectionBackground()
1483: {
1484: return selectionBackground;
1485: }
1486:
1487:
1492: public Color getSelectionForeground()
1493: {
1494: return selectionForeground;
1495: }
1496:
1497:
1502: public boolean getShowHorizontalLines()
1503: {
1504: return showHorizontalLines;
1505: }
1506:
1507:
1512: public boolean getShowVerticalLines()
1513: {
1514: return showVerticalLines;
1515: }
1516:
1517:
1522: public JTableHeader getTableHeader()
1523: {
1524: return tableHeader;
1525: }
1526:
1527:
1532: public void removeColumn(TableColumn column)
1533: {
1534: columnModel.removeColumn(column);
1535: }
1536:
1537:
1543: public void moveColumn(int column,int targetColumn)
1544: {
1545: columnModel.moveColumn(column, targetColumn);
1546: }
1547:
1548:
1555: public void setAutoCreateColumnsFromModel(boolean autoCreate)
1556: {
1557: if (autoCreateColumnsFromModel != autoCreate)
1558: {
1559: autoCreateColumnsFromModel = autoCreate;
1560: if (autoCreate)
1561: createDefaultColumnsFromModel();
1562: }
1563: }
1564:
1565:
1570: public void setAutoResizeMode(int a)
1571: {
1572: autoResizeMode = a;
1573: revalidate();
1574: repaint();
1575: }
1576:
1577:
1582: public void setRowHeight(int r)
1583: {
1584: if (r < 1)
1585: throw new IllegalArgumentException();
1586:
1587: rowHeight = r;
1588: revalidate();
1589: repaint();
1590: }
1591:
1592:
1599: public void setRowHeight(int row, int rh)
1600: {
1601: setRowHeight(rh);
1602:
1603: }
1604:
1605:
1610: public void setRowMargin(int r)
1611: {
1612: rowMargin = r;
1613: revalidate();
1614: repaint();
1615: }
1616:
1617:
1622: public void setRowSelectionAllowed(boolean r)
1623: {
1624: rowSelectionAllowed = r;
1625: repaint();
1626: }
1627:
1628:
1633: public void setCellSelectionEnabled(boolean c)
1634: {
1635: setColumnSelectionAllowed(c);
1636: setRowSelectionAllowed(c);
1637:
1638: cellSelectionEnabled = true;
1639: }
1640:
1641:
1650: public void setModel(TableModel m)
1651: {
1652:
1653: if (m == null)
1654: throw new IllegalArgumentException();
1655:
1656:
1657: if (dataModel == m)
1658: return;
1659:
1660:
1661: if (dataModel != null)
1662: dataModel.removeTableModelListener(this);
1663:
1664: if (m != null)
1665: {
1666:
1667: dataModel = m;
1668:
1669:
1670: dataModel.addTableModelListener(this);
1671:
1672:
1673: if (autoCreateColumnsFromModel)
1674: createColumnsFromModel();
1675: }
1676:
1677:
1678: revalidate();
1679: repaint();
1680: }
1681:
1682:
1691: public void setColumnModel(TableColumnModel c)
1692: {
1693: if (c == null)
1694: throw new IllegalArgumentException();
1695: TableColumnModel tmp = columnModel;
1696: if (tmp != null)
1697: tmp.removeColumnModelListener(this);
1698: if (c != null)
1699: c.addColumnModelListener(this);
1700: columnModel = c;
1701: if (dataModel != null && columnModel != null)
1702: {
1703: int ncols = getColumnCount();
1704: for (int i = 0; i < ncols; ++i)
1705: columnModel.getColumn(i).setHeaderValue(dataModel.getColumnName(i));
1706: }
1707:
1708:
1709:
1710: if (tableHeader != null)
1711: tableHeader.setColumnModel(c);
1712:
1713: revalidate();
1714: repaint();
1715: }
1716:
1717:
1722: public void setColumnSelectionAllowed(boolean c)
1723: {
1724: getColumnModel().setColumnSelectionAllowed(c);
1725: repaint();
1726: }
1727:
1728:
1737: public void setSelectionModel(ListSelectionModel s)
1738: {
1739: if (s == null)
1740: throw new IllegalArgumentException();
1741: ListSelectionModel tmp = selectionModel;
1742: if (tmp != null)
1743: tmp.removeListSelectionListener(this);
1744: if (s != null)
1745: s.addListSelectionListener(this);
1746: selectionModel = s;
1747: }
1748:
1749:
1756: public void setSelectionMode(int s)
1757: {
1758: selectionModel.setSelectionMode(s);
1759: columnModel.getSelectionModel().setSelectionMode(s);
1760:
1761: repaint();
1762: }
1763:
1764:
1773: public void setCellEditor(TableCellEditor c)
1774: {
1775: TableCellEditor tmp = cellEditor;
1776: if (tmp != null)
1777: tmp.removeCellEditorListener(this);
1778: if (c != null)
1779: c.addCellEditorListener(this);
1780: cellEditor = c;
1781: }
1782:
1783:
1788: public void setDragEnabled(boolean d)
1789: {
1790: dragEnabled = d;
1791: }
1792:
1793:
1798: public void setGridColor(Color g)
1799: {
1800: gridColor = g;
1801: repaint();
1802: }
1803:
1804:
1809: public void setIntercellSpacing(Dimension i)
1810: {
1811: rowMargin = i.height;
1812: columnModel.setColumnMargin(i.width);
1813: repaint();
1814: }
1815:
1816:
1821: public void setPreferredScrollableViewportSize(Dimension p)
1822: {
1823: preferredViewportSize = p;
1824: revalidate();
1825: repaint();
1826: }
1827:
1828:
1837: public void setSelectionBackground(Color s)
1838: {
1839: Color tmp = selectionBackground;
1840: selectionBackground = s;
1841: if (((tmp == null && s != null)
1842: || (s == null && tmp != null)
1843: || (tmp != null && s != null && !tmp.equals(s))))
1844: firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
1845: repaint();
1846: }
1847:
1848:
1857: public void setSelectionForeground(Color s)
1858: {
1859: Color tmp = selectionForeground;
1860: selectionForeground = s;
1861: if (((tmp == null && s != null)
1862: || (s == null && tmp != null)
1863: || (tmp != null && s != null && !tmp.equals(s))))
1864: firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
1865: repaint();
1866: }
1867:
1868:
1873: public void setShowGrid(boolean s)
1874: {
1875: setShowVerticalLines(s);
1876: setShowHorizontalLines(s);
1877: }
1878:
1879:
1884: public void setShowHorizontalLines(boolean s)
1885: {
1886: showHorizontalLines = s;
1887: repaint();
1888: }
1889:
1890:
1895: public void setShowVerticalLines(boolean s)
1896: {
1897: showVerticalLines = s;
1898: repaint();
1899: }
1900:
1901:
1906: public void setTableHeader(JTableHeader t)
1907: {
1908: if (tableHeader != null)
1909: tableHeader.setTable(null);
1910: tableHeader = t;
1911: if (tableHeader != null)
1912: tableHeader.setTable(this);
1913: revalidate();
1914: repaint();
1915: }
1916:
1917: protected void configureEnclosingScrollPane()
1918: {
1919: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
1920: if (jsp != null && tableHeader != null)
1921: {
1922: jsp.setColumnHeaderView(tableHeader);
1923: }
1924: }
1925:
1926: protected void unconfigureEnclosingScrollPane()
1927: {
1928: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
1929: if (jsp != null)
1930: {
1931: jsp.setColumnHeaderView(null);
1932: }
1933: }
1934:
1935:
1936: public void addNotify()
1937: {
1938: super.addNotify();
1939: configureEnclosingScrollPane();
1940: }
1941:
1942: public void removeNotify()
1943: {
1944: super.addNotify();
1945: unconfigureEnclosingScrollPane();
1946: }
1947:
1948:
1949:
1957: private void distributeSpill(TableColumn[] cols, int spill)
1958: {
1959: int average = spill / cols.length;
1960: for (int i = 0; i < cols.length; i++)
1961: {
1962: cols[i].setWidth(cols[i].getWidth() + average);
1963: }
1964: }
1965:
1966: public void doLayout()
1967: {
1968: TableColumn resizingColumn = null;
1969:
1970: int ncols = getColumnCount();
1971: if (ncols < 1)
1972: return;
1973:
1974: int[] pref = new int[ncols];
1975: int prefSum = 0;
1976: int rCol = -1;
1977:
1978: if (tableHeader != null)
1979: resizingColumn = tableHeader.getResizingColumn();
1980:
1981: for (int i = 0; i < ncols; ++i)
1982: {
1983: TableColumn col = columnModel.getColumn(i);
1984: int p = col.getWidth();
1985: pref[i] = p;
1986: prefSum += p;
1987: if (resizingColumn == col)
1988: rCol = i;
1989: }
1990:
1991: int spill = getWidth() - prefSum;
1992:
1993: if (resizingColumn != null)
1994: {
1995: TableColumn col;
1996: TableColumn [] cols;
1997:
1998: switch (getAutoResizeMode())
1999: {
2000: case AUTO_RESIZE_LAST_COLUMN:
2001: col = columnModel.getColumn(ncols-1);
2002: col.setWidth(col.getPreferredWidth() + spill);
2003: break;
2004:
2005: case AUTO_RESIZE_NEXT_COLUMN:
2006: col = columnModel.getColumn(ncols-1);
2007: col.setWidth(col.getPreferredWidth() + spill);
2008: break;
2009:
2010: case AUTO_RESIZE_ALL_COLUMNS:
2011: cols = new TableColumn[ncols];
2012: for (int i = 0; i < ncols; ++i)
2013: cols[i] = columnModel.getColumn(i);
2014: distributeSpill(cols, spill);
2015: break;
2016:
2017: case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
2018: cols = new TableColumn[ncols];
2019: for (int i = rCol; i < ncols; ++i)
2020: cols[i] = columnModel.getColumn(i);
2021: distributeSpill(cols, spill);
2022: break;
2023:
2024: case AUTO_RESIZE_OFF:
2025: default:
2026: }
2027: }
2028: else
2029: {
2030: TableColumn [] cols = new TableColumn[ncols];
2031: for (int i = 0; i < ncols; ++i)
2032: cols[i] = columnModel.getColumn(i);
2033: distributeSpill(cols, spill);
2034: }
2035: }
2036:
2037:
2040: public void sizeColumnsToFit(boolean lastColumnOnly)
2041: {
2042: doLayout();
2043: }
2044:
2045:
2048: public void sizeColumnsToFit(int resizingColumn)
2049: {
2050: doLayout();
2051: }
2052:
2053: public String getUIClassID()
2054: {
2055: return "TableUI";
2056: }
2057:
2058:
2063: public TableUI getUI()
2064: {
2065: return (TableUI) ui;
2066: }
2067:
2068:
2073: public void setUI(TableUI ui)
2074: {
2075: super.setUI(ui);
2076: }
2077:
2078: public void updateUI()
2079: {
2080: setUI((TableUI) UIManager.getUI(this));
2081: revalidate();
2082: repaint();
2083: }
2084:
2085: public Class getColumnClass(int column)
2086: {
2087: return dataModel.getColumnClass(column);
2088: }
2089:
2090: public String getColumnName(int column)
2091: {
2092: int modelColumn = columnModel.getColumn(column).getModelIndex();
2093: return dataModel.getColumnName(modelColumn);
2094: }
2095:
2096: public int getEditingColumn()
2097: {
2098: return editingColumn;
2099: }
2100:
2101: public void setEditingColumn(int column)
2102: {
2103: editingColumn = column;
2104: }
2105:
2106: public int getEditingRow()
2107: {
2108: return editingRow;
2109: }
2110:
2111: public void setEditingRow(int column)
2112: {
2113: editingRow = column;
2114: }
2115:
2116: public Component getEditorComponent()
2117: {
2118: return editorComp;
2119: }
2120:
2121: public boolean isEditing()
2122: {
2123: return editorComp != null;
2124: }
2125:
2126: public void setDefaultEditor(Class columnClass, TableCellEditor editor)
2127: {
2128: if (editor != null)
2129: defaultEditorsByColumnClass.put(columnClass, editor);
2130: else
2131: defaultEditorsByColumnClass.remove(columnClass);
2132: }
2133:
2134: public void addColumnSelectionInterval(int index0, int index1)
2135: {
2136: if ((index0 < 0 || index0 > (getColumnCount()-1)
2137: || index1 < 0 || index1 > (getColumnCount()-1)))
2138: throw new IllegalArgumentException("Column index out of range.");
2139:
2140: getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
2141: }
2142:
2143: public void addRowSelectionInterval(int index0, int index1)
2144: {
2145: if ((index0 < 0 || index0 > (getRowCount()-1)
2146: || index1 < 0 || index1 > (getRowCount()-1)))
2147: throw new IllegalArgumentException("Row index out of range.");
2148:
2149: getSelectionModel().addSelectionInterval(index0, index1);
2150: }
2151:
2152: public void setColumnSelectionInterval(int index0, int index1)
2153: {
2154: if ((index0 < 0 || index0 > (getColumnCount()-1)
2155: || index1 < 0 || index1 > (getColumnCount()-1)))
2156: throw new IllegalArgumentException("Column index out of range.");
2157:
2158: getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
2159: }
2160:
2161: public void setRowSelectionInterval(int index0, int index1)
2162: {
2163: if ((index0 < 0 || index0 > (getRowCount()-1)
2164: || index1 < 0 || index1 > (getRowCount()-1)))
2165: throw new IllegalArgumentException("Row index out of range.");
2166:
2167: getSelectionModel().setSelectionInterval(index0, index1);
2168: }
2169:
2170: public void removeColumnSelectionInterval(int index0, int index1)
2171: {
2172: if ((index0 < 0 || index0 > (getColumnCount()-1)
2173: || index1 < 0 || index1 > (getColumnCount()-1)))
2174: throw new IllegalArgumentException("Column index out of range.");
2175:
2176: getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
2177: }
2178:
2179: public void removeRowSelectionInterval(int index0, int index1)
2180: {
2181: if ((index0 < 0 || index0 > (getRowCount()-1)
2182: || index1 < 0 || index1 > (getRowCount()-1)))
2183: throw new IllegalArgumentException("Row index out of range.");
2184:
2185: getSelectionModel().removeSelectionInterval(index0, index1);
2186: }
2187:
2188: public boolean isColumnSelected(int column)
2189: {
2190: return getColumnModel().getSelectionModel().isSelectedIndex(column);
2191: }
2192:
2193: public boolean isRowSelected(int row)
2194: {
2195: return getSelectionModel().isSelectedIndex(row);
2196: }
2197:
2198: public boolean isCellSelected(int row, int column)
2199: {
2200: return isRowSelected(row) && isColumnSelected(column);
2201: }
2202:
2203: public void selectAll()
2204: {
2205:
2206: int rowLead = selectionModel.getLeadSelectionIndex();
2207: int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
2208:
2209:
2210: setColumnSelectionInterval(0, getColumnCount() - 1);
2211: setRowSelectionInterval(0, getRowCount() - 1);
2212:
2213:
2214: addColumnSelectionInterval(colLead,colLead);
2215: addRowSelectionInterval(rowLead, rowLead);
2216: }
2217:
2218: public Object getValueAt(int row, int column)
2219: {
2220: return dataModel.getValueAt(row, convertColumnIndexToModel(column));
2221: }
2222:
2223: public void setValueAt(Object value, int row, int column)
2224: {
2225: if (!isCellEditable(row, column))
2226: return;
2227:
2228: if (value instanceof Component)
2229: add((Component)value);
2230: dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
2231: }
2232:
2233: public TableColumn getColumn(Object identifier)
2234: {
2235: return columnModel.getColumn(columnModel.getColumnIndex(identifier));
2236: }
2237:
2238:
2247: public boolean isCellEditable(int row, int column)
2248: {
2249: return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
2250: }
2251:
2252:
2259: public void createDefaultColumnsFromModel()
2260: {
2261:
2262: int columnIndex = columnModel.getColumnCount() - 1;
2263: while (columnIndex >= 0)
2264: {
2265: columnModel.removeColumn(columnModel.getColumn(columnIndex));
2266: columnIndex--;
2267: }
2268:
2269:
2270: int columnCount = dataModel.getColumnCount();
2271: for (int c = 0; c < columnCount; c++)
2272: {
2273: TableColumn column = new TableColumn(c);
2274: column.setIdentifier(dataModel.getColumnName(c));
2275: columnModel.addColumn(column);
2276: }
2277: }
2278:
2279: public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
2280: {
2281: if (toggle && extend)
2282: {
2283:
2284:
2285: selectionModel.setAnchorSelectionIndex(rowIndex);
2286: getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
2287: }
2288: else if (toggle)
2289: {
2290:
2291: if (isCellSelected(rowIndex,columnIndex))
2292: {
2293: selectionModel.removeSelectionInterval(rowIndex,rowIndex);
2294: getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
2295: }
2296: else
2297: {
2298: selectionModel.addSelectionInterval(rowIndex,rowIndex);
2299: getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
2300: }
2301: }
2302: else if (extend)
2303: {
2304:
2305:
2306: selectionModel.setLeadSelectionIndex(rowIndex);
2307: getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
2308: }
2309: else
2310: {
2311:
2312:
2313: selectionModel.clearSelection();
2314: selectionModel.setSelectionInterval(rowIndex,rowIndex);
2315: getColumnModel().getSelectionModel().clearSelection();
2316: getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
2317:
2318:
2319: }
2320: }
2321:
2322:
2328: public boolean editCellAt (int row, int column)
2329: {
2330: oldCellValue = getValueAt(row, column);
2331: setCellEditor(getCellEditor(row, column));
2332: editorComp = prepareEditor(cellEditor, row, column);
2333: cellEditor.addCellEditorListener(this);
2334: rowBeingEdited = row;
2335: columnBeingEdited = column;
2336: setValueAt(editorComp, row, column);
2337: ((JTextField)editorComp).requestFocusInWindow(false);
2338: editorTimer.start();
2339: return true;
2340: }
2341:
2342:
2348: public boolean editCellAt (int row, int column, EventObject e)
2349: {
2350: return editCellAt(row, column);
2351: }
2352:
2353:
2356: public void removeEditor()
2357: {
2358: editingStopped(new ChangeEvent(this));
2359: }
2360:
2361:
2370: public Component prepareEditor (TableCellEditor editor, int row, int column)
2371: {
2372: return editor.getTableCellEditorComponent
2373: (this, getValueAt(row, column), isCellSelected(row, column), row, column);
2374: }
2375: }