| /* |
| * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.swing.plaf.basic; |
| |
| import java.awt.*; |
| import java.awt.datatransfer.*; |
| import java.awt.dnd.*; |
| import java.awt.event.*; |
| import java.util.Enumeration; |
| import java.util.EventObject; |
| import java.util.Hashtable; |
| import java.util.TooManyListenersException; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import javax.swing.plaf.*; |
| import javax.swing.text.*; |
| import javax.swing.table.*; |
| import javax.swing.plaf.basic.DragRecognitionSupport.BeforeDrag; |
| import sun.swing.SwingUtilities2; |
| |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| |
| import sun.swing.DefaultLookup; |
| import sun.swing.UIAction; |
| |
| /** |
| * BasicTableUI implementation |
| * |
| * @author Philip Milne |
| * @author Shannon Hickey (drag and drop) |
| */ |
| public class BasicTableUI extends TableUI |
| { |
| private static final StringBuilder BASELINE_COMPONENT_KEY = |
| new StringBuilder("Table.baselineComponent"); |
| |
| // |
| // Instance Variables |
| // |
| |
| // The JTable that is delegating the painting to this UI. |
| protected JTable table; |
| protected CellRendererPane rendererPane; |
| |
| // Listeners that are attached to the JTable |
| protected KeyListener keyListener; |
| protected FocusListener focusListener; |
| protected MouseInputListener mouseInputListener; |
| |
| private Handler handler; |
| |
| /** |
| * Local cache of Table's client property "Table.isFileList" |
| */ |
| private boolean isFileList = false; |
| |
| // |
| // Helper class for keyboard actions |
| // |
| |
| private static class Actions extends UIAction { |
| private static final String CANCEL_EDITING = "cancel"; |
| private static final String SELECT_ALL = "selectAll"; |
| private static final String CLEAR_SELECTION = "clearSelection"; |
| private static final String START_EDITING = "startEditing"; |
| |
| private static final String NEXT_ROW = "selectNextRow"; |
| private static final String NEXT_ROW_CELL = "selectNextRowCell"; |
| private static final String NEXT_ROW_EXTEND_SELECTION = |
| "selectNextRowExtendSelection"; |
| private static final String NEXT_ROW_CHANGE_LEAD = |
| "selectNextRowChangeLead"; |
| private static final String PREVIOUS_ROW = "selectPreviousRow"; |
| private static final String PREVIOUS_ROW_CELL = "selectPreviousRowCell"; |
| private static final String PREVIOUS_ROW_EXTEND_SELECTION = |
| "selectPreviousRowExtendSelection"; |
| private static final String PREVIOUS_ROW_CHANGE_LEAD = |
| "selectPreviousRowChangeLead"; |
| |
| private static final String NEXT_COLUMN = "selectNextColumn"; |
| private static final String NEXT_COLUMN_CELL = "selectNextColumnCell"; |
| private static final String NEXT_COLUMN_EXTEND_SELECTION = |
| "selectNextColumnExtendSelection"; |
| private static final String NEXT_COLUMN_CHANGE_LEAD = |
| "selectNextColumnChangeLead"; |
| private static final String PREVIOUS_COLUMN = "selectPreviousColumn"; |
| private static final String PREVIOUS_COLUMN_CELL = |
| "selectPreviousColumnCell"; |
| private static final String PREVIOUS_COLUMN_EXTEND_SELECTION = |
| "selectPreviousColumnExtendSelection"; |
| private static final String PREVIOUS_COLUMN_CHANGE_LEAD = |
| "selectPreviousColumnChangeLead"; |
| |
| private static final String SCROLL_LEFT_CHANGE_SELECTION = |
| "scrollLeftChangeSelection"; |
| private static final String SCROLL_LEFT_EXTEND_SELECTION = |
| "scrollLeftExtendSelection"; |
| private static final String SCROLL_RIGHT_CHANGE_SELECTION = |
| "scrollRightChangeSelection"; |
| private static final String SCROLL_RIGHT_EXTEND_SELECTION = |
| "scrollRightExtendSelection"; |
| |
| private static final String SCROLL_UP_CHANGE_SELECTION = |
| "scrollUpChangeSelection"; |
| private static final String SCROLL_UP_EXTEND_SELECTION = |
| "scrollUpExtendSelection"; |
| private static final String SCROLL_DOWN_CHANGE_SELECTION = |
| "scrollDownChangeSelection"; |
| private static final String SCROLL_DOWN_EXTEND_SELECTION = |
| "scrollDownExtendSelection"; |
| |
| private static final String FIRST_COLUMN = |
| "selectFirstColumn"; |
| private static final String FIRST_COLUMN_EXTEND_SELECTION = |
| "selectFirstColumnExtendSelection"; |
| private static final String LAST_COLUMN = |
| "selectLastColumn"; |
| private static final String LAST_COLUMN_EXTEND_SELECTION = |
| "selectLastColumnExtendSelection"; |
| |
| private static final String FIRST_ROW = |
| "selectFirstRow"; |
| private static final String FIRST_ROW_EXTEND_SELECTION = |
| "selectFirstRowExtendSelection"; |
| private static final String LAST_ROW = |
| "selectLastRow"; |
| private static final String LAST_ROW_EXTEND_SELECTION = |
| "selectLastRowExtendSelection"; |
| |
| // add the lead item to the selection without changing lead or anchor |
| private static final String ADD_TO_SELECTION = "addToSelection"; |
| |
| // toggle the selected state of the lead item and move the anchor to it |
| private static final String TOGGLE_AND_ANCHOR = "toggleAndAnchor"; |
| |
| // extend the selection to the lead item |
| private static final String EXTEND_TO = "extendTo"; |
| |
| // move the anchor to the lead and ensure only that item is selected |
| private static final String MOVE_SELECTION_TO = "moveSelectionTo"; |
| |
| // give focus to the JTableHeader, if one exists |
| private static final String FOCUS_HEADER = "focusHeader"; |
| |
| protected int dx; |
| protected int dy; |
| protected boolean extend; |
| protected boolean inSelection; |
| |
| // horizontally, forwards always means right, |
| // regardless of component orientation |
| protected boolean forwards; |
| protected boolean vertically; |
| protected boolean toLimit; |
| |
| protected int leadRow; |
| protected int leadColumn; |
| |
| Actions(String name) { |
| super(name); |
| } |
| |
| Actions(String name, int dx, int dy, boolean extend, |
| boolean inSelection) { |
| super(name); |
| |
| // Actions spcifying true for "inSelection" are |
| // fairly sensitive to bad parameter values. They require |
| // that one of dx and dy be 0 and the other be -1 or 1. |
| // Bogus parameter values could cause an infinite loop. |
| // To prevent any problems we massage the params here |
| // and complain if we get something we can't deal with. |
| if (inSelection) { |
| this.inSelection = true; |
| |
| // look at the sign of dx and dy only |
| dx = sign(dx); |
| dy = sign(dy); |
| |
| // make sure one is zero, but not both |
| assert (dx == 0 || dy == 0) && !(dx == 0 && dy == 0); |
| } |
| |
| this.dx = dx; |
| this.dy = dy; |
| this.extend = extend; |
| } |
| |
| Actions(String name, boolean extend, boolean forwards, |
| boolean vertically, boolean toLimit) { |
| this(name, 0, 0, extend, false); |
| this.forwards = forwards; |
| this.vertically = vertically; |
| this.toLimit = toLimit; |
| } |
| |
| private static int clipToRange(int i, int a, int b) { |
| return Math.min(Math.max(i, a), b-1); |
| } |
| |
| private void moveWithinTableRange(JTable table, int dx, int dy) { |
| leadRow = clipToRange(leadRow+dy, 0, table.getRowCount()); |
| leadColumn = clipToRange(leadColumn+dx, 0, table.getColumnCount()); |
| } |
| |
| private static int sign(int num) { |
| return (num < 0) ? -1 : ((num == 0) ? 0 : 1); |
| } |
| |
| /** |
| * Called to move within the selected range of the given JTable. |
| * This method uses the table's notion of selection, which is |
| * important to allow the user to navigate between items visually |
| * selected on screen. This notion may or may not be the same as |
| * what could be determined by directly querying the selection models. |
| * It depends on certain table properties (such as whether or not |
| * row or column selection is allowed). When performing modifications, |
| * it is recommended that caution be taken in order to preserve |
| * the intent of this method, especially when deciding whether to |
| * query the selection models or interact with JTable directly. |
| */ |
| private boolean moveWithinSelectedRange(JTable table, int dx, int dy, |
| ListSelectionModel rsm, ListSelectionModel csm) { |
| |
| // Note: The Actions constructor ensures that only one of |
| // dx and dy is 0, and the other is either -1 or 1 |
| |
| // find out how many items the table is showing as selected |
| // and the range of items to navigate through |
| int totalCount; |
| int minX, maxX, minY, maxY; |
| |
| boolean rs = table.getRowSelectionAllowed(); |
| boolean cs = table.getColumnSelectionAllowed(); |
| |
| // both column and row selection |
| if (rs && cs) { |
| totalCount = table.getSelectedRowCount() * table.getSelectedColumnCount(); |
| minX = csm.getMinSelectionIndex(); |
| maxX = csm.getMaxSelectionIndex(); |
| minY = rsm.getMinSelectionIndex(); |
| maxY = rsm.getMaxSelectionIndex(); |
| // row selection only |
| } else if (rs) { |
| totalCount = table.getSelectedRowCount(); |
| minX = 0; |
| maxX = table.getColumnCount() - 1; |
| minY = rsm.getMinSelectionIndex(); |
| maxY = rsm.getMaxSelectionIndex(); |
| // column selection only |
| } else if (cs) { |
| totalCount = table.getSelectedColumnCount(); |
| minX = csm.getMinSelectionIndex(); |
| maxX = csm.getMaxSelectionIndex(); |
| minY = 0; |
| maxY = table.getRowCount() - 1; |
| // no selection allowed |
| } else { |
| totalCount = 0; |
| // A bogus assignment to stop javac from complaining |
| // about unitialized values. In this case, these |
| // won't even be used. |
| minX = maxX = minY = maxY = 0; |
| } |
| |
| // For some cases, there is no point in trying to stay within the |
| // selected area. Instead, move outside the selection, wrapping at |
| // the table boundaries. The cases are: |
| boolean stayInSelection; |
| |
| // - nothing selected |
| if (totalCount == 0 || |
| // - one item selected, and the lead is already selected |
| (totalCount == 1 && table.isCellSelected(leadRow, leadColumn))) { |
| |
| stayInSelection = false; |
| |
| maxX = table.getColumnCount() - 1; |
| maxY = table.getRowCount() - 1; |
| |
| // the mins are calculated like this in case the max is -1 |
| minX = Math.min(0, maxX); |
| minY = Math.min(0, maxY); |
| } else { |
| stayInSelection = true; |
| } |
| |
| // the algorithm below isn't prepared to deal with -1 lead/anchor |
| // so massage appropriately here first |
| if (dy == 1 && leadColumn == -1) { |
| leadColumn = minX; |
| leadRow = -1; |
| } else if (dx == 1 && leadRow == -1) { |
| leadRow = minY; |
| leadColumn = -1; |
| } else if (dy == -1 && leadColumn == -1) { |
| leadColumn = maxX; |
| leadRow = maxY + 1; |
| } else if (dx == -1 && leadRow == -1) { |
| leadRow = maxY; |
| leadColumn = maxX + 1; |
| } |
| |
| // In cases where the lead is not within the search range, |
| // we need to bring it within one cell for the the search |
| // to work properly. Check these here. |
| leadRow = Math.min(Math.max(leadRow, minY - 1), maxY + 1); |
| leadColumn = Math.min(Math.max(leadColumn, minX - 1), maxX + 1); |
| |
| // find the next position, possibly looping until it is selected |
| do { |
| calcNextPos(dx, minX, maxX, dy, minY, maxY); |
| } while (stayInSelection && !table.isCellSelected(leadRow, leadColumn)); |
| |
| return stayInSelection; |
| } |
| |
| /** |
| * Find the next lead row and column based on the given |
| * dx/dy and max/min values. |
| */ |
| private void calcNextPos(int dx, int minX, int maxX, |
| int dy, int minY, int maxY) { |
| |
| if (dx != 0) { |
| leadColumn += dx; |
| if (leadColumn > maxX) { |
| leadColumn = minX; |
| leadRow++; |
| if (leadRow > maxY) { |
| leadRow = minY; |
| } |
| } else if (leadColumn < minX) { |
| leadColumn = maxX; |
| leadRow--; |
| if (leadRow < minY) { |
| leadRow = maxY; |
| } |
| } |
| } else { |
| leadRow += dy; |
| if (leadRow > maxY) { |
| leadRow = minY; |
| leadColumn++; |
| if (leadColumn > maxX) { |
| leadColumn = minX; |
| } |
| } else if (leadRow < minY) { |
| leadRow = maxY; |
| leadColumn--; |
| if (leadColumn < minX) { |
| leadColumn = maxX; |
| } |
| } |
| } |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| String key = getName(); |
| JTable table = (JTable)e.getSource(); |
| |
| ListSelectionModel rsm = table.getSelectionModel(); |
| leadRow = getAdjustedLead(table, true, rsm); |
| |
| ListSelectionModel csm = table.getColumnModel().getSelectionModel(); |
| leadColumn = getAdjustedLead(table, false, csm); |
| |
| if (key == SCROLL_LEFT_CHANGE_SELECTION || // Paging Actions |
| key == SCROLL_LEFT_EXTEND_SELECTION || |
| key == SCROLL_RIGHT_CHANGE_SELECTION || |
| key == SCROLL_RIGHT_EXTEND_SELECTION || |
| key == SCROLL_UP_CHANGE_SELECTION || |
| key == SCROLL_UP_EXTEND_SELECTION || |
| key == SCROLL_DOWN_CHANGE_SELECTION || |
| key == SCROLL_DOWN_EXTEND_SELECTION || |
| key == FIRST_COLUMN || |
| key == FIRST_COLUMN_EXTEND_SELECTION || |
| key == FIRST_ROW || |
| key == FIRST_ROW_EXTEND_SELECTION || |
| key == LAST_COLUMN || |
| key == LAST_COLUMN_EXTEND_SELECTION || |
| key == LAST_ROW || |
| key == LAST_ROW_EXTEND_SELECTION) { |
| if (toLimit) { |
| if (vertically) { |
| int rowCount = table.getRowCount(); |
| this.dx = 0; |
| this.dy = forwards ? rowCount : -rowCount; |
| } |
| else { |
| int colCount = table.getColumnCount(); |
| this.dx = forwards ? colCount : -colCount; |
| this.dy = 0; |
| } |
| } |
| else { |
| if (!(table.getParent().getParent() instanceof |
| JScrollPane)) { |
| return; |
| } |
| |
| Dimension delta = table.getParent().getSize(); |
| |
| if (vertically) { |
| Rectangle r = table.getCellRect(leadRow, 0, true); |
| if (forwards) { |
| // scroll by at least one cell |
| r.y += Math.max(delta.height, r.height); |
| } else { |
| r.y -= delta.height; |
| } |
| |
| this.dx = 0; |
| int newRow = table.rowAtPoint(r.getLocation()); |
| if (newRow == -1 && forwards) { |
| newRow = table.getRowCount(); |
| } |
| this.dy = newRow - leadRow; |
| } |
| else { |
| Rectangle r = table.getCellRect(0, leadColumn, true); |
| |
| if (forwards) { |
| // scroll by at least one cell |
| r.x += Math.max(delta.width, r.width); |
| } else { |
| r.x -= delta.width; |
| } |
| |
| int newColumn = table.columnAtPoint(r.getLocation()); |
| if (newColumn == -1) { |
| boolean ltr = table.getComponentOrientation().isLeftToRight(); |
| |
| newColumn = forwards ? (ltr ? table.getColumnCount() : 0) |
| : (ltr ? 0 : table.getColumnCount()); |
| |
| } |
| this.dx = newColumn - leadColumn; |
| this.dy = 0; |
| } |
| } |
| } |
| if (key == NEXT_ROW || // Navigate Actions |
| key == NEXT_ROW_CELL || |
| key == NEXT_ROW_EXTEND_SELECTION || |
| key == NEXT_ROW_CHANGE_LEAD || |
| key == NEXT_COLUMN || |
| key == NEXT_COLUMN_CELL || |
| key == NEXT_COLUMN_EXTEND_SELECTION || |
| key == NEXT_COLUMN_CHANGE_LEAD || |
| key == PREVIOUS_ROW || |
| key == PREVIOUS_ROW_CELL || |
| key == PREVIOUS_ROW_EXTEND_SELECTION || |
| key == PREVIOUS_ROW_CHANGE_LEAD || |
| key == PREVIOUS_COLUMN || |
| key == PREVIOUS_COLUMN_CELL || |
| key == PREVIOUS_COLUMN_EXTEND_SELECTION || |
| key == PREVIOUS_COLUMN_CHANGE_LEAD || |
| // Paging Actions. |
| key == SCROLL_LEFT_CHANGE_SELECTION || |
| key == SCROLL_LEFT_EXTEND_SELECTION || |
| key == SCROLL_RIGHT_CHANGE_SELECTION || |
| key == SCROLL_RIGHT_EXTEND_SELECTION || |
| key == SCROLL_UP_CHANGE_SELECTION || |
| key == SCROLL_UP_EXTEND_SELECTION || |
| key == SCROLL_DOWN_CHANGE_SELECTION || |
| key == SCROLL_DOWN_EXTEND_SELECTION || |
| key == FIRST_COLUMN || |
| key == FIRST_COLUMN_EXTEND_SELECTION || |
| key == FIRST_ROW || |
| key == FIRST_ROW_EXTEND_SELECTION || |
| key == LAST_COLUMN || |
| key == LAST_COLUMN_EXTEND_SELECTION || |
| key == LAST_ROW || |
| key == LAST_ROW_EXTEND_SELECTION) { |
| |
| if (table.isEditing() && |
| !table.getCellEditor().stopCellEditing()) { |
| return; |
| } |
| |
| // Unfortunately, this strategy introduces bugs because |
| // of the asynchronous nature of requestFocus() call below. |
| // Introducing a delay with invokeLater() makes this work |
| // in the typical case though race conditions then allow |
| // focus to disappear altogether. The right solution appears |
| // to be to fix requestFocus() so that it queues a request |
| // for the focus regardless of who owns the focus at the |
| // time the call to requestFocus() is made. The optimisation |
| // to ignore the call to requestFocus() when the component |
| // already has focus may ligitimately be made as the |
| // request focus event is dequeued, not before. |
| |
| // boolean wasEditingWithFocus = table.isEditing() && |
| // table.getEditorComponent().isFocusOwner(); |
| |
| boolean changeLead = false; |
| if (key == NEXT_ROW_CHANGE_LEAD || key == PREVIOUS_ROW_CHANGE_LEAD) { |
| changeLead = (rsm.getSelectionMode() |
| == ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); |
| } else if (key == NEXT_COLUMN_CHANGE_LEAD || key == PREVIOUS_COLUMN_CHANGE_LEAD) { |
| changeLead = (csm.getSelectionMode() |
| == ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); |
| } |
| |
| if (changeLead) { |
| moveWithinTableRange(table, dx, dy); |
| if (dy != 0) { |
| // casting should be safe since the action is only enabled |
| // for DefaultListSelectionModel |
| ((DefaultListSelectionModel)rsm).moveLeadSelectionIndex(leadRow); |
| if (getAdjustedLead(table, false, csm) == -1 |
| && table.getColumnCount() > 0) { |
| |
| ((DefaultListSelectionModel)csm).moveLeadSelectionIndex(0); |
| } |
| } else { |
| // casting should be safe since the action is only enabled |
| // for DefaultListSelectionModel |
| ((DefaultListSelectionModel)csm).moveLeadSelectionIndex(leadColumn); |
| if (getAdjustedLead(table, true, rsm) == -1 |
| && table.getRowCount() > 0) { |
| |
| ((DefaultListSelectionModel)rsm).moveLeadSelectionIndex(0); |
| } |
| } |
| |
| Rectangle cellRect = table.getCellRect(leadRow, leadColumn, false); |
| if (cellRect != null) { |
| table.scrollRectToVisible(cellRect); |
| } |
| } else if (!inSelection) { |
| moveWithinTableRange(table, dx, dy); |
| table.changeSelection(leadRow, leadColumn, false, extend); |
| } |
| else { |
| if (table.getRowCount() <= 0 || table.getColumnCount() <= 0) { |
| // bail - don't try to move selection on an empty table |
| return; |
| } |
| |
| if (moveWithinSelectedRange(table, dx, dy, rsm, csm)) { |
| // this is the only way we have to set both the lead |
| // and the anchor without changing the selection |
| if (rsm.isSelectedIndex(leadRow)) { |
| rsm.addSelectionInterval(leadRow, leadRow); |
| } else { |
| rsm.removeSelectionInterval(leadRow, leadRow); |
| } |
| |
| if (csm.isSelectedIndex(leadColumn)) { |
| csm.addSelectionInterval(leadColumn, leadColumn); |
| } else { |
| csm.removeSelectionInterval(leadColumn, leadColumn); |
| } |
| |
| Rectangle cellRect = table.getCellRect(leadRow, leadColumn, false); |
| if (cellRect != null) { |
| table.scrollRectToVisible(cellRect); |
| } |
| } |
| else { |
| table.changeSelection(leadRow, leadColumn, |
| false, false); |
| } |
| } |
| |
| /* |
| if (wasEditingWithFocus) { |
| table.editCellAt(leadRow, leadColumn); |
| final Component editorComp = table.getEditorComponent(); |
| if (editorComp != null) { |
| SwingUtilities.invokeLater(new Runnable() { |
| public void run() { |
| editorComp.requestFocus(); |
| } |
| }); |
| } |
| } |
| */ |
| } else if (key == CANCEL_EDITING) { |
| table.removeEditor(); |
| } else if (key == SELECT_ALL) { |
| table.selectAll(); |
| } else if (key == CLEAR_SELECTION) { |
| table.clearSelection(); |
| } else if (key == START_EDITING) { |
| if (!table.hasFocus()) { |
| CellEditor cellEditor = table.getCellEditor(); |
| if (cellEditor != null && !cellEditor.stopCellEditing()) { |
| return; |
| } |
| table.requestFocus(); |
| return; |
| } |
| table.editCellAt(leadRow, leadColumn, e); |
| Component editorComp = table.getEditorComponent(); |
| if (editorComp != null) { |
| editorComp.requestFocus(); |
| } |
| } else if (key == ADD_TO_SELECTION) { |
| if (!table.isCellSelected(leadRow, leadColumn)) { |
| int oldAnchorRow = rsm.getAnchorSelectionIndex(); |
| int oldAnchorColumn = csm.getAnchorSelectionIndex(); |
| rsm.setValueIsAdjusting(true); |
| csm.setValueIsAdjusting(true); |
| table.changeSelection(leadRow, leadColumn, true, false); |
| rsm.setAnchorSelectionIndex(oldAnchorRow); |
| csm.setAnchorSelectionIndex(oldAnchorColumn); |
| rsm.setValueIsAdjusting(false); |
| csm.setValueIsAdjusting(false); |
| } |
| } else if (key == TOGGLE_AND_ANCHOR) { |
| table.changeSelection(leadRow, leadColumn, true, false); |
| } else if (key == EXTEND_TO) { |
| table.changeSelection(leadRow, leadColumn, false, true); |
| } else if (key == MOVE_SELECTION_TO) { |
| table.changeSelection(leadRow, leadColumn, false, false); |
| } else if (key == FOCUS_HEADER) { |
| JTableHeader th = table.getTableHeader(); |
| if (th != null) { |
| //Set the header's selected column to match the table. |
| int col = table.getSelectedColumn(); |
| if (col >= 0) { |
| TableHeaderUI thUI = th.getUI(); |
| if (thUI instanceof BasicTableHeaderUI) { |
| ((BasicTableHeaderUI)thUI).selectColumn(col); |
| } |
| } |
| |
| //Then give the header the focus. |
| th.requestFocusInWindow(); |
| } |
| } |
| } |
| |
| public boolean isEnabled(Object sender) { |
| String key = getName(); |
| |
| if (sender instanceof JTable && |
| Boolean.TRUE.equals(((JTable)sender).getClientProperty("Table.isFileList"))) { |
| if (key == NEXT_COLUMN || |
| key == NEXT_COLUMN_CELL || |
| key == NEXT_COLUMN_EXTEND_SELECTION || |
| key == NEXT_COLUMN_CHANGE_LEAD || |
| key == PREVIOUS_COLUMN || |
| key == PREVIOUS_COLUMN_CELL || |
| key == PREVIOUS_COLUMN_EXTEND_SELECTION || |
| key == PREVIOUS_COLUMN_CHANGE_LEAD || |
| key == SCROLL_LEFT_CHANGE_SELECTION || |
| key == SCROLL_LEFT_EXTEND_SELECTION || |
| key == SCROLL_RIGHT_CHANGE_SELECTION || |
| key == SCROLL_RIGHT_EXTEND_SELECTION || |
| key == FIRST_COLUMN || |
| key == FIRST_COLUMN_EXTEND_SELECTION || |
| key == LAST_COLUMN || |
| key == LAST_COLUMN_EXTEND_SELECTION || |
| key == NEXT_ROW_CELL || |
| key == PREVIOUS_ROW_CELL) { |
| |
| return false; |
| } |
| } |
| |
| if (key == CANCEL_EDITING && sender instanceof JTable) { |
| return ((JTable)sender).isEditing(); |
| } else if (key == NEXT_ROW_CHANGE_LEAD || |
| key == PREVIOUS_ROW_CHANGE_LEAD) { |
| // discontinuous selection actions are only enabled for |
| // DefaultListSelectionModel |
| return sender != null && |
| ((JTable)sender).getSelectionModel() |
| instanceof DefaultListSelectionModel; |
| } else if (key == NEXT_COLUMN_CHANGE_LEAD || |
| key == PREVIOUS_COLUMN_CHANGE_LEAD) { |
| // discontinuous selection actions are only enabled for |
| // DefaultListSelectionModel |
| return sender != null && |
| ((JTable)sender).getColumnModel().getSelectionModel() |
| instanceof DefaultListSelectionModel; |
| } else if (key == ADD_TO_SELECTION && sender instanceof JTable) { |
| // This action is typically bound to SPACE. |
| // If the table is already in an editing mode, SPACE should |
| // simply enter a space character into the table, and not |
| // select a cell. Likewise, if the lead cell is already selected |
| // then hitting SPACE should just enter a space character |
| // into the cell and begin editing. In both of these cases |
| // this action will be disabled. |
| JTable table = (JTable)sender; |
| int leadRow = getAdjustedLead(table, true); |
| int leadCol = getAdjustedLead(table, false); |
| return !(table.isEditing() || table.isCellSelected(leadRow, leadCol)); |
| } else if (key == FOCUS_HEADER && sender instanceof JTable) { |
| JTable table = (JTable)sender; |
| return table.getTableHeader() != null; |
| } |
| |
| return true; |
| } |
| } |
| |
| |
| // |
| // The Table's Key listener |
| // |
| |
| /** |
| * This inner class is marked "public" due to a compiler bug. |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of BasicTableUI. |
| * <p>As of Java 2 platform v1.3 this class is no longer used. |
| * Instead <code>JTable</code> |
| * overrides <code>processKeyBinding</code> to dispatch the event to |
| * the current <code>TableCellEditor</code>. |
| */ |
| public class KeyHandler implements KeyListener { |
| // NOTE: This class exists only for backward compatability. All |
| // its functionality has been moved into Handler. If you need to add |
| // new functionality add it to the Handler, but make sure this |
| // class calls into the Handler. |
| public void keyPressed(KeyEvent e) { |
| getHandler().keyPressed(e); |
| } |
| |
| public void keyReleased(KeyEvent e) { |
| getHandler().keyReleased(e); |
| } |
| |
| public void keyTyped(KeyEvent e) { |
| getHandler().keyTyped(e); |
| } |
| } |
| |
| // |
| // The Table's focus listener |
| // |
| |
| /** |
| * This inner class is marked "public" due to a compiler bug. |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of BasicTableUI. |
| */ |
| public class FocusHandler implements FocusListener { |
| // NOTE: This class exists only for backward compatability. All |
| // its functionality has been moved into Handler. If you need to add |
| // new functionality add it to the Handler, but make sure this |
| // class calls into the Handler. |
| public void focusGained(FocusEvent e) { |
| getHandler().focusGained(e); |
| } |
| |
| public void focusLost(FocusEvent e) { |
| getHandler().focusLost(e); |
| } |
| } |
| |
| // |
| // The Table's mouse and mouse motion listeners |
| // |
| |
| /** |
| * This inner class is marked "public" due to a compiler bug. |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of BasicTableUI. |
| */ |
| public class MouseInputHandler implements MouseInputListener { |
| // NOTE: This class exists only for backward compatability. All |
| // its functionality has been moved into Handler. If you need to add |
| // new functionality add it to the Handler, but make sure this |
| // class calls into the Handler. |
| public void mouseClicked(MouseEvent e) { |
| getHandler().mouseClicked(e); |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| getHandler().mousePressed(e); |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| getHandler().mouseReleased(e); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| getHandler().mouseEntered(e); |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| getHandler().mouseExited(e); |
| } |
| |
| public void mouseMoved(MouseEvent e) { |
| getHandler().mouseMoved(e); |
| } |
| |
| public void mouseDragged(MouseEvent e) { |
| getHandler().mouseDragged(e); |
| } |
| } |
| |
| private class Handler implements FocusListener, MouseInputListener, |
| PropertyChangeListener, ListSelectionListener, ActionListener, |
| BeforeDrag { |
| |
| // FocusListener |
| private void repaintLeadCell( ) { |
| int lr = getAdjustedLead(table, true); |
| int lc = getAdjustedLead(table, false); |
| |
| if (lr < 0 || lc < 0) { |
| return; |
| } |
| |
| Rectangle dirtyRect = table.getCellRect(lr, lc, false); |
| table.repaint(dirtyRect); |
| } |
| |
| public void focusGained(FocusEvent e) { |
| repaintLeadCell(); |
| } |
| |
| public void focusLost(FocusEvent e) { |
| repaintLeadCell(); |
| } |
| |
| |
| // KeyListener |
| public void keyPressed(KeyEvent e) { } |
| |
| public void keyReleased(KeyEvent e) { } |
| |
| public void keyTyped(KeyEvent e) { |
| KeyStroke keyStroke = KeyStroke.getKeyStroke(e.getKeyChar(), |
| e.getModifiers()); |
| |
| // We register all actions using ANCESTOR_OF_FOCUSED_COMPONENT |
| // which means that we might perform the appropriate action |
| // in the table and then forward it to the editor if the editor |
| // had focus. Make sure this doesn't happen by checking our |
| // InputMaps. |
| InputMap map = table.getInputMap(JComponent.WHEN_FOCUSED); |
| if (map != null && map.get(keyStroke) != null) { |
| return; |
| } |
| map = table.getInputMap(JComponent. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); |
| if (map != null && map.get(keyStroke) != null) { |
| return; |
| } |
| |
| keyStroke = KeyStroke.getKeyStrokeForEvent(e); |
| |
| // The AWT seems to generate an unconsumed \r event when |
| // ENTER (\n) is pressed. |
| if (e.getKeyChar() == '\r') { |
| return; |
| } |
| |
| int leadRow = getAdjustedLead(table, true); |
| int leadColumn = getAdjustedLead(table, false); |
| if (leadRow != -1 && leadColumn != -1 && !table.isEditing()) { |
| if (!table.editCellAt(leadRow, leadColumn)) { |
| return; |
| } |
| } |
| |
| // Forwarding events this way seems to put the component |
| // in a state where it believes it has focus. In reality |
| // the table retains focus - though it is difficult for |
| // a user to tell, since the caret is visible and flashing. |
| |
| // Calling table.requestFocus() here, to get the focus back to |
| // the table, seems to have no effect. |
| |
| Component editorComp = table.getEditorComponent(); |
| if (table.isEditing() && editorComp != null) { |
| if (editorComp instanceof JComponent) { |
| JComponent component = (JComponent)editorComp; |
| map = component.getInputMap(JComponent.WHEN_FOCUSED); |
| Object binding = (map != null) ? map.get(keyStroke) : null; |
| if (binding == null) { |
| map = component.getInputMap(JComponent. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); |
| binding = (map != null) ? map.get(keyStroke) : null; |
| } |
| if (binding != null) { |
| ActionMap am = component.getActionMap(); |
| Action action = (am != null) ? am.get(binding) : null; |
| if (action != null && SwingUtilities. |
| notifyAction(action, keyStroke, e, component, |
| e.getModifiers())) { |
| e.consume(); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| // MouseInputListener |
| |
| // Component receiving mouse events during editing. |
| // May not be editorComponent. |
| private Component dispatchComponent; |
| |
| public void mouseClicked(MouseEvent e) {} |
| |
| private void setDispatchComponent(MouseEvent e) { |
| Component editorComponent = table.getEditorComponent(); |
| Point p = e.getPoint(); |
| Point p2 = SwingUtilities.convertPoint(table, p, editorComponent); |
| dispatchComponent = |
| SwingUtilities.getDeepestComponentAt(editorComponent, |
| p2.x, p2.y); |
| SwingUtilities2.setSkipClickCount(dispatchComponent, |
| e.getClickCount() - 1); |
| } |
| |
| private boolean repostEvent(MouseEvent e) { |
| // Check for isEditing() in case another event has |
| // caused the editor to be removed. See bug #4306499. |
| if (dispatchComponent == null || !table.isEditing()) { |
| return false; |
| } |
| MouseEvent e2 = SwingUtilities.convertMouseEvent(table, e, |
| dispatchComponent); |
| dispatchComponent.dispatchEvent(e2); |
| return true; |
| } |
| |
| private void setValueIsAdjusting(boolean flag) { |
| table.getSelectionModel().setValueIsAdjusting(flag); |
| table.getColumnModel().getSelectionModel(). |
| setValueIsAdjusting(flag); |
| } |
| |
| // The row and column where the press occurred and the |
| // press event itself |
| private int pressedRow; |
| private int pressedCol; |
| private MouseEvent pressedEvent; |
| |
| // Whether or not the mouse press (which is being considered as part |
| // of a drag sequence) also caused the selection change to be fully |
| // processed. |
| private boolean dragPressDidSelection; |
| |
| // Set to true when a drag gesture has been fully recognized and DnD |
| // begins. Use this to ignore further mouse events which could be |
| // delivered if DnD is cancelled (via ESCAPE for example) |
| private boolean dragStarted; |
| |
| // Whether or not we should start the editing timer on release |
| private boolean shouldStartTimer; |
| |
| // To cache the return value of pointOutsidePrefSize since we use |
| // it multiple times. |
| private boolean outsidePrefSize; |
| |
| // Used to delay the start of editing. |
| private Timer timer = null; |
| |
| private boolean canStartDrag() { |
| if (pressedRow == -1 || pressedCol == -1) { |
| return false; |
| } |
| |
| if (isFileList) { |
| return !outsidePrefSize; |
| } |
| |
| // if this is a single selection table |
| if ((table.getSelectionModel().getSelectionMode() == |
| ListSelectionModel.SINGLE_SELECTION) && |
| (table.getColumnModel().getSelectionModel().getSelectionMode() == |
| ListSelectionModel.SINGLE_SELECTION)) { |
| |
| return true; |
| } |
| |
| return table.isCellSelected(pressedRow, pressedCol); |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| if (SwingUtilities2.shouldIgnore(e, table)) { |
| return; |
| } |
| |
| if (table.isEditing() && !table.getCellEditor().stopCellEditing()) { |
| Component editorComponent = table.getEditorComponent(); |
| if (editorComponent != null && !editorComponent.hasFocus()) { |
| SwingUtilities2.compositeRequestFocus(editorComponent); |
| } |
| return; |
| } |
| |
| Point p = e.getPoint(); |
| pressedRow = table.rowAtPoint(p); |
| pressedCol = table.columnAtPoint(p); |
| outsidePrefSize = pointOutsidePrefSize(pressedRow, pressedCol, p); |
| |
| if (isFileList) { |
| shouldStartTimer = |
| table.isCellSelected(pressedRow, pressedCol) && |
| !e.isShiftDown() && |
| !BasicGraphicsUtils.isMenuShortcutKeyDown(e) && |
| !outsidePrefSize; |
| } |
| |
| if (table.getDragEnabled()) { |
| mousePressedDND(e); |
| } else { |
| SwingUtilities2.adjustFocus(table); |
| if (!isFileList) { |
| setValueIsAdjusting(true); |
| } |
| adjustSelection(e); |
| } |
| } |
| |
| private void mousePressedDND(MouseEvent e) { |
| pressedEvent = e; |
| boolean grabFocus = true; |
| dragStarted = false; |
| |
| if (canStartDrag() && DragRecognitionSupport.mousePressed(e)) { |
| |
| dragPressDidSelection = false; |
| |
| if (BasicGraphicsUtils.isMenuShortcutKeyDown(e) && isFileList) { |
| // do nothing for control - will be handled on release |
| // or when drag starts |
| return; |
| } else if (!e.isShiftDown() && table.isCellSelected(pressedRow, pressedCol)) { |
| // clicking on something that's already selected |
| // and need to make it the lead now |
| table.getSelectionModel().addSelectionInterval(pressedRow, |
| pressedRow); |
| table.getColumnModel().getSelectionModel(). |
| addSelectionInterval(pressedCol, pressedCol); |
| |
| return; |
| } |
| |
| dragPressDidSelection = true; |
| |
| // could be a drag initiating event - don't grab focus |
| grabFocus = false; |
| } else if (!isFileList) { |
| // When drag can't happen, mouse drags might change the selection in the table |
| // so we want the isAdjusting flag to be set |
| setValueIsAdjusting(true); |
| } |
| |
| if (grabFocus) { |
| SwingUtilities2.adjustFocus(table); |
| } |
| |
| adjustSelection(e); |
| } |
| |
| private void adjustSelection(MouseEvent e) { |
| // Fix for 4835633 |
| if (outsidePrefSize) { |
| // If shift is down in multi-select, we should just return. |
| // For single select or non-shift-click, clear the selection |
| if (e.getID() == MouseEvent.MOUSE_PRESSED && |
| (!e.isShiftDown() || |
| table.getSelectionModel().getSelectionMode() == |
| ListSelectionModel.SINGLE_SELECTION)) { |
| table.clearSelection(); |
| TableCellEditor tce = table.getCellEditor(); |
| if (tce != null) { |
| tce.stopCellEditing(); |
| } |
| } |
| return; |
| } |
| // The autoscroller can generate drag events outside the |
| // table's range. |
| if ((pressedCol == -1) || (pressedRow == -1)) { |
| return; |
| } |
| |
| boolean dragEnabled = table.getDragEnabled(); |
| |
| if (!dragEnabled && !isFileList && table.editCellAt(pressedRow, pressedCol, e)) { |
| setDispatchComponent(e); |
| repostEvent(e); |
| } |
| |
| CellEditor editor = table.getCellEditor(); |
| if (dragEnabled || editor == null || editor.shouldSelectCell(e)) { |
| table.changeSelection(pressedRow, pressedCol, |
| BasicGraphicsUtils.isMenuShortcutKeyDown(e), |
| e.isShiftDown()); |
| } |
| } |
| |
| public void valueChanged(ListSelectionEvent e) { |
| if (timer != null) { |
| timer.stop(); |
| timer = null; |
| } |
| } |
| |
| public void actionPerformed(ActionEvent ae) { |
| table.editCellAt(pressedRow, pressedCol, null); |
| Component editorComponent = table.getEditorComponent(); |
| if (editorComponent != null && !editorComponent.hasFocus()) { |
| SwingUtilities2.compositeRequestFocus(editorComponent); |
| } |
| return; |
| } |
| |
| private void maybeStartTimer() { |
| if (!shouldStartTimer) { |
| return; |
| } |
| |
| if (timer == null) { |
| timer = new Timer(1200, this); |
| timer.setRepeats(false); |
| } |
| |
| timer.start(); |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| if (SwingUtilities2.shouldIgnore(e, table)) { |
| return; |
| } |
| |
| if (table.getDragEnabled()) { |
| mouseReleasedDND(e); |
| } else { |
| if (isFileList) { |
| maybeStartTimer(); |
| } |
| } |
| |
| pressedEvent = null; |
| repostEvent(e); |
| dispatchComponent = null; |
| setValueIsAdjusting(false); |
| } |
| |
| private void mouseReleasedDND(MouseEvent e) { |
| MouseEvent me = DragRecognitionSupport.mouseReleased(e); |
| if (me != null) { |
| SwingUtilities2.adjustFocus(table); |
| if (!dragPressDidSelection) { |
| adjustSelection(me); |
| } |
| } |
| |
| if (!dragStarted) { |
| if (isFileList) { |
| maybeStartTimer(); |
| return; |
| } |
| |
| Point p = e.getPoint(); |
| |
| if (pressedEvent != null && |
| table.rowAtPoint(p) == pressedRow && |
| table.columnAtPoint(p) == pressedCol && |
| table.editCellAt(pressedRow, pressedCol, pressedEvent)) { |
| |
| setDispatchComponent(pressedEvent); |
| repostEvent(pressedEvent); |
| |
| // This may appear completely odd, but must be done for backward |
| // compatibility reasons. Developers have been known to rely on |
| // a call to shouldSelectCell after editing has begun. |
| CellEditor ce = table.getCellEditor(); |
| if (ce != null) { |
| ce.shouldSelectCell(pressedEvent); |
| } |
| } |
| } |
| } |
| |
| public void mouseEntered(MouseEvent e) {} |
| |
| public void mouseExited(MouseEvent e) {} |
| |
| public void mouseMoved(MouseEvent e) {} |
| |
| public void dragStarting(MouseEvent me) { |
| dragStarted = true; |
| |
| if (BasicGraphicsUtils.isMenuShortcutKeyDown(me) && isFileList) { |
| table.getSelectionModel().addSelectionInterval(pressedRow, |
| pressedRow); |
| table.getColumnModel().getSelectionModel(). |
| addSelectionInterval(pressedCol, pressedCol); |
| } |
| |
| pressedEvent = null; |
| } |
| |
| public void mouseDragged(MouseEvent e) { |
| if (SwingUtilities2.shouldIgnore(e, table)) { |
| return; |
| } |
| |
| if (table.getDragEnabled() && |
| (DragRecognitionSupport.mouseDragged(e, this) || dragStarted)) { |
| |
| return; |
| } |
| |
| repostEvent(e); |
| |
| // Check isFileList: |
| // Until we support drag-selection, dragging should not change |
| // the selection (act like single-select). |
| if (isFileList || table.isEditing()) { |
| return; |
| } |
| |
| Point p = e.getPoint(); |
| int row = table.rowAtPoint(p); |
| int column = table.columnAtPoint(p); |
| // The autoscroller can generate drag events outside the |
| // table's range. |
| if ((column == -1) || (row == -1)) { |
| return; |
| } |
| |
| table.changeSelection(row, column, |
| BasicGraphicsUtils.isMenuShortcutKeyDown(e), true); |
| } |
| |
| |
| // PropertyChangeListener |
| public void propertyChange(PropertyChangeEvent event) { |
| String changeName = event.getPropertyName(); |
| |
| if ("componentOrientation" == changeName) { |
| InputMap inputMap = getInputMap( |
| JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); |
| |
| SwingUtilities.replaceUIInputMap(table, |
| JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, |
| inputMap); |
| |
| JTableHeader header = table.getTableHeader(); |
| if (header != null) { |
| header.setComponentOrientation( |
| (ComponentOrientation)event.getNewValue()); |
| } |
| } else if ("dropLocation" == changeName) { |
| JTable.DropLocation oldValue = (JTable.DropLocation)event.getOldValue(); |
| repaintDropLocation(oldValue); |
| repaintDropLocation(table.getDropLocation()); |
| } else if ("Table.isFileList" == changeName) { |
| isFileList = Boolean.TRUE.equals(table.getClientProperty("Table.isFileList")); |
| table.revalidate(); |
| table.repaint(); |
| if (isFileList) { |
| table.getSelectionModel().addListSelectionListener(getHandler()); |
| } else { |
| table.getSelectionModel().removeListSelectionListener(getHandler()); |
| timer = null; |
| } |
| } else if ("selectionModel" == changeName) { |
| if (isFileList) { |
| ListSelectionModel old = (ListSelectionModel)event.getOldValue(); |
| old.removeListSelectionListener(getHandler()); |
| table.getSelectionModel().addListSelectionListener(getHandler()); |
| } |
| } |
| } |
| |
| private void repaintDropLocation(JTable.DropLocation loc) { |
| if (loc == null) { |
| return; |
| } |
| |
| if (!loc.isInsertRow() && !loc.isInsertColumn()) { |
| Rectangle rect = table.getCellRect(loc.getRow(), loc.getColumn(), false); |
| if (rect != null) { |
| table.repaint(rect); |
| } |
| return; |
| } |
| |
| if (loc.isInsertRow()) { |
| Rectangle rect = extendRect(getHDropLineRect(loc), true); |
| if (rect != null) { |
| table.repaint(rect); |
| } |
| } |
| |
| if (loc.isInsertColumn()) { |
| Rectangle rect = extendRect(getVDropLineRect(loc), false); |
| if (rect != null) { |
| table.repaint(rect); |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| * Returns true if the given point is outside the preferredSize of the |
| * item at the given row of the table. (Column must be 0). |
| * Returns false if the "Table.isFileList" client property is not set. |
| */ |
| private boolean pointOutsidePrefSize(int row, int column, Point p) { |
| if (!isFileList) { |
| return false; |
| } |
| |
| return SwingUtilities2.pointOutsidePrefSize(table, row, column, p); |
| } |
| |
| // |
| // Factory methods for the Listeners |
| // |
| |
| private Handler getHandler() { |
| if (handler == null) { |
| handler = new Handler(); |
| } |
| return handler; |
| } |
| |
| /** |
| * Creates the key listener for handling keyboard navigation in the JTable. |
| */ |
| protected KeyListener createKeyListener() { |
| return null; |
| } |
| |
| /** |
| * Creates the focus listener for handling keyboard navigation in the JTable. |
| */ |
| protected FocusListener createFocusListener() { |
| return getHandler(); |
| } |
| |
| /** |
| * Creates the mouse listener for the JTable. |
| */ |
| protected MouseInputListener createMouseInputListener() { |
| return getHandler(); |
| } |
| |
| // |
| // The installation/uninstall procedures and support |
| // |
| |
| public static ComponentUI createUI(JComponent c) { |
| return new BasicTableUI(); |
| } |
| |
| // Installation |
| |
| public void installUI(JComponent c) { |
| table = (JTable)c; |
| |
| rendererPane = new CellRendererPane(); |
| table.add(rendererPane); |
| installDefaults(); |
| installDefaults2(); |
| installListeners(); |
| installKeyboardActions(); |
| } |
| |
| /** |
| * Initialize JTable properties, e.g. font, foreground, and background. |
| * The font, foreground, and background properties are only set if their |
| * current value is either null or a UIResource, other properties are set |
| * if the current value is null. |
| * |
| * @see #installUI |
| */ |
| protected void installDefaults() { |
| LookAndFeel.installColorsAndFont(table, "Table.background", |
| "Table.foreground", "Table.font"); |
| // JTable's original row height is 16. To correctly display the |
| // contents on Linux we should have set it to 18, Windows 19 and |
| // Solaris 20. As these values vary so much it's too hard to |
| // be backward compatable and try to update the row height, we're |
| // therefor NOT going to adjust the row height based on font. If the |
| // developer changes the font, it's there responsability to update |
| // the row height. |
| |
| LookAndFeel.installProperty(table, "opaque", Boolean.TRUE); |
| |
| Color sbg = table.getSelectionBackground(); |
| if (sbg == null || sbg instanceof UIResource) { |
| sbg = UIManager.getColor("Table.selectionBackground"); |
| table.setSelectionBackground(sbg != null ? sbg : UIManager.getColor("textHighlight")); |
| } |
| |
| Color sfg = table.getSelectionForeground(); |
| if (sfg == null || sfg instanceof UIResource) { |
| sfg = UIManager.getColor("Table.selectionForeground"); |
| table.setSelectionForeground(sfg != null ? sfg : UIManager.getColor("textHighlightText")); |
| } |
| |
| Color gridColor = table.getGridColor(); |
| if (gridColor == null || gridColor instanceof UIResource) { |
| gridColor = UIManager.getColor("Table.gridColor"); |
| table.setGridColor(gridColor != null ? gridColor : Color.GRAY); |
| } |
| |
| // install the scrollpane border |
| Container parent = table.getParent(); // should be viewport |
| if (parent != null) { |
| parent = parent.getParent(); // should be the scrollpane |
| if (parent != null && parent instanceof JScrollPane) { |
| LookAndFeel.installBorder((JScrollPane)parent, "Table.scrollPaneBorder"); |
| } |
| } |
| |
| isFileList = Boolean.TRUE.equals(table.getClientProperty("Table.isFileList")); |
| } |
| |
| private void installDefaults2() { |
| TransferHandler th = table.getTransferHandler(); |
| if (th == null || th instanceof UIResource) { |
| table.setTransferHandler(defaultTransferHandler); |
| // default TransferHandler doesn't support drop |
| // so we don't want drop handling |
| if (table.getDropTarget() instanceof UIResource) { |
| table.setDropTarget(null); |
| } |
| } |
| } |
| |
| /** |
| * Attaches listeners to the JTable. |
| */ |
| protected void installListeners() { |
| focusListener = createFocusListener(); |
| keyListener = createKeyListener(); |
| mouseInputListener = createMouseInputListener(); |
| |
| table.addFocusListener(focusListener); |
| table.addKeyListener(keyListener); |
| table.addMouseListener(mouseInputListener); |
| table.addMouseMotionListener(mouseInputListener); |
| table.addPropertyChangeListener(getHandler()); |
| if (isFileList) { |
| table.getSelectionModel().addListSelectionListener(getHandler()); |
| } |
| } |
| |
| /** |
| * Register all keyboard actions on the JTable. |
| */ |
| protected void installKeyboardActions() { |
| LazyActionMap.installLazyActionMap(table, BasicTableUI.class, |
| "Table.actionMap"); |
| |
| InputMap inputMap = getInputMap(JComponent. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); |
| SwingUtilities.replaceUIInputMap(table, |
| JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, |
| inputMap); |
| } |
| |
| InputMap getInputMap(int condition) { |
| if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) { |
| InputMap keyMap = |
| (InputMap)DefaultLookup.get(table, this, |
| "Table.ancestorInputMap"); |
| InputMap rtlKeyMap; |
| |
| if (table.getComponentOrientation().isLeftToRight() || |
| ((rtlKeyMap = (InputMap)DefaultLookup.get(table, this, |
| "Table.ancestorInputMap.RightToLeft")) == null)) { |
| return keyMap; |
| } else { |
| rtlKeyMap.setParent(keyMap); |
| return rtlKeyMap; |
| } |
| } |
| return null; |
| } |
| |
| static void loadActionMap(LazyActionMap map) { |
| // IMPORTANT: There is a very close coupling between the parameters |
| // passed to the Actions constructor. Only certain parameter |
| // combinations are supported. For example, the following Action would |
| // not work as expected: |
| // new Actions(Actions.NEXT_ROW_CELL, 1, 4, false, true) |
| // Actions which move within the selection only (having a true |
| // inSelection parameter) require that one of dx or dy be |
| // zero and the other be -1 or 1. The point of this warning is |
| // that you should be very careful about making sure a particular |
| // combination of parameters is supported before changing or |
| // adding anything here. |
| |
| map.put(new Actions(Actions.NEXT_COLUMN, 1, 0, |
| false, false)); |
| map.put(new Actions(Actions.NEXT_COLUMN_CHANGE_LEAD, 1, 0, |
| false, false)); |
| map.put(new Actions(Actions.PREVIOUS_COLUMN, -1, 0, |
| false, false)); |
| map.put(new Actions(Actions.PREVIOUS_COLUMN_CHANGE_LEAD, -1, 0, |
| false, false)); |
| map.put(new Actions(Actions.NEXT_ROW, 0, 1, |
| false, false)); |
| map.put(new Actions(Actions.NEXT_ROW_CHANGE_LEAD, 0, 1, |
| false, false)); |
| map.put(new Actions(Actions.PREVIOUS_ROW, 0, -1, |
| false, false)); |
| map.put(new Actions(Actions.PREVIOUS_ROW_CHANGE_LEAD, 0, -1, |
| false, false)); |
| map.put(new Actions(Actions.NEXT_COLUMN_EXTEND_SELECTION, |
| 1, 0, true, false)); |
| map.put(new Actions(Actions.PREVIOUS_COLUMN_EXTEND_SELECTION, |
| -1, 0, true, false)); |
| map.put(new Actions(Actions.NEXT_ROW_EXTEND_SELECTION, |
| 0, 1, true, false)); |
| map.put(new Actions(Actions.PREVIOUS_ROW_EXTEND_SELECTION, |
| 0, -1, true, false)); |
| map.put(new Actions(Actions.SCROLL_UP_CHANGE_SELECTION, |
| false, false, true, false)); |
| map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_SELECTION, |
| false, true, true, false)); |
| map.put(new Actions(Actions.FIRST_COLUMN, |
| false, false, false, true)); |
| map.put(new Actions(Actions.LAST_COLUMN, |
| false, true, false, true)); |
| |
| map.put(new Actions(Actions.SCROLL_UP_EXTEND_SELECTION, |
| true, false, true, false)); |
| map.put(new Actions(Actions.SCROLL_DOWN_EXTEND_SELECTION, |
| true, true, true, false)); |
| map.put(new Actions(Actions.FIRST_COLUMN_EXTEND_SELECTION, |
| true, false, false, true)); |
| map.put(new Actions(Actions.LAST_COLUMN_EXTEND_SELECTION, |
| true, true, false, true)); |
| |
| map.put(new Actions(Actions.FIRST_ROW, false, false, true, true)); |
| map.put(new Actions(Actions.LAST_ROW, false, true, true, true)); |
| |
| map.put(new Actions(Actions.FIRST_ROW_EXTEND_SELECTION, |
| true, false, true, true)); |
| map.put(new Actions(Actions.LAST_ROW_EXTEND_SELECTION, |
| true, true, true, true)); |
| |
| map.put(new Actions(Actions.NEXT_COLUMN_CELL, |
| 1, 0, false, true)); |
| map.put(new Actions(Actions.PREVIOUS_COLUMN_CELL, |
| -1, 0, false, true)); |
| map.put(new Actions(Actions.NEXT_ROW_CELL, 0, 1, false, true)); |
| map.put(new Actions(Actions.PREVIOUS_ROW_CELL, |
| 0, -1, false, true)); |
| |
| map.put(new Actions(Actions.SELECT_ALL)); |
| map.put(new Actions(Actions.CLEAR_SELECTION)); |
| map.put(new Actions(Actions.CANCEL_EDITING)); |
| map.put(new Actions(Actions.START_EDITING)); |
| |
| map.put(TransferHandler.getCutAction().getValue(Action.NAME), |
| TransferHandler.getCutAction()); |
| map.put(TransferHandler.getCopyAction().getValue(Action.NAME), |
| TransferHandler.getCopyAction()); |
| map.put(TransferHandler.getPasteAction().getValue(Action.NAME), |
| TransferHandler.getPasteAction()); |
| |
| map.put(new Actions(Actions.SCROLL_LEFT_CHANGE_SELECTION, |
| false, false, false, false)); |
| map.put(new Actions(Actions.SCROLL_RIGHT_CHANGE_SELECTION, |
| false, true, false, false)); |
| map.put(new Actions(Actions.SCROLL_LEFT_EXTEND_SELECTION, |
| true, false, false, false)); |
| map.put(new Actions(Actions.SCROLL_RIGHT_EXTEND_SELECTION, |
| true, true, false, false)); |
| |
| map.put(new Actions(Actions.ADD_TO_SELECTION)); |
| map.put(new Actions(Actions.TOGGLE_AND_ANCHOR)); |
| map.put(new Actions(Actions.EXTEND_TO)); |
| map.put(new Actions(Actions.MOVE_SELECTION_TO)); |
| map.put(new Actions(Actions.FOCUS_HEADER)); |
| } |
| |
| // Uninstallation |
| |
| public void uninstallUI(JComponent c) { |
| uninstallDefaults(); |
| uninstallListeners(); |
| uninstallKeyboardActions(); |
| |
| table.remove(rendererPane); |
| rendererPane = null; |
| table = null; |
| } |
| |
| protected void uninstallDefaults() { |
| if (table.getTransferHandler() instanceof UIResource) { |
| table.setTransferHandler(null); |
| } |
| } |
| |
| protected void uninstallListeners() { |
| table.removeFocusListener(focusListener); |
| table.removeKeyListener(keyListener); |
| table.removeMouseListener(mouseInputListener); |
| table.removeMouseMotionListener(mouseInputListener); |
| table.removePropertyChangeListener(getHandler()); |
| if (isFileList) { |
| table.getSelectionModel().removeListSelectionListener(getHandler()); |
| } |
| |
| focusListener = null; |
| keyListener = null; |
| mouseInputListener = null; |
| handler = null; |
| } |
| |
| protected void uninstallKeyboardActions() { |
| SwingUtilities.replaceUIInputMap(table, JComponent. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null); |
| SwingUtilities.replaceUIActionMap(table, null); |
| } |
| |
| /** |
| * Returns the baseline. |
| * |
| * @throws NullPointerException {@inheritDoc} |
| * @throws IllegalArgumentException {@inheritDoc} |
| * @see javax.swing.JComponent#getBaseline(int, int) |
| * @since 1.6 |
| */ |
| public int getBaseline(JComponent c, int width, int height) { |
| super.getBaseline(c, width, height); |
| UIDefaults lafDefaults = UIManager.getLookAndFeelDefaults(); |
| Component renderer = (Component)lafDefaults.get( |
| BASELINE_COMPONENT_KEY); |
| if (renderer == null) { |
| DefaultTableCellRenderer tcr = new DefaultTableCellRenderer(); |
| renderer = tcr.getTableCellRendererComponent( |
| table, "a", false, false, -1, -1); |
| lafDefaults.put(BASELINE_COMPONENT_KEY, renderer); |
| } |
| renderer.setFont(table.getFont()); |
| int rowMargin = table.getRowMargin(); |
| return renderer.getBaseline(Integer.MAX_VALUE, table.getRowHeight() - |
| rowMargin) + rowMargin / 2; |
| } |
| |
| /** |
| * Returns an enum indicating how the baseline of the component |
| * changes as the size changes. |
| * |
| * @throws NullPointerException {@inheritDoc} |
| * @see javax.swing.JComponent#getBaseline(int, int) |
| * @since 1.6 |
| */ |
| public Component.BaselineResizeBehavior getBaselineResizeBehavior( |
| JComponent c) { |
| super.getBaselineResizeBehavior(c); |
| return Component.BaselineResizeBehavior.CONSTANT_ASCENT; |
| } |
| |
| // |
| // Size Methods |
| // |
| |
| private Dimension createTableSize(long width) { |
| int height = 0; |
| int rowCount = table.getRowCount(); |
| if (rowCount > 0 && table.getColumnCount() > 0) { |
| Rectangle r = table.getCellRect(rowCount-1, 0, true); |
| height = r.y + r.height; |
| } |
| // Width is always positive. The call to abs() is a workaround for |
| // a bug in the 1.1.6 JIT on Windows. |
| long tmp = Math.abs(width); |
| if (tmp > Integer.MAX_VALUE) { |
| tmp = Integer.MAX_VALUE; |
| } |
| return new Dimension((int)tmp, height); |
| } |
| |
| /** |
| * Return the minimum size of the table. The minimum height is the |
| * row height times the number of rows. |
| * The minimum width is the sum of the minimum widths of each column. |
| */ |
| public Dimension getMinimumSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = table.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getMinWidth(); |
| } |
| return createTableSize(width); |
| } |
| |
| /** |
| * Return the preferred size of the table. The preferred height is the |
| * row height times the number of rows. |
| * The preferred width is the sum of the preferred widths of each column. |
| */ |
| public Dimension getPreferredSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = table.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getPreferredWidth(); |
| } |
| return createTableSize(width); |
| } |
| |
| /** |
| * Return the maximum size of the table. The maximum height is the |
| * row heighttimes the number of rows. |
| * The maximum width is the sum of the maximum widths of each column. |
| */ |
| public Dimension getMaximumSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = table.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getMaxWidth(); |
| } |
| return createTableSize(width); |
| } |
| |
| // |
| // Paint methods and support |
| // |
| |
| /** Paint a representation of the <code>table</code> instance |
| * that was set in installUI(). |
| */ |
| public void paint(Graphics g, JComponent c) { |
| Rectangle clip = g.getClipBounds(); |
| |
| Rectangle bounds = table.getBounds(); |
| // account for the fact that the graphics has already been translated |
| // into the table's bounds |
| bounds.x = bounds.y = 0; |
| |
| if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 || |
| // this check prevents us from painting the entire table |
| // when the clip doesn't intersect our bounds at all |
| !bounds.intersects(clip)) { |
| |
| paintDropLines(g); |
| return; |
| } |
| |
| boolean ltr = table.getComponentOrientation().isLeftToRight(); |
| |
| Point upperLeft = clip.getLocation(); |
| Point lowerRight = new Point(clip.x + clip.width - 1, |
| clip.y + clip.height - 1); |
| |
| int rMin = table.rowAtPoint(upperLeft); |
| int rMax = table.rowAtPoint(lowerRight); |
| // This should never happen (as long as our bounds intersect the clip, |
| // which is why we bail above if that is the case). |
| if (rMin == -1) { |
| rMin = 0; |
| } |
| // If the table does not have enough rows to fill the view we'll get -1. |
| // (We could also get -1 if our bounds don't intersect the clip, |
| // which is why we bail above if that is the case). |
| // Replace this with the index of the last row. |
| if (rMax == -1) { |
| rMax = table.getRowCount()-1; |
| } |
| |
| int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight); |
| int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft); |
| // This should never happen. |
| if (cMin == -1) { |
| cMin = 0; |
| } |
| // If the table does not have enough columns to fill the view we'll get -1. |
| // Replace this with the index of the last column. |
| if (cMax == -1) { |
| cMax = table.getColumnCount()-1; |
| } |
| |
| // Paint the grid. |
| paintGrid(g, rMin, rMax, cMin, cMax); |
| |
| // Paint the cells. |
| paintCells(g, rMin, rMax, cMin, cMax); |
| |
| paintDropLines(g); |
| } |
| |
| private void paintDropLines(Graphics g) { |
| JTable.DropLocation loc = table.getDropLocation(); |
| if (loc == null) { |
| return; |
| } |
| |
| Color color = UIManager.getColor("Table.dropLineColor"); |
| Color shortColor = UIManager.getColor("Table.dropLineShortColor"); |
| if (color == null && shortColor == null) { |
| return; |
| } |
| |
| Rectangle rect; |
| |
| rect = getHDropLineRect(loc); |
| if (rect != null) { |
| int x = rect.x; |
| int w = rect.width; |
| if (color != null) { |
| extendRect(rect, true); |
| g.setColor(color); |
| g.fillRect(rect.x, rect.y, rect.width, rect.height); |
| } |
| if (!loc.isInsertColumn() && shortColor != null) { |
| g.setColor(shortColor); |
| g.fillRect(x, rect.y, w, rect.height); |
| } |
| } |
| |
| rect = getVDropLineRect(loc); |
| if (rect != null) { |
| int y = rect.y; |
| int h = rect.height; |
| if (color != null) { |
| extendRect(rect, false); |
| g.setColor(color); |
| g.fillRect(rect.x, rect.y, rect.width, rect.height); |
| } |
| if (!loc.isInsertRow() && shortColor != null) { |
| g.setColor(shortColor); |
| g.fillRect(rect.x, y, rect.width, h); |
| } |
| } |
| } |
| |
| private Rectangle getHDropLineRect(JTable.DropLocation loc) { |
| if (!loc.isInsertRow()) { |
| return null; |
| } |
| |
| int row = loc.getRow(); |
| int col = loc.getColumn(); |
| if (col >= table.getColumnCount()) { |
| col--; |
| } |
| |
| Rectangle rect = table.getCellRect(row, col, true); |
| |
| if (row >= table.getRowCount()) { |
| row--; |
| Rectangle prevRect = table.getCellRect(row, col, true); |
| rect.y = prevRect.y + prevRect.height; |
| } |
| |
| if (rect.y == 0) { |
| rect.y = -1; |
| } else { |
| rect.y -= 2; |
| } |
| |
| rect.height = 3; |
| |
| return rect; |
| } |
| |
| private Rectangle getVDropLineRect(JTable.DropLocation loc) { |
| if (!loc.isInsertColumn()) { |
| return null; |
| } |
| |
| boolean ltr = table.getComponentOrientation().isLeftToRight(); |
| int col = loc.getColumn(); |
| Rectangle rect = table.getCellRect(loc.getRow(), col, true); |
| |
| if (col >= table.getColumnCount()) { |
| col--; |
| rect = table.getCellRect(loc.getRow(), col, true); |
| if (ltr) { |
| rect.x = rect.x + rect.width; |
| } |
| } else if (!ltr) { |
| rect.x = rect.x + rect.width; |
| } |
| |
| if (rect.x == 0) { |
| rect.x = -1; |
| } else { |
| rect.x -= 2; |
| } |
| |
| rect.width = 3; |
| |
| return rect; |
| } |
| |
| private Rectangle extendRect(Rectangle rect, boolean horizontal) { |
| if (rect == null) { |
| return rect; |
| } |
| |
| if (horizontal) { |
| rect.x = 0; |
| rect.width = table.getWidth(); |
| } else { |
| rect.y = 0; |
| |
| if (table.getRowCount() != 0) { |
| Rectangle lastRect = table.getCellRect(table.getRowCount() - 1, 0, true); |
| rect.height = lastRect.y + lastRect.height; |
| } else { |
| rect.height = table.getHeight(); |
| } |
| } |
| |
| return rect; |
| } |
| |
| /* |
| * Paints the grid lines within <I>aRect</I>, using the grid |
| * color set with <I>setGridColor</I>. Paints vertical lines |
| * if <code>getShowVerticalLines()</code> returns true and paints |
| * horizontal lines if <code>getShowHorizontalLines()</code> |
| * returns true. |
| */ |
| private void paintGrid(Graphics g, int rMin, int rMax, int cMin, int cMax) { |
| g.setColor(table.getGridColor()); |
| |
| Rectangle minCell = table.getCellRect(rMin, cMin, true); |
| Rectangle maxCell = table.getCellRect(rMax, cMax, true); |
| Rectangle damagedArea = minCell.union( maxCell ); |
| |
| if (table.getShowHorizontalLines()) { |
| int tableWidth = damagedArea.x + damagedArea.width; |
| int y = damagedArea.y; |
| for (int row = rMin; row <= rMax; row++) { |
| y += table.getRowHeight(row); |
| g.drawLine(damagedArea.x, y - 1, tableWidth - 1, y - 1); |
| } |
| } |
| if (table.getShowVerticalLines()) { |
| TableColumnModel cm = table.getColumnModel(); |
| int tableHeight = damagedArea.y + damagedArea.height; |
| int x; |
| if (table.getComponentOrientation().isLeftToRight()) { |
| x = damagedArea.x; |
| for (int column = cMin; column <= cMax; column++) { |
| int w = cm.getColumn(column).getWidth(); |
| x += w; |
| g.drawLine(x - 1, 0, x - 1, tableHeight - 1); |
| } |
| } else { |
| x = damagedArea.x; |
| for (int column = cMax; column >= cMin; column--) { |
| int w = cm.getColumn(column).getWidth(); |
| x += w; |
| g.drawLine(x - 1, 0, x - 1, tableHeight - 1); |
| } |
| } |
| } |
| } |
| |
| private int viewIndexForColumn(TableColumn aColumn) { |
| TableColumnModel cm = table.getColumnModel(); |
| for (int column = 0; column < cm.getColumnCount(); column++) { |
| if (cm.getColumn(column) == aColumn) { |
| return column; |
| } |
| } |
| return -1; |
| } |
| |
| private void paintCells(Graphics g, int rMin, int rMax, int cMin, int cMax) { |
| JTableHeader header = table.getTableHeader(); |
| TableColumn draggedColumn = (header == null) ? null : header.getDraggedColumn(); |
| |
| TableColumnModel cm = table.getColumnModel(); |
| int columnMargin = cm.getColumnMargin(); |
| |
| Rectangle cellRect; |
| TableColumn aColumn; |
| int columnWidth; |
| if (table.getComponentOrientation().isLeftToRight()) { |
| for(int row = rMin; row <= rMax; row++) { |
| cellRect = table.getCellRect(row, cMin, false); |
| for(int column = cMin; column <= cMax; column++) { |
| aColumn = cm.getColumn(column); |
| columnWidth = aColumn.getWidth(); |
| cellRect.width = columnWidth - columnMargin; |
| if (aColumn != draggedColumn) { |
| paintCell(g, cellRect, row, column); |
| } |
| cellRect.x += columnWidth; |
| } |
| } |
| } else { |
| for(int row = rMin; row <= rMax; row++) { |
| cellRect = table.getCellRect(row, cMin, false); |
| aColumn = cm.getColumn(cMin); |
| if (aColumn != draggedColumn) { |
| columnWidth = aColumn.getWidth(); |
| cellRect.width = columnWidth - columnMargin; |
| paintCell(g, cellRect, row, cMin); |
| } |
| for(int column = cMin+1; column <= cMax; column++) { |
| aColumn = cm.getColumn(column); |
| columnWidth = aColumn.getWidth(); |
| cellRect.width = columnWidth - columnMargin; |
| cellRect.x -= columnWidth; |
| if (aColumn != draggedColumn) { |
| paintCell(g, cellRect, row, column); |
| } |
| } |
| } |
| } |
| |
| // Paint the dragged column if we are dragging. |
| if (draggedColumn != null) { |
| paintDraggedArea(g, rMin, rMax, draggedColumn, header.getDraggedDistance()); |
| } |
| |
| // Remove any renderers that may be left in the rendererPane. |
| rendererPane.removeAll(); |
| } |
| |
| private void paintDraggedArea(Graphics g, int rMin, int rMax, TableColumn draggedColumn, int distance) { |
| int draggedColumnIndex = viewIndexForColumn(draggedColumn); |
| |
| Rectangle minCell = table.getCellRect(rMin, draggedColumnIndex, true); |
| Rectangle maxCell = table.getCellRect(rMax, draggedColumnIndex, true); |
| |
| Rectangle vacatedColumnRect = minCell.union(maxCell); |
| |
| // Paint a gray well in place of the moving column. |
| g.setColor(table.getParent().getBackground()); |
| g.fillRect(vacatedColumnRect.x, vacatedColumnRect.y, |
| vacatedColumnRect.width, vacatedColumnRect.height); |
| |
| // Move to the where the cell has been dragged. |
| vacatedColumnRect.x += distance; |
| |
| // Fill the background. |
| g.setColor(table.getBackground()); |
| g.fillRect(vacatedColumnRect.x, vacatedColumnRect.y, |
| vacatedColumnRect.width, vacatedColumnRect.height); |
| |
| // Paint the vertical grid lines if necessary. |
| if (table.getShowVerticalLines()) { |
| g.setColor(table.getGridColor()); |
| int x1 = vacatedColumnRect.x; |
| int y1 = vacatedColumnRect.y; |
| int x2 = x1 + vacatedColumnRect.width - 1; |
| int y2 = y1 + vacatedColumnRect.height - 1; |
| // Left |
| g.drawLine(x1-1, y1, x1-1, y2); |
| // Right |
| g.drawLine(x2, y1, x2, y2); |
| } |
| |
| for(int row = rMin; row <= rMax; row++) { |
| // Render the cell value |
| Rectangle r = table.getCellRect(row, draggedColumnIndex, false); |
| r.x += distance; |
| paintCell(g, r, row, draggedColumnIndex); |
| |
| // Paint the (lower) horizontal grid line if necessary. |
| if (table.getShowHorizontalLines()) { |
| g.setColor(table.getGridColor()); |
| Rectangle rcr = table.getCellRect(row, draggedColumnIndex, true); |
| rcr.x += distance; |
| int x1 = rcr.x; |
| int y1 = rcr.y; |
| int x2 = x1 + rcr.width - 1; |
| int y2 = y1 + rcr.height - 1; |
| g.drawLine(x1, y2, x2, y2); |
| } |
| } |
| } |
| |
| private void paintCell(Graphics g, Rectangle cellRect, int row, int column) { |
| if (table.isEditing() && table.getEditingRow()==row && |
| table.getEditingColumn()==column) { |
| Component component = table.getEditorComponent(); |
| component.setBounds(cellRect); |
| component.validate(); |
| } |
| else { |
| TableCellRenderer renderer = table.getCellRenderer(row, column); |
| Component component = table.prepareRenderer(renderer, row, column); |
| rendererPane.paintComponent(g, component, table, cellRect.x, cellRect.y, |
| cellRect.width, cellRect.height, true); |
| } |
| } |
| |
| private static int getAdjustedLead(JTable table, |
| boolean row, |
| ListSelectionModel model) { |
| |
| int index = model.getLeadSelectionIndex(); |
| int compare = row ? table.getRowCount() : table.getColumnCount(); |
| return index < compare ? index : -1; |
| } |
| |
| private static int getAdjustedLead(JTable table, boolean row) { |
| return row ? getAdjustedLead(table, row, table.getSelectionModel()) |
| : getAdjustedLead(table, row, table.getColumnModel().getSelectionModel()); |
| } |
| |
| |
| private static final TransferHandler defaultTransferHandler = new TableTransferHandler(); |
| |
| static class TableTransferHandler extends TransferHandler implements UIResource { |
| |
| /** |
| * Create a Transferable to use as the source for a data transfer. |
| * |
| * @param c The component holding the data to be transfered. This |
| * argument is provided to enable sharing of TransferHandlers by |
| * multiple components. |
| * @return The representation of the data to be transfered. |
| * |
| */ |
| protected Transferable createTransferable(JComponent c) { |
| if (c instanceof JTable) { |
| JTable table = (JTable) c; |
| int[] rows; |
| int[] cols; |
| |
| if (!table.getRowSelectionAllowed() && !table.getColumnSelectionAllowed()) { |
| return null; |
| } |
| |
| if (!table.getRowSelectionAllowed()) { |
| int rowCount = table.getRowCount(); |
| |
| rows = new int[rowCount]; |
| for (int counter = 0; counter < rowCount; counter++) { |
| rows[counter] = counter; |
| } |
| } else { |
| rows = table.getSelectedRows(); |
| } |
| |
| if (!table.getColumnSelectionAllowed()) { |
| int colCount = table.getColumnCount(); |
| |
| cols = new int[colCount]; |
| for (int counter = 0; counter < colCount; counter++) { |
| cols[counter] = counter; |
| } |
| } else { |
| cols = table.getSelectedColumns(); |
| } |
| |
| if (rows == null || cols == null || rows.length == 0 || cols.length == 0) { |
| return null; |
| } |
| |
| StringBuffer plainBuf = new StringBuffer(); |
| StringBuffer htmlBuf = new StringBuffer(); |
| |
| htmlBuf.append("<html>\n<body>\n<table>\n"); |
| |
| for (int row = 0; row < rows.length; row++) { |
| htmlBuf.append("<tr>\n"); |
| for (int col = 0; col < cols.length; col++) { |
| Object obj = table.getValueAt(rows[row], cols[col]); |
| String val = ((obj == null) ? "" : obj.toString()); |
| plainBuf.append(val + "\t"); |
| htmlBuf.append(" <td>" + val + "</td>\n"); |
| } |
| // we want a newline at the end of each line and not a tab |
| plainBuf.deleteCharAt(plainBuf.length() - 1).append("\n"); |
| htmlBuf.append("</tr>\n"); |
| } |
| |
| // remove the last newline |
| plainBuf.deleteCharAt(plainBuf.length() - 1); |
| htmlBuf.append("</table>\n</body>\n</html>"); |
| |
| return new BasicTransferable(plainBuf.toString(), htmlBuf.toString()); |
| } |
| |
| return null; |
| } |
| |
| public int getSourceActions(JComponent c) { |
| return COPY; |
| } |
| |
| } |
| } // End of Class BasicTableUI |