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: import ;
57: import ;
58: import ;
59:
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: import ;
79: import ;
80: import ;
81: import ;
82: import ;
83: import ;
84: import ;
85: import ;
86: import ;
87: import ;
88:
89:
98: public class JTable
99: extends JComponent
100: implements TableModelListener, Scrollable, TableColumnModelListener,
101: ListSelectionListener, CellEditorListener, Accessible
102: {
103:
108: protected class AccessibleJTable
109: extends AccessibleJComponent
110: implements AccessibleSelection, ListSelectionListener, TableModelListener,
111: TableColumnModelListener, CellEditorListener, PropertyChangeListener,
112: AccessibleExtendedTable
113: {
114:
115:
120: protected class AccessibleJTableCell
121: extends AccessibleContext
122: implements Accessible, AccessibleComponent
123: {
124:
125:
128: private JTable table;
129:
130:
133: private int row;
134:
135:
138: private int column;
139:
140:
143: private int index;
144:
145:
153: public AccessibleJTableCell(JTable t, int r, int c, int i)
154: {
155: table = t;
156: row = r;
157: column = c;
158: index = i;
159: }
160:
161:
166: public AccessibleRole getAccessibleRole()
167: {
168:
169:
170:
171: return AccessibleRole.UNKNOWN;
172: }
173:
174:
179: public AccessibleStateSet getAccessibleStateSet()
180: {
181: AccessibleStateSet state = new AccessibleStateSet();
182:
183:
184: Rectangle visibleRect = getVisibleRect();
185: Rectangle cellRect = getCellRect(row, column, false);
186: if (visibleRect.intersects(cellRect))
187: state.add(AccessibleState.SHOWING);
188:
189:
190: if (isCellSelected(row, column))
191: state.add(AccessibleState.SELECTED);
192:
193:
194: if (row == getSelectedRow() && column == getSelectedColumn())
195: state.add(AccessibleState.ACTIVE);
196:
197:
198: state.add(AccessibleState.TRANSIENT);
199:
200:
201: return state;
202: }
203:
204:
209: public int getAccessibleIndexInParent()
210: {
211: return index;
212: }
213:
214:
220: public int getAccessibleChildrenCount()
221: {
222: return 0;
223: }
224:
225:
231: public Accessible getAccessibleChild(int i)
232: {
233: return null;
234: }
235:
236:
241: public Locale getLocale()
242: {
243:
244:
245: return Locale.ENGLISH;
246: }
247:
248:
255: public AccessibleContext getAccessibleContext()
256: {
257: return this;
258: }
259:
260:
265: public Color getBackground()
266: {
267: return table.getBackground();
268: }
269:
270:
277: public void setBackground(Color color)
278: {
279:
280: }
281:
282:
287: public Color getForeground()
288: {
289: return table.getForeground();
290: }
291:
292:
299: public void setForeground(Color color)
300: {
301:
302: }
303:
304:
309: public Cursor getCursor()
310: {
311: return table.getCursor();
312: }
313:
314:
321: public void setCursor(Cursor cursor)
322: {
323:
324: }
325:
326:
331: public Font getFont()
332: {
333: return table.getFont();
334: }
335:
336:
343: public void setFont(Font font)
344: {
345:
346: }
347:
348:
355: public FontMetrics getFontMetrics(Font font)
356: {
357: return table.getFontMetrics(font);
358: }
359:
360:
367: public boolean isEnabled()
368: {
369: return table.isEnabled();
370: }
371:
372:
378: public void setEnabled(boolean b)
379: {
380:
381: }
382:
383:
390: public boolean isVisible()
391: {
392: return table.isVisible();
393: }
394:
395:
401: public void setVisible(boolean b)
402: {
403:
404: }
405:
406:
413: public boolean isShowing()
414: {
415: return table.isShowing();
416: }
417:
418:
427: public boolean contains(Point point)
428: {
429: Rectangle cellRect = table.getCellRect(row, column, true);
430: cellRect.x = 0;
431: cellRect.y = 0;
432: return cellRect.contains(point);
433: }
434:
435:
440: public Point getLocationOnScreen()
441: {
442: Point tableLoc = table.getLocationOnScreen();
443: Rectangle cellRect = table.getCellRect(row, column, true);
444: tableLoc.x += cellRect.x;
445: tableLoc.y += cellRect.y;
446: return tableLoc;
447: }
448:
449:
454: public Point getLocation()
455: {
456: Rectangle cellRect = table.getCellRect(row, column, true);
457: return new Point(cellRect.x, cellRect.y);
458: }
459:
460:
466: public void setLocation(Point point)
467: {
468:
469: }
470:
471:
476: public Rectangle getBounds()
477: {
478: return table.getCellRect(row, column, true);
479: }
480:
481:
487: public void setBounds(Rectangle rectangle)
488: {
489:
490: }
491:
492:
497: public Dimension getSize()
498: {
499: Rectangle cellRect = table.getCellRect(row, column, true);
500: return new Dimension(cellRect.width, cellRect.height);
501: }
502:
503:
509: public void setSize(Dimension dimension)
510: {
511:
512: }
513:
514:
519: public Accessible getAccessibleAt(Point point)
520: {
521: return null;
522: }
523:
524:
531: public boolean isFocusTraversable()
532: {
533: return table.isFocusable();
534: }
535:
536:
539: public void requestFocus()
540: {
541:
542: table.getColumnModel().getSelectionModel()
543: .setLeadSelectionIndex(column);
544: table.getSelectionModel().setLeadSelectionIndex(row);
545:
546: table.requestFocus();
547: }
548:
549:
556: public void addFocusListener(FocusListener listener)
557: {
558: table.addFocusListener(listener);
559: }
560:
561:
567: public void removeFocusListener(FocusListener listener)
568: {
569: table.removeFocusListener(listener);
570: }
571:
572: }
573:
574: protected class AccessibleJTableModelChange
575: implements AccessibleTableModelChange
576: {
577: protected int type;
578: protected int firstRow;
579: protected int lastRow;
580: protected int firstColumn;
581: protected int lastColumn;
582:
583: protected AccessibleJTableModelChange(int type, int firstRow,
584: int lastRow, int firstColumn,
585: int lastColumn)
586: {
587: this.type = type;
588: this.firstRow = firstRow;
589: this.lastRow = lastRow;
590: this.firstColumn = firstColumn;
591: this.lastColumn = lastColumn;
592: }
593:
594: public int getType()
595: {
596: return type;
597: }
598:
599: public int getFirstRow()
600: {
601: return firstRow;
602: }
603:
604: public int getLastRow()
605: {
606: return lastRow;
607: }
608:
609: public int getFirstColumn()
610: {
611: return firstColumn;
612: }
613:
614: public int getLastColumn()
615: {
616: return lastColumn;
617: }
618: }
619:
620:
625: private class AccessibleTableHeader
626: implements AccessibleTable
627: {
628:
629:
632: private JTableHeader header;
633:
634:
639: private AccessibleTableHeader(JTableHeader h)
640: {
641: header = h;
642: }
643:
644:
649: public Accessible getAccessibleCaption()
650: {
651:
652: return null;
653: }
654:
655:
660: public void setAccessibleCaption(Accessible caption)
661: {
662:
663: }
664:
665:
670: public Accessible getAccessibleSummary()
671: {
672:
673: return null;
674: }
675:
676:
681: public void setAccessibleSummary(Accessible summary)
682: {
683:
684: }
685:
686:
691: public int getAccessibleRowCount()
692: {
693: return 1;
694: }
695:
696:
701: public int getAccessibleColumnCount()
702: {
703: return header.getColumnModel().getColumnCount();
704: }
705:
706:
717: public Accessible getAccessibleAt(int r, int c)
718: {
719: TableColumn column = header.getColumnModel().getColumn(c);
720: TableCellRenderer rend = column.getHeaderRenderer();
721: if (rend == null)
722: rend = header.getDefaultRenderer();
723: Component comp =
724: rend.getTableCellRendererComponent(header.getTable(),
725: column.getHeaderValue(), false,
726: false, -1, c);
727: return new AccessibleJTableHeaderCell(header, comp, r, c);
728: }
729:
730: public int getAccessibleRowExtentAt(int r, int c)
731: {
732:
733: return 0;
734: }
735:
736: public int getAccessibleColumnExtentAt(int r, int c)
737: {
738:
739: return 0;
740: }
741:
742: public AccessibleTable getAccessibleRowHeader()
743: {
744:
745: return null;
746: }
747:
748: public void setAccessibleRowHeader(AccessibleTable header)
749: {
750:
751:
752: }
753:
754: public AccessibleTable getAccessibleColumnHeader()
755: {
756:
757: return null;
758: }
759:
760: public void setAccessibleColumnHeader(AccessibleTable header)
761: {
762:
763:
764: }
765:
766: public Accessible getAccessibleRowDescription(int r)
767: {
768:
769: return null;
770: }
771:
772: public void setAccessibleRowDescription(int r, Accessible description)
773: {
774:
775:
776: }
777:
778: public Accessible getAccessibleColumnDescription(int c)
779: {
780:
781: return null;
782: }
783:
784: public void setAccessibleColumnDescription(int c, Accessible description)
785: {
786:
787:
788: }
789:
790: public boolean isAccessibleSelected(int r, int c)
791: {
792:
793: return false;
794: }
795:
796: public boolean isAccessibleRowSelected(int r)
797: {
798:
799: return false;
800: }
801:
802: public boolean isAccessibleColumnSelected(int c)
803: {
804:
805: return false;
806: }
807:
808: public int[] getSelectedAccessibleRows()
809: {
810:
811: return null;
812: }
813:
814: public int[] getSelectedAccessibleColumns()
815: {
816:
817: return null;
818: }
819:
820: }
821:
822:
827: private class AccessibleJTableHeaderCell
828: extends AccessibleContext
829: implements Accessible, AccessibleComponent
830: {
831:
832: JTableHeader header;
833:
834: int columnIndex;
835:
836:
843: private AccessibleJTableHeaderCell(JTableHeader h, Component comp, int r,
844: int c)
845: {
846: header = h;
847: columnIndex = c;
848: }
849:
850:
855: Component getColumnHeaderRenderer()
856: {
857: TableColumn tc = header.getColumnModel().getColumn(columnIndex);
858: TableCellRenderer r = tc.getHeaderRenderer();
859: if (r == null)
860: r = header.getDefaultRenderer();
861: return r.getTableCellRendererComponent(header.getTable(),
862: tc.getHeaderValue(), false, false, -1, columnIndex);
863: }
864:
865:
870: public AccessibleRole getAccessibleRole()
871: {
872: Component renderer = getColumnHeaderRenderer();
873: if (renderer instanceof Accessible)
874: {
875: Accessible ac = (Accessible) renderer;
876: return ac.getAccessibleContext().getAccessibleRole();
877: }
878: return null;
879: }
880:
881: public AccessibleStateSet getAccessibleStateSet()
882: {
883:
884: return null;
885: }
886:
887: public int getAccessibleIndexInParent()
888: {
889:
890: return 0;
891: }
892:
893: public int getAccessibleChildrenCount()
894: {
895:
896: return 0;
897: }
898:
899: public Accessible getAccessibleChild(int i)
900: {
901:
902: return null;
903: }
904:
905: public Locale getLocale()
906: {
907:
908: return null;
909: }
910:
911:
916: public AccessibleContext getAccessibleContext()
917: {
918: return this;
919: }
920:
921: public Color getBackground()
922: {
923:
924: return null;
925: }
926:
927: public void setBackground(Color color)
928: {
929:
930:
931: }
932:
933: public Color getForeground()
934: {
935:
936: return null;
937: }
938:
939: public void setForeground(Color color)
940: {
941:
942:
943: }
944:
945: public Cursor getCursor()
946: {
947:
948: return null;
949: }
950:
951: public void setCursor(Cursor cursor)
952: {
953:
954:
955: }
956:
957: public Font getFont()
958: {
959:
960: return null;
961: }
962:
963: public void setFont(Font font)
964: {
965:
966:
967: }
968:
969: public FontMetrics getFontMetrics(Font font)
970: {
971:
972: return null;
973: }
974:
975: public boolean isEnabled()
976: {
977:
978: return false;
979: }
980:
981: public void setEnabled(boolean b)
982: {
983:
984:
985: }
986:
987: public boolean isVisible()
988: {
989:
990: return false;
991: }
992:
993: public void setVisible(boolean b)
994: {
995:
996:
997: }
998:
999: public boolean isShowing()
1000: {
1001:
1002: return false;
1003: }
1004:
1005: public boolean contains(Point point)
1006: {
1007:
1008: return false;
1009: }
1010:
1011: public Point getLocationOnScreen()
1012: {
1013:
1014: return null;
1015: }
1016:
1017: public Point getLocation()
1018: {
1019:
1020: return null;
1021: }
1022:
1023: public void setLocation(Point point)
1024: {
1025:
1026:
1027: }
1028:
1029: public Rectangle getBounds()
1030: {
1031:
1032: return null;
1033: }
1034:
1035: public void setBounds(Rectangle rectangle)
1036: {
1037:
1038:
1039: }
1040:
1041: public Dimension getSize()
1042: {
1043:
1044: return null;
1045: }
1046:
1047: public void setSize(Dimension dimension)
1048: {
1049:
1050:
1051: }
1052:
1053: public Accessible getAccessibleAt(Point point)
1054: {
1055:
1056: return null;
1057: }
1058:
1059: public boolean isFocusTraversable()
1060: {
1061:
1062: return false;
1063: }
1064:
1065: public void requestFocus()
1066: {
1067:
1068:
1069: }
1070:
1071: public void addFocusListener(FocusListener listener)
1072: {
1073:
1074:
1075: }
1076:
1077: public void removeFocusListener(FocusListener listener)
1078: {
1079:
1080:
1081: }
1082:
1083: }
1084:
1085:
1089: private int lastSelectedRow;
1090:
1091:
1095: private int lastSelectedColumn;
1096:
1097:
1100: private Accessible caption;
1101:
1102:
1105: private Accessible summary;
1106:
1107:
1110: private Accessible[] rowDescriptions;
1111:
1112:
1115: private Accessible[] columnDescriptions;
1116:
1117:
1122: protected AccessibleJTable()
1123: {
1124: getModel().addTableModelListener(this);
1125: getSelectionModel().addListSelectionListener(this);
1126: getColumnModel().addColumnModelListener(this);
1127: lastSelectedRow = getSelectedRow();
1128: lastSelectedColumn = getSelectedColumn();
1129: TableCellEditor editor = getCellEditor();
1130: if (editor != null)
1131: editor.addCellEditorListener(this);
1132: }
1133:
1134:
1139: public AccessibleRole getAccessibleRole()
1140: {
1141: return AccessibleRole.TABLE;
1142: }
1143:
1144:
1149: public AccessibleTable getAccessibleTable()
1150: {
1151: return this;
1152: }
1153:
1154:
1157: public int getAccessibleSelectionCount()
1158: {
1159: return getSelectedColumnCount();
1160: }
1161:
1162:
1172: public Accessible getAccessibleSelection(int i)
1173: {
1174: Accessible found = null;
1175:
1176: int[] selectedRows = getSelectedRows();
1177: int[] selectedColumns = getSelectedColumns();
1178: int numCols = getColumnCount();
1179: int numRows = getRowCount();
1180:
1181:
1182:
1183:
1184: if (getRowSelectionAllowed() && getColumnSelectionAllowed())
1185: {
1186: int current = -1;
1187: int newIndex = current;
1188: int lastSelectedRow = -1;
1189:
1190:
1191: for (int j = 0; i < selectedRows.length; i++)
1192: {
1193:
1194:
1195: int selectedRow = selectedRows[j];
1196: int r = -1;
1197: int ci = -1;
1198: for (r = lastSelectedRow + 1;
1199: r < selectedRow && current < i; r++)
1200: {
1201: for (ci = 0; ci < selectedColumns.length && current < i;
1202: ci++)
1203: {
1204: current++;
1205: }
1206: }
1207: if (current == i)
1208: {
1209:
1210: found = getAccessibleChild(r * numCols
1211: + selectedColumns[ci]);
1212: break;
1213: }
1214:
1215:
1216: if (current < i && current + numCols >= i)
1217: {
1218:
1219: found = getAccessibleChild(r * numCols + (i - current));
1220: break;
1221: }
1222: current += numCols;
1223: }
1224: if (found == null)
1225: {
1226:
1227: int r = 0;
1228: int ci = 0;
1229: for (r = lastSelectedRow + 1;
1230: r < numRows && current < i; r++)
1231: {
1232: for (ci = 0; ci < selectedColumns.length && current < i;
1233: ci++)
1234: {
1235: current++;
1236: }
1237: }
1238: if (current == i)
1239: {
1240:
1241: found = getAccessibleChild(r * numCols
1242: + selectedColumns[ci]);
1243: }
1244: }
1245: }
1246:
1247: else if (getRowSelectionAllowed())
1248: {
1249: int c = i % numCols;
1250: int r = selectedRows[i / numCols];
1251: found = getAccessibleChild(r * numCols + c);
1252: }
1253:
1254: else if (getRowSelectionAllowed())
1255: {
1256: int numSelectedColumns = selectedColumns.length;
1257: int c = selectedColumns[i % numSelectedColumns];
1258: int r = i / numSelectedColumns;
1259: found = getAccessibleChild(r * numCols + c);
1260: }
1261:
1262: return found;
1263: }
1264:
1265:
1274: public boolean isAccessibleChildSelected(int i)
1275: {
1276: int r = getAccessibleRowAtIndex(i);
1277: int c = getAccessibleColumnAtIndex(i);
1278: return isCellSelected(r, c);
1279: }
1280:
1281:
1287: public void addAccessibleSelection(int i)
1288: {
1289: int r = getAccessibleRowAtIndex(i);
1290: int c = getAccessibleColumnAtIndex(i);
1291: changeSelection(r, c, true, false);
1292: }
1293:
1294:
1302: public void removeAccessibleSelection(int i)
1303: {
1304: if (! getRowSelectionAllowed() && ! getColumnSelectionAllowed())
1305: {
1306: int r = getAccessibleRowAtIndex(i);
1307: int c = getAccessibleColumnAtIndex(i);
1308: removeRowSelectionInterval(r, r);
1309: removeColumnSelectionInterval(c, c);
1310: }
1311: }
1312:
1313:
1316: public void clearAccessibleSelection()
1317: {
1318: clearSelection();
1319: }
1320:
1321:
1326: public void selectAllAccessibleSelection()
1327: {
1328: selectAll();
1329: }
1330:
1331:
1337: public void valueChanged(ListSelectionEvent event)
1338: {
1339: firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
1340: Boolean.FALSE, Boolean.TRUE);
1341: int r = getSelectedRow();
1342: int c = getSelectedColumn();
1343: if (r != lastSelectedRow || c != lastSelectedColumn)
1344: {
1345: Accessible o = getAccessibleAt(lastSelectedRow,
1346: lastSelectedColumn);
1347: Accessible n = getAccessibleAt(r, c);
1348: firePropertyChange(AccessibleContext
1349: .ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY, o, n);
1350: lastSelectedRow = r;
1351: lastSelectedColumn = c;
1352: }
1353: }
1354:
1355:
1362: public void tableChanged(TableModelEvent event)
1363: {
1364: switch (event.getType())
1365: {
1366: case TableModelEvent.INSERT:
1367: tableRowsInserted(event);
1368: break;
1369: case TableModelEvent.DELETE:
1370: tableRowsDeleted(event);
1371: break;
1372: }
1373: }
1374:
1375:
1381: public void tableRowsInserted(TableModelEvent event)
1382: {
1383: handleRowChange(event);
1384: }
1385:
1386:
1392: public void tableRowsDeleted(TableModelEvent event)
1393: {
1394: handleRowChange(event);
1395: }
1396:
1397:
1402: private void handleRowChange(TableModelEvent event)
1403: {
1404: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1405: null, null);
1406: int firstColumn = event.getColumn();
1407: int lastColumn = event.getColumn();
1408: if (firstColumn == TableModelEvent.ALL_COLUMNS)
1409: {
1410: firstColumn = 0;
1411: lastColumn = getColumnCount() - 1;
1412: }
1413: AccessibleJTableModelChange change = new AccessibleJTableModelChange
1414: (event.getType(), event.getFirstRow(), event.getLastRow(),
1415: firstColumn, lastColumn);
1416: firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
1417: null, change);
1418: }
1419:
1420: public void columnAdded(TableColumnModelEvent event)
1421: {
1422: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1423: null, null);
1424: handleColumnChange(AccessibleTableModelChange.INSERT,
1425: event.getFromIndex(), event.getToIndex());
1426: }
1427:
1428: public void columnRemoved(TableColumnModelEvent event)
1429: {
1430: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1431: null, null);
1432: handleColumnChange(AccessibleTableModelChange.DELETE,
1433: event.getFromIndex(), event.getToIndex());
1434: }
1435:
1436: public void columnMoved(TableColumnModelEvent event)
1437: {
1438: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1439: null, null);
1440: handleColumnChange(AccessibleTableModelChange.DELETE,
1441: event.getFromIndex(), event.getFromIndex());
1442: handleColumnChange(AccessibleTableModelChange.INSERT,
1443: event.getFromIndex(), event.getToIndex());
1444: }
1445:
1446:
1453: private void handleColumnChange(int type, int from, int to)
1454: {
1455: AccessibleJTableModelChange change =
1456: new AccessibleJTableModelChange(type, 0, 0, from, to);
1457: firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
1458: null, change);
1459: }
1460:
1461: public void columnMarginChanged(ChangeEvent event)
1462: {
1463: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1464: null, null);
1465: }
1466:
1467: public void columnSelectionChanged(ListSelectionEvent event)
1468: {
1469:
1470: }
1471:
1472: public void editingCanceled(ChangeEvent event)
1473: {
1474:
1475: }
1476:
1477: public void editingStopped(ChangeEvent event)
1478: {
1479: firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1480: null, null);
1481: }
1482:
1483:
1490: public void propertyChange(PropertyChangeEvent e)
1491: {
1492: String propName = e.getPropertyName();
1493: if (propName.equals("tableModel"))
1494: {
1495: TableModel oldModel = (TableModel) e.getOldValue();
1496: oldModel.removeTableModelListener(this);
1497: TableModel newModel = (TableModel) e.getNewValue();
1498: newModel.addTableModelListener(this);
1499: }
1500: else if (propName.equals("columnModel"))
1501: {
1502: TableColumnModel oldModel = (TableColumnModel) e.getOldValue();
1503: oldModel.removeColumnModelListener(this);
1504: TableColumnModel newModel = (TableColumnModel) e.getNewValue();
1505: newModel.addColumnModelListener(this);
1506: }
1507: else if (propName.equals("selectionModel"))
1508: {
1509: ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue();
1510: oldModel.removeListSelectionListener(this);
1511: ListSelectionModel newModel = (ListSelectionModel) e.getNewValue();
1512: newModel.addListSelectionListener(this);
1513: }
1514: else if (propName.equals("cellEditor"))
1515: {
1516: CellEditor oldEd = (CellEditor) e.getOldValue();
1517: oldEd.removeCellEditorListener(this);
1518: CellEditor newEd = (CellEditor) e.getNewValue();
1519: newEd.addCellEditorListener(this);
1520: }
1521: }
1522:
1523:
1532: public int getAccessibleRow(int index)
1533: {
1534: return getAccessibleRowAtIndex(index);
1535: }
1536:
1537:
1546: public int getAccessibleColumn(int index)
1547: {
1548: return getAccessibleColumnAtIndex(index);
1549: }
1550:
1551:
1561: public int getAccessibleIndex(int r, int c)
1562: {
1563: return getAccessibleIndexAt(r, c);
1564: }
1565:
1566:
1573: public Accessible getAccessibleCaption()
1574: {
1575: return caption;
1576: }
1577:
1578:
1583: public void setAccessibleCaption(Accessible c)
1584: {
1585: caption = c;
1586: }
1587:
1588:
1593: public Accessible getAccessibleSummary()
1594: {
1595: return summary;
1596: }
1597:
1598:
1603: public void setAccessibleSummary(Accessible s)
1604: {
1605: summary = s;
1606: }
1607:
1608:
1613: public int getAccessibleRowCount()
1614: {
1615: return getRowCount();
1616: }
1617:
1618:
1623: public int getAccessibleColumnCount()
1624: {
1625: return getColumnCount();
1626: }
1627:
1628:
1635: public Accessible getAccessibleChild(int index)
1636: {
1637: int r = getAccessibleRow(index);
1638: int c = getAccessibleColumn(index);
1639: return getAccessibleAt(r, c);
1640: }
1641:
1642:
1652: public Accessible getAccessibleAt(int r, int c)
1653: {
1654: TableCellRenderer cellRenderer = getCellRenderer(r, c);
1655: Component renderer = cellRenderer.getTableCellRendererComponent(
1656: JTable.this, getValueAt(r, c), isCellSelected(r, c), false, r, c);
1657: if (renderer instanceof Accessible)
1658: return (Accessible) renderer;
1659: return null;
1660: }
1661:
1662:
1672: public int getAccessibleRowExtentAt(int r, int c)
1673: {
1674: return 1;
1675: }
1676:
1677:
1687: public int getAccessibleColumnExtentAt(int r, int c)
1688: {
1689: return 1;
1690: }
1691:
1692:
1697: public AccessibleTable getAccessibleRowHeader()
1698: {
1699:
1700: return null;
1701: }
1702:
1703:
1708: public void setAccessibleRowHeader(AccessibleTable header)
1709: {
1710:
1711: }
1712:
1713:
1719: public AccessibleTable getAccessibleColumnHeader()
1720: {
1721: JTableHeader h = getTableHeader();
1722: AccessibleTable header = null;
1723: if (h != null)
1724: header = new AccessibleTableHeader(h);
1725: return header;
1726: }
1727:
1728:
1734: public void setAccessibleColumnHeader(AccessibleTable header)
1735: {
1736:
1737: }
1738:
1739:
1748: public Accessible getAccessibleRowDescription(int r)
1749: {
1750: Accessible descr = null;
1751: if (rowDescriptions != null)
1752: descr = rowDescriptions[r];
1753: return descr;
1754: }
1755:
1756:
1762: public void setAccessibleRowDescription(int r, Accessible description)
1763: {
1764: if (rowDescriptions == null)
1765: rowDescriptions = new Accessible[getAccessibleRowCount()];
1766: rowDescriptions[r] = description;
1767: }
1768:
1769:
1778: public Accessible getAccessibleColumnDescription(int c)
1779: {
1780: Accessible descr = null;
1781: if (columnDescriptions != null)
1782: descr = columnDescriptions[c];
1783: return descr;
1784: }
1785:
1786:
1792: public void setAccessibleColumnDescription(int c, Accessible description)
1793: {
1794: if (columnDescriptions == null)
1795: columnDescriptions = new Accessible[getAccessibleRowCount()];
1796: columnDescriptions[c] = description;
1797: }
1798:
1799:
1809: public boolean isAccessibleSelected(int r, int c)
1810: {
1811: return isCellSelected(r, c);
1812: }
1813:
1814:
1823: public boolean isAccessibleRowSelected(int r)
1824: {
1825: return isRowSelected(r);
1826: }
1827:
1828:
1837: public boolean isAccessibleColumnSelected(int c)
1838: {
1839: return isColumnSelected(c);
1840: }
1841:
1842:
1847: public int[] getSelectedAccessibleRows()
1848: {
1849: return getSelectedRows();
1850: }
1851:
1852:
1857: public int[] getSelectedAccessibleColumns()
1858: {
1859: return getSelectedColumns();
1860: }
1861:
1862:
1869: public int getAccessibleRowAtIndex(int index)
1870: {
1871:
1872: return index / getColumnCount();
1873: }
1874:
1875:
1882: public int getAccessibleColumnAtIndex(int index)
1883: {
1884:
1885: return index % getColumnCount();
1886: }
1887:
1888:
1897: public int getAccessibleIndexAt(int row, int column)
1898: {
1899:
1900: return row * getColumnCount() + column;
1901: }
1902: }
1903:
1910: class TableColumnPropertyChangeHandler implements PropertyChangeListener
1911: {
1912:
1918: public void propertyChange(PropertyChangeEvent ev)
1919: {
1920: if (ev.getPropertyName().equals("preferredWidth"))
1921: {
1922: JTableHeader header = getTableHeader();
1923: if (header != null)
1924:
1925: if (header.getResizingColumn() == null)
1926: {
1927: TableColumn col = (TableColumn) ev.getSource();
1928: header.setResizingColumn(col);
1929: doLayout();
1930: header.setResizingColumn(null);
1931: }
1932: }
1933: }
1934: }
1935:
1936:
1939: private class BooleanCellRenderer
1940: extends DefaultTableCellRenderer
1941: {
1942:
1945: private final JCheckBox checkBox;
1946:
1947:
1951: BooleanCellRenderer()
1952: {
1953: checkBox = new JCheckBox();
1954: checkBox.setHorizontalAlignment(SwingConstants.CENTER);
1955: }
1956:
1957:
1960: JCheckBox getCheckBox()
1961: {
1962: return checkBox;
1963: }
1964:
1965:
1976: public Component getTableCellRendererComponent(JTable table, Object value,
1977: boolean isSelected,
1978: boolean hasFocus, int row,
1979: int column)
1980: {
1981: if (isSelected)
1982: {
1983: checkBox.setBackground(table.getSelectionBackground());
1984: checkBox.setForeground(table.getSelectionForeground());
1985: }
1986: else
1987: {
1988: checkBox.setBackground(table.getBackground());
1989: checkBox.setForeground(table.getForeground());
1990: }
1991:
1992: if (hasFocus)
1993: {
1994: checkBox.setBorder(
1995: UIManager.getBorder("Table.focusCellHighlightBorder"));
1996: if (table.isCellEditable(row, column))
1997: {
1998: checkBox.setBackground(
1999: UIManager.getColor("Table.focusCellBackground"));
2000: checkBox.setForeground(
2001: UIManager.getColor("Table.focusCellForeground"));
2002: }
2003: }
2004: else
2005: checkBox.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
2006:
2007:
2008: if (value == null)
2009: checkBox.setSelected(false);
2010: else
2011: {
2012: Boolean boolValue = (Boolean) value;
2013: checkBox.setSelected(boolValue.booleanValue());
2014: }
2015: return checkBox;
2016: }
2017: }
2018:
2019:
2022: private class DateCellRenderer
2023: extends DefaultTableCellRenderer
2024: {
2025:
2037: public Component getTableCellRendererComponent(JTable table, Object value,
2038: boolean isSelected,
2039: boolean hasFocus, int row,
2040: int column)
2041: {
2042: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2043: row, column);
2044: if (value instanceof Date)
2045: {
2046: Date dateValue = (Date) value;
2047: DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
2048: setText(df.format(dateValue));
2049: }
2050: return this;
2051: }
2052: }
2053:
2054:
2057: private class DoubleCellRenderer
2058: extends DefaultTableCellRenderer
2059: {
2060:
2063: public DoubleCellRenderer()
2064: {
2065: setHorizontalAlignment(JLabel.RIGHT);
2066: }
2067:
2068:
2080: public Component getTableCellRendererComponent(JTable table, Object value,
2081: boolean isSelected,
2082: boolean hasFocus, int row,
2083: int column)
2084: {
2085: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2086: row, column);
2087: if (value instanceof Double)
2088: {
2089: Double doubleValue = (Double) value;
2090: NumberFormat nf = NumberFormat.getInstance();
2091: setText(nf.format(doubleValue.doubleValue()));
2092: }
2093: return this;
2094: }
2095: }
2096:
2097:
2100: private class FloatCellRenderer
2101: extends DefaultTableCellRenderer
2102: {
2103:
2106: public FloatCellRenderer()
2107: {
2108: setHorizontalAlignment(JLabel.RIGHT);
2109: }
2110:
2111:
2123: public Component getTableCellRendererComponent(JTable table, Object value,
2124: boolean isSelected,
2125: boolean hasFocus, int row,
2126: int column)
2127: {
2128: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2129: row, column);
2130: if (value instanceof Float)
2131: {
2132: Float floatValue = (Float) value;
2133: NumberFormat nf = NumberFormat.getInstance();
2134: setText(nf.format(floatValue.floatValue()));
2135: }
2136: return this;
2137: }
2138: }
2139:
2140:
2143: private class NumberCellRenderer
2144: extends DefaultTableCellRenderer
2145: {
2146:
2149: public NumberCellRenderer()
2150: {
2151: setHorizontalAlignment(JLabel.RIGHT);
2152: }
2153: }
2154:
2155:
2158: private class IconCellRenderer
2159: extends DefaultTableCellRenderer
2160: {
2161: IconCellRenderer()
2162: {
2163: setHorizontalAlignment(SwingConstants.CENTER);
2164: }
2165:
2166:
2167:
2179: public Component getTableCellRendererComponent(JTable table, Object value,
2180: boolean isSelected,
2181: boolean hasFocus, int row,
2182: int column)
2183: {
2184: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2185: row, column);
2186: if (value instanceof Icon)
2187: {
2188: Icon iconValue = (Icon) value;
2189: setIcon(iconValue);
2190: }
2191: else
2192: {
2193: setIcon(null);
2194: }
2195: setText("");
2196: return this;
2197: }
2198: }
2199:
2200:
2207: private class TableTextField extends JTextField
2208: {
2209:
2212: TableTextField()
2213: {
2214: setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
2215: }
2216: }
2217:
2218:
2219: private static final long serialVersionUID = 3876025080382781659L;
2220:
2221:
2224: final JTable this_table = this;
2225:
2226:
2227:
2232: public static final int AUTO_RESIZE_OFF = 0;
2233:
2234:
2239: public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
2240:
2241:
2246: public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
2247:
2248:
2254: public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
2255:
2256:
2261: public static final int AUTO_RESIZE_LAST_COLUMN = 3;
2262:
2263:
2268: protected Hashtable defaultEditorsByColumnClass = new Hashtable();
2269:
2270:
2275: protected Hashtable defaultRenderersByColumnClass = new Hashtable();
2276:
2277:
2280: protected int editingColumn;
2281:
2282:
2285: protected int editingRow;
2286:
2287:
2292: protected transient Component editorComp;
2293:
2294:
2295:
2306: protected boolean autoCreateColumnsFromModel;
2307:
2308:
2318: protected int autoResizeMode;
2319:
2320:
2331: protected int rowHeight;
2332:
2333:
2343: protected int rowMargin;
2344:
2345:
2358: protected boolean rowSelectionAllowed;
2359:
2360:
2365: protected boolean cellSelectionEnabled;
2366:
2367:
2376: protected TableModel dataModel;
2377:
2378:
2400: protected TableColumnModel columnModel;
2401:
2402:
2414: protected ListSelectionModel selectionModel;
2415:
2416:
2419: protected TableCellEditor cellEditor;
2420:
2421:
2427: private boolean dragEnabled;
2428:
2429:
2436: protected Color gridColor;
2437:
2438:
2445: protected Dimension preferredViewportSize;
2446:
2447:
2455: protected Color selectionBackground;
2456:
2457:
2461: private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
2462:
2463:
2471: protected Color selectionForeground;
2472:
2473:
2477: private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
2478:
2479:
2482: protected boolean showHorizontalLines;
2483:
2484:
2487: protected boolean showVerticalLines;
2488:
2489:
2492: protected JTableHeader tableHeader;
2493:
2494:
2497: TableColumnPropertyChangeHandler tableColumnPropertyChangeHandler =
2498: new TableColumnPropertyChangeHandler();
2499:
2500:
2504: private boolean surrendersFocusOnKeystroke = false;
2505:
2506:
2509: private Rectangle rectCache = new Rectangle();
2510:
2511:
2518: private boolean clientRowHeightSet = false;
2519:
2520:
2533: private SizeSequence rowHeights;
2534:
2535:
2539: private transient TableCellEditor booleanInvertingEditor;
2540:
2541:
2544: public JTable ()
2545: {
2546: this(null, null, null);
2547: }
2548:
2549:
2556: public JTable (int numRows, int numColumns)
2557: {
2558: this(new DefaultTableModel(numRows, numColumns));
2559: }
2560:
2561:
2569: public JTable(Object[][] data, Object[] columnNames)
2570: {
2571: this(new DefaultTableModel(data, columnNames));
2572: }
2573:
2574:
2583: public JTable (TableModel model)
2584: {
2585: this(model, null, null);
2586: }
2587:
2588:
2601: public JTable (TableModel dm, TableColumnModel cm)
2602: {
2603: this(dm, cm, null);
2604: }
2605:
2606:
2615: public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
2616: {
2617: boolean autoCreate = false;
2618: TableColumnModel columnModel;
2619: if (cm != null)
2620: columnModel = cm;
2621: else
2622: {
2623: columnModel = createDefaultColumnModel();
2624: autoCreate = true;
2625: }
2626:
2627:
2628:
2629:
2630: rowMargin = 1;
2631: columnModel.setColumnMargin(1);
2632: setColumnModel(columnModel);
2633:
2634: setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
2635: setModel(dm == null ? createDefaultDataModel() : dm);
2636: setAutoCreateColumnsFromModel(autoCreate);
2637: initializeLocalVars();
2638:
2639:
2640:
2641:
2642:
2643:
2644:
2645: selectionModel.setAnchorSelectionIndex(0);
2646: selectionModel.setLeadSelectionIndex(0);
2647: columnModel.getSelectionModel().setAnchorSelectionIndex(0);
2648: columnModel.getSelectionModel().setLeadSelectionIndex(0);
2649: updateUI();
2650: }
2651:
2652:
2659: public JTable(Vector data, Vector columnNames)
2660: {
2661: this(new DefaultTableModel(data, columnNames));
2662: }
2663:
2664:
2667: protected void initializeLocalVars()
2668: {
2669: setTableHeader(createDefaultTableHeader());
2670: if (autoCreateColumnsFromModel)
2671: createDefaultColumnsFromModel();
2672: this.columnModel.addColumnModelListener(this);
2673:
2674: this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
2675: setRowHeight(16);
2676: this.rowMargin = 1;
2677: this.rowSelectionAllowed = true;
2678:
2679: this.cellEditor = null;
2680:
2681: this.dragEnabled = true;
2682: this.preferredViewportSize = new Dimension(450,400);
2683: this.showHorizontalLines = true;
2684: this.showVerticalLines = true;
2685: this.editingColumn = -1;
2686: this.editingRow = -1;
2687: }
2688:
2689:
2700: public void addColumn(TableColumn column)
2701: {
2702: if (column.getHeaderValue() == null)
2703: {
2704: String name = dataModel.getColumnName(column.getModelIndex());
2705: column.setHeaderValue(name);
2706: }
2707:
2708: columnModel.addColumn(column);
2709: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
2710: }
2711:
2712:
2718: protected void createDefaultEditors()
2719: {
2720: JCheckBox box = new BooleanCellRenderer().getCheckBox();
2721: box.setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
2722: box.setBorderPainted(true);
2723: booleanInvertingEditor = new DefaultCellEditor(box);
2724: setDefaultEditor(Boolean.class, booleanInvertingEditor);
2725: }
2726:
2727:
2732: protected void createDefaultRenderers()
2733: {
2734: setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
2735: setDefaultRenderer(Number.class, new NumberCellRenderer());
2736: setDefaultRenderer(Double.class, new DoubleCellRenderer());
2737: setDefaultRenderer(Double.class, new FloatCellRenderer());
2738: setDefaultRenderer(Date.class, new DateCellRenderer());
2739: setDefaultRenderer(Icon.class, new IconCellRenderer());
2740: setDefaultRenderer(ImageIcon.class, new IconCellRenderer());
2741: }
2742:
2743:
2746: public static JScrollPane createScrollPaneForTable(JTable table)
2747: {
2748: return new JScrollPane(table);
2749: }
2750:
2751:
2758: protected TableColumnModel createDefaultColumnModel()
2759: {
2760: return new DefaultTableColumnModel();
2761: }
2762:
2763:
2770: protected TableModel createDefaultDataModel()
2771: {
2772: return new DefaultTableModel();
2773: }
2774:
2775:
2782: protected ListSelectionModel createDefaultSelectionModel()
2783: {
2784: return new DefaultListSelectionModel();
2785: }
2786:
2787:
2793: protected JTableHeader createDefaultTableHeader()
2794: {
2795: return new JTableHeader(columnModel);
2796: }
2797:
2798:
2801: public void columnAdded (TableColumnModelEvent event)
2802: {
2803: revalidate();
2804: repaint();
2805: }
2806:
2807:
2811: public void columnMarginChanged (ChangeEvent event)
2812: {
2813: revalidate();
2814: repaint();
2815: }
2816:
2817:
2820: public void columnMoved (TableColumnModelEvent event)
2821: {
2822: if (isEditing())
2823: editingCanceled(null);
2824: revalidate();
2825: repaint();
2826: }
2827:
2828:
2831: public void columnRemoved (TableColumnModelEvent event)
2832: {
2833: revalidate();
2834: repaint();
2835: }
2836:
2837:
2842: public void columnSelectionChanged (ListSelectionEvent event)
2843: {
2844:
2845:
2846:
2847: int idx0 = Math.max(0, Math.min(getColumnCount() - 1,
2848: event.getFirstIndex()));
2849: int idxn = Math.max(0, Math.min(getColumnCount() - 1,
2850: event.getLastIndex()));
2851:
2852: int minRow = 0;
2853: int maxRow = getRowCount() - 1;
2854: if (getRowSelectionAllowed())
2855: {
2856: minRow = selectionModel.getMinSelectionIndex();
2857: maxRow = selectionModel.getMaxSelectionIndex();
2858: int leadRow = selectionModel.getLeadSelectionIndex();
2859: if (minRow == -1 && maxRow == -1)
2860: {
2861: minRow = leadRow;
2862: maxRow = leadRow;
2863: }
2864: else
2865: {
2866:
2867:
2868: if (leadRow != -1)
2869: {
2870: minRow = Math.min(minRow, leadRow);
2871: maxRow = Math.max(maxRow, leadRow);
2872: }
2873: }
2874: }
2875: if (minRow != -1 && maxRow != -1)
2876: {
2877: Rectangle first = getCellRect(minRow, idx0, false);
2878: Rectangle last = getCellRect(maxRow, idxn, false);
2879: Rectangle dirty = SwingUtilities.computeUnion(first.x, first.y,
2880: first.width,
2881: first.height, last);
2882: repaint(dirty);
2883: }
2884: }
2885:
2886:
2889: public void editingCanceled (ChangeEvent event)
2890: {
2891: if (editorComp!=null)
2892: {
2893: remove(editorComp);
2894: repaint(editorComp.getBounds());
2895: editorComp = null;
2896: }
2897: }
2898:
2899:
2905: public void editingStopped (ChangeEvent event)
2906: {
2907: if (editorComp!=null)
2908: {
2909: remove(editorComp);
2910: setValueAt(cellEditor.getCellEditorValue(), editingRow, editingColumn);
2911: repaint(editorComp.getBounds());
2912: editorComp = null;
2913: }
2914: requestFocusInWindow();
2915: }
2916:
2917:
2921: public void tableChanged (TableModelEvent event)
2922: {
2923:
2924:
2925: if (event == null || (event.getFirstRow() == TableModelEvent.HEADER_ROW))
2926: handleCompleteChange(event);
2927: else if (event.getType() == TableModelEvent.INSERT)
2928: handleInsert(event);
2929: else if (event.getType() == TableModelEvent.DELETE)
2930: handleDelete(event);
2931: else
2932: handleUpdate(event);
2933: }
2934:
2935:
2941: private void handleCompleteChange(TableModelEvent ev)
2942: {
2943: clearSelection();
2944: checkSelection();
2945: rowHeights = null;
2946: if (getAutoCreateColumnsFromModel())
2947: createDefaultColumnsFromModel();
2948: else
2949: resizeAndRepaint();
2950: }
2951:
2952:
2957: private void handleInsert(TableModelEvent ev)
2958: {
2959:
2960: int first = ev.getFirstRow();
2961: if (first < 0)
2962: first = 0;
2963: int last = ev.getLastRow();
2964: if (last < 0)
2965: last = getRowCount() - 1;
2966: selectionModel.insertIndexInterval(first, last - first + 1, true);
2967: checkSelection();
2968:
2969:
2970: if (rowHeights != null)
2971: {
2972: rowHeights.insertEntries(first, last - first + 1, rowHeight);
2973:
2974:
2975: repaint();
2976: }
2977: else
2978: {
2979:
2980: int rowHeight = getRowHeight();
2981: Rectangle dirty = new Rectangle(0, first * rowHeight,
2982: getColumnModel().getTotalColumnWidth(),
2983: (getRowCount() - first) * rowHeight);
2984: repaint(dirty);
2985: }
2986: revalidate();
2987: }
2988:
2989:
2994: private void handleDelete(TableModelEvent ev)
2995: {
2996:
2997: int first = ev.getFirstRow();
2998: if (first < 0)
2999: first = 0;
3000: int last = ev.getLastRow();
3001: if (last < 0)
3002: last = getRowCount() - 1;
3003:
3004: selectionModel.removeIndexInterval(first, last);
3005:
3006: checkSelection();
3007:
3008: if (dataModel.getRowCount() == 0)
3009: clearSelection();
3010:
3011:
3012: if (rowHeights != null)
3013: {
3014: rowHeights.removeEntries(first, last - first + 1);
3015:
3016:
3017: repaint();
3018: }
3019: else
3020: {
3021:
3022: int rowHeight = getRowHeight();
3023: int oldRowCount = getRowCount() + last - first + 1;
3024: Rectangle dirty = new Rectangle(0, first * rowHeight,
3025: getColumnModel().getTotalColumnWidth(),
3026: (oldRowCount - first) * rowHeight);
3027: repaint(dirty);
3028: }
3029: revalidate();
3030: }
3031:
3032:
3037: private void handleUpdate(TableModelEvent ev)
3038: {
3039: if (rowHeights == null)
3040: {
3041:
3042:
3043: int firstRow = ev.getFirstRow();
3044: int lastRow = ev.getLastRow();
3045: int col = ev.getColumn();
3046: Rectangle dirty;
3047: if (col == TableModelEvent.ALL_COLUMNS)
3048: {
3049:
3050: dirty = new Rectangle(0, firstRow * getRowHeight(),
3051: getColumnModel().getTotalColumnWidth(), 0);
3052: }
3053: else
3054: {
3055:
3056:
3057: int column = convertColumnIndexToModel(col);
3058: dirty = getCellRect(firstRow, column, false);
3059: }
3060:
3061:
3062: dirty.height = (lastRow + 1) * getRowHeight();
3063:
3064: repaint(dirty);
3065: }
3066: else
3067: {
3068:
3069:
3070: repaint();
3071: }
3072: }
3073:
3074:
3080: private void checkSelection()
3081: {
3082: TableModel m = getModel();
3083: ListSelectionModel sm = selectionModel;
3084: if (m != null)
3085: {
3086: int lead = sm.getLeadSelectionIndex();
3087: int c = m.getRowCount();
3088: if (c == 0 && lead != -1)
3089: {
3090:
3091: sm.setValueIsAdjusting(true);
3092: sm.setAnchorSelectionIndex(-1);
3093: sm.setLeadSelectionIndex(-1);
3094: sm.setValueIsAdjusting(false);
3095: }
3096: else if (c != 0 && lead == -1)
3097: {
3098:
3099:
3100:
3101: if (sm.isSelectedIndex(0))
3102: sm.addSelectionInterval(0, 0);
3103: else
3104: sm.removeSelectionInterval(0, 0);
3105: }
3106:
3107: }
3108: }
3109:
3110:
3114: public void valueChanged (ListSelectionEvent event)
3115: {
3116:
3117: if (isEditing())
3118: editingStopped(null);
3119:
3120:
3121: int first = Math.max(0, Math.min(getRowCount() - 1, event.getFirstIndex()));
3122: int last = Math.max(0, Math.min(getRowCount() - 1, event.getLastIndex()));
3123: Rectangle rect1 = getCellRect(first, 0, false);
3124: Rectangle rect2 = getCellRect(last, getColumnCount() - 1, false);
3125: Rectangle dirty = SwingUtilities.computeUnion(rect2.x, rect2.y,
3126: rect2.width, rect2.height,
3127: rect1);
3128: repaint(dirty);
3129: }
3130:
3131:
3139: public int columnAtPoint(Point point)
3140: {
3141: int ncols = getColumnCount();
3142: Dimension gap = getIntercellSpacing();
3143: TableColumnModel cols = getColumnModel();
3144: int x = point.x;
3145:
3146: for (int i = 0; i < ncols; ++i)
3147: {
3148: int width = cols.getColumn(i).getWidth()
3149: + (gap == null ? 0 : gap.width);
3150: if (0 <= x && x < width)
3151: return i;
3152: x -= width;
3153: }
3154: return -1;
3155: }
3156:
3157:
3165: public int rowAtPoint(Point point)
3166: {
3167: if (point != null)
3168: {
3169: int nrows = getRowCount();
3170: int r;
3171: int y = point.y;
3172: if (rowHeights == null)
3173: {
3174: int height = getRowHeight();
3175: r = y / height;
3176: }
3177: else
3178: r = rowHeights.getIndex(y);
3179:
3180: if (r < 0 || r >= nrows)
3181: return -1;
3182: else
3183: return r;
3184: }
3185: else
3186: return -1;
3187: }
3188:
3189:
3205: public Rectangle getCellRect(int row,
3206: int column,
3207: boolean includeSpacing)
3208: {
3209: Rectangle cellRect = new Rectangle(0, 0, 0, 0);
3210:
3211:
3212: if (row >= getRowCount())
3213: {
3214: cellRect.height = getHeight();
3215: }
3216: else if (row >= 0)
3217: {
3218: cellRect.height = getRowHeight(row);
3219: if (rowHeights == null)
3220: cellRect.y = row * cellRect.height;
3221: else
3222: cellRect.y = rowHeights.getPosition(row);
3223:
3224: if (! includeSpacing)
3225: {
3226:
3227: int rMargin = getRowMargin();
3228: cellRect.y += rMargin / 2;
3229: cellRect.height -= rMargin;
3230: }
3231: }
3232:
3233:
3234:
3235: if (column < 0)
3236: {
3237: if (! getComponentOrientation().isLeftToRight())
3238: {
3239: cellRect.x = getWidth();
3240: }
3241: }
3242: else if (column >= getColumnCount())
3243: {
3244: if (getComponentOrientation().isLeftToRight())
3245: {
3246: cellRect.x = getWidth();
3247: }
3248: }
3249: else
3250: {
3251: TableColumnModel tcm = getColumnModel();
3252: if (getComponentOrientation().isLeftToRight())
3253: {
3254: for (int i = 0; i < column; i++)
3255: cellRect.x += tcm.getColumn(i).getWidth();
3256: }
3257: else
3258: {
3259: for (int i = tcm.getColumnCount() - 1; i > column; i--)
3260: cellRect.x += tcm.getColumn(i).getWidth();
3261: }
3262: cellRect.width = tcm.getColumn(column).getWidth();
3263: if (! includeSpacing)
3264: {
3265:
3266: int cMargin = tcm.getColumnMargin();
3267: cellRect.x += cMargin / 2;
3268: cellRect.width -= cMargin;
3269: }
3270: }
3271:
3272: return cellRect;
3273: }
3274:
3275: public void clearSelection()
3276: {
3277: selectionModel.clearSelection();
3278: getColumnModel().getSelectionModel().clearSelection();
3279: }
3280:
3281:
3288: public int getSelectedRow ()
3289: {
3290: return selectionModel.getMinSelectionIndex();
3291: }
3292:
3293:
3298: public ListSelectionModel getSelectionModel()
3299: {
3300:
3301: return selectionModel;
3302: }
3303:
3304: public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
3305: {
3306: if (orientation == SwingConstants.VERTICAL)
3307: return visibleRect.height * direction;
3308: else
3309: return visibleRect.width * direction;
3310: }
3311:
3312:
3317: public boolean getScrollableTracksViewportHeight()
3318: {
3319: return false;
3320: }
3321:
3322:
3328: public boolean getScrollableTracksViewportWidth()
3329: {
3330: if (autoResizeMode == AUTO_RESIZE_OFF)
3331: return false;
3332: else
3333: return true;
3334: }
3335:
3336:
3350: public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
3351: int direction)
3352: {
3353: int h = (rowHeight + rowMargin);
3354: int delta = h * direction;
3355:
3356:
3357: if (orientation == SwingConstants.VERTICAL)
3358: {
3359:
3360: int near = ((visibleRect.y + delta + h / 2) / h) * h;
3361: int diff = visibleRect.y + delta - near;
3362: delta -= diff;
3363: }
3364: return delta;
3365:
3366: }
3367:
3368:
3379: public TableCellEditor getCellEditor(int row, int column)
3380: {
3381: TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
3382:
3383: if (editor == null)
3384: {
3385: int mcolumn = convertColumnIndexToModel(column);
3386: editor = getDefaultEditor(dataModel.getColumnClass(mcolumn));
3387: }
3388:
3389: return editor;
3390: }
3391:
3392:
3400: public TableCellEditor getDefaultEditor(Class columnClass)
3401: {
3402: if (defaultEditorsByColumnClass.containsKey(columnClass))
3403: return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
3404: else
3405: {
3406: JTextField t = new TableTextField();
3407: TableCellEditor r = new DefaultCellEditor(t);
3408: defaultEditorsByColumnClass.put(columnClass, r);
3409: return r;
3410: }
3411: }
3412:
3413:
3420: public TableCellRenderer getCellRenderer(int row, int column)
3421: {
3422: TableCellRenderer renderer = columnModel.getColumn(column).getCellRenderer();
3423: if (renderer == null)
3424: {
3425: int mcolumn = convertColumnIndexToModel(column);
3426: renderer = getDefaultRenderer(dataModel.getColumnClass(mcolumn));
3427: }
3428: return renderer;
3429: }
3430:
3431:
3438: public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
3439: {
3440: defaultRenderersByColumnClass.put(columnClass, rend);
3441: }
3442:
3443:
3450: public TableCellRenderer getDefaultRenderer(Class columnClass)
3451: {
3452: if (defaultRenderersByColumnClass.containsKey(columnClass))
3453: return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
3454: else
3455: {
3456: TableCellRenderer r = new DefaultTableCellRenderer();
3457: defaultRenderersByColumnClass.put(columnClass, r);
3458: return r;
3459: }
3460: }
3461:
3462:
3474: public int convertColumnIndexToModel(int vc)
3475: {
3476: if (vc < 0)
3477: return vc;
3478: else
3479: return columnModel.getColumn(vc).getModelIndex();
3480: }
3481:
3482:
3494: public int convertColumnIndexToView(int mc)
3495: {
3496: if (mc < 0)
3497: return mc;
3498: int ncols = getColumnCount();
3499: for (int vc = 0; vc < ncols; ++vc)
3500: {
3501: if (columnModel.getColumn(vc).getModelIndex() == mc)
3502: return vc;
3503: }
3504: return -1;
3505: }
3506:
3507:
3516: public Component prepareRenderer(TableCellRenderer renderer,
3517: int row,
3518: int column)
3519: {
3520: boolean rowSelAllowed = getRowSelectionAllowed();
3521: boolean colSelAllowed = getColumnSelectionAllowed();
3522: boolean isSel = false;
3523: if (rowSelAllowed && colSelAllowed || !rowSelAllowed && !colSelAllowed)
3524: isSel = isCellSelected(row, column);
3525: else
3526: isSel = isRowSelected(row) && getRowSelectionAllowed()
3527: || isColumnSelected(column) && getColumnSelectionAllowed();
3528:
3529:
3530:
3531: ListSelectionModel rowSel = getSelectionModel();
3532: ListSelectionModel colSel = getColumnModel().getSelectionModel();
3533: boolean hasFocus = hasFocus() && isEnabled()
3534: && rowSel.getLeadSelectionIndex() == row
3535: && colSel.getLeadSelectionIndex() == column;
3536:
3537: return renderer.getTableCellRendererComponent(this,
3538: dataModel.getValueAt(row,
3539: convertColumnIndexToModel(column)),
3540: isSel,
3541: hasFocus,
3542: row, column);
3543: }
3544:
3545:
3546:
3551: public boolean getAutoCreateColumnsFromModel()
3552: {
3553: return autoCreateColumnsFromModel;
3554: }
3555:
3556:
3561: public int getAutoResizeMode()
3562: {
3563: return autoResizeMode;
3564: }
3565:
3566:
3571: public int getRowHeight()
3572: {
3573: return rowHeight;
3574: }
3575:
3576:
3581: public int getRowHeight(int row)
3582: {
3583: int rh = rowHeight;
3584: if (rowHeights != null)
3585: rh = rowHeights.getSize(row);
3586: return rh;
3587: }
3588:
3589:
3590:
3595: public int getRowMargin()
3596: {
3597: return rowMargin;
3598: }
3599:
3600:
3607: public boolean getRowSelectionAllowed()
3608: {
3609: return rowSelectionAllowed;
3610: }
3611:
3612:
3617: public boolean getCellSelectionEnabled()
3618: {
3619: return getColumnSelectionAllowed() && getRowSelectionAllowed();
3620: }
3621:
3622:
3627: public TableModel getModel()
3628: {
3629: return dataModel;
3630: }
3631:
3632:
3638: public int getColumnCount()
3639: {
3640: return columnModel.getColumnCount();
3641: }
3642:
3643:
3649: public int getRowCount()
3650: {
3651: return dataModel.getRowCount();
3652: }
3653:
3654:
3659: public TableColumnModel getColumnModel()
3660: {
3661: return columnModel;
3662: }
3663:
3664:
3670: public int getSelectedColumn()
3671: {
3672: return columnModel.getSelectionModel().getMinSelectionIndex();
3673: }
3674:
3675: private static int countSelections(ListSelectionModel lsm)
3676: {
3677: int lo = lsm.getMinSelectionIndex();
3678: int hi = lsm.getMaxSelectionIndex();
3679: int sum = 0;
3680: if (lo != -1 && hi != -1)
3681: {
3682: switch (lsm.getSelectionMode())
3683: {
3684: case ListSelectionModel.SINGLE_SELECTION:
3685: sum = 1;
3686: break;
3687:
3688: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
3689: sum = hi - lo + 1;
3690: break;
3691:
3692: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
3693: for (int i = lo; i <= hi; ++i)
3694: if (lsm.isSelectedIndex(i))
3695: ++sum;
3696: break;
3697: }
3698: }
3699: return sum;
3700: }
3701:
3702: private static int[] getSelections(ListSelectionModel lsm)
3703: {
3704: int sz = countSelections(lsm);
3705: int [] ret = new int[sz];
3706:
3707: int lo = lsm.getMinSelectionIndex();
3708: int hi = lsm.getMaxSelectionIndex();
3709: int j = 0;
3710: if (lo != -1 && hi != -1)
3711: {
3712: switch (lsm.getSelectionMode())
3713: {
3714: case ListSelectionModel.SINGLE_SELECTION:
3715: ret[0] = lo;
3716: break;
3717:
3718: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
3719: for (int i = lo; i <= hi; ++i)
3720: ret[j++] = i;
3721: break;
3722:
3723: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
3724: for (int i = lo; i <= hi; ++i)
3725: if (lsm.isSelectedIndex(i))
3726: ret[j++] = i;
3727: break;
3728: }
3729: }
3730: return ret;
3731: }
3732:
3733:
3739: public int getSelectedColumnCount()
3740: {
3741: return countSelections(columnModel.getSelectionModel());
3742: }
3743:
3744:
3750: public int[] getSelectedColumns()
3751: {
3752: return getSelections(columnModel.getSelectionModel());
3753: }
3754:
3755:
3762: public boolean getColumnSelectionAllowed()
3763: {
3764: return getColumnModel().getColumnSelectionAllowed();
3765: }
3766:
3767:
3773: public int getSelectedRowCount()
3774: {
3775: return countSelections(selectionModel);
3776: }
3777:
3778:
3784: public int[] getSelectedRows()
3785: {
3786: return getSelections(selectionModel);
3787: }
3788:
3789:
3794: public AccessibleContext getAccessibleContext()
3795: {
3796: if (accessibleContext == null)
3797: {
3798: AccessibleJTable ctx = new AccessibleJTable();
3799: addPropertyChangeListener(ctx);
3800: TableColumnModel tcm = getColumnModel();
3801: tcm.addColumnModelListener(ctx);
3802: tcm.getSelectionModel().addListSelectionListener(ctx);
3803: getSelectionModel().addListSelectionListener(ctx);
3804:
3805: accessibleContext = ctx;
3806: }
3807: return accessibleContext;
3808: }
3809:
3810:
3815: public TableCellEditor getCellEditor()
3816: {
3817: return cellEditor;
3818: }
3819:
3820:
3825: public boolean getDragEnabled()
3826: {
3827: return dragEnabled;
3828: }
3829:
3830:
3835: public Color getGridColor()
3836: {
3837: return gridColor;
3838: }
3839:
3840:
3845: public Dimension getIntercellSpacing()
3846: {
3847: return new Dimension(columnModel.getColumnMargin(), rowMargin);
3848: }
3849:
3850:
3855: public Dimension getPreferredScrollableViewportSize()
3856: {
3857: return preferredViewportSize;
3858: }
3859:
3860:
3865: public Color getSelectionBackground()
3866: {
3867: return selectionBackground;
3868: }
3869:
3870:
3875: public Color getSelectionForeground()
3876: {
3877: return selectionForeground;
3878: }
3879:
3880:
3885: public boolean getShowHorizontalLines()
3886: {
3887: return showHorizontalLines;
3888: }
3889:
3890:
3895: public boolean getShowVerticalLines()
3896: {
3897: return showVerticalLines;
3898: }
3899:
3900:
3905: public JTableHeader getTableHeader()
3906: {
3907: return tableHeader;
3908: }
3909:
3910:
3915: public void removeColumn(TableColumn column)
3916: {
3917: columnModel.removeColumn(column);
3918: }
3919:
3920:
3926: public void moveColumn(int column,int targetColumn)
3927: {
3928: columnModel.moveColumn(column, targetColumn);
3929: }
3930:
3931:
3938: public void setAutoCreateColumnsFromModel(boolean autoCreate)
3939: {
3940: if (autoCreateColumnsFromModel != autoCreate)
3941: {
3942: autoCreateColumnsFromModel = autoCreate;
3943: if (autoCreate)
3944: createDefaultColumnsFromModel();
3945: }
3946: }
3947:
3948:
3953: public void setAutoResizeMode(int a)
3954: {
3955: autoResizeMode = a;
3956: revalidate();
3957: repaint();
3958: }
3959:
3960:
3970: public void setRowHeight(int r)
3971: {
3972: if (r < 1)
3973: throw new IllegalArgumentException();
3974:
3975: clientRowHeightSet = true;
3976:
3977: rowHeight = r;
3978: rowHeights = null;
3979: revalidate();
3980: repaint();
3981: }
3982:
3983:
3989: public void setRowHeight(int row, int rh)
3990: {
3991: if (rowHeights == null)
3992: {
3993: rowHeights = new SizeSequence(getRowCount(), rowHeight);
3994: }
3995: rowHeights.setSize(row, rh);
3996: }
3997:
3998:
4003: public void setRowMargin(int r)
4004: {
4005: rowMargin = r;
4006: revalidate();
4007: repaint();
4008: }
4009:
4010:
4017: public void setRowSelectionAllowed(boolean r)
4018: {
4019: if (rowSelectionAllowed != r)
4020: {
4021: rowSelectionAllowed = r;
4022: firePropertyChange("rowSelectionAllowed", !r, r);
4023: repaint();
4024: }
4025: }
4026:
4027:
4032: public void setCellSelectionEnabled(boolean c)
4033: {
4034: setColumnSelectionAllowed(c);
4035: setRowSelectionAllowed(c);
4036:
4037: cellSelectionEnabled = true;
4038: }
4039:
4040:
4049: public void setModel(TableModel m)
4050: {
4051:
4052: if (m == null)
4053: throw new IllegalArgumentException();
4054:
4055:
4056: if (dataModel == m)
4057: return;
4058:
4059: TableModel oldModel = dataModel;
4060:
4061:
4062: if (dataModel != null)
4063: dataModel.removeTableModelListener(this);
4064:
4065: if (m != null)
4066: {
4067:
4068: dataModel = m;
4069:
4070:
4071: dataModel.addTableModelListener(this);
4072:
4073:
4074: tableChanged(new TableModelEvent(dataModel,
4075: TableModelEvent.HEADER_ROW));
4076:
4077:
4078: if (autoCreateColumnsFromModel)
4079: createDefaultColumnsFromModel();
4080: }
4081:
4082:
4083: firePropertyChange("model", oldModel, dataModel);
4084:
4085:
4086: revalidate();
4087: repaint();
4088: }
4089:
4090:
4099: public void setColumnModel(TableColumnModel c)
4100: {
4101: if (c == null)
4102: throw new IllegalArgumentException();
4103: TableColumnModel tmp = columnModel;
4104: if (tmp != null)
4105: tmp.removeColumnModelListener(this);
4106: if (c != null)
4107: c.addColumnModelListener(this);
4108: columnModel = c;
4109: if (dataModel != null && columnModel != null)
4110: {
4111: int ncols = getColumnCount();
4112: TableColumn column;
4113: for (int i = 0; i < ncols; ++i)
4114: {
4115: column = columnModel.getColumn(i);
4116: if (column.getHeaderValue()==null)
4117: column.setHeaderValue(dataModel.getColumnName(i));
4118: }
4119: }
4120:
4121:
4122:
4123: if (tableHeader != null)
4124: tableHeader.setColumnModel(c);
4125:
4126: revalidate();
4127: repaint();
4128: }
4129:
4130:
4137: public void setColumnSelectionAllowed(boolean c)
4138: {
4139: if (columnModel.getColumnSelectionAllowed() != c)
4140: {
4141: columnModel.setColumnSelectionAllowed(c);
4142: firePropertyChange("columnSelectionAllowed", !c, c);
4143: repaint();
4144: }
4145: }
4146:
4147:
4156: public void setSelectionModel(ListSelectionModel s)
4157: {
4158: if (s == null)
4159: throw new IllegalArgumentException();
4160: ListSelectionModel tmp = selectionModel;
4161: if (tmp != null)
4162: tmp.removeListSelectionListener(this);
4163: if (s != null)
4164: s.addListSelectionListener(this);
4165: selectionModel = s;
4166: checkSelection();
4167: }
4168:
4169:
4176: public void setSelectionMode(int s)
4177: {
4178: selectionModel.setSelectionMode(s);
4179: columnModel.getSelectionModel().setSelectionMode(s);
4180:
4181: repaint();
4182: }
4183:
4184:
4193: public void setCellEditor(TableCellEditor c)
4194: {
4195: TableCellEditor tmp = cellEditor;
4196: if (tmp != null)
4197: tmp.removeCellEditorListener(this);
4198: if (c != null)
4199: c.addCellEditorListener(this);
4200: cellEditor = c;
4201: }
4202:
4203:
4208: public void setDragEnabled(boolean d)
4209: {
4210: dragEnabled = d;
4211: }
4212:
4213:
4218: public void setGridColor(Color g)
4219: {
4220: gridColor = g;
4221: repaint();
4222: }
4223:
4224:
4229: public void setIntercellSpacing(Dimension i)
4230: {
4231: rowMargin = i.height;
4232: columnModel.setColumnMargin(i.width);
4233: repaint();
4234: }
4235:
4236:
4241: public void setPreferredScrollableViewportSize(Dimension p)
4242: {
4243: preferredViewportSize = p;
4244: revalidate();
4245: repaint();
4246: }
4247:
4248:
4257: public void setSelectionBackground(Color s)
4258: {
4259: Color tmp = selectionBackground;
4260: selectionBackground = s;
4261: if (((tmp == null && s != null)
4262: || (s == null && tmp != null)
4263: || (tmp != null && s != null && !tmp.equals(s))))
4264: firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
4265: repaint();
4266: }
4267:
4268:
4277: public void setSelectionForeground(Color s)
4278: {
4279: Color tmp = selectionForeground;
4280: selectionForeground = s;
4281: if (((tmp == null && s != null)
4282: || (s == null && tmp != null)
4283: || (tmp != null && s != null && !tmp.equals(s))))
4284: firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
4285: repaint();
4286: }
4287:
4288:
4293: public void setShowGrid(boolean s)
4294: {
4295: setShowVerticalLines(s);
4296: setShowHorizontalLines(s);
4297: }
4298:
4299:
4304: public void setShowHorizontalLines(boolean s)
4305: {
4306: showHorizontalLines = s;
4307: repaint();
4308: }
4309:
4310:
4315: public void setShowVerticalLines(boolean s)
4316: {
4317: showVerticalLines = s;
4318: repaint();
4319: }
4320:
4321:
4326: public void setTableHeader(JTableHeader t)
4327: {
4328: if (tableHeader != null)
4329: tableHeader.setTable(null);
4330: tableHeader = t;
4331: if (tableHeader != null)
4332: tableHeader.setTable(this);
4333: revalidate();
4334: repaint();
4335: }
4336:
4337: protected void configureEnclosingScrollPane()
4338: {
4339: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4340: if (jsp != null && tableHeader != null)
4341: {
4342: jsp.setColumnHeaderView(tableHeader);
4343: }
4344: }
4345:
4346: protected void unconfigureEnclosingScrollPane()
4347: {
4348: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4349: if (jsp != null)
4350: {
4351: jsp.setColumnHeaderView(null);
4352: }
4353: }
4354:
4355:
4356: public void addNotify()
4357: {
4358: super.addNotify();
4359: configureEnclosingScrollPane();
4360: }
4361:
4362: public void removeNotify()
4363: {
4364: super.addNotify();
4365: unconfigureEnclosingScrollPane();
4366: }
4367:
4368:
4369:
4377: private void distributeSpill(TableColumn[] cols, int spill)
4378: {
4379: int average = spill / cols.length;
4380: for (int i = 0; i < cols.length; i++)
4381: {
4382: if (cols[i] != null)
4383: cols[i].setWidth(cols[i].getPreferredWidth() + average);
4384: }
4385: }
4386:
4387:
4391: private void distributeSpillResizing(TableColumn[] cols, int spill,
4392: TableColumn resizeIt)
4393: {
4394: int average = 0;
4395: if (cols.length != 1)
4396: average = spill / (cols.length-1);
4397: for (int i = 0; i < cols.length; i++)
4398: {
4399: if (cols[i] != null && !cols[i].equals(resizeIt))
4400: cols[i].setWidth(cols[i].getPreferredWidth() + average);
4401: }
4402: resizeIt.setWidth(resizeIt.getPreferredWidth());
4403: }
4404:
4405:
4413: public void doLayout()
4414: {
4415: TableColumn resizingColumn = null;
4416:
4417: int ncols = getColumnCount();
4418: if (ncols < 1)
4419: return;
4420:
4421: int prefSum = 0;
4422: int rCol = -1;
4423:
4424: if (tableHeader != null)
4425: resizingColumn = tableHeader.getResizingColumn();
4426:
4427: for (int i = 0; i < ncols; ++i)
4428: {
4429: TableColumn col = columnModel.getColumn(i);
4430: int p = col.getPreferredWidth();
4431: prefSum += p;
4432: if (resizingColumn == col)
4433: rCol = i;
4434: }
4435:
4436: int spill = getWidth() - prefSum;
4437:
4438: if (resizingColumn != null)
4439: {
4440: TableColumn col;
4441: TableColumn [] cols;
4442:
4443: switch (getAutoResizeMode())
4444: {
4445: case AUTO_RESIZE_LAST_COLUMN:
4446: col = columnModel.getColumn(ncols-1);
4447: col.setWidth(col.getPreferredWidth() + spill);
4448: break;
4449:
4450: case AUTO_RESIZE_NEXT_COLUMN:
4451: col = columnModel.getColumn(ncols-1);
4452: col.setWidth(col.getPreferredWidth() + spill);
4453: break;
4454:
4455: case AUTO_RESIZE_ALL_COLUMNS:
4456: cols = new TableColumn[ncols];
4457: for (int i = 0; i < ncols; ++i)
4458: cols[i] = columnModel.getColumn(i);
4459: distributeSpillResizing(cols, spill, resizingColumn);
4460: break;
4461:
4462: case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
4463:
4464:
4465: int w = 0;
4466: int wp = 0;
4467: TableColumn column;
4468: for (int i = 0; i < rCol; i++)
4469: {
4470: column = columnModel.getColumn(i);
4471: w += column.getWidth();
4472: wp+= column.getPreferredWidth();
4473: }
4474:
4475:
4476: int n = ncols-rCol-1;
4477: if (n>0)
4478: {
4479:
4480: spill = (getWidth()-w) - (prefSum-wp);
4481: int average = spill / n;
4482:
4483:
4484: for (int i = rCol+1; i < ncols; i++)
4485: {
4486: column = columnModel.getColumn(i);
4487: column.setWidth(column.getPreferredWidth() + average);
4488: }
4489: }
4490: resizingColumn.setWidth(resizingColumn.getPreferredWidth());
4491: break;
4492:
4493: case AUTO_RESIZE_OFF:
4494: default:
4495: int prefWidth = resizingColumn.getPreferredWidth();
4496: resizingColumn.setWidth(prefWidth);
4497: }
4498: }
4499: else
4500: {
4501: TableColumn [] cols = new TableColumn[ncols];
4502: for (int i = 0; i < ncols; ++i)
4503: cols[i] = columnModel.getColumn(i);
4504: distributeSpill(cols, spill);
4505: }
4506:
4507: if (editorComp!=null)
4508: moveToCellBeingEdited(editorComp);
4509:
4510: int leftBoundary = getLeftResizingBoundary();
4511: int width = getWidth() - leftBoundary;
4512: repaint(leftBoundary, 0, width, getHeight());
4513: if (tableHeader != null)
4514: tableHeader.repaint(leftBoundary, 0, width, tableHeader.getHeight());
4515: }
4516:
4517:
4521: int getLeftResizingBoundary()
4522: {
4523: if (tableHeader == null || getAutoResizeMode() == AUTO_RESIZE_ALL_COLUMNS)
4524: return 0;
4525: else
4526: {
4527: TableColumn resizingColumn = tableHeader.getResizingColumn();
4528: if (resizingColumn == null)
4529: return 0;
4530:
4531: int rc = convertColumnIndexToView(resizingColumn.getModelIndex());
4532: int p = 0;
4533:
4534: for (int i = 0; i < rc; i++)
4535: p += columnModel.getColumn(i).getWidth();
4536:
4537: return p;
4538: }
4539: }
4540:
4541:
4542:
4545: public void sizeColumnsToFit(boolean lastColumnOnly)
4546: {
4547: doLayout();
4548: }
4549:
4550:
4553: public void sizeColumnsToFit(int resizingColumn)
4554: {
4555: doLayout();
4556: }
4557:
4558: public String getUIClassID()
4559: {
4560: return "TableUI";
4561: }
4562:
4563:
4568: public TableUI getUI()
4569: {
4570: return (TableUI) ui;
4571: }
4572:
4573:
4578: public void setUI(TableUI ui)
4579: {
4580: super.setUI(ui);
4581:
4582:
4583: createDefaultEditors();
4584: createDefaultRenderers();
4585: }
4586:
4587: public void updateUI()
4588: {
4589: setUI((TableUI) UIManager.getUI(this));
4590: }
4591:
4592:
4601: public Class getColumnClass(int column)
4602: {
4603: return getModel().getColumnClass(convertColumnIndexToModel(column));
4604: }
4605:
4606:
4617: public String getColumnName(int column)
4618: {
4619: int modelColumn = columnModel.getColumn(column).getModelIndex();
4620: return dataModel.getColumnName(modelColumn);
4621: }
4622:
4623:
4628: public int getEditingColumn()
4629: {
4630: return editingColumn;
4631: }
4632:
4633:
4638: public void setEditingColumn(int column)
4639: {
4640: editingColumn = column;
4641: }
4642:
4643:
4648: public int getEditingRow()
4649: {
4650: return editingRow;
4651: }
4652:
4653:
4658: public void setEditingRow(int row)
4659: {
4660: editingRow = row;
4661: }
4662:
4663:
4669: public Component getEditorComponent()
4670: {
4671: return editorComp;
4672: }
4673:
4674:
4679: public boolean isEditing()
4680: {
4681: return editorComp != null;
4682: }
4683:
4684:
4694: public void setDefaultEditor(Class columnClass, TableCellEditor editor)
4695: {
4696: if (editor != null)
4697: defaultEditorsByColumnClass.put(columnClass, editor);
4698: else
4699: defaultEditorsByColumnClass.remove(columnClass);
4700: }
4701:
4702: public void addColumnSelectionInterval(int index0, int index1)
4703: {
4704: if ((index0 < 0 || index0 > (getColumnCount()-1)
4705: || index1 < 0 || index1 > (getColumnCount()-1)))
4706: throw new IllegalArgumentException("Column index out of range.");
4707:
4708: getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
4709: }
4710:
4711: public void addRowSelectionInterval(int index0, int index1)
4712: {
4713: if ((index0 < 0 || index0 > (getRowCount()-1)
4714: || index1 < 0 || index1 > (getRowCount()-1)))
4715: throw new IllegalArgumentException("Row index out of range.");
4716:
4717: getSelectionModel().addSelectionInterval(index0, index1);
4718: }
4719:
4720: public void setColumnSelectionInterval(int index0, int index1)
4721: {
4722: if ((index0 < 0 || index0 > (getColumnCount()-1)
4723: || index1 < 0 || index1 > (getColumnCount()-1)))
4724: throw new IllegalArgumentException("Column index out of range.");
4725:
4726: getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
4727: }
4728:
4729: public void setRowSelectionInterval(int index0, int index1)
4730: {
4731: if ((index0 < 0 || index0 > (getRowCount()-1)
4732: || index1 < 0 || index1 > (getRowCount()-1)))
4733: throw new IllegalArgumentException("Row index out of range.");
4734:
4735: getSelectionModel().setSelectionInterval(index0, index1);
4736: }
4737:
4738: public void removeColumnSelectionInterval(int index0, int index1)
4739: {
4740: if ((index0 < 0 || index0 > (getColumnCount()-1)
4741: || index1 < 0 || index1 > (getColumnCount()-1)))
4742: throw new IllegalArgumentException("Column index out of range.");
4743:
4744: getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
4745: }
4746:
4747: public void removeRowSelectionInterval(int index0, int index1)
4748: {
4749: if ((index0 < 0 || index0 > (getRowCount()-1)
4750: || index1 < 0 || index1 > (getRowCount()-1)))
4751: throw new IllegalArgumentException("Row index out of range.");
4752:
4753: getSelectionModel().removeSelectionInterval(index0, index1);
4754: }
4755:
4756:
4764: public boolean isColumnSelected(int column)
4765: {
4766: return getColumnModel().getSelectionModel().isSelectedIndex(column);
4767: }
4768:
4769:
4777: public boolean isRowSelected(int row)
4778: {
4779: return getSelectionModel().isSelectedIndex(row);
4780: }
4781:
4782:
4791: public boolean isCellSelected(int row, int column)
4792: {
4793: return isRowSelected(row) && isColumnSelected(column);
4794: }
4795:
4796:
4799: public void selectAll()
4800: {
4801:
4802: if (getRowCount() == 0 || getColumnCount() == 0)
4803: return;
4804:
4805:
4806: int rowLead = selectionModel.getLeadSelectionIndex();
4807: int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
4808:
4809:
4810: setColumnSelectionInterval(0, getColumnCount() - 1);
4811: setRowSelectionInterval(0, getRowCount() - 1);
4812:
4813:
4814: addColumnSelectionInterval(colLead,colLead);
4815: addRowSelectionInterval(rowLead, rowLead);
4816: }
4817:
4818:
4827: public Object getValueAt(int row, int column)
4828: {
4829: return dataModel.getValueAt(row, convertColumnIndexToModel(column));
4830: }
4831:
4832:
4840: public void setValueAt(Object value, int row, int column)
4841: {
4842: dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
4843:
4844: repaint(getCellRect(row, column, true));
4845: }
4846:
4847:
4859: public TableColumn getColumn(Object identifier)
4860: {
4861: return columnModel.getColumn(columnModel.getColumnIndex(identifier));
4862: }
4863:
4864:
4873: public boolean isCellEditable(int row, int column)
4874: {
4875: return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
4876: }
4877:
4878:
4885: public void createDefaultColumnsFromModel()
4886: {
4887: assert columnModel != null : "The columnModel must not be null.";
4888:
4889:
4890: int columnIndex = columnModel.getColumnCount() - 1;
4891: while (columnIndex >= 0)
4892: {
4893: columnModel.removeColumn(columnModel.getColumn(columnIndex));
4894: columnIndex--;
4895: }
4896:
4897:
4898: int columnCount = dataModel.getColumnCount();
4899: for (int c = 0; c < columnCount; c++)
4900: {
4901: TableColumn column = new TableColumn(c);
4902: column.setIdentifier(dataModel.getColumnName(c));
4903: column.setHeaderValue(dataModel.getColumnName(c));
4904: columnModel.addColumn(column);
4905: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
4906: }
4907: }
4908:
4909: public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
4910: {
4911: if (toggle && extend)
4912: {
4913:
4914:
4915: selectionModel.setAnchorSelectionIndex(rowIndex);
4916: getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
4917: }
4918: else if (toggle)
4919: {
4920:
4921: if (isCellSelected(rowIndex,columnIndex))
4922: {
4923: selectionModel.removeSelectionInterval(rowIndex,rowIndex);
4924: getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
4925: }
4926: else
4927: {
4928: selectionModel.addSelectionInterval(rowIndex,rowIndex);
4929: getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
4930: }
4931: }
4932: else if (extend)
4933: {
4934:
4935:
4936: selectionModel.setLeadSelectionIndex(rowIndex);
4937: getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
4938: }
4939: else
4940: {
4941:
4942:
4943: selectionModel.clearSelection();
4944: selectionModel.setSelectionInterval(rowIndex,rowIndex);
4945: getColumnModel().getSelectionModel().clearSelection();
4946: getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
4947:
4948:
4949: }
4950: }
4951:
4952:
4958: public boolean editCellAt(int row, int column)
4959: {
4960:
4961: if (isEditing())
4962: editingStopped(new ChangeEvent("editingStopped"));
4963:
4964: TableCellEditor editor = getCellEditor(row, column);
4965:
4966:
4967:
4968: if (editor == booleanInvertingEditor && isCellEditable(row, column))
4969: {
4970: if (Boolean.TRUE.equals(getValueAt(row, column)))
4971: setValueAt(Boolean.FALSE, row, column);
4972: else
4973: setValueAt(Boolean.TRUE, row, column);
4974: return false;
4975: }
4976: else
4977: {
4978: editingRow = row;
4979: editingColumn = column;
4980:
4981: setCellEditor(editor);
4982: editorComp = prepareEditor(cellEditor, row, column);
4983:
4984:
4985:
4986: removeAll();
4987: add(editorComp);
4988: moveToCellBeingEdited(editorComp);
4989: scrollRectToVisible(editorComp.getBounds());
4990: editorComp.requestFocusInWindow();
4991:
4992:
4993: return editor.shouldSelectCell(null);
4994: }
4995: }
4996:
4997:
5003: private void moveToCellBeingEdited(Component component)
5004: {
5005: Rectangle r = getCellRect(editingRow, editingColumn, true);
5006:
5007:
5008:
5009: r.x -= 1;
5010: r.y -= 1;
5011: r.width += 1;
5012: r.height += 1;
5013: component.setBounds(r);
5014: }
5015:
5016:
5022: public boolean editCellAt (int row, int column, EventObject e)
5023: {
5024: return editCellAt(row, column);
5025: }
5026:
5027:
5030: public void removeEditor()
5031: {
5032: editingStopped(new ChangeEvent(this));
5033: }
5034:
5035:
5044: public Component prepareEditor (TableCellEditor editor, int row, int column)
5045: {
5046: return editor.getTableCellEditorComponent
5047: (this, getValueAt(row, column), isCellSelected(row, column), row, column);
5048: }
5049:
5050:
5053: protected void resizeAndRepaint()
5054: {
5055: revalidate();
5056: repaint();
5057: }
5058:
5059:
5069: public void setSurrendersFocusOnKeystroke(boolean value)
5070: {
5071:
5072: surrendersFocusOnKeystroke = value;
5073: }
5074:
5075:
5086: public boolean getSurrendersFocusOnKeystroke()
5087: {
5088:
5089: return surrendersFocusOnKeystroke;
5090: }
5091:
5092:
5106: void setUIProperty(String propertyName, Object value)
5107: {
5108: if (propertyName.equals("rowHeight"))
5109: {
5110: if (! clientRowHeightSet)
5111: {
5112: setRowHeight(((Integer) value).intValue());
5113: clientRowHeightSet = false;
5114: }
5115: }
5116: else
5117: {
5118: super.setUIProperty(propertyName, value);
5119: }
5120: }
5121: }