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: import ;
60: import ;
61:
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: import ;
89: import ;
90:
91: public class JTable
92: extends JComponent
93: implements TableModelListener, Scrollable, TableColumnModelListener,
94: ListSelectionListener, CellEditorListener, Accessible
95: {
96:
101: protected class AccessibleJTable
102: extends AccessibleJComponent
103: implements AccessibleSelection, ListSelectionListener, TableModelListener,
104: TableColumnModelListener, CellEditorListener, PropertyChangeListener,
105: AccessibleExtendedTable
106: {
107:
108:
113: protected class AccessibleJTableCell
114: extends AccessibleContext
115: implements Accessible, AccessibleComponent
116: {
117:
118:
121: private JTable table;
122:
123:
126: private int row;
127:
128:
131: private int column;
132:
133:
136: private int index;
137:
138:
146: public AccessibleJTableCell(JTable t, int r, int c, int i)
147: {
148: table = t;
149: row = r;
150: column = c;
151: index = i;
152: }
153:
154:
159: public AccessibleRole getAccessibleRole()
160: {
161:
162: return AccessibleRole.UNKNOWN;
163: }
164:
165:
170: public AccessibleStateSet getAccessibleStateSet()
171: {
172:
173: return new AccessibleStateSet();
174: }
175:
176:
181: public int getAccessibleIndexInParent()
182: {
183: return index;
184: }
185:
186:
192: public int getAccessibleChildrenCount()
193: {
194: return 0;
195: }
196:
197:
203: public Accessible getAccessibleChild(int i)
204: {
205: return null;
206: }
207:
208:
213: public Locale getLocale()
214: {
215:
216:
217: return Locale.ENGLISH;
218: }
219:
220:
227: public AccessibleContext getAccessibleContext()
228: {
229: return this;
230: }
231:
232:
237: public Color getBackground()
238: {
239: return table.getBackground();
240: }
241:
242:
249: public void setBackground(Color color)
250: {
251:
252: }
253:
254:
259: public Color getForeground()
260: {
261: return table.getForeground();
262: }
263:
264:
271: public void setForeground(Color color)
272: {
273:
274: }
275:
276:
281: public Cursor getCursor()
282: {
283: return table.getCursor();
284: }
285:
286:
293: public void setCursor(Cursor cursor)
294: {
295:
296: }
297:
298:
303: public Font getFont()
304: {
305: return table.getFont();
306: }
307:
308:
315: public void setFont(Font font)
316: {
317:
318: }
319:
320:
327: public FontMetrics getFontMetrics(Font font)
328: {
329: return table.getFontMetrics(font);
330: }
331:
332:
339: public boolean isEnabled()
340: {
341: return table.isEnabled();
342: }
343:
344:
350: public void setEnabled(boolean b)
351: {
352:
353: }
354:
355:
362: public boolean isVisible()
363: {
364: return table.isVisible();
365: }
366:
367:
373: public void setVisible(boolean b)
374: {
375:
376: }
377:
378:
385: public boolean isShowing()
386: {
387: return table.isShowing();
388: }
389:
390:
399: public boolean contains(Point point)
400: {
401: Rectangle cellRect = table.getCellRect(row, column, true);
402: cellRect.x = 0;
403: cellRect.y = 0;
404: return cellRect.contains(point);
405: }
406:
407:
412: public Point getLocationOnScreen()
413: {
414: Point tableLoc = table.getLocationOnScreen();
415: Rectangle cellRect = table.getCellRect(row, column, true);
416: tableLoc.x += cellRect.x;
417: tableLoc.y += cellRect.y;
418: return tableLoc;
419: }
420:
421:
426: public Point getLocation()
427: {
428: Rectangle cellRect = table.getCellRect(row, column, true);
429: return new Point(cellRect.x, cellRect.y);
430: }
431:
432:
438: public void setLocation(Point point)
439: {
440:
441: }
442:
443:
448: public Rectangle getBounds()
449: {
450: return table.getCellRect(row, column, true);
451: }
452:
453:
459: public void setBounds(Rectangle rectangle)
460: {
461:
462: }
463:
464:
469: public Dimension getSize()
470: {
471: Rectangle cellRect = table.getCellRect(row, column, true);
472: return new Dimension(cellRect.width, cellRect.height);
473: }
474:
475:
481: public void setSize(Dimension dimension)
482: {
483:
484: }
485:
486:
491: public Accessible getAccessibleAt(Point point)
492: {
493: return null;
494: }
495:
496:
503: public boolean isFocusTraversable()
504: {
505: return table.isFocusable();
506: }
507:
508:
511: public void requestFocus()
512: {
513:
514: table.getColumnModel().getSelectionModel()
515: .setLeadSelectionIndex(column);
516: table.getSelectionModel().setLeadSelectionIndex(row);
517:
518: table.requestFocus();
519: }
520:
521:
528: public void addFocusListener(FocusListener listener)
529: {
530: table.addFocusListener(listener);
531: }
532:
533:
539: public void removeFocusListener(FocusListener listener)
540: {
541: table.removeFocusListener(listener);
542: }
543:
544: }
545:
546: protected class AccessibleJTableModelChange
547: implements AccessibleTableModelChange
548: {
549: protected int type;
550: protected int firstRow;
551: protected int lastRow;
552: protected int firstColumn;
553: protected int lastColumn;
554:
555: protected AccessibleJTableModelChange(int type, int firstRow,
556: int lastRow, int firstColumn,
557: int lastColumn)
558: {
559: this.type = type;
560: this.firstRow = firstRow;
561: this.lastRow = lastRow;
562: this.firstColumn = firstColumn;
563: this.lastColumn = lastColumn;
564: }
565:
566: public int getType()
567: {
568: return type;
569: }
570:
571: public int getFirstRow()
572: {
573: return firstRow;
574: }
575:
576: public int getLastRow()
577: {
578: return lastRow;
579: }
580:
581: public int getFirstColumn()
582: {
583: return firstColumn;
584: }
585:
586: public int getLastColumn()
587: {
588: return lastColumn;
589: }
590: }
591:
592:
597: protected AccessibleJTable()
598: {
599: getModel().addTableModelListener(this);
600: getSelectionModel().addListSelectionListener(this);
601: getColumnModel().addColumnModelListener(this);
602: getCellEditor().addCellEditorListener(this);
603: }
604:
605:
608: public int getAccessibleSelectionCount()
609: {
610: return getSelectedColumnCount();
611: }
612:
613: public Accessible getAccessibleSelection(int i)
614: {
615:
616: return null;
617: }
618:
619: public boolean isAccessibleChildSelected(int i)
620: {
621:
622: return false;
623: }
624:
625: public void addAccessibleSelection(int i)
626: {
627:
628:
629: }
630:
631: public void removeAccessibleSelection(int i)
632: {
633:
634:
635: }
636:
637: public void clearAccessibleSelection()
638: {
639:
640:
641: }
642:
643: public void selectAllAccessibleSelection()
644: {
645:
646:
647: }
648:
649: public void valueChanged(ListSelectionEvent event)
650: {
651:
652:
653: }
654:
655:
662: public void tableChanged(TableModelEvent event)
663: {
664: switch (event.getType())
665: {
666: case TableModelEvent.INSERT:
667: tableRowsInserted(event);
668: break;
669: case TableModelEvent.DELETE:
670: tableRowsDeleted(event);
671: break;
672: }
673: }
674:
675:
681: public void tableRowsInserted(TableModelEvent event)
682: {
683:
684:
685: }
686:
687:
693: public void tableRowsDeleted(TableModelEvent event)
694: {
695:
696:
697: }
698:
699: public void columnAdded(TableColumnModelEvent event)
700: {
701:
702:
703: }
704:
705: public void columnMarginChanged(ChangeEvent event)
706: {
707:
708:
709: }
710:
711: public void columnMoved(TableColumnModelEvent event)
712: {
713:
714:
715: }
716:
717: public void columnRemoved(TableColumnModelEvent event)
718: {
719:
720:
721: }
722:
723: public void columnSelectionChanged(ListSelectionEvent event)
724: {
725:
726:
727: }
728:
729: public void editingCanceled(ChangeEvent event)
730: {
731:
732:
733: }
734:
735: public void editingStopped(ChangeEvent event)
736: {
737:
738:
739: }
740:
741:
748: public void propertyChange(PropertyChangeEvent e)
749: {
750: String propName = e.getPropertyName();
751: if (propName.equals("tableModel"))
752: {
753: TableModel oldModel = (TableModel) e.getOldValue();
754: oldModel.removeTableModelListener(this);
755: TableModel newModel = (TableModel) e.getNewValue();
756: newModel.addTableModelListener(this);
757: }
758: else if (propName.equals("columnModel"))
759: {
760: TableColumnModel oldModel = (TableColumnModel) e.getOldValue();
761: oldModel.removeColumnModelListener(this);
762: TableColumnModel newModel = (TableColumnModel) e.getNewValue();
763: newModel.addColumnModelListener(this);
764: }
765: else if (propName.equals("selectionModel"))
766: {
767: ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue();
768: oldModel.removeListSelectionListener(this);
769: ListSelectionModel newModel = (ListSelectionModel) e.getNewValue();
770: newModel.addListSelectionListener(this);
771: }
772: else if (propName.equals("cellEditor"))
773: {
774: CellEditor oldEd = (CellEditor) e.getOldValue();
775: oldEd.removeCellEditorListener(this);
776: CellEditor newEd = (CellEditor) e.getNewValue();
777: newEd.addCellEditorListener(this);
778: }
779: }
780:
781: public int getAccessibleRow(int index)
782: {
783:
784: return 0;
785: }
786:
787: public int getAccessibleColumn(int index)
788: {
789:
790: return 0;
791: }
792:
793: public int getAccessibleIndex(int r, int c)
794: {
795:
796: return 0;
797: }
798:
799: public Accessible getAccessibleCaption()
800: {
801:
802: return null;
803: }
804:
805: public void setAccessibleCaption(Accessible caption)
806: {
807:
808:
809: }
810:
811: public Accessible getAccessibleSummary()
812: {
813:
814: return null;
815: }
816:
817: public void setAccessibleSummary(Accessible summary)
818: {
819:
820:
821: }
822:
823: public int getAccessibleRowCount()
824: {
825:
826: return 0;
827: }
828:
829: public int getAccessibleColumnCount()
830: {
831:
832: return 0;
833: }
834:
835: public Accessible getAccessibleAt(int r, int c)
836: {
837:
838: return null;
839: }
840:
841: public int getAccessibleRowExtentAt(int r, int c)
842: {
843:
844: return 0;
845: }
846:
847: public int getAccessibleColumnExtentAt(int r, int c)
848: {
849:
850: return 0;
851: }
852:
853: public AccessibleTable getAccessibleRowHeader()
854: {
855:
856: return null;
857: }
858:
859: public void setAccessibleRowHeader(AccessibleTable header)
860: {
861:
862:
863: }
864:
865: public AccessibleTable getAccessibleColumnHeader()
866: {
867:
868: return null;
869: }
870:
871: public void setAccessibleColumnHeader(AccessibleTable header)
872: {
873:
874:
875: }
876:
877: public Accessible getAccessibleRowDescription(int r)
878: {
879:
880: return null;
881: }
882:
883: public void setAccessibleRowDescription(int r, Accessible description)
884: {
885:
886:
887: }
888:
889: public Accessible getAccessibleColumnDescription(int c)
890: {
891:
892: return null;
893: }
894:
895: public void setAccessibleColumnDescription(int c, Accessible description)
896: {
897:
898:
899: }
900:
901: public boolean isAccessibleSelected(int r, int c)
902: {
903:
904: return false;
905: }
906:
907: public boolean isAccessibleRowSelected(int r)
908: {
909:
910: return false;
911: }
912:
913: public boolean isAccessibleColumnSelected(int c)
914: {
915:
916: return false;
917: }
918:
919: public int[] getSelectedAccessibleRows()
920: {
921:
922: return null;
923: }
924:
925: public int[] getSelectedAccessibleColumns()
926: {
927:
928: return null;
929: }
930:
931:
938: public int getAccessibleRowAtIndex(int index)
939: {
940:
941: return index / getColumnCount();
942: }
943:
944:
951: public int getAccessibleColumnAtIndex(int index)
952: {
953:
954: return index % getColumnCount();
955: }
956:
957:
966: public int getAccessibleIndexAt(int row, int column)
967: {
968:
969: return row * getColumnCount() + column;
970: }
971: }
972:
979: class TableColumnPropertyChangeHandler implements PropertyChangeListener
980: {
981:
987: public void propertyChange(PropertyChangeEvent ev)
988: {
989: if (ev.getPropertyName().equals("preferredWidth"))
990: {
991: JTableHeader header = getTableHeader();
992: if (header != null)
993: {
994: TableColumn col = (TableColumn) ev.getSource();
995: header.setResizingColumn(col);
996: doLayout();
997: header.setResizingColumn(null);
998: }
999: }
1000: }
1001: }
1002:
1003:
1006: private class BooleanCellRenderer
1007: extends DefaultTableCellRenderer
1008: {
1009:
1010:
1013: private JCheckBox checkBox = new JCheckBox();
1014:
1015:
1027: public Component getTableCellRendererComponent(JTable table, Object value,
1028: boolean isSelected,
1029: boolean hasFocus, int row,
1030: int column)
1031: {
1032: Boolean boolValue = (Boolean) value;
1033: checkBox.setSelected(boolValue.booleanValue());
1034: return checkBox;
1035: }
1036: }
1037:
1038:
1041: private class DateCellRenderer
1042: extends DefaultTableCellRenderer
1043: {
1044:
1056: public Component getTableCellRendererComponent(JTable table, Object value,
1057: boolean isSelected,
1058: boolean hasFocus, int row,
1059: int column)
1060: {
1061: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1062: row, column);
1063: if (value instanceof Date)
1064: {
1065: Date dateValue = (Date) value;
1066: DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
1067: setText(df.format(dateValue));
1068: }
1069: return this;
1070: }
1071: }
1072:
1073:
1076: private class DoubleCellRenderer
1077: extends DefaultTableCellRenderer
1078: {
1079:
1082: public DoubleCellRenderer()
1083: {
1084: setHorizontalAlignment(JLabel.RIGHT);
1085: }
1086:
1087:
1099: public Component getTableCellRendererComponent(JTable table, Object value,
1100: boolean isSelected,
1101: boolean hasFocus, int row,
1102: int column)
1103: {
1104: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1105: row, column);
1106: if (value instanceof Double)
1107: {
1108: Double doubleValue = (Double) value;
1109: NumberFormat nf = NumberFormat.getInstance();
1110: setText(nf.format(doubleValue.doubleValue()));
1111: }
1112: return this;
1113: }
1114: }
1115:
1116:
1119: private class FloatCellRenderer
1120: extends DefaultTableCellRenderer
1121: {
1122:
1125: public FloatCellRenderer()
1126: {
1127: setHorizontalAlignment(JLabel.RIGHT);
1128: }
1129:
1130:
1142: public Component getTableCellRendererComponent(JTable table, Object value,
1143: boolean isSelected,
1144: boolean hasFocus, int row,
1145: int column)
1146: {
1147: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1148: row, column);
1149: if (value instanceof Float)
1150: {
1151: Float floatValue = (Float) value;
1152: NumberFormat nf = NumberFormat.getInstance();
1153: setText(nf.format(floatValue.floatValue()));
1154: }
1155: return this;
1156: }
1157: }
1158:
1159:
1162: private class NumberCellRenderer
1163: extends DefaultTableCellRenderer
1164: {
1165:
1168: public NumberCellRenderer()
1169: {
1170: setHorizontalAlignment(JLabel.RIGHT);
1171: }
1172: }
1173:
1174:
1177: private class IconCellRenderer
1178: extends DefaultTableCellRenderer
1179: {
1180:
1192: public Component getTableCellRendererComponent(JTable table, Object value,
1193: boolean isSelected,
1194: boolean hasFocus, int row,
1195: int column)
1196: {
1197: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1198: row, column);
1199: if (value instanceof Icon)
1200: {
1201: Icon iconValue = (Icon) value;
1202: setIcon(iconValue);
1203: }
1204: return this;
1205: }
1206: }
1207:
1208: private static final long serialVersionUID = 3876025080382781659L;
1209:
1210:
1211:
1216: public static final int AUTO_RESIZE_OFF = 0;
1217:
1218:
1223: public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
1224:
1225:
1230: public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
1231:
1232:
1238: public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
1239:
1240:
1245: public static final int AUTO_RESIZE_LAST_COLUMN = 3;
1246:
1247:
1248:
1253: protected Hashtable defaultEditorsByColumnClass;
1254:
1255:
1260: protected Hashtable defaultRenderersByColumnClass;
1261:
1262:
1265: protected int editingColumn;
1266:
1267:
1270: protected int editingRow;
1271:
1272:
1277: protected transient Component editorComp;
1278:
1279:
1280:
1291: protected boolean autoCreateColumnsFromModel;
1292:
1293:
1303: protected int autoResizeMode;
1304:
1305:
1316: protected int rowHeight;
1317:
1318:
1328: protected int rowMargin;
1329:
1330:
1343: protected boolean rowSelectionAllowed;
1344:
1345:
1350: protected boolean cellSelectionEnabled;
1351:
1352:
1361: protected TableModel dataModel;
1362:
1363:
1385: protected TableColumnModel columnModel;
1386:
1387:
1399: protected ListSelectionModel selectionModel;
1400:
1401:
1404: protected TableCellEditor cellEditor;
1405:
1406:
1412: private boolean dragEnabled;
1413:
1414:
1421: protected Color gridColor;
1422:
1423:
1430: protected Dimension preferredViewportSize;
1431:
1432:
1440: protected Color selectionBackground;
1441:
1442:
1446: private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
1447:
1448:
1456: protected Color selectionForeground;
1457:
1458:
1462: private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
1463:
1464:
1467: protected boolean showHorizontalLines;
1468:
1469:
1472: protected boolean showVerticalLines;
1473:
1474:
1477: protected JTableHeader tableHeader;
1478:
1479:
1482: int rowBeingEdited = -1;
1483:
1484:
1487: int columnBeingEdited = -1;
1488:
1489:
1492: Timer editorTimer = new EditorUpdateTimer();
1493:
1494:
1498: Object oldCellValue;
1499:
1500:
1503: TableColumnPropertyChangeHandler tableColumnPropertyChangeHandler =
1504: new TableColumnPropertyChangeHandler();
1505:
1506:
1510: private boolean surrendersFocusOnKeystroke = false;
1511:
1512:
1515: public JTable ()
1516: {
1517: this(null, null, null);
1518: }
1519:
1520:
1526: public JTable (int numRows, int numColumns)
1527: {
1528: this(new DefaultTableModel(numRows, numColumns));
1529: }
1530:
1531:
1537: public JTable(Object[][] data, Object[] columnNames)
1538: {
1539: this(new DefaultTableModel(data, columnNames));
1540: }
1541:
1542:
1547: public JTable (TableModel dm)
1548: {
1549: this(dm, null, null);
1550: }
1551:
1552:
1558: public JTable (TableModel dm, TableColumnModel cm)
1559: {
1560: this(dm, cm, null);
1561: }
1562:
1563:
1570: public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
1571: {
1572: boolean autoCreate = false;
1573: if (cm != null)
1574: setColumnModel(cm);
1575: else
1576: {
1577: setColumnModel(createDefaultColumnModel());
1578: autoCreate = true;
1579: }
1580: setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
1581: setModel(dm == null ? createDefaultDataModel() : dm);
1582: setAutoCreateColumnsFromModel(autoCreate);
1583: initializeLocalVars();
1584:
1585:
1586:
1587:
1588:
1589:
1590:
1591: selectionModel.setAnchorSelectionIndex(0);
1592: selectionModel.setLeadSelectionIndex(0);
1593: columnModel.getSelectionModel().setAnchorSelectionIndex(0);
1594: columnModel.getSelectionModel().setLeadSelectionIndex(0);
1595: updateUI();
1596: }
1597:
1598: protected void initializeLocalVars()
1599: {
1600: setTableHeader(createDefaultTableHeader());
1601: if (autoCreateColumnsFromModel)
1602: createDefaultColumnsFromModel();
1603: this.columnModel.addColumnModelListener(this);
1604:
1605: this.defaultRenderersByColumnClass = new Hashtable();
1606: createDefaultRenderers();
1607:
1608: this.defaultEditorsByColumnClass = new Hashtable();
1609: createDefaultEditors();
1610:
1611: this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
1612: this.rowHeight = 16;
1613: this.rowMargin = 1;
1614: this.rowSelectionAllowed = true;
1615:
1616: this.cellEditor = null;
1617:
1618: this.dragEnabled = true;
1619: this.preferredViewportSize = new Dimension(450,400);
1620: this.showHorizontalLines = true;
1621: this.showVerticalLines = true;
1622: this.editingColumn = -1;
1623: this.editingRow = -1;
1624: setIntercellSpacing(new Dimension(1,1));
1625: }
1626:
1627:
1633: public JTable(Vector data, Vector columnNames)
1634: {
1635: this(new DefaultTableModel(data, columnNames));
1636: }
1637:
1638:
1641: private class EditorUpdateTimer
1642: extends Timer
1643: implements ActionListener
1644: {
1645:
1648: public EditorUpdateTimer()
1649: {
1650: super(500, null);
1651: addActionListener(this);
1652: }
1653:
1654:
1657: public void actionPerformed(ActionEvent ev)
1658: {
1659: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
1660: if (c != null)
1661: c.setVisible(!c.isVisible());
1662: JTable.this.repaint();
1663: }
1664:
1665:
1668: public void update()
1669: {
1670: stop();
1671: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
1672: if (c != null)
1673: {
1674: setDelay(c.getBlinkRate());
1675: if (((JTextField)JTable.this.editorComp).isEditable())
1676: start();
1677: else
1678: c.setVisible(false);
1679: }
1680: }
1681: }
1682:
1683: public void addColumn(TableColumn column)
1684: {
1685: if (column.getHeaderValue() == null)
1686: {
1687: String name = dataModel.getColumnName(column.getModelIndex());
1688: column.setHeaderValue(name);
1689: }
1690:
1691: columnModel.addColumn(column);
1692: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
1693: }
1694:
1695: protected void createDefaultEditors()
1696: {
1697:
1698: }
1699:
1700: protected void createDefaultRenderers()
1701: {
1702: setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
1703: setDefaultRenderer(Number.class, new NumberCellRenderer());
1704: setDefaultRenderer(Double.class, new DoubleCellRenderer());
1705: setDefaultRenderer(Double.class, new FloatCellRenderer());
1706: setDefaultRenderer(Date.class, new DateCellRenderer());
1707: setDefaultRenderer(Icon.class, new IconCellRenderer());
1708: }
1709:
1710:
1713: public static JScrollPane createScrollPaneForTable(JTable table)
1714: {
1715: return new JScrollPane(table);
1716: }
1717:
1718: protected TableColumnModel createDefaultColumnModel()
1719: {
1720: return new DefaultTableColumnModel();
1721: }
1722:
1723: protected TableModel createDefaultDataModel()
1724: {
1725: return new DefaultTableModel();
1726: }
1727:
1728: protected ListSelectionModel createDefaultSelectionModel()
1729: {
1730: return new DefaultListSelectionModel();
1731: }
1732:
1733: protected JTableHeader createDefaultTableHeader()
1734: {
1735: return new JTableHeader(columnModel);
1736: }
1737:
1738:
1739:
1740: public void columnAdded (TableColumnModelEvent event)
1741: {
1742: revalidate();
1743: repaint();
1744: }
1745:
1746: public void columnMarginChanged (ChangeEvent event)
1747: {
1748: revalidate();
1749: repaint();
1750: }
1751:
1752: public void columnMoved (TableColumnModelEvent event)
1753: {
1754: revalidate();
1755: repaint();
1756: }
1757:
1758: public void columnRemoved (TableColumnModelEvent event)
1759: {
1760: revalidate();
1761: repaint();
1762: }
1763:
1764: public void columnSelectionChanged (ListSelectionEvent event)
1765: {
1766: repaint();
1767: }
1768:
1769: public void editingCanceled (ChangeEvent event)
1770: {
1771: if (rowBeingEdited > -1 && columnBeingEdited > -1)
1772: {
1773: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
1774: {
1775: remove ((Component)getValueAt(rowBeingEdited, columnBeingEdited));
1776: setValueAt(oldCellValue, rowBeingEdited, columnBeingEdited);
1777: }
1778: rowBeingEdited = -1;
1779: columnBeingEdited = -1;
1780: }
1781: editorTimer.stop();
1782: editorComp = null;
1783: cellEditor = null;
1784: requestFocusInWindow(false);
1785: repaint();
1786: }
1787:
1788: public void editingStopped (ChangeEvent event)
1789: {
1790: if (rowBeingEdited > -1 && columnBeingEdited > -1)
1791: {
1792: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
1793: {
1794: remove((Component)getValueAt(rowBeingEdited, columnBeingEdited));
1795: setValueAt(((JTextField)editorComp).getText(),
1796: rowBeingEdited, columnBeingEdited);
1797: }
1798: rowBeingEdited = -1;
1799: columnBeingEdited = -1;
1800: }
1801: editorTimer.stop();
1802: editorComp = null;
1803: cellEditor = null;
1804: requestFocusInWindow(false);
1805: repaint();
1806: }
1807:
1808: public void tableChanged (TableModelEvent event)
1809: {
1810:
1811:
1812: if ((event.getFirstRow() ==TableModelEvent.HEADER_ROW)
1813: && autoCreateColumnsFromModel)
1814:
1815: createDefaultColumnsFromModel();
1816:
1817:
1818:
1819:
1820: if (event.getType() == TableModelEvent.INSERT)
1821: revalidate();
1822: else if (event.getType() == TableModelEvent.DELETE)
1823: {
1824: if (dataModel.getRowCount() == 0)
1825: clearSelection();
1826: revalidate();
1827: }
1828: repaint();
1829: }
1830:
1831: public void valueChanged (ListSelectionEvent event)
1832: {
1833: repaint();
1834: }
1835:
1836:
1844: public int columnAtPoint(Point point)
1845: {
1846: if (point != null)
1847: {
1848: int ncols = getColumnCount();
1849: Dimension gap = getIntercellSpacing();
1850: TableColumnModel cols = getColumnModel();
1851: int x = point.x;
1852:
1853: for (int i = 0; i < ncols; ++i)
1854: {
1855: int width = cols.getColumn(i).getWidth()
1856: + (gap == null ? 0 : gap.width);
1857: if (0 <= x && x < width)
1858: return i;
1859: x -= width;
1860: }
1861: }
1862: return -1;
1863: }
1864:
1865:
1873: public int rowAtPoint(Point point)
1874: {
1875: if (point != null)
1876: {
1877: int nrows = getRowCount();
1878: int height = getRowHeight();
1879: int y = point.y;
1880:
1881: for (int i = 0; i < nrows; ++i)
1882: {
1883: if (0 <= y && y < height)
1884: return i;
1885: y -= height;
1886: }
1887: }
1888: return -1;
1889: }
1890:
1891:
1907: public Rectangle getCellRect(int row,
1908: int column,
1909: boolean includeSpacing)
1910: {
1911: int height = getRowHeight(row);
1912: int width = columnModel.getColumn(column).getWidth();
1913: int x_gap = columnModel.getColumnMargin();
1914: int y_gap = rowMargin;
1915:
1916: column = Math.max(0, Math.min(column, getColumnCount() - 1));
1917: row = Math.max(0, Math.min(row, getRowCount() - 1));
1918:
1919: int x = 0;
1920: int y = (height + y_gap) * row;
1921:
1922: for (int i = 0; i < column; ++i)
1923: x += columnModel.getColumn(i).getWidth();
1924:
1925: if (includeSpacing)
1926: return new Rectangle(x, y, width, height);
1927: else
1928: return new Rectangle(x, y, width - x_gap, height - y_gap);
1929: }
1930:
1931: public void clearSelection()
1932: {
1933: selectionModel.clearSelection();
1934: getColumnModel().getSelectionModel().clearSelection();
1935: }
1936:
1937:
1944: public int getSelectedRow ()
1945: {
1946: return selectionModel.getMinSelectionIndex();
1947: }
1948:
1949:
1954: public ListSelectionModel getSelectionModel()
1955: {
1956:
1957: return selectionModel;
1958: }
1959:
1960: public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
1961: {
1962: if (orientation == SwingConstants.VERTICAL)
1963: return visibleRect.height * direction;
1964: else
1965: return visibleRect.width * direction;
1966: }
1967:
1968:
1973: public boolean getScrollableTracksViewportHeight()
1974: {
1975: return false;
1976: }
1977:
1978:
1984: public boolean getScrollableTracksViewportWidth()
1985: {
1986: if (autoResizeMode == AUTO_RESIZE_OFF)
1987: return false;
1988: else
1989: return true;
1990: }
1991:
1992: public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)
1993: {
1994:
1995:
1996:
1997:
1998: if (orientation == SwingConstants.VERTICAL)
1999: return direction * rowHeight;
2000: else
2001: {
2002: int sum = 0;
2003: for (int i = 0; i < getColumnCount(); ++i)
2004: sum += columnModel.getColumn(0).getWidth();
2005: int inc = getColumnCount() == 0 ? 10 : sum / getColumnCount();
2006: return direction * inc;
2007: }
2008: }
2009:
2010:
2011: public TableCellEditor getCellEditor(int row, int column)
2012: {
2013: TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
2014:
2015: if (editor == null)
2016: editor = getDefaultEditor(dataModel.getColumnClass(column));
2017:
2018: return editor;
2019: }
2020:
2021: public TableCellEditor getDefaultEditor(Class columnClass)
2022: {
2023: if (defaultEditorsByColumnClass.containsKey(columnClass))
2024: return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
2025: else
2026: {
2027:
2028: TableCellEditor r = new DefaultCellEditor(new JTextField());
2029: defaultEditorsByColumnClass.put(columnClass, r);
2030: return r;
2031: }
2032: }
2033:
2034: public TableCellRenderer getCellRenderer(int row, int column)
2035: {
2036: TableCellRenderer renderer =
2037: columnModel.getColumn(column).getCellRenderer();
2038: if (renderer == null)
2039: renderer = getDefaultRenderer(getColumnClass(column));
2040:
2041: return renderer;
2042: }
2043:
2044: public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
2045: {
2046: defaultRenderersByColumnClass.put(columnClass, rend);
2047: }
2048:
2049: public TableCellRenderer getDefaultRenderer(Class columnClass)
2050: {
2051: if (defaultRenderersByColumnClass.containsKey(columnClass))
2052: return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
2053: else
2054: {
2055: TableCellRenderer r = new DefaultTableCellRenderer();
2056: defaultRenderersByColumnClass.put(columnClass, r);
2057: return r;
2058: }
2059: }
2060:
2061: public int convertColumnIndexToModel(int vc)
2062: {
2063: if (vc < 0)
2064: return vc;
2065: else
2066: return columnModel.getColumn(vc).getModelIndex();
2067: }
2068:
2069: public int convertColumnIndexToView(int mc)
2070: {
2071: if (mc < 0)
2072: return mc;
2073: int ncols = getColumnCount();
2074: for (int vc = 0; vc < ncols; ++vc)
2075: {
2076: if (columnModel.getColumn(vc).getModelIndex() == mc)
2077: return vc;
2078: }
2079: return -1;
2080: }
2081:
2082: public Component prepareRenderer(TableCellRenderer renderer,
2083: int row,
2084: int column)
2085: {
2086:
2087: boolean rowSelAllowed = getRowSelectionAllowed();
2088: boolean colSelAllowed = getColumnSelectionAllowed();
2089: boolean isSel = false;
2090: if (rowSelAllowed && colSelAllowed || !rowSelAllowed && !colSelAllowed)
2091: isSel = isCellSelected(row, column);
2092: else
2093: isSel = isRowSelected(row) && getRowSelectionAllowed()
2094: || isColumnSelected(column) && getColumnSelectionAllowed();
2095:
2096:
2097:
2098: ListSelectionModel rowSel = getSelectionModel();
2099: ListSelectionModel colSel = getColumnModel().getSelectionModel();
2100: boolean hasFocus = hasFocus() && isEnabled()
2101: && rowSel.getLeadSelectionIndex() == row
2102: && colSel.getLeadSelectionIndex() == column;
2103:
2104: return renderer.getTableCellRendererComponent(this,
2105: dataModel.getValueAt(row,
2106: convertColumnIndexToModel(column)),
2107: isSel,
2108: hasFocus,
2109: row, column);
2110: }
2111:
2112:
2113:
2118: public boolean getAutoCreateColumnsFromModel()
2119: {
2120: return autoCreateColumnsFromModel;
2121: }
2122:
2123:
2128: public int getAutoResizeMode()
2129: {
2130: return autoResizeMode;
2131: }
2132:
2133:
2138: public int getRowHeight()
2139: {
2140: return rowHeight;
2141: }
2142:
2143:
2148: public int getRowHeight(int row)
2149: {
2150:
2151:
2152: return rowHeight;
2153: }
2154:
2155:
2156:
2161: public int getRowMargin()
2162: {
2163: return rowMargin;
2164: }
2165:
2166:
2171: public boolean getRowSelectionAllowed()
2172: {
2173: return rowSelectionAllowed;
2174: }
2175:
2176:
2181: public boolean getCellSelectionEnabled()
2182: {
2183: return getColumnSelectionAllowed() && getRowSelectionAllowed();
2184: }
2185:
2186:
2191: public TableModel getModel()
2192: {
2193: return dataModel;
2194: }
2195:
2196:
2202: public int getColumnCount()
2203: {
2204: return columnModel.getColumnCount();
2205: }
2206:
2207:
2213: public int getRowCount()
2214: {
2215: return dataModel.getRowCount();
2216: }
2217:
2218:
2223: public TableColumnModel getColumnModel()
2224: {
2225: return columnModel;
2226: }
2227:
2228:
2234: public int getSelectedColumn()
2235: {
2236: return columnModel.getSelectionModel().getMinSelectionIndex();
2237: }
2238:
2239: private static int countSelections(ListSelectionModel lsm)
2240: {
2241: int lo = lsm.getMinSelectionIndex();
2242: int hi = lsm.getMaxSelectionIndex();
2243: int sum = 0;
2244: if (lo != -1 && hi != -1)
2245: {
2246: switch (lsm.getSelectionMode())
2247: {
2248: case ListSelectionModel.SINGLE_SELECTION:
2249: sum = 1;
2250: break;
2251:
2252: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
2253: sum = hi - lo + 1;
2254: break;
2255:
2256: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
2257: for (int i = lo; i <= hi; ++i)
2258: if (lsm.isSelectedIndex(i))
2259: ++sum;
2260: break;
2261: }
2262: }
2263: return sum;
2264: }
2265:
2266: private static int[] getSelections(ListSelectionModel lsm)
2267: {
2268: int sz = countSelections(lsm);
2269: int [] ret = new int[sz];
2270:
2271: int lo = lsm.getMinSelectionIndex();
2272: int hi = lsm.getMaxSelectionIndex();
2273: int j = 0;
2274: if (lo != -1 && hi != -1)
2275: {
2276: switch (lsm.getSelectionMode())
2277: {
2278: case ListSelectionModel.SINGLE_SELECTION:
2279: ret[0] = lo;
2280: break;
2281:
2282: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
2283: for (int i = lo; i <= hi; ++i)
2284: ret[j++] = i;
2285: break;
2286:
2287: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
2288: for (int i = lo; i <= hi; ++i)
2289: if (lsm.isSelectedIndex(i))
2290: ret[j++] = i;
2291: break;
2292: }
2293: }
2294: return ret;
2295: }
2296:
2297:
2303: public int getSelectedColumnCount()
2304: {
2305: return countSelections(columnModel.getSelectionModel());
2306: }
2307:
2308:
2314: public int[] getSelectedColumns()
2315: {
2316: return getSelections(columnModel.getSelectionModel());
2317: }
2318:
2319:
2324: public boolean getColumnSelectionAllowed()
2325: {
2326: return getColumnModel().getColumnSelectionAllowed();
2327: }
2328:
2329:
2335: public int getSelectedRowCount()
2336: {
2337: return countSelections(selectionModel);
2338: }
2339:
2340:
2346: public int[] getSelectedRows()
2347: {
2348: return getSelections(selectionModel);
2349: }
2350:
2351:
2356: public AccessibleContext getAccessibleContext()
2357: {
2358: return accessibleContext;
2359: }
2360:
2361:
2366: public TableCellEditor getCellEditor()
2367: {
2368: return cellEditor;
2369: }
2370:
2371:
2376: public boolean getDragEnabled()
2377: {
2378: return dragEnabled;
2379: }
2380:
2381:
2386: public Color getGridColor()
2387: {
2388: return gridColor;
2389: }
2390:
2391:
2396: public Dimension getIntercellSpacing()
2397: {
2398: return new Dimension(columnModel.getColumnMargin(), rowMargin);
2399: }
2400:
2401:
2406: public Dimension getPreferredScrollableViewportSize()
2407: {
2408: return preferredViewportSize;
2409: }
2410:
2411:
2416: public Color getSelectionBackground()
2417: {
2418: return selectionBackground;
2419: }
2420:
2421:
2426: public Color getSelectionForeground()
2427: {
2428: return selectionForeground;
2429: }
2430:
2431:
2436: public boolean getShowHorizontalLines()
2437: {
2438: return showHorizontalLines;
2439: }
2440:
2441:
2446: public boolean getShowVerticalLines()
2447: {
2448: return showVerticalLines;
2449: }
2450:
2451:
2456: public JTableHeader getTableHeader()
2457: {
2458: return tableHeader;
2459: }
2460:
2461:
2466: public void removeColumn(TableColumn column)
2467: {
2468: columnModel.removeColumn(column);
2469: }
2470:
2471:
2477: public void moveColumn(int column,int targetColumn)
2478: {
2479: columnModel.moveColumn(column, targetColumn);
2480: }
2481:
2482:
2489: public void setAutoCreateColumnsFromModel(boolean autoCreate)
2490: {
2491: if (autoCreateColumnsFromModel != autoCreate)
2492: {
2493: autoCreateColumnsFromModel = autoCreate;
2494: if (autoCreate)
2495: createDefaultColumnsFromModel();
2496: }
2497: }
2498:
2499:
2504: public void setAutoResizeMode(int a)
2505: {
2506: autoResizeMode = a;
2507: revalidate();
2508: repaint();
2509: }
2510:
2511:
2516: public void setRowHeight(int r)
2517: {
2518: if (r < 1)
2519: throw new IllegalArgumentException();
2520:
2521: rowHeight = r;
2522: revalidate();
2523: repaint();
2524: }
2525:
2526:
2533: public void setRowHeight(int row, int rh)
2534: {
2535: setRowHeight(rh);
2536:
2537: }
2538:
2539:
2544: public void setRowMargin(int r)
2545: {
2546: rowMargin = r;
2547: revalidate();
2548: repaint();
2549: }
2550:
2551:
2556: public void setRowSelectionAllowed(boolean r)
2557: {
2558: rowSelectionAllowed = r;
2559: repaint();
2560: }
2561:
2562:
2567: public void setCellSelectionEnabled(boolean c)
2568: {
2569: setColumnSelectionAllowed(c);
2570: setRowSelectionAllowed(c);
2571:
2572: cellSelectionEnabled = true;
2573: }
2574:
2575:
2584: public void setModel(TableModel m)
2585: {
2586:
2587: if (m == null)
2588: throw new IllegalArgumentException();
2589:
2590:
2591: if (dataModel == m)
2592: return;
2593:
2594: TableModel oldModel = dataModel;
2595:
2596:
2597: if (dataModel != null)
2598: dataModel.removeTableModelListener(this);
2599:
2600: if (m != null)
2601: {
2602:
2603: dataModel = m;
2604:
2605:
2606: dataModel.addTableModelListener(this);
2607:
2608:
2609: if (autoCreateColumnsFromModel)
2610: createDefaultColumnsFromModel();
2611: }
2612:
2613:
2614: firePropertyChange("model", oldModel, dataModel);
2615:
2616:
2617: revalidate();
2618: repaint();
2619: }
2620:
2621:
2630: public void setColumnModel(TableColumnModel c)
2631: {
2632: if (c == null)
2633: throw new IllegalArgumentException();
2634: TableColumnModel tmp = columnModel;
2635: if (tmp != null)
2636: tmp.removeColumnModelListener(this);
2637: if (c != null)
2638: c.addColumnModelListener(this);
2639: columnModel = c;
2640: if (dataModel != null && columnModel != null)
2641: {
2642: int ncols = getColumnCount();
2643: for (int i = 0; i < ncols; ++i)
2644: columnModel.getColumn(i).setHeaderValue(dataModel.getColumnName(i));
2645: }
2646:
2647:
2648:
2649: if (tableHeader != null)
2650: tableHeader.setColumnModel(c);
2651:
2652: revalidate();
2653: repaint();
2654: }
2655:
2656:
2661: public void setColumnSelectionAllowed(boolean c)
2662: {
2663: getColumnModel().setColumnSelectionAllowed(c);
2664: repaint();
2665: }
2666:
2667:
2676: public void setSelectionModel(ListSelectionModel s)
2677: {
2678: if (s == null)
2679: throw new IllegalArgumentException();
2680: ListSelectionModel tmp = selectionModel;
2681: if (tmp != null)
2682: tmp.removeListSelectionListener(this);
2683: if (s != null)
2684: s.addListSelectionListener(this);
2685: selectionModel = s;
2686: }
2687:
2688:
2695: public void setSelectionMode(int s)
2696: {
2697: selectionModel.setSelectionMode(s);
2698: columnModel.getSelectionModel().setSelectionMode(s);
2699:
2700: repaint();
2701: }
2702:
2703:
2712: public void setCellEditor(TableCellEditor c)
2713: {
2714: TableCellEditor tmp = cellEditor;
2715: if (tmp != null)
2716: tmp.removeCellEditorListener(this);
2717: if (c != null)
2718: c.addCellEditorListener(this);
2719: cellEditor = c;
2720: }
2721:
2722:
2727: public void setDragEnabled(boolean d)
2728: {
2729: dragEnabled = d;
2730: }
2731:
2732:
2737: public void setGridColor(Color g)
2738: {
2739: gridColor = g;
2740: repaint();
2741: }
2742:
2743:
2748: public void setIntercellSpacing(Dimension i)
2749: {
2750: rowMargin = i.height;
2751: columnModel.setColumnMargin(i.width);
2752: repaint();
2753: }
2754:
2755:
2760: public void setPreferredScrollableViewportSize(Dimension p)
2761: {
2762: preferredViewportSize = p;
2763: revalidate();
2764: repaint();
2765: }
2766:
2767:
2776: public void setSelectionBackground(Color s)
2777: {
2778: Color tmp = selectionBackground;
2779: selectionBackground = s;
2780: if (((tmp == null && s != null)
2781: || (s == null && tmp != null)
2782: || (tmp != null && s != null && !tmp.equals(s))))
2783: firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
2784: repaint();
2785: }
2786:
2787:
2796: public void setSelectionForeground(Color s)
2797: {
2798: Color tmp = selectionForeground;
2799: selectionForeground = s;
2800: if (((tmp == null && s != null)
2801: || (s == null && tmp != null)
2802: || (tmp != null && s != null && !tmp.equals(s))))
2803: firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
2804: repaint();
2805: }
2806:
2807:
2812: public void setShowGrid(boolean s)
2813: {
2814: setShowVerticalLines(s);
2815: setShowHorizontalLines(s);
2816: }
2817:
2818:
2823: public void setShowHorizontalLines(boolean s)
2824: {
2825: showHorizontalLines = s;
2826: repaint();
2827: }
2828:
2829:
2834: public void setShowVerticalLines(boolean s)
2835: {
2836: showVerticalLines = s;
2837: repaint();
2838: }
2839:
2840:
2845: public void setTableHeader(JTableHeader t)
2846: {
2847: if (tableHeader != null)
2848: tableHeader.setTable(null);
2849: tableHeader = t;
2850: if (tableHeader != null)
2851: tableHeader.setTable(this);
2852: revalidate();
2853: repaint();
2854: }
2855:
2856: protected void configureEnclosingScrollPane()
2857: {
2858: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
2859: if (jsp != null && tableHeader != null)
2860: {
2861: jsp.setColumnHeaderView(tableHeader);
2862: }
2863: }
2864:
2865: protected void unconfigureEnclosingScrollPane()
2866: {
2867: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
2868: if (jsp != null)
2869: {
2870: jsp.setColumnHeaderView(null);
2871: }
2872: }
2873:
2874:
2875: public void addNotify()
2876: {
2877: super.addNotify();
2878: configureEnclosingScrollPane();
2879: }
2880:
2881: public void removeNotify()
2882: {
2883: super.addNotify();
2884: unconfigureEnclosingScrollPane();
2885: }
2886:
2887:
2888:
2896: private void distributeSpill(TableColumn[] cols, int spill)
2897: {
2898: int average = spill / cols.length;
2899: for (int i = 0; i < cols.length; i++)
2900: {
2901: if (cols[i] != null)
2902: cols[i].setWidth(cols[i].getWidth() + average);
2903: }
2904: }
2905:
2906: public void doLayout()
2907: {
2908: TableColumn resizingColumn = null;
2909:
2910: int ncols = getColumnCount();
2911: if (ncols < 1)
2912: return;
2913:
2914: int[] pref = new int[ncols];
2915: int prefSum = 0;
2916: int rCol = -1;
2917:
2918: if (tableHeader != null)
2919: resizingColumn = tableHeader.getResizingColumn();
2920:
2921: for (int i = 0; i < ncols; ++i)
2922: {
2923: TableColumn col = columnModel.getColumn(i);
2924: int p = col.getWidth();
2925: pref[i] = p;
2926: prefSum += p;
2927: if (resizingColumn == col)
2928: rCol = i;
2929: }
2930:
2931: int spill = getWidth() - prefSum;
2932:
2933: if (resizingColumn != null)
2934: {
2935: TableColumn col;
2936: TableColumn [] cols;
2937:
2938: switch (getAutoResizeMode())
2939: {
2940: case AUTO_RESIZE_LAST_COLUMN:
2941: col = columnModel.getColumn(ncols-1);
2942: col.setWidth(col.getPreferredWidth() + spill);
2943: break;
2944:
2945: case AUTO_RESIZE_NEXT_COLUMN:
2946: col = columnModel.getColumn(ncols-1);
2947: col.setWidth(col.getPreferredWidth() + spill);
2948: break;
2949:
2950: case AUTO_RESIZE_ALL_COLUMNS:
2951: cols = new TableColumn[ncols];
2952: for (int i = 0; i < ncols; ++i)
2953: cols[i] = columnModel.getColumn(i);
2954: distributeSpill(cols, spill);
2955: break;
2956:
2957: case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
2958: cols = new TableColumn[ncols];
2959: for (int i = rCol; i < ncols; ++i)
2960: cols[i] = columnModel.getColumn(i);
2961: distributeSpill(cols, spill);
2962: break;
2963:
2964: case AUTO_RESIZE_OFF:
2965: default:
2966: int prefWidth = resizingColumn.getPreferredWidth();
2967: resizingColumn.setWidth(prefWidth);
2968: }
2969: }
2970: else
2971: {
2972: TableColumn [] cols = new TableColumn[ncols];
2973: for (int i = 0; i < ncols; ++i)
2974: cols[i] = columnModel.getColumn(i);
2975: distributeSpill(cols, spill);
2976: }
2977: }
2978:
2979:
2982: public void sizeColumnsToFit(boolean lastColumnOnly)
2983: {
2984: doLayout();
2985: }
2986:
2987:
2990: public void sizeColumnsToFit(int resizingColumn)
2991: {
2992: doLayout();
2993: }
2994:
2995: public String getUIClassID()
2996: {
2997: return "TableUI";
2998: }
2999:
3000:
3005: public TableUI getUI()
3006: {
3007: return (TableUI) ui;
3008: }
3009:
3010:
3015: public void setUI(TableUI ui)
3016: {
3017: super.setUI(ui);
3018: }
3019:
3020: public void updateUI()
3021: {
3022: setUI((TableUI) UIManager.getUI(this));
3023: revalidate();
3024: repaint();
3025: }
3026:
3027: public Class getColumnClass(int column)
3028: {
3029: return getModel().getColumnClass(column);
3030: }
3031:
3032: public String getColumnName(int column)
3033: {
3034: int modelColumn = columnModel.getColumn(column).getModelIndex();
3035: return dataModel.getColumnName(modelColumn);
3036: }
3037:
3038: public int getEditingColumn()
3039: {
3040: return editingColumn;
3041: }
3042:
3043: public void setEditingColumn(int column)
3044: {
3045: editingColumn = column;
3046: }
3047:
3048: public int getEditingRow()
3049: {
3050: return editingRow;
3051: }
3052:
3053: public void setEditingRow(int column)
3054: {
3055: editingRow = column;
3056: }
3057:
3058: public Component getEditorComponent()
3059: {
3060: return editorComp;
3061: }
3062:
3063: public boolean isEditing()
3064: {
3065: return editorComp != null;
3066: }
3067:
3068: public void setDefaultEditor(Class columnClass, TableCellEditor editor)
3069: {
3070: if (editor != null)
3071: defaultEditorsByColumnClass.put(columnClass, editor);
3072: else
3073: defaultEditorsByColumnClass.remove(columnClass);
3074: }
3075:
3076: public void addColumnSelectionInterval(int index0, int index1)
3077: {
3078: if ((index0 < 0 || index0 > (getColumnCount()-1)
3079: || index1 < 0 || index1 > (getColumnCount()-1)))
3080: throw new IllegalArgumentException("Column index out of range.");
3081:
3082: getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
3083: }
3084:
3085: public void addRowSelectionInterval(int index0, int index1)
3086: {
3087: if ((index0 < 0 || index0 > (getRowCount()-1)
3088: || index1 < 0 || index1 > (getRowCount()-1)))
3089: throw new IllegalArgumentException("Row index out of range.");
3090:
3091: getSelectionModel().addSelectionInterval(index0, index1);
3092: }
3093:
3094: public void setColumnSelectionInterval(int index0, int index1)
3095: {
3096: if ((index0 < 0 || index0 > (getColumnCount()-1)
3097: || index1 < 0 || index1 > (getColumnCount()-1)))
3098: throw new IllegalArgumentException("Column index out of range.");
3099:
3100: getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
3101: }
3102:
3103: public void setRowSelectionInterval(int index0, int index1)
3104: {
3105: if ((index0 < 0 || index0 > (getRowCount()-1)
3106: || index1 < 0 || index1 > (getRowCount()-1)))
3107: throw new IllegalArgumentException("Row index out of range.");
3108:
3109: getSelectionModel().setSelectionInterval(index0, index1);
3110: }
3111:
3112: public void removeColumnSelectionInterval(int index0, int index1)
3113: {
3114: if ((index0 < 0 || index0 > (getColumnCount()-1)
3115: || index1 < 0 || index1 > (getColumnCount()-1)))
3116: throw new IllegalArgumentException("Column index out of range.");
3117:
3118: getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
3119: }
3120:
3121: public void removeRowSelectionInterval(int index0, int index1)
3122: {
3123: if ((index0 < 0 || index0 > (getRowCount()-1)
3124: || index1 < 0 || index1 > (getRowCount()-1)))
3125: throw new IllegalArgumentException("Row index out of range.");
3126:
3127: getSelectionModel().removeSelectionInterval(index0, index1);
3128: }
3129:
3130: public boolean isColumnSelected(int column)
3131: {
3132: return getColumnModel().getSelectionModel().isSelectedIndex(column);
3133: }
3134:
3135: public boolean isRowSelected(int row)
3136: {
3137: return getSelectionModel().isSelectedIndex(row);
3138: }
3139:
3140: public boolean isCellSelected(int row, int column)
3141: {
3142: return isRowSelected(row) && isColumnSelected(column);
3143: }
3144:
3145: public void selectAll()
3146: {
3147:
3148: int rowLead = selectionModel.getLeadSelectionIndex();
3149: int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
3150:
3151:
3152: setColumnSelectionInterval(0, getColumnCount() - 1);
3153: setRowSelectionInterval(0, getRowCount() - 1);
3154:
3155:
3156: addColumnSelectionInterval(colLead,colLead);
3157: addRowSelectionInterval(rowLead, rowLead);
3158: }
3159:
3160: public Object getValueAt(int row, int column)
3161: {
3162: return dataModel.getValueAt(row, convertColumnIndexToModel(column));
3163: }
3164:
3165: public void setValueAt(Object value, int row, int column)
3166: {
3167: if (!isCellEditable(row, column))
3168: return;
3169:
3170: if (value instanceof Component)
3171: add((Component)value);
3172: dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
3173: }
3174:
3175: public TableColumn getColumn(Object identifier)
3176: {
3177: return columnModel.getColumn(columnModel.getColumnIndex(identifier));
3178: }
3179:
3180:
3189: public boolean isCellEditable(int row, int column)
3190: {
3191: return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
3192: }
3193:
3194:
3201: public void createDefaultColumnsFromModel()
3202: {
3203: assert columnModel != null : "The columnModel must not be null.";
3204:
3205:
3206: int columnIndex = columnModel.getColumnCount() - 1;
3207: while (columnIndex >= 0)
3208: {
3209: columnModel.removeColumn(columnModel.getColumn(columnIndex));
3210: columnIndex--;
3211: }
3212:
3213:
3214: int columnCount = dataModel.getColumnCount();
3215: for (int c = 0; c < columnCount; c++)
3216: {
3217: TableColumn column = new TableColumn(c);
3218: column.setIdentifier(dataModel.getColumnName(c));
3219: column.setHeaderValue(dataModel.getColumnName(c));
3220: columnModel.addColumn(column);
3221: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
3222: }
3223: }
3224:
3225: public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
3226: {
3227: if (toggle && extend)
3228: {
3229:
3230:
3231: selectionModel.setAnchorSelectionIndex(rowIndex);
3232: getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
3233: }
3234: else if (toggle)
3235: {
3236:
3237: if (isCellSelected(rowIndex,columnIndex))
3238: {
3239: selectionModel.removeSelectionInterval(rowIndex,rowIndex);
3240: getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
3241: }
3242: else
3243: {
3244: selectionModel.addSelectionInterval(rowIndex,rowIndex);
3245: getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
3246: }
3247: }
3248: else if (extend)
3249: {
3250:
3251:
3252: selectionModel.setLeadSelectionIndex(rowIndex);
3253: getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
3254: }
3255: else
3256: {
3257:
3258:
3259: selectionModel.clearSelection();
3260: selectionModel.setSelectionInterval(rowIndex,rowIndex);
3261: getColumnModel().getSelectionModel().clearSelection();
3262: getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
3263:
3264:
3265: }
3266: }
3267:
3268:
3274: public boolean editCellAt (int row, int column)
3275: {
3276: oldCellValue = getValueAt(row, column);
3277: setCellEditor(getCellEditor(row, column));
3278: editorComp = prepareEditor(cellEditor, row, column);
3279: cellEditor.addCellEditorListener(this);
3280: rowBeingEdited = row;
3281: columnBeingEdited = column;
3282: setValueAt(editorComp, row, column);
3283: ((JTextField)editorComp).requestFocusInWindow(false);
3284: editorTimer.start();
3285: return true;
3286: }
3287:
3288:
3294: public boolean editCellAt (int row, int column, EventObject e)
3295: {
3296: return editCellAt(row, column);
3297: }
3298:
3299:
3302: public void removeEditor()
3303: {
3304: editingStopped(new ChangeEvent(this));
3305: }
3306:
3307:
3316: public Component prepareEditor (TableCellEditor editor, int row, int column)
3317: {
3318: return editor.getTableCellEditorComponent
3319: (this, getValueAt(row, column), isCellSelected(row, column), row, column);
3320: }
3321:
3322:
3325: protected void resizeAndRepaint()
3326: {
3327: revalidate();
3328: repaint();
3329: }
3330:
3331:
3341: public void setSurrendersFocusOnKeystroke(boolean value)
3342: {
3343:
3344: surrendersFocusOnKeystroke = value;
3345: }
3346:
3347:
3358: public boolean getSurrendersFocusOnKeystroke()
3359: {
3360:
3361: return surrendersFocusOnKeystroke;
3362: }
3363: }