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: }
932:
939: class TableColumnPropertyChangeHandler implements PropertyChangeListener
940: {
941:
947: public void propertyChange(PropertyChangeEvent ev)
948: {
949: if (ev.getPropertyName().equals("preferredWidth"))
950: {
951: JTableHeader header = getTableHeader();
952: TableColumn col = (TableColumn) ev.getSource();
953: header.setResizingColumn(col);
954: doLayout();
955: header.setResizingColumn(null);
956: }
957: }
958: }
959:
960:
963: private class BooleanCellRenderer
964: extends DefaultTableCellRenderer
965: {
966:
967:
970: private JCheckBox checkBox = new JCheckBox();
971:
972:
984: public Component getTableCellRendererComponent(JTable table, Object value,
985: boolean isSelected,
986: boolean hasFocus, int row,
987: int column)
988: {
989: Boolean boolValue = (Boolean) value;
990: checkBox.setSelected(boolValue.booleanValue());
991: return checkBox;
992: }
993: }
994:
995:
998: private class DateCellRenderer
999: extends DefaultTableCellRenderer
1000: {
1001:
1013: public Component getTableCellRendererComponent(JTable table, Object value,
1014: boolean isSelected,
1015: boolean hasFocus, int row,
1016: int column)
1017: {
1018: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1019: row, column);
1020: if (value instanceof Date)
1021: {
1022: Date dateValue = (Date) value;
1023: DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
1024: setText(df.format(dateValue));
1025: }
1026: return this;
1027: }
1028: }
1029:
1030:
1033: private class DoubleCellRenderer
1034: extends DefaultTableCellRenderer
1035: {
1036:
1039: public DoubleCellRenderer()
1040: {
1041: setHorizontalAlignment(JLabel.RIGHT);
1042: }
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 Double)
1064: {
1065: Double doubleValue = (Double) value;
1066: NumberFormat nf = NumberFormat.getInstance();
1067: setText(nf.format(doubleValue.doubleValue()));
1068: }
1069: return this;
1070: }
1071: }
1072:
1073:
1076: private class FloatCellRenderer
1077: extends DefaultTableCellRenderer
1078: {
1079:
1082: public FloatCellRenderer()
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 Float)
1107: {
1108: Float floatValue = (Float) value;
1109: NumberFormat nf = NumberFormat.getInstance();
1110: setText(nf.format(floatValue.floatValue()));
1111: }
1112: return this;
1113: }
1114: }
1115:
1116:
1119: private class NumberCellRenderer
1120: extends DefaultTableCellRenderer
1121: {
1122:
1125: public NumberCellRenderer()
1126: {
1127: setHorizontalAlignment(JLabel.RIGHT);
1128: }
1129: }
1130:
1131:
1134: private class IconCellRenderer
1135: extends DefaultTableCellRenderer
1136: {
1137:
1149: public Component getTableCellRendererComponent(JTable table, Object value,
1150: boolean isSelected,
1151: boolean hasFocus, int row,
1152: int column)
1153: {
1154: super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
1155: row, column);
1156: if (value instanceof Icon)
1157: {
1158: Icon iconValue = (Icon) value;
1159: setIcon(iconValue);
1160: }
1161: return this;
1162: }
1163: }
1164:
1165: private static final long serialVersionUID = 3876025080382781659L;
1166:
1167:
1168:
1173: public static final int AUTO_RESIZE_OFF = 0;
1174:
1175:
1180: public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
1181:
1182:
1187: public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
1188:
1189:
1195: public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
1196:
1197:
1202: public static final int AUTO_RESIZE_LAST_COLUMN = 3;
1203:
1204:
1205:
1210: protected Hashtable defaultEditorsByColumnClass;
1211:
1212:
1217: protected Hashtable defaultRenderersByColumnClass;
1218:
1219:
1222: protected int editingColumn;
1223:
1224:
1227: protected int editingRow;
1228:
1229:
1234: protected transient Component editorComp;
1235:
1236:
1237:
1248: protected boolean autoCreateColumnsFromModel;
1249:
1250:
1260: protected int autoResizeMode;
1261:
1262:
1273: protected int rowHeight;
1274:
1275:
1285: protected int rowMargin;
1286:
1287:
1300: protected boolean rowSelectionAllowed;
1301:
1302:
1307: protected boolean cellSelectionEnabled;
1308:
1309:
1318: protected TableModel dataModel;
1319:
1320:
1342: protected TableColumnModel columnModel;
1343:
1344:
1356: protected ListSelectionModel selectionModel;
1357:
1358:
1361: protected TableCellEditor cellEditor;
1362:
1363:
1369: private boolean dragEnabled;
1370:
1371:
1378: protected Color gridColor;
1379:
1380:
1387: protected Dimension preferredViewportSize;
1388:
1389:
1397: protected Color selectionBackground;
1398:
1399:
1403: private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
1404:
1405:
1413: protected Color selectionForeground;
1414:
1415:
1419: private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
1420:
1421:
1424: protected boolean showHorizontalLines;
1425:
1426:
1429: protected boolean showVerticalLines;
1430:
1431:
1434: protected JTableHeader tableHeader;
1435:
1436:
1439: int rowBeingEdited = -1;
1440:
1441:
1444: int columnBeingEdited = -1;
1445:
1446:
1449: Timer editorTimer = new EditorUpdateTimer();
1450:
1451:
1455: Object oldCellValue;
1456:
1457:
1460: TableColumnPropertyChangeHandler tableColumnPropertyChangeHandler =
1461: new TableColumnPropertyChangeHandler();
1462:
1463:
1466: public JTable ()
1467: {
1468: this(null, null, null);
1469: }
1470:
1471:
1477: public JTable (int numRows, int numColumns)
1478: {
1479: this(new DefaultTableModel(numRows, numColumns));
1480: }
1481:
1482:
1488: public JTable(Object[][] data, Object[] columnNames)
1489: {
1490: this(new DefaultTableModel(data, columnNames));
1491: }
1492:
1493:
1498: public JTable (TableModel dm)
1499: {
1500: this(dm, null, null);
1501: }
1502:
1503:
1509: public JTable (TableModel dm, TableColumnModel cm)
1510: {
1511: this(dm, cm, null);
1512: }
1513:
1514:
1521: public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
1522: {
1523: boolean autoCreate = false;
1524: if (cm != null)
1525: setColumnModel(cm);
1526: else
1527: {
1528: setColumnModel(createDefaultColumnModel());
1529: autoCreate = true;
1530: }
1531: setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
1532: setModel(dm == null ? createDefaultDataModel() : dm);
1533: setAutoCreateColumnsFromModel(autoCreate);
1534: initializeLocalVars();
1535:
1536:
1537:
1538:
1539:
1540:
1541:
1542: selectionModel.setAnchorSelectionIndex(0);
1543: selectionModel.setLeadSelectionIndex(0);
1544: columnModel.getSelectionModel().setAnchorSelectionIndex(0);
1545: columnModel.getSelectionModel().setLeadSelectionIndex(0);
1546: updateUI();
1547: }
1548:
1549: protected void initializeLocalVars()
1550: {
1551: setTableHeader(createDefaultTableHeader());
1552: if (autoCreateColumnsFromModel)
1553: createDefaultColumnsFromModel();
1554: this.columnModel.addColumnModelListener(this);
1555:
1556: this.defaultRenderersByColumnClass = new Hashtable();
1557: createDefaultRenderers();
1558:
1559: this.defaultEditorsByColumnClass = new Hashtable();
1560: createDefaultEditors();
1561:
1562: this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
1563: this.rowHeight = 16;
1564: this.rowMargin = 1;
1565: this.rowSelectionAllowed = true;
1566:
1567: this.cellEditor = null;
1568:
1569: this.dragEnabled = true;
1570: this.preferredViewportSize = new Dimension(450,400);
1571: this.showHorizontalLines = true;
1572: this.showVerticalLines = true;
1573: this.editingColumn = -1;
1574: this.editingRow = -1;
1575: setIntercellSpacing(new Dimension(1,1));
1576: }
1577:
1578:
1584: public JTable(Vector data, Vector columnNames)
1585: {
1586: this(new DefaultTableModel(data, columnNames));
1587: }
1588:
1589:
1592: private class EditorUpdateTimer
1593: extends Timer
1594: implements ActionListener
1595: {
1596:
1599: public EditorUpdateTimer()
1600: {
1601: super(500, null);
1602: addActionListener(this);
1603: }
1604:
1605:
1608: public void actionPerformed(ActionEvent ev)
1609: {
1610: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
1611: if (c != null)
1612: c.setVisible(!c.isVisible());
1613: JTable.this.repaint();
1614: }
1615:
1616:
1619: public void update()
1620: {
1621: stop();
1622: Caret c = ((JTextField)JTable.this.editorComp).getCaret();
1623: if (c != null)
1624: {
1625: setDelay(c.getBlinkRate());
1626: if (((JTextField)JTable.this.editorComp).isEditable())
1627: start();
1628: else
1629: c.setVisible(false);
1630: }
1631: }
1632: }
1633:
1634: public void addColumn(TableColumn column)
1635: {
1636: if (column.getHeaderValue() == null)
1637: {
1638: String name = dataModel.getColumnName(column.getModelIndex());
1639: column.setHeaderValue(name);
1640: }
1641:
1642: columnModel.addColumn(column);
1643: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
1644: }
1645:
1646: protected void createDefaultEditors()
1647: {
1648:
1649: }
1650:
1651: protected void createDefaultRenderers()
1652: {
1653: setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
1654: setDefaultRenderer(Number.class, new NumberCellRenderer());
1655: setDefaultRenderer(Double.class, new DoubleCellRenderer());
1656: setDefaultRenderer(Double.class, new FloatCellRenderer());
1657: setDefaultRenderer(Date.class, new DateCellRenderer());
1658: setDefaultRenderer(Icon.class, new IconCellRenderer());
1659: }
1660:
1661:
1664: public static JScrollPane createScrollPaneForTable(JTable table)
1665: {
1666: return new JScrollPane(table);
1667: }
1668:
1669: protected TableColumnModel createDefaultColumnModel()
1670: {
1671: return new DefaultTableColumnModel();
1672: }
1673:
1674: protected TableModel createDefaultDataModel()
1675: {
1676: return new DefaultTableModel();
1677: }
1678:
1679: protected ListSelectionModel createDefaultSelectionModel()
1680: {
1681: return new DefaultListSelectionModel();
1682: }
1683:
1684: protected JTableHeader createDefaultTableHeader()
1685: {
1686: return new JTableHeader(columnModel);
1687: }
1688:
1689:
1690:
1691: public void columnAdded (TableColumnModelEvent event)
1692: {
1693: revalidate();
1694: repaint();
1695: }
1696:
1697: public void columnMarginChanged (ChangeEvent event)
1698: {
1699: revalidate();
1700: repaint();
1701: }
1702:
1703: public void columnMoved (TableColumnModelEvent event)
1704: {
1705: revalidate();
1706: repaint();
1707: }
1708:
1709: public void columnRemoved (TableColumnModelEvent event)
1710: {
1711: revalidate();
1712: repaint();
1713: }
1714:
1715: public void columnSelectionChanged (ListSelectionEvent event)
1716: {
1717: repaint();
1718: }
1719:
1720: public void editingCanceled (ChangeEvent event)
1721: {
1722: if (rowBeingEdited > -1 && columnBeingEdited > -1)
1723: {
1724: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
1725: {
1726: remove ((Component)getValueAt(rowBeingEdited, columnBeingEdited));
1727: setValueAt(oldCellValue, rowBeingEdited, columnBeingEdited);
1728: }
1729: rowBeingEdited = -1;
1730: columnBeingEdited = -1;
1731: }
1732: editorTimer.stop();
1733: editorComp = null;
1734: cellEditor = null;
1735: requestFocusInWindow(false);
1736: repaint();
1737: }
1738:
1739: public void editingStopped (ChangeEvent event)
1740: {
1741: if (rowBeingEdited > -1 && columnBeingEdited > -1)
1742: {
1743: if (getValueAt(rowBeingEdited, columnBeingEdited) instanceof JTextField)
1744: {
1745: remove((Component)getValueAt(rowBeingEdited, columnBeingEdited));
1746: setValueAt(((JTextField)editorComp).getText(),
1747: rowBeingEdited, columnBeingEdited);
1748: }
1749: rowBeingEdited = -1;
1750: columnBeingEdited = -1;
1751: }
1752: editorTimer.stop();
1753: editorComp = null;
1754: cellEditor = null;
1755: requestFocusInWindow(false);
1756: repaint();
1757: }
1758:
1759: public void tableChanged (TableModelEvent event)
1760: {
1761:
1762:
1763: if ((event.getFirstRow() ==TableModelEvent.HEADER_ROW)
1764: && autoCreateColumnsFromModel)
1765:
1766: createDefaultColumnsFromModel();
1767:
1768:
1769:
1770:
1771: if (event.getType() == TableModelEvent.INSERT)
1772: revalidate();
1773: else if (event.getType() == TableModelEvent.DELETE)
1774: {
1775: if (dataModel.getRowCount() == 0)
1776: clearSelection();
1777: revalidate();
1778: }
1779: repaint();
1780: }
1781:
1782: public void valueChanged (ListSelectionEvent event)
1783: {
1784: repaint();
1785: }
1786:
1787:
1795: public int columnAtPoint(Point point)
1796: {
1797: if (point != null)
1798: {
1799: int x0 = getLocation().x;
1800: int ncols = getColumnCount();
1801: Dimension gap = getIntercellSpacing();
1802: TableColumnModel cols = getColumnModel();
1803: int x = point.x;
1804:
1805: for (int i = 0; i < ncols; ++i)
1806: {
1807: int width = cols.getColumn(i).getWidth()
1808: + (gap == null ? 0 : gap.width);
1809: if (0 <= x && x < width)
1810: return i;
1811: x -= width;
1812: }
1813: }
1814: return -1;
1815: }
1816:
1817:
1825: public int rowAtPoint(Point point)
1826: {
1827: if (point != null)
1828: {
1829: int y0 = getLocation().y;
1830: int nrows = getRowCount();
1831: int height = getRowHeight();
1832: int y = point.y;
1833:
1834: for (int i = 0; i < nrows; ++i)
1835: {
1836: if (0 <= y && y < height)
1837: return i;
1838: y -= height;
1839: }
1840: }
1841: return -1;
1842: }
1843:
1844:
1860: public Rectangle getCellRect(int row,
1861: int column,
1862: boolean includeSpacing)
1863: {
1864: int height = getRowHeight(row);
1865: int width = columnModel.getColumn(column).getWidth();
1866: int x_gap = columnModel.getColumnMargin();
1867: int y_gap = rowMargin;
1868:
1869: column = Math.max(0, Math.min(column, getColumnCount() - 1));
1870: row = Math.max(0, Math.min(row, getRowCount() - 1));
1871:
1872: int x = 0;
1873: int y = (height + y_gap) * row;
1874:
1875: for (int i = 0; i < column; ++i)
1876: x += columnModel.getColumn(i).getWidth();
1877:
1878: if (includeSpacing)
1879: return new Rectangle(x, y, width, height);
1880: else
1881: return new Rectangle(x, y, width - x_gap, height - y_gap);
1882: }
1883:
1884: public void clearSelection()
1885: {
1886: selectionModel.clearSelection();
1887: getColumnModel().getSelectionModel().clearSelection();
1888: }
1889:
1890:
1897: public int getSelectedRow ()
1898: {
1899: return selectionModel.getMinSelectionIndex();
1900: }
1901:
1902:
1907: public ListSelectionModel getSelectionModel()
1908: {
1909:
1910: return selectionModel;
1911: }
1912:
1913: public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
1914: {
1915: if (orientation == SwingConstants.VERTICAL)
1916: return visibleRect.height * direction;
1917: else
1918: return visibleRect.width * direction;
1919: }
1920:
1921:
1926: public boolean getScrollableTracksViewportHeight()
1927: {
1928: return false;
1929: }
1930:
1931:
1937: public boolean getScrollableTracksViewportWidth()
1938: {
1939: if (autoResizeMode == AUTO_RESIZE_OFF)
1940: return false;
1941: else
1942: return true;
1943: }
1944:
1945: public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)
1946: {
1947:
1948:
1949:
1950:
1951: if (orientation == SwingConstants.VERTICAL)
1952: return direction * rowHeight;
1953: else
1954: {
1955: int sum = 0;
1956: for (int i = 0; i < getColumnCount(); ++i)
1957: sum += columnModel.getColumn(0).getWidth();
1958: int inc = getColumnCount() == 0 ? 10 : sum / getColumnCount();
1959: return direction * inc;
1960: }
1961: }
1962:
1963:
1964: public TableCellEditor getCellEditor(int row, int column)
1965: {
1966: TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
1967:
1968: if (editor == null)
1969: editor = getDefaultEditor(dataModel.getColumnClass(column));
1970:
1971: return editor;
1972: }
1973:
1974: public TableCellEditor getDefaultEditor(Class columnClass)
1975: {
1976: if (defaultEditorsByColumnClass.containsKey(columnClass))
1977: return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
1978: else
1979: {
1980:
1981: TableCellEditor r = new DefaultCellEditor(new JTextField());
1982: defaultEditorsByColumnClass.put(columnClass, r);
1983: return r;
1984: }
1985: }
1986:
1987:
1988:
1989: public TableCellRenderer getCellRenderer(int row, int column)
1990: {
1991: TableCellRenderer renderer =
1992: columnModel.getColumn(column).getCellRenderer();
1993:
1994: if (renderer == null)
1995: renderer = getDefaultRenderer(dataModel.getColumnClass(column));
1996:
1997: return renderer;
1998: }
1999:
2000: public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
2001: {
2002: defaultRenderersByColumnClass.put(columnClass, rend);
2003: }
2004:
2005: public TableCellRenderer getDefaultRenderer(Class columnClass)
2006: {
2007: if (defaultRenderersByColumnClass.containsKey(columnClass))
2008: return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
2009: else
2010: {
2011: TableCellRenderer r = new DefaultTableCellRenderer();
2012: defaultRenderersByColumnClass.put(columnClass, r);
2013: return r;
2014: }
2015: }
2016:
2017: public int convertColumnIndexToModel(int vc)
2018: {
2019: if (vc < 0)
2020: return vc;
2021: else
2022: return columnModel.getColumn(vc).getModelIndex();
2023: }
2024:
2025: public int convertColumnIndexToView(int mc)
2026: {
2027: if (mc < 0)
2028: return mc;
2029: int ncols = getColumnCount();
2030: for (int vc = 0; vc < ncols; ++vc)
2031: {
2032: if (columnModel.getColumn(vc).getModelIndex() == mc)
2033: return vc;
2034: }
2035: return -1;
2036: }
2037:
2038: public Component prepareRenderer(TableCellRenderer renderer,
2039: int row,
2040: int column)
2041: {
2042: boolean rsa = getRowSelectionAllowed();
2043: boolean csa = getColumnSelectionAllowed();
2044: boolean rs = rsa ? getSelectionModel().isSelectedIndex(row) : false;
2045: boolean cs = csa ? columnModel.getSelectionModel().isSelectedIndex(column) : false;
2046: boolean isSelected = ((rsa && csa && rs && cs)
2047: || (rsa && !csa && rs)
2048: || (!rsa && csa && cs));
2049:
2050: return renderer.getTableCellRendererComponent(this,
2051: dataModel.getValueAt(row,
2052: convertColumnIndexToModel(column)),
2053: isSelected,
2054: false,
2055: row, column);
2056: }
2057:
2058:
2059:
2064: public boolean getAutoCreateColumnsFromModel()
2065: {
2066: return autoCreateColumnsFromModel;
2067: }
2068:
2069:
2074: public int getAutoResizeMode()
2075: {
2076: return autoResizeMode;
2077: }
2078:
2079:
2084: public int getRowHeight()
2085: {
2086: return rowHeight;
2087: }
2088:
2089:
2094: public int getRowHeight(int row)
2095: {
2096:
2097:
2098: return rowHeight;
2099: }
2100:
2101:
2102:
2107: public int getRowMargin()
2108: {
2109: return rowMargin;
2110: }
2111:
2112:
2117: public boolean getRowSelectionAllowed()
2118: {
2119: return rowSelectionAllowed;
2120: }
2121:
2122:
2127: public boolean getCellSelectionEnabled()
2128: {
2129: return getColumnSelectionAllowed() && getRowSelectionAllowed();
2130: }
2131:
2132:
2137: public TableModel getModel()
2138: {
2139: return dataModel;
2140: }
2141:
2142:
2148: public int getColumnCount()
2149: {
2150: return columnModel.getColumnCount();
2151: }
2152:
2153:
2159: public int getRowCount()
2160: {
2161: return dataModel.getRowCount();
2162: }
2163:
2164:
2169: public TableColumnModel getColumnModel()
2170: {
2171: return columnModel;
2172: }
2173:
2174:
2180: public int getSelectedColumn()
2181: {
2182: return columnModel.getSelectionModel().getMinSelectionIndex();
2183: }
2184:
2185: private static int countSelections(ListSelectionModel lsm)
2186: {
2187: int lo = lsm.getMinSelectionIndex();
2188: int hi = lsm.getMaxSelectionIndex();
2189: int sum = 0;
2190: if (lo != -1 && hi != -1)
2191: {
2192: switch (lsm.getSelectionMode())
2193: {
2194: case ListSelectionModel.SINGLE_SELECTION:
2195: sum = 1;
2196: break;
2197:
2198: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
2199: sum = hi - lo + 1;
2200: break;
2201:
2202: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
2203: for (int i = lo; i <= hi; ++i)
2204: if (lsm.isSelectedIndex(i))
2205: ++sum;
2206: break;
2207: }
2208: }
2209: return sum;
2210: }
2211:
2212: private static int[] getSelections(ListSelectionModel lsm)
2213: {
2214: int sz = countSelections(lsm);
2215: int [] ret = new int[sz];
2216:
2217: int lo = lsm.getMinSelectionIndex();
2218: int hi = lsm.getMaxSelectionIndex();
2219: int j = 0;
2220: java.util.ArrayList ls = new java.util.ArrayList();
2221: if (lo != -1 && hi != -1)
2222: {
2223: switch (lsm.getSelectionMode())
2224: {
2225: case ListSelectionModel.SINGLE_SELECTION:
2226: ret[0] = lo;
2227: break;
2228:
2229: case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
2230: for (int i = lo; i <= hi; ++i)
2231: ret[j++] = i;
2232: break;
2233:
2234: case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
2235: for (int i = lo; i <= hi; ++i)
2236: if (lsm.isSelectedIndex(i))
2237: ret[j++] = i;
2238: break;
2239: }
2240: }
2241: return ret;
2242: }
2243:
2244:
2250: public int getSelectedColumnCount()
2251: {
2252: return countSelections(columnModel.getSelectionModel());
2253: }
2254:
2255:
2261: public int[] getSelectedColumns()
2262: {
2263: return getSelections(columnModel.getSelectionModel());
2264: }
2265:
2266:
2271: public boolean getColumnSelectionAllowed()
2272: {
2273: return getColumnModel().getColumnSelectionAllowed();
2274: }
2275:
2276:
2282: public int getSelectedRowCount()
2283: {
2284: return countSelections(selectionModel);
2285: }
2286:
2287:
2293: public int[] getSelectedRows()
2294: {
2295: return getSelections(selectionModel);
2296: }
2297:
2298:
2303: public AccessibleContext getAccessibleContext()
2304: {
2305: return accessibleContext;
2306: }
2307:
2308:
2313: public TableCellEditor getCellEditor()
2314: {
2315: return cellEditor;
2316: }
2317:
2318:
2323: public boolean getDragEnabled()
2324: {
2325: return dragEnabled;
2326: }
2327:
2328:
2333: public Color getGridColor()
2334: {
2335: return gridColor;
2336: }
2337:
2338:
2343: public Dimension getIntercellSpacing()
2344: {
2345: return new Dimension(columnModel.getColumnMargin(), rowMargin);
2346: }
2347:
2348:
2353: public Dimension getPreferredScrollableViewportSize()
2354: {
2355: return preferredViewportSize;
2356: }
2357:
2358:
2363: public Color getSelectionBackground()
2364: {
2365: return selectionBackground;
2366: }
2367:
2368:
2373: public Color getSelectionForeground()
2374: {
2375: return selectionForeground;
2376: }
2377:
2378:
2383: public boolean getShowHorizontalLines()
2384: {
2385: return showHorizontalLines;
2386: }
2387:
2388:
2393: public boolean getShowVerticalLines()
2394: {
2395: return showVerticalLines;
2396: }
2397:
2398:
2403: public JTableHeader getTableHeader()
2404: {
2405: return tableHeader;
2406: }
2407:
2408:
2413: public void removeColumn(TableColumn column)
2414: {
2415: columnModel.removeColumn(column);
2416: }
2417:
2418:
2424: public void moveColumn(int column,int targetColumn)
2425: {
2426: columnModel.moveColumn(column, targetColumn);
2427: }
2428:
2429:
2436: public void setAutoCreateColumnsFromModel(boolean autoCreate)
2437: {
2438: if (autoCreateColumnsFromModel != autoCreate)
2439: {
2440: autoCreateColumnsFromModel = autoCreate;
2441: if (autoCreate)
2442: createDefaultColumnsFromModel();
2443: }
2444: }
2445:
2446:
2451: public void setAutoResizeMode(int a)
2452: {
2453: autoResizeMode = a;
2454: revalidate();
2455: repaint();
2456: }
2457:
2458:
2463: public void setRowHeight(int r)
2464: {
2465: if (r < 1)
2466: throw new IllegalArgumentException();
2467:
2468: rowHeight = r;
2469: revalidate();
2470: repaint();
2471: }
2472:
2473:
2480: public void setRowHeight(int row, int rh)
2481: {
2482: setRowHeight(rh);
2483:
2484: }
2485:
2486:
2491: public void setRowMargin(int r)
2492: {
2493: rowMargin = r;
2494: revalidate();
2495: repaint();
2496: }
2497:
2498:
2503: public void setRowSelectionAllowed(boolean r)
2504: {
2505: rowSelectionAllowed = r;
2506: repaint();
2507: }
2508:
2509:
2514: public void setCellSelectionEnabled(boolean c)
2515: {
2516: setColumnSelectionAllowed(c);
2517: setRowSelectionAllowed(c);
2518:
2519: cellSelectionEnabled = true;
2520: }
2521:
2522:
2531: public void setModel(TableModel m)
2532: {
2533:
2534: if (m == null)
2535: throw new IllegalArgumentException();
2536:
2537:
2538: if (dataModel == m)
2539: return;
2540:
2541: TableModel oldModel = dataModel;
2542:
2543:
2544: if (dataModel != null)
2545: dataModel.removeTableModelListener(this);
2546:
2547: if (m != null)
2548: {
2549:
2550: dataModel = m;
2551:
2552:
2553: dataModel.addTableModelListener(this);
2554:
2555:
2556: if (autoCreateColumnsFromModel)
2557: createDefaultColumnsFromModel();
2558: }
2559:
2560:
2561: firePropertyChange("model", oldModel, dataModel);
2562:
2563:
2564: revalidate();
2565: repaint();
2566: }
2567:
2568:
2577: public void setColumnModel(TableColumnModel c)
2578: {
2579: if (c == null)
2580: throw new IllegalArgumentException();
2581: TableColumnModel tmp = columnModel;
2582: if (tmp != null)
2583: tmp.removeColumnModelListener(this);
2584: if (c != null)
2585: c.addColumnModelListener(this);
2586: columnModel = c;
2587: if (dataModel != null && columnModel != null)
2588: {
2589: int ncols = getColumnCount();
2590: for (int i = 0; i < ncols; ++i)
2591: columnModel.getColumn(i).setHeaderValue(dataModel.getColumnName(i));
2592: }
2593:
2594:
2595:
2596: if (tableHeader != null)
2597: tableHeader.setColumnModel(c);
2598:
2599: revalidate();
2600: repaint();
2601: }
2602:
2603:
2608: public void setColumnSelectionAllowed(boolean c)
2609: {
2610: getColumnModel().setColumnSelectionAllowed(c);
2611: repaint();
2612: }
2613:
2614:
2623: public void setSelectionModel(ListSelectionModel s)
2624: {
2625: if (s == null)
2626: throw new IllegalArgumentException();
2627: ListSelectionModel tmp = selectionModel;
2628: if (tmp != null)
2629: tmp.removeListSelectionListener(this);
2630: if (s != null)
2631: s.addListSelectionListener(this);
2632: selectionModel = s;
2633: }
2634:
2635:
2642: public void setSelectionMode(int s)
2643: {
2644: selectionModel.setSelectionMode(s);
2645: columnModel.getSelectionModel().setSelectionMode(s);
2646:
2647: repaint();
2648: }
2649:
2650:
2659: public void setCellEditor(TableCellEditor c)
2660: {
2661: TableCellEditor tmp = cellEditor;
2662: if (tmp != null)
2663: tmp.removeCellEditorListener(this);
2664: if (c != null)
2665: c.addCellEditorListener(this);
2666: cellEditor = c;
2667: }
2668:
2669:
2674: public void setDragEnabled(boolean d)
2675: {
2676: dragEnabled = d;
2677: }
2678:
2679:
2684: public void setGridColor(Color g)
2685: {
2686: gridColor = g;
2687: repaint();
2688: }
2689:
2690:
2695: public void setIntercellSpacing(Dimension i)
2696: {
2697: rowMargin = i.height;
2698: columnModel.setColumnMargin(i.width);
2699: repaint();
2700: }
2701:
2702:
2707: public void setPreferredScrollableViewportSize(Dimension p)
2708: {
2709: preferredViewportSize = p;
2710: revalidate();
2711: repaint();
2712: }
2713:
2714:
2723: public void setSelectionBackground(Color s)
2724: {
2725: Color tmp = selectionBackground;
2726: selectionBackground = s;
2727: if (((tmp == null && s != null)
2728: || (s == null && tmp != null)
2729: || (tmp != null && s != null && !tmp.equals(s))))
2730: firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
2731: repaint();
2732: }
2733:
2734:
2743: public void setSelectionForeground(Color s)
2744: {
2745: Color tmp = selectionForeground;
2746: selectionForeground = s;
2747: if (((tmp == null && s != null)
2748: || (s == null && tmp != null)
2749: || (tmp != null && s != null && !tmp.equals(s))))
2750: firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
2751: repaint();
2752: }
2753:
2754:
2759: public void setShowGrid(boolean s)
2760: {
2761: setShowVerticalLines(s);
2762: setShowHorizontalLines(s);
2763: }
2764:
2765:
2770: public void setShowHorizontalLines(boolean s)
2771: {
2772: showHorizontalLines = s;
2773: repaint();
2774: }
2775:
2776:
2781: public void setShowVerticalLines(boolean s)
2782: {
2783: showVerticalLines = s;
2784: repaint();
2785: }
2786:
2787:
2792: public void setTableHeader(JTableHeader t)
2793: {
2794: if (tableHeader != null)
2795: tableHeader.setTable(null);
2796: tableHeader = t;
2797: if (tableHeader != null)
2798: tableHeader.setTable(this);
2799: revalidate();
2800: repaint();
2801: }
2802:
2803: protected void configureEnclosingScrollPane()
2804: {
2805: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
2806: if (jsp != null && tableHeader != null)
2807: {
2808: jsp.setColumnHeaderView(tableHeader);
2809: }
2810: }
2811:
2812: protected void unconfigureEnclosingScrollPane()
2813: {
2814: JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
2815: if (jsp != null)
2816: {
2817: jsp.setColumnHeaderView(null);
2818: }
2819: }
2820:
2821:
2822: public void addNotify()
2823: {
2824: super.addNotify();
2825: configureEnclosingScrollPane();
2826: }
2827:
2828: public void removeNotify()
2829: {
2830: super.addNotify();
2831: unconfigureEnclosingScrollPane();
2832: }
2833:
2834:
2835:
2843: private void distributeSpill(TableColumn[] cols, int spill)
2844: {
2845: int average = spill / cols.length;
2846: for (int i = 0; i < cols.length; i++)
2847: {
2848: if (cols[i] != null)
2849: cols[i].setWidth(cols[i].getWidth() + average);
2850: }
2851: }
2852:
2853: public void doLayout()
2854: {
2855: TableColumn resizingColumn = null;
2856:
2857: int ncols = getColumnCount();
2858: if (ncols < 1)
2859: return;
2860:
2861: int[] pref = new int[ncols];
2862: int prefSum = 0;
2863: int rCol = -1;
2864:
2865: if (tableHeader != null)
2866: resizingColumn = tableHeader.getResizingColumn();
2867:
2868: for (int i = 0; i < ncols; ++i)
2869: {
2870: TableColumn col = columnModel.getColumn(i);
2871: int p = col.getWidth();
2872: pref[i] = p;
2873: prefSum += p;
2874: if (resizingColumn == col)
2875: rCol = i;
2876: }
2877:
2878: int spill = getWidth() - prefSum;
2879:
2880: if (resizingColumn != null)
2881: {
2882: TableColumn col;
2883: TableColumn [] cols;
2884:
2885: switch (getAutoResizeMode())
2886: {
2887: case AUTO_RESIZE_LAST_COLUMN:
2888: col = columnModel.getColumn(ncols-1);
2889: col.setWidth(col.getPreferredWidth() + spill);
2890: break;
2891:
2892: case AUTO_RESIZE_NEXT_COLUMN:
2893: col = columnModel.getColumn(ncols-1);
2894: col.setWidth(col.getPreferredWidth() + spill);
2895: break;
2896:
2897: case AUTO_RESIZE_ALL_COLUMNS:
2898: cols = new TableColumn[ncols];
2899: for (int i = 0; i < ncols; ++i)
2900: cols[i] = columnModel.getColumn(i);
2901: distributeSpill(cols, spill);
2902: break;
2903:
2904: case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
2905: cols = new TableColumn[ncols];
2906: for (int i = rCol; i < ncols; ++i)
2907: cols[i] = columnModel.getColumn(i);
2908: distributeSpill(cols, spill);
2909: break;
2910:
2911: case AUTO_RESIZE_OFF:
2912: default:
2913: int prefWidth = resizingColumn.getPreferredWidth();
2914: resizingColumn.setWidth(prefWidth);
2915: }
2916: }
2917: else
2918: {
2919: TableColumn [] cols = new TableColumn[ncols];
2920: for (int i = 0; i < ncols; ++i)
2921: cols[i] = columnModel.getColumn(i);
2922: distributeSpill(cols, spill);
2923: }
2924: }
2925:
2926:
2929: public void sizeColumnsToFit(boolean lastColumnOnly)
2930: {
2931: doLayout();
2932: }
2933:
2934:
2937: public void sizeColumnsToFit(int resizingColumn)
2938: {
2939: doLayout();
2940: }
2941:
2942: public String getUIClassID()
2943: {
2944: return "TableUI";
2945: }
2946:
2947:
2952: public TableUI getUI()
2953: {
2954: return (TableUI) ui;
2955: }
2956:
2957:
2962: public void setUI(TableUI ui)
2963: {
2964: super.setUI(ui);
2965: }
2966:
2967: public void updateUI()
2968: {
2969: setUI((TableUI) UIManager.getUI(this));
2970: revalidate();
2971: repaint();
2972: }
2973:
2974: public Class getColumnClass(int column)
2975: {
2976: return dataModel.getColumnClass(column);
2977: }
2978:
2979: public String getColumnName(int column)
2980: {
2981: int modelColumn = columnModel.getColumn(column).getModelIndex();
2982: return dataModel.getColumnName(modelColumn);
2983: }
2984:
2985: public int getEditingColumn()
2986: {
2987: return editingColumn;
2988: }
2989:
2990: public void setEditingColumn(int column)
2991: {
2992: editingColumn = column;
2993: }
2994:
2995: public int getEditingRow()
2996: {
2997: return editingRow;
2998: }
2999:
3000: public void setEditingRow(int column)
3001: {
3002: editingRow = column;
3003: }
3004:
3005: public Component getEditorComponent()
3006: {
3007: return editorComp;
3008: }
3009:
3010: public boolean isEditing()
3011: {
3012: return editorComp != null;
3013: }
3014:
3015: public void setDefaultEditor(Class columnClass, TableCellEditor editor)
3016: {
3017: if (editor != null)
3018: defaultEditorsByColumnClass.put(columnClass, editor);
3019: else
3020: defaultEditorsByColumnClass.remove(columnClass);
3021: }
3022:
3023: public void addColumnSelectionInterval(int index0, int index1)
3024: {
3025: if ((index0 < 0 || index0 > (getColumnCount()-1)
3026: || index1 < 0 || index1 > (getColumnCount()-1)))
3027: throw new IllegalArgumentException("Column index out of range.");
3028:
3029: getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
3030: }
3031:
3032: public void addRowSelectionInterval(int index0, int index1)
3033: {
3034: if ((index0 < 0 || index0 > (getRowCount()-1)
3035: || index1 < 0 || index1 > (getRowCount()-1)))
3036: throw new IllegalArgumentException("Row index out of range.");
3037:
3038: getSelectionModel().addSelectionInterval(index0, index1);
3039: }
3040:
3041: public void setColumnSelectionInterval(int index0, int index1)
3042: {
3043: if ((index0 < 0 || index0 > (getColumnCount()-1)
3044: || index1 < 0 || index1 > (getColumnCount()-1)))
3045: throw new IllegalArgumentException("Column index out of range.");
3046:
3047: getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
3048: }
3049:
3050: public void setRowSelectionInterval(int index0, int index1)
3051: {
3052: if ((index0 < 0 || index0 > (getRowCount()-1)
3053: || index1 < 0 || index1 > (getRowCount()-1)))
3054: throw new IllegalArgumentException("Row index out of range.");
3055:
3056: getSelectionModel().setSelectionInterval(index0, index1);
3057: }
3058:
3059: public void removeColumnSelectionInterval(int index0, int index1)
3060: {
3061: if ((index0 < 0 || index0 > (getColumnCount()-1)
3062: || index1 < 0 || index1 > (getColumnCount()-1)))
3063: throw new IllegalArgumentException("Column index out of range.");
3064:
3065: getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
3066: }
3067:
3068: public void removeRowSelectionInterval(int index0, int index1)
3069: {
3070: if ((index0 < 0 || index0 > (getRowCount()-1)
3071: || index1 < 0 || index1 > (getRowCount()-1)))
3072: throw new IllegalArgumentException("Row index out of range.");
3073:
3074: getSelectionModel().removeSelectionInterval(index0, index1);
3075: }
3076:
3077: public boolean isColumnSelected(int column)
3078: {
3079: return getColumnModel().getSelectionModel().isSelectedIndex(column);
3080: }
3081:
3082: public boolean isRowSelected(int row)
3083: {
3084: return getSelectionModel().isSelectedIndex(row);
3085: }
3086:
3087: public boolean isCellSelected(int row, int column)
3088: {
3089: return isRowSelected(row) && isColumnSelected(column);
3090: }
3091:
3092: public void selectAll()
3093: {
3094:
3095: int rowLead = selectionModel.getLeadSelectionIndex();
3096: int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
3097:
3098:
3099: setColumnSelectionInterval(0, getColumnCount() - 1);
3100: setRowSelectionInterval(0, getRowCount() - 1);
3101:
3102:
3103: addColumnSelectionInterval(colLead,colLead);
3104: addRowSelectionInterval(rowLead, rowLead);
3105: }
3106:
3107: public Object getValueAt(int row, int column)
3108: {
3109: return dataModel.getValueAt(row, convertColumnIndexToModel(column));
3110: }
3111:
3112: public void setValueAt(Object value, int row, int column)
3113: {
3114: if (!isCellEditable(row, column))
3115: return;
3116:
3117: if (value instanceof Component)
3118: add((Component)value);
3119: dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
3120: }
3121:
3122: public TableColumn getColumn(Object identifier)
3123: {
3124: return columnModel.getColumn(columnModel.getColumnIndex(identifier));
3125: }
3126:
3127:
3136: public boolean isCellEditable(int row, int column)
3137: {
3138: return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
3139: }
3140:
3141:
3148: public void createDefaultColumnsFromModel()
3149: {
3150: assert columnModel != null : "The columnModel must not be null.";
3151:
3152:
3153: int columnIndex = columnModel.getColumnCount() - 1;
3154: while (columnIndex >= 0)
3155: {
3156: columnModel.removeColumn(columnModel.getColumn(columnIndex));
3157: columnIndex--;
3158: }
3159:
3160:
3161: int columnCount = dataModel.getColumnCount();
3162: for (int c = 0; c < columnCount; c++)
3163: {
3164: TableColumn column = new TableColumn(c);
3165: column.setIdentifier(dataModel.getColumnName(c));
3166: column.setHeaderValue(dataModel.getColumnName(c));
3167: columnModel.addColumn(column);
3168: column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
3169: }
3170: }
3171:
3172: public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
3173: {
3174: if (toggle && extend)
3175: {
3176:
3177:
3178: selectionModel.setAnchorSelectionIndex(rowIndex);
3179: getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
3180: }
3181: else if (toggle)
3182: {
3183:
3184: if (isCellSelected(rowIndex,columnIndex))
3185: {
3186: selectionModel.removeSelectionInterval(rowIndex,rowIndex);
3187: getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
3188: }
3189: else
3190: {
3191: selectionModel.addSelectionInterval(rowIndex,rowIndex);
3192: getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
3193: }
3194: }
3195: else if (extend)
3196: {
3197:
3198:
3199: selectionModel.setLeadSelectionIndex(rowIndex);
3200: getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
3201: }
3202: else
3203: {
3204:
3205:
3206: selectionModel.clearSelection();
3207: selectionModel.setSelectionInterval(rowIndex,rowIndex);
3208: getColumnModel().getSelectionModel().clearSelection();
3209: getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
3210:
3211:
3212: }
3213: }
3214:
3215:
3221: public boolean editCellAt (int row, int column)
3222: {
3223: oldCellValue = getValueAt(row, column);
3224: setCellEditor(getCellEditor(row, column));
3225: editorComp = prepareEditor(cellEditor, row, column);
3226: cellEditor.addCellEditorListener(this);
3227: rowBeingEdited = row;
3228: columnBeingEdited = column;
3229: setValueAt(editorComp, row, column);
3230: ((JTextField)editorComp).requestFocusInWindow(false);
3231: editorTimer.start();
3232: return true;
3233: }
3234:
3235:
3241: public boolean editCellAt (int row, int column, EventObject e)
3242: {
3243: return editCellAt(row, column);
3244: }
3245:
3246:
3249: public void removeEditor()
3250: {
3251: editingStopped(new ChangeEvent(this));
3252: }
3253:
3254:
3263: public Component prepareEditor (TableCellEditor editor, int row, int column)
3264: {
3265: return editor.getTableCellEditorComponent
3266: (this, getValueAt(row, column), isCellSelected(row, column), row, column);
3267: }
3268:
3269:
3272: protected void resizeAndRepaint()
3273: {
3274: revalidate();
3275: repaint();
3276: }
3277: }