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: && autoCreateColumnsFromModel)
2927: {
2928: rowHeights = null;
2929: if (getAutoCreateColumnsFromModel())
2930: createDefaultColumnsFromModel();
2931: resizeAndRepaint();
2932: return;
2933: }
2934:
2935:
2936:
2937:
2938: if (event == null || event.getType() == TableModelEvent.INSERT)
2939: {
2940:
2941: if (event != null)
2942: {
2943: int first = event.getFirstRow();
2944: if (first < 0)
2945: first = 0;
2946: int last = event.getLastRow();
2947: if (last < 0)
2948: last = getRowCount() - 1;
2949: selectionModel.insertIndexInterval(first, last - first + 1, true);
2950: if (rowHeights != null)
2951: rowHeights.insertEntries(first, last - first + 1, rowHeight);
2952: }
2953: revalidate();
2954: }
2955: if (event == null || event.getType() == TableModelEvent.DELETE)
2956: {
2957:
2958: if (event != null)
2959: {
2960: int first = event.getFirstRow();
2961: if (first < 0)
2962: first = 0;
2963: int last = event.getLastRow();
2964: if (last < 0)
2965: last = getRowCount() - 1;
2966: selectionModel.removeIndexInterval(first, last);
2967: if (rowHeights != null)
2968: rowHeights.removeEntries(first, last - first + 1);
2969: }
2970: if (dataModel.getRowCount() == 0)
2971: clearSelection();
2972: revalidate();
2973: }
2974: repaint();
2975: }
2976:
2977:
2981: public void valueChanged (ListSelectionEvent event)
2982: {
2983:
2984: if (isEditing())
2985: editingStopped(null);
2986:
2987:
2988: int first = Math.max(0, Math.min(getRowCount() - 1, event.getFirstIndex()));
2989: int last = Math.max(0, Math.min(getRowCount() - 1, event.getLastIndex()));
2990: Rectangle rect1 = getCellRect(first, 0, false);
2991: Rectangle rect2 = getCellRect(last, getColumnCount() - 1, false);
2992: Rectangle dirty = SwingUtilities.computeUnion(rect2.x, rect2.y,
2993: rect2.width, rect2.height,
2994: rect1);
2995: repaint(dirty);
2996: }
2997:
2998:
3006: public int columnAtPoint(Point point)
3007: {
3008: int ncols = getColumnCount();
3009: Dimension gap = getIntercellSpacing();
3010: TableColumnModel cols = getColumnModel();
3011: int x = point.x;
3012:
3013: for (int i = 0; i < ncols; ++i)
3014: {
3015: int width = cols.getColumn(i).getWidth()
3016: + (gap == null ? 0 : gap.width);
3017: if (0 <= x && x < width)
3018: return i;
3019: x -= width;
3020: }
3021: return -1;
3022: }
3023:
3024:
3032: public int rowAtPoint(Point point)
3033: {
3034: if (point != null)
3035: {
3036: int nrows = getRowCount();
3037: int r;
3038: int y = point.y;
3039: if (rowHeights == null)
3040: {
3041: int height = getRowHeight();
3042: r = y / height;
3043: }
3044: else
3045: r = rowHeights.getIndex(y);
3046:
3047: if (r < 0 || r >= nrows)
3048: return -1;
3049: else
3050: return r;
3051: }
3052: else
3053: return -1;
3054: }
3055:
3056:
3072: public Rectangle getCellRect(int row,
3073: int column,
3074: boolean includeSpacing)
3075: {
3076: Rectangle cellRect = new Rectangle(0, 0, 0, 0);
3077:
3078:
3079: if (row >= getRowCount())
3080: {
3081: cellRect.height = getHeight();
3082: }
3083: else if (row >= 0)
3084: {
3085: cellRect.height = getRowHeight(row);
3086: if (rowHeights == null)
3087: cellRect.y = row * cellRect.height;
3088: else
3089: cellRect.y = rowHeights.getPosition(row);
3090:
3091: if (! includeSpacing)
3092: {
3093:
3094: int rMargin = getRowMargin();
3095: cellRect.y += rMargin / 2;
3096: cellRect.height -= rMargin;
3097: }
3098: }
3099:
3100:
3101:
3102: if (column < 0)
3103: {
3104: if (! getComponentOrientation().isLeftToRight())
3105: {
3106: cellRect.x = getWidth();
3107: }
3108: }
3109: else if (column >= getColumnCount())
3110: {
3111: if (getComponentOrientation().isLeftToRight())
3112: {
3113: cellRect.x = getWidth();
3114: }
3115: }
3116: else
3117: {
3118: TableColumnModel tcm = getColumnModel();
3119: if (getComponentOrientation().isLeftToRight())
3120: {
3121: for (int i = 0; i < column; i++)
3122: cellRect.x += tcm.getColumn(i).getWidth();
3123: }
3124: else
3125: {
3126: for (int i = tcm.getColumnCount() - 1; i > column; i--)
3127: cellRect.x += tcm.getColumn(i).getWidth();
3128: }
3129: cellRect.width = tcm.getColumn(column).getWidth();
3130: if (! includeSpacing)
3131: {
3132:
3133: int cMargin = tcm.getColumnMargin();
3134: cellRect.x += cMargin / 2;
3135: cellRect.width -= cMargin;
3136: }
3137: }
3138:
3139: return cellRect;
3140: }
3141:
3142: public void clearSelection()
3143: {
3144: selectionModel.clearSelection();
3145: getColumnModel().getSelectionModel().clearSelection();
3146: }
3147:
3148:
3155: public int getSelectedRow ()
3156: {
3157: return selectionModel.getMinSelectionIndex();
3158: }
3159:
3160:
3165: public ListSelectionModel getSelectionModel()
3166: {
3167:
3168: return selectionModel;
3169: }
3170:
3171: public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
3172: {
3173: if (orientation == SwingConstants.VERTICAL)
3174: return visibleRect.height * direction;
3175: else
3176: return visibleRect.width * direction;
3177: }
3178:
3179:
3184: public boolean getScrollableTracksViewportHeight()
3185: {
3186: return false;
3187: }
3188:
3189:
3195: public boolean getScrollableTracksViewportWidth()
3196: {
3197: if (autoResizeMode == AUTO_RESIZE_OFF)
3198: return false;
3199: else
3200: return true;
3201: }
3202:
3203:
3217: public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
3218: int direction)
3219: {
3220: int h = (rowHeight + rowMargin);
3221: int delta = h * direction;
3222:
3223:
3224: if (orientation == SwingConstants.VERTICAL)
3225: {
3226:
3227: int near = ((visibleRect.y + delta + h / 2) / h) * h;
3228: int diff = visibleRect.y + delta - near;
3229: delta -= diff;
3230: }
3231: return delta;
3232:
3233: }
3234:
3235:
3246: public TableCellEditor getCellEditor(int row, int column)
3247: {
3248: TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
3249:
3250: if (editor == null)
3251: {
3252: int mcolumn = convertColumnIndexToModel(column);
3253: editor = getDefaultEditor(dataModel.getColumnClass(mcolumn));
3254: }
3255:
3256: return editor;
3257: }
3258:
3259:
3267: public TableCellEditor getDefaultEditor(Class columnClass)
3268: {
3269: if (defaultEditorsByColumnClass.containsKey(columnClass))
3270: return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
3271: else
3272: {
3273: JTextField t = new TableTextField();
3274: TableCellEditor r = new DefaultCellEditor(t);
3275: defaultEditorsByColumnClass.put(columnClass, r);
3276: return r;
3277: }
3278: }
3279:
3280:
3287: public TableCellRenderer getCellRenderer(int row, int column)
3288: {
3289: TableCellRenderer renderer = columnModel.getColumn(column).getCellRenderer();
3290: if (renderer == null)
3291: {
3292: int mcolumn = convertColumnIndexToModel(column);
3293: renderer = getDefaultRenderer(dataModel.getColumnClass(mcolumn));
3294: }
3295: return renderer;
3296: }
3297:
3298:
3305: public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
3306: {
3307: defaultRenderersByColumnClass.put(columnClass, rend);
3308: }
3309:
3310:
3317: public TableCellRenderer getDefaultRenderer(Class columnClass)
3318: {
3319: if (defaultRenderersByColumnClass.containsKey(columnClass))
3320: return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
3321: else
3322: {
3323: TableCellRenderer r = new DefaultTableCellRenderer();
3324: defaultRenderersByColumnClass.put(columnClass, r);
3325: return r;
3326: }
3327: }
3328:
3329:
3341: public int convertColumnIndexToModel(int vc)
3342: {
3343: if (vc < 0)
3344: return vc;
3345: else
3346: return columnModel.getColumn(vc).getModelIndex();
3347: }
3348:
3349:
3361: public int convertColumnIndexToView(int mc)
3362: {
3363: if (mc < 0)
3364: return mc;
3365: int ncols = getColumnCount();
3366: for (int vc = 0; vc < ncols; ++vc)
3367: {
3368: if (columnModel.getColumn(vc).getModelIndex() == mc)
3369: return vc;
3370: }
3371: return -1;
3372: }
3373:
3374:
3383: public Component prepareRenderer(TableCellRenderer renderer,
3384: int row,
3385: int column)
3386: {
3387: boolean rowSelAllowed = getRowSelectionAllowed();
3388: boolean colSelAllowed = getColumnSelectionAllowed();
3389: boolean isSel = false;
3390: if (rowSelAllowed && colSelAllowed || !rowSelAllowed && !colSelAllowed)
3391: isSel = isCellSelected(row, column);
3392: else
3393: isSel = isRowSelected(row) && getRowSelectionAllowed()
3394: || isColumnSelected(column) && getColumnSelectionAllowed();
3395:
3396:
3397:
3398: ListSelectionModel rowSel = getSelectionModel();
3399: ListSelectionModel colSel = getColumnModel().getSelectionModel();
3400: boolean hasFocus = hasFocus() && isEnabled()
3401: && rowSel.getLeadSelectionIndex() == row
3402: && colSel.getLeadSelectionIndex() == column;
3403:
3404: return renderer.getTableCellRendererComponent(this,
3405: dataModel.getValueAt(row,
3406: convertColumnIndexToModel(column)),
3407: isSel,
3408: hasFocus,
3409: row, column);
3410: }
3411:
3412:
3413:
3418: public boolean getAutoCreateColumnsFromModel()
3419: {
3420: return autoCreateColumnsFromModel;
3421: }
3422:
3423:
3428: public int getAutoResizeMode()
3429: {
3430: return autoResizeMode;
3431: }
3432:
3433:
3438: public int getRowHeight()
3439: {
3440: return rowHeight;
3441: }
3442:
3443:
3448: public int getRowHeight(int row)
3449: {
3450: int rh = rowHeight;
3451: if (rowHeights != null)
3452: rh = rowHeights.getSize(row);
3453: return rh;
3454: }
3455:
3456:
3457:
3462: public int getRowMargin()
3463: {
3464: return rowMargin;
3465: }
3466:
3467:
3472: public boolean getRowSelectionAllowed()
3473: {
3474: return rowSelectionAllowed;
3475: }
3476:
3477:
3482: public boolean getCellSelectionEnabled()
3483: {
3484: return getColumnSelectionAllowed() && getRowSelectionAllowed();
3485: }
3486:
3487:
3492: public TableModel getModel()
3493: {
3494: return dataModel;
3495: }
3496:
3497:
3503: public int getColumnCount()
3504: {
3505: return columnModel.getColumnCount();
3506: }
3507:
3508:
3514: public int getRowCount()
3515: {
3516: return dataModel.getRowCount();
3517: }
3518:
3519:
3524: public TableColumnModel getColumnModel()
3525: {
3526: return columnModel;
3527: }
3528:
3529:
3535: public int getSelectedColumn()
3536: {
3537: return columnModel.getSelectionModel().getMinSelectionIndex();
3538: }
3539:
3540: private static int countSelections(ListSelectionModel lsm)
3541: {
3542: int lo = lsm.getMinSelectionIndex();
3543: int hi = lsm.getMaxSelectionIndex();
3544: int sum = 0;
3545: if (lo != -1 && hi != -1)
3546: {
3547: switch (lsm.getSelectionMode())
3548: {
3549: case ListSelectionModel.SINGLE_SELECTION:
3550: sum = 1;
3551: break;
3552:
3553: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
3554: sum = hi - lo + 1;
3555: break;
3556:
3557: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
3558: for (int i = lo; i <= hi; ++i)
3559: if (lsm.isSelectedIndex(i))
3560: ++sum;
3561: break;
3562: }
3563: }
3564: return sum;
3565: }
3566:
3567: private static int[] getSelections(ListSelectionModel lsm)
3568: {
3569: int sz = countSelections(lsm);
3570: int [] ret = new int[sz];
3571:
3572: int lo = lsm.getMinSelectionIndex();
3573: int hi = lsm.getMaxSelectionIndex();
3574: int j = 0;
3575: if (lo != -1 && hi != -1)
3576: {
3577: switch (lsm.getSelectionMode())
3578: {
3579: case ListSelectionModel.SINGLE_SELECTION:
3580: ret[0] = lo;
3581: break;
3582:
3583: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
3584: for (int i = lo; i <= hi; ++i)
3585: ret[j++] = i;
3586: break;
3587:
3588: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
3589: for (int i = lo; i <= hi; ++i)
3590: if (lsm.isSelectedIndex(i))
3591: ret[j++] = i;
3592: break;
3593: }
3594: }
3595: return ret;
3596: }
3597:
3598:
3604: public int getSelectedColumnCount()
3605: {
3606: return countSelections(columnModel.getSelectionModel());
3607: }
3608:
3609:
3615: public int[] getSelectedColumns()
3616: {
3617: return getSelections(columnModel.getSelectionModel());
3618: }
3619:
3620:
3625: public boolean getColumnSelectionAllowed()
3626: {
3627: return getColumnModel().getColumnSelectionAllowed();
3628: }
3629:
3630:
3636: public int getSelectedRowCount()
3637: {
3638: return countSelections(selectionModel);
3639: }
3640:
3641:
3647: public int[] getSelectedRows()
3648: {
3649: return getSelections(selectionModel);
3650: }
3651:
3652:
3657: public AccessibleContext getAccessibleContext()
3658: {
3659: if (accessibleContext == null)
3660: {
3661: AccessibleJTable ctx = new AccessibleJTable();
3662: addPropertyChangeListener(ctx);
3663: TableColumnModel tcm = getColumnModel();
3664: tcm.addColumnModelListener(ctx);
3665: tcm.getSelectionModel().addListSelectionListener(ctx);
3666: getSelectionModel().addListSelectionListener(ctx);
3667:
3668: accessibleContext = ctx;
3669: }
3670: return accessibleContext;
3671: }
3672:
3673:
3678: public TableCellEditor getCellEditor()
3679: {
3680: return cellEditor;
3681: }
3682:
3683:
3688: public boolean getDragEnabled()
3689: {
3690: return dragEnabled;
3691: }
3692:
3693:
3698: public Color getGridColor()
3699: {
3700: return gridColor;
3701: }
3702:
3703:
3708: public Dimension getIntercellSpacing()
3709: {
3710: return new Dimension(columnModel.getColumnMargin(), rowMargin);
3711: }
3712:
3713:
3718: public Dimension getPreferredScrollableViewportSize()
3719: {
3720: return preferredViewportSize;
3721: }
3722:
3723:
3728: public Color getSelectionBackground()
3729: {
3730: return selectionBackground;
3731: }
3732:
3733:
3738: public Color getSelectionForeground()
3739: {
3740: return selectionForeground;
3741: }
3742:
3743:
3748: public boolean getShowHorizontalLines()
3749: {
3750: return showHorizontalLines;
3751: }
3752:
3753:
3758: public boolean getShowVerticalLines()
3759: {
3760: return showVerticalLines;
3761: }
3762:
3763:
3768: public JTableHeader getTableHeader()
3769: {
3770: return tableHeader;
3771: }
3772:
3773:
3778: public void removeColumn(TableColumn column)
3779: {
3780: columnModel.removeColumn(column);
3781: }
3782:
3783:
3789: public void moveColumn(int column,int targetColumn)
3790: {
3791: columnModel.moveColumn(column, targetColumn);
3792: }
3793:
3794:
3801: public void setAutoCreateColumnsFromModel(boolean autoCreate)
3802: {
3803: if (autoCreateColumnsFromModel != autoCreate)
3804: {
3805: autoCreateColumnsFromModel = autoCreate;
3806: if (autoCreate)
3807: createDefaultColumnsFromModel();
3808: }
3809: }
3810:
3811:
3816: public void setAutoResizeMode(int a)
3817: {
3818: autoResizeMode = a;
3819: revalidate();
3820: repaint();
3821: }
3822:
3823:
3833: public void setRowHeight(int r)
3834: {
3835: if (r < 1)
3836: throw new IllegalArgumentException();
3837:
3838: clientRowHeightSet = true;
3839:
3840: rowHeight = r;
3841: rowHeights = null;
3842: revalidate();
3843: repaint();
3844: }
3845:
3846:
3852: public void setRowHeight(int row, int rh)
3853: {
3854: if (rowHeights == null)
3855: {
3856: rowHeights = new SizeSequence(getRowCount(), rowHeight);
3857: }
3858: rowHeights.setSize(row, rh);
3859: }
3860:
3861:
3866: public void setRowMargin(int r)
3867: {
3868: rowMargin = r;
3869: revalidate();
3870: repaint();
3871: }
3872:
3873:
3878: public void setRowSelectionAllowed(boolean r)
3879: {
3880: rowSelectionAllowed = r;
3881: repaint();
3882: }
3883:
3884:
3889: public void setCellSelectionEnabled(boolean c)
3890: {
3891: setColumnSelectionAllowed(c);
3892: setRowSelectionAllowed(c);
3893:
3894: cellSelectionEnabled = true;
3895: }
3896:
3897:
3906: public void setModel(TableModel m)
3907: {
3908:
3909: if (m == null)
3910: throw new IllegalArgumentException();
3911:
3912:
3913: if (dataModel == m)
3914: return;
3915:
3916: TableModel oldModel = dataModel;
3917:
3918:
3919: if (dataModel != null)
3920: dataModel.removeTableModelListener(this);
3921:
3922: if (m != null)
3923: {
3924:
3925: dataModel = m;
3926:
3927:
3928: dataModel.addTableModelListener(this);
3929:
3930:
3931: tableChanged(new TableModelEvent(dataModel,
3932: TableModelEvent.HEADER_ROW));
3933:
3934:
3935: if (autoCreateColumnsFromModel)
3936: createDefaultColumnsFromModel();
3937: }
3938:
3939:
3940: firePropertyChange("model", oldModel, dataModel);
3941:
3942:
3943: revalidate();
3944: repaint();
3945: }
3946:
3947:
3956: public void setColumnModel(TableColumnModel c)
3957: {
3958: if (c == null)
3959: throw new IllegalArgumentException();
3960: TableColumnModel tmp = columnModel;
3961: if (tmp != null)
3962: tmp.removeColumnModelListener(this);
3963: if (c != null)
3964: c.addColumnModelListener(this);
3965: columnModel = c;
3966: if (dataModel != null && columnModel != null)
3967: {
3968: int ncols = getColumnCount();
3969: TableColumn column;
3970: for (int i = 0; i < ncols; ++i)
3971: {
3972: column = columnModel.getColumn(i);
3973: if (column.getHeaderValue()==null)
3974: column.setHeaderValue(dataModel.getColumnName(i));
3975: }
3976: }
3977:
3978:
3979:
3980: if (tableHeader != null)
3981: tableHeader.setColumnModel(c);
3982:
3983: revalidate();
3984: repaint();
3985: }
3986:
3987:
3992: public void setColumnSelectionAllowed(boolean c)
3993: {
3994: getColumnModel().setColumnSelectionAllowed(c);
3995: repaint();
3996: }
3997:
3998:
4007: public void setSelectionModel(ListSelectionModel s)
4008: {
4009: if (s == null)
4010: throw new IllegalArgumentException();
4011: ListSelectionModel tmp = selectionModel;
4012: if (tmp != null)
4013: tmp.removeListSelectionListener(this);
4014: if (s != null)
4015: s.addListSelectionListener(this);
4016: selectionModel = s;
4017: }
4018:
4019:
4026: public void setSelectionMode(int s)
4027: {
4028: selectionModel.setSelectionMode(s);
4029: columnModel.getSelectionModel().setSelectionMode(s);
4030:
4031: repaint();
4032: }
4033:
4034:
4043: public void setCellEditor(TableCellEditor c)
4044: {
4045: TableCellEditor tmp = cellEditor;
4046: if (tmp != null)
4047: tmp.removeCellEditorListener(this);
4048: if (c != null)
4049: c.addCellEditorListener(this);
4050: cellEditor = c;
4051: }
4052:
4053:
4058: public void setDragEnabled(boolean d)
4059: {
4060: dragEnabled = d;
4061: }
4062:
4063:
4068: public void setGridColor(Color g)
4069: {
4070: gridColor = g;
4071: repaint();
4072: }
4073:
4074:
4079: public void setIntercellSpacing(Dimension i)
4080: {
4081: rowMargin = i.height;
4082: columnModel.setColumnMargin(i.width);
4083: repaint();
4084: }
4085:
4086:
4091: public void setPreferredScrollableViewportSize(Dimension p)
4092: {
4093: preferredViewportSize = p;
4094: revalidate();
4095: repaint();
4096: }
4097:
4098:
4107: public void setSelectionBackground(Color s)
4108: {
4109: Color tmp = selectionBackground;
4110: selectionBackground = s;
4111: if (((tmp == null && s != null)
4112: || (s == null && tmp != null)
4113: || (tmp != null && s != null && !tmp.equals(s))))
4114: firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
4115: repaint();
4116: }
4117:
4118:
4127: public void setSelectionForeground(Color s)
4128: {
4129: Color tmp = selectionForeground;
4130: selectionForeground = s;
4131: if (((tmp == null && s != null)
4132: || (s == null && tmp != null)
4133: || (tmp != null && s != null && !tmp.equals(s))))
4134: firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
4135: repaint();
4136: }
4137:
4138:
4143: public void setShowGrid(boolean s)
4144: {
4145: setShowVerticalLines(s);
4146: setShowHorizontalLines(s);
4147: }
4148:
4149:
4154: public void setShowHorizontalLines(boolean s)
4155: {
4156: showHorizontalLines = s;
4157: repaint();
4158: }
4159:
4160:
4165: public void setShowVerticalLines(boolean s)
4166: {
4167: showVerticalLines = s;
4168: repaint();
4169: }
4170:
4171:
4176: public void setTableHeader(JTableHeader t)
4177: {
4178: if (tableHeader != null)
4179: tableHeader.setTable(null);
4180: tableHeader = t;
4181: if (tableHeader != null)
4182: tableHeader.setTable(this);
4183: revalidate();
4184: repaint();
4185: }
4186:
4187: protected void configureEnclosingScrollPane()
4188: {
4189: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4190: if (jsp != null && tableHeader != null)
4191: {
4192: jsp.setColumnHeaderView(tableHeader);
4193: }
4194: }
4195:
4196: protected void unconfigureEnclosingScrollPane()
4197: {
4198: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4199: if (jsp != null)
4200: {
4201: jsp.setColumnHeaderView(null);
4202: }
4203: }
4204:
4205:
4206: public void addNotify()
4207: {
4208: super.addNotify();
4209: configureEnclosingScrollPane();
4210: }
4211:
4212: public void removeNotify()
4213: {
4214: super.addNotify();
4215: unconfigureEnclosingScrollPane();
4216: }
4217:
4218:
4219:
4227: private void distributeSpill(TableColumn[] cols, int spill)
4228: {
4229: int average = spill / cols.length;
4230: for (int i = 0; i < cols.length; i++)
4231: {
4232: if (cols[i] != null)
4233: cols[i].setWidth(cols[i].getPreferredWidth() + average);
4234: }
4235: }
4236:
4237:
4241: private void distributeSpillResizing(TableColumn[] cols, int spill,
4242: TableColumn resizeIt)
4243: {
4244: int average = 0;
4245: if (cols.length != 1)
4246: average = spill / (cols.length-1);
4247: for (int i = 0; i < cols.length; i++)
4248: {
4249: if (cols[i] != null && !cols[i].equals(resizeIt))
4250: cols[i].setWidth(cols[i].getPreferredWidth() + average);
4251: }
4252: resizeIt.setWidth(resizeIt.getPreferredWidth());
4253: }
4254:
4255:
4263: public void doLayout()
4264: {
4265: TableColumn resizingColumn = null;
4266:
4267: int ncols = getColumnCount();
4268: if (ncols < 1)
4269: return;
4270:
4271: int prefSum = 0;
4272: int rCol = -1;
4273:
4274: if (tableHeader != null)
4275: resizingColumn = tableHeader.getResizingColumn();
4276:
4277: for (int i = 0; i < ncols; ++i)
4278: {
4279: TableColumn col = columnModel.getColumn(i);
4280: int p = col.getPreferredWidth();
4281: prefSum += p;
4282: if (resizingColumn == col)
4283: rCol = i;
4284: }
4285:
4286: int spill = getWidth() - prefSum;
4287:
4288: if (resizingColumn != null)
4289: {
4290: TableColumn col;
4291: TableColumn [] cols;
4292:
4293: switch (getAutoResizeMode())
4294: {
4295: case AUTO_RESIZE_LAST_COLUMN:
4296: col = columnModel.getColumn(ncols-1);
4297: col.setWidth(col.getPreferredWidth() + spill);
4298: break;
4299:
4300: case AUTO_RESIZE_NEXT_COLUMN:
4301: col = columnModel.getColumn(ncols-1);
4302: col.setWidth(col.getPreferredWidth() + spill);
4303: break;
4304:
4305: case AUTO_RESIZE_ALL_COLUMNS:
4306: cols = new TableColumn[ncols];
4307: for (int i = 0; i < ncols; ++i)
4308: cols[i] = columnModel.getColumn(i);
4309: distributeSpillResizing(cols, spill, resizingColumn);
4310: break;
4311:
4312: case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
4313:
4314:
4315: int w = 0;
4316: int wp = 0;
4317: TableColumn column;
4318: for (int i = 0; i < rCol; i++)
4319: {
4320: column = columnModel.getColumn(i);
4321: w += column.getWidth();
4322: wp+= column.getPreferredWidth();
4323: }
4324:
4325:
4326: int n = ncols-rCol-1;
4327: if (n>0)
4328: {
4329:
4330: spill = (getWidth()-w) - (prefSum-wp);
4331: int average = spill / n;
4332:
4333:
4334: for (int i = rCol+1; i < ncols; i++)
4335: {
4336: column = columnModel.getColumn(i);
4337: column.setWidth(column.getPreferredWidth() + average);
4338: }
4339: }
4340: resizingColumn.setWidth(resizingColumn.getPreferredWidth());
4341: break;
4342:
4343: case AUTO_RESIZE_OFF:
4344: default:
4345: int prefWidth = resizingColumn.getPreferredWidth();
4346: resizingColumn.setWidth(prefWidth);
4347: }
4348: }
4349: else
4350: {
4351: TableColumn [] cols = new TableColumn[ncols];
4352: for (int i = 0; i < ncols; ++i)
4353: cols[i] = columnModel.getColumn(i);
4354: distributeSpill(cols, spill);
4355: }
4356:
4357: if (editorComp!=null)
4358: moveToCellBeingEdited(editorComp);
4359:
4360: int leftBoundary = getLeftResizingBoundary();
4361: int width = getWidth() - leftBoundary;
4362: repaint(leftBoundary, 0, width, getHeight());
4363: if (tableHeader != null)
4364: tableHeader.repaint(leftBoundary, 0, width, tableHeader.getHeight());
4365: }
4366:
4367:
4371: int getLeftResizingBoundary()
4372: {
4373: if (tableHeader == null || getAutoResizeMode() == AUTO_RESIZE_ALL_COLUMNS)
4374: return 0;
4375: else
4376: {
4377: TableColumn resizingColumn = tableHeader.getResizingColumn();
4378: if (resizingColumn == null)
4379: return 0;
4380:
4381: int rc = convertColumnIndexToView(resizingColumn.getModelIndex());
4382: int p = 0;
4383:
4384: for (int i = 0; i < rc; i++)
4385: p += columnModel.getColumn(i).getWidth();
4386:
4387: return p;
4388: }
4389: }
4390:
4391:
4392:
4395: public void sizeColumnsToFit(boolean lastColumnOnly)
4396: {
4397: doLayout();
4398: }
4399:
4400:
4403: public void sizeColumnsToFit(int resizingColumn)
4404: {
4405: doLayout();
4406: }
4407:
4408: public String getUIClassID()
4409: {
4410: return "TableUI";
4411: }
4412:
4413:
4418: public TableUI getUI()
4419: {
4420: return (TableUI) ui;
4421: }
4422:
4423:
4428: public void setUI(TableUI ui)
4429: {
4430: super.setUI(ui);
4431:
4432:
4433: createDefaultEditors();
4434: createDefaultRenderers();
4435: }
4436:
4437: public void updateUI()
4438: {
4439: setUI((TableUI) UIManager.getUI(this));
4440: }
4441:
4442:
4451: public Class getColumnClass(int column)
4452: {
4453: return getModel().getColumnClass(convertColumnIndexToModel(column));
4454: }
4455:
4456:
4467: public String getColumnName(int column)
4468: {
4469: int modelColumn = columnModel.getColumn(column).getModelIndex();
4470: return dataModel.getColumnName(modelColumn);
4471: }
4472:
4473:
4478: public int getEditingColumn()
4479: {
4480: return editingColumn;
4481: }
4482:
4483:
4488: public void setEditingColumn(int column)
4489: {
4490: editingColumn = column;
4491: }
4492:
4493:
4498: public int getEditingRow()
4499: {
4500: return editingRow;
4501: }
4502:
4503:
4508: public void setEditingRow(int row)
4509: {
4510: editingRow = row;
4511: }
4512:
4513:
4519: public Component getEditorComponent()
4520: {
4521: return editorComp;
4522: }
4523:
4524:
4529: public boolean isEditing()
4530: {
4531: return editorComp != null;
4532: }
4533:
4534:
4544: public void setDefaultEditor(Class columnClass, TableCellEditor editor)
4545: {
4546: if (editor != null)
4547: defaultEditorsByColumnClass.put(columnClass, editor);
4548: else
4549: defaultEditorsByColumnClass.remove(columnClass);
4550: }
4551:
4552: public void addColumnSelectionInterval(int index0, int index1)
4553: {
4554: if ((index0 < 0 || index0 > (getColumnCount()-1)
4555: || index1 < 0 || index1 > (getColumnCount()-1)))
4556: throw new IllegalArgumentException("Column index out of range.");
4557:
4558: getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
4559: }
4560:
4561: public void addRowSelectionInterval(int index0, int index1)
4562: {
4563: if ((index0 < 0 || index0 > (getRowCount()-1)
4564: || index1 < 0 || index1 > (getRowCount()-1)))
4565: throw new IllegalArgumentException("Row index out of range.");
4566:
4567: getSelectionModel().addSelectionInterval(index0, index1);
4568: }
4569:
4570: public void setColumnSelectionInterval(int index0, int index1)
4571: {
4572: if ((index0 < 0 || index0 > (getColumnCount()-1)
4573: || index1 < 0 || index1 > (getColumnCount()-1)))
4574: throw new IllegalArgumentException("Column index out of range.");
4575:
4576: getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
4577: }
4578:
4579: public void setRowSelectionInterval(int index0, int index1)
4580: {
4581: if ((index0 < 0 || index0 > (getRowCount()-1)
4582: || index1 < 0 || index1 > (getRowCount()-1)))
4583: throw new IllegalArgumentException("Row index out of range.");
4584:
4585: getSelectionModel().setSelectionInterval(index0, index1);
4586: }
4587:
4588: public void removeColumnSelectionInterval(int index0, int index1)
4589: {
4590: if ((index0 < 0 || index0 > (getColumnCount()-1)
4591: || index1 < 0 || index1 > (getColumnCount()-1)))
4592: throw new IllegalArgumentException("Column index out of range.");
4593:
4594: getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
4595: }
4596:
4597: public void removeRowSelectionInterval(int index0, int index1)
4598: {
4599: if ((index0 < 0 || index0 > (getRowCount()-1)
4600: || index1 < 0 || index1 > (getRowCount()-1)))
4601: throw new IllegalArgumentException("Row index out of range.");
4602:
4603: getSelectionModel().removeSelectionInterval(index0, index1);
4604: }
4605:
4606:
4614: public boolean isColumnSelected(int column)
4615: {
4616: return getColumnModel().getSelectionModel().isSelectedIndex(column);
4617: }
4618:
4619:
4627: public boolean isRowSelected(int row)
4628: {
4629: return getSelectionModel().isSelectedIndex(row);
4630: }
4631:
4632:
4641: public boolean isCellSelected(int row, int column)
4642: {
4643: return isRowSelected(row) && isColumnSelected(column);
4644: }
4645:
4646:
4649: public void selectAll()
4650: {
4651:
4652: if (getRowCount() == 0 || getColumnCount() == 0)
4653: return;
4654:
4655:
4656: int rowLead = selectionModel.getLeadSelectionIndex();
4657: int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
4658:
4659:
4660: setColumnSelectionInterval(0, getColumnCount() - 1);
4661: setRowSelectionInterval(0, getRowCount() - 1);
4662:
4663:
4664: addColumnSelectionInterval(colLead,colLead);
4665: addRowSelectionInterval(rowLead, rowLead);
4666: }
4667:
4668:
4677: public Object getValueAt(int row, int column)
4678: {
4679: return dataModel.getValueAt(row, convertColumnIndexToModel(column));
4680: }
4681:
4682:
4690: public void setValueAt(Object value, int row, int column)
4691: {
4692: dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
4693:
4694: repaint(getCellRect(row, column, true));
4695: }
4696:
4697:
4709: public TableColumn getColumn(Object identifier)
4710: {
4711: return columnModel.getColumn(columnModel.getColumnIndex(identifier));
4712: }
4713:
4714:
4723: public boolean isCellEditable(int row, int column)
4724: {
4725: return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
4726: }
4727:
4728:
4735: public void createDefaultColumnsFromModel()
4736: {
4737: assert columnModel != null : "The columnModel must not be null.";
4738:
4739:
4740: int columnIndex = columnModel.getColumnCount() - 1;
4741: while (columnIndex >= 0)
4742: {
4743: columnModel.removeColumn(columnModel.getColumn(columnIndex));
4744: columnIndex--;
4745: }
4746:
4747:
4748: int columnCount = dataModel.getColumnCount();
4749: for (int c = 0; c < columnCount; c++)
4750: {
4751: TableColumn column = new TableColumn(c);
4752: column.setIdentifier(dataModel.getColumnName(c));
4753: column.setHeaderValue(dataModel.getColumnName(c));
4754: columnModel.addColumn(column);
4755: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
4756: }
4757: }
4758:
4759: public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
4760: {
4761: if (toggle && extend)
4762: {
4763:
4764:
4765: selectionModel.setAnchorSelectionIndex(rowIndex);
4766: getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
4767: }
4768: else if (toggle)
4769: {
4770:
4771: if (isCellSelected(rowIndex,columnIndex))
4772: {
4773: selectionModel.removeSelectionInterval(rowIndex,rowIndex);
4774: getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
4775: }
4776: else
4777: {
4778: selectionModel.addSelectionInterval(rowIndex,rowIndex);
4779: getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
4780: }
4781: }
4782: else if (extend)
4783: {
4784:
4785:
4786: selectionModel.setLeadSelectionIndex(rowIndex);
4787: getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
4788: }
4789: else
4790: {
4791:
4792:
4793: selectionModel.clearSelection();
4794: selectionModel.setSelectionInterval(rowIndex,rowIndex);
4795: getColumnModel().getSelectionModel().clearSelection();
4796: getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
4797:
4798:
4799: }
4800: }
4801:
4802:
4808: public boolean editCellAt(int row, int column)
4809: {
4810:
4811: if (isEditing())
4812: editingStopped(new ChangeEvent("editingStopped"));
4813:
4814: TableCellEditor editor = getCellEditor(row, column);
4815:
4816:
4817:
4818: if (editor == booleanInvertingEditor && isCellEditable(row, column))
4819: {
4820: if (Boolean.TRUE.equals(getValueAt(row, column)))
4821: setValueAt(Boolean.FALSE, row, column);
4822: else
4823: setValueAt(Boolean.TRUE, row, column);
4824: return false;
4825: }
4826: else
4827: {
4828: editingRow = row;
4829: editingColumn = column;
4830:
4831: setCellEditor(editor);
4832: editorComp = prepareEditor(cellEditor, row, column);
4833:
4834:
4835:
4836: removeAll();
4837: add(editorComp);
4838: moveToCellBeingEdited(editorComp);
4839: scrollRectToVisible(editorComp.getBounds());
4840: editorComp.requestFocusInWindow();
4841:
4842:
4843: return editor.shouldSelectCell(null);
4844: }
4845: }
4846:
4847:
4853: private void moveToCellBeingEdited(Component component)
4854: {
4855: Rectangle r = getCellRect(editingRow, editingColumn, true);
4856:
4857:
4858:
4859: r.x -= 1;
4860: r.y -= 1;
4861: r.width += 1;
4862: r.height += 1;
4863: component.setBounds(r);
4864: }
4865:
4866:
4872: public boolean editCellAt (int row, int column, EventObject e)
4873: {
4874: return editCellAt(row, column);
4875: }
4876:
4877:
4880: public void removeEditor()
4881: {
4882: editingStopped(new ChangeEvent(this));
4883: }
4884:
4885:
4894: public Component prepareEditor (TableCellEditor editor, int row, int column)
4895: {
4896: return editor.getTableCellEditorComponent
4897: (this, getValueAt(row, column), isCellSelected(row, column), row, column);
4898: }
4899:
4900:
4903: protected void resizeAndRepaint()
4904: {
4905: revalidate();
4906: repaint();
4907: }
4908:
4909:
4919: public void setSurrendersFocusOnKeystroke(boolean value)
4920: {
4921:
4922: surrendersFocusOnKeystroke = value;
4923: }
4924:
4925:
4936: public boolean getSurrendersFocusOnKeystroke()
4937: {
4938:
4939: return surrendersFocusOnKeystroke;
4940: }
4941:
4942:
4956: void setUIProperty(String propertyName, Object value)
4957: {
4958: if (propertyName.equals("rowHeight"))
4959: {
4960: if (! clientRowHeightSet)
4961: {
4962: setRowHeight(((Integer) value).intValue());
4963: clientRowHeightSet = false;
4964: }
4965: }
4966: else
4967: {
4968: super.setUIProperty(propertyName, value);
4969: }
4970: }
4971: }