| /* |
| * Copyright (c) 1997, 2010, 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.event.*; |
| import java.util.*; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import javax.swing.plaf.*; |
| import javax.swing.table.*; |
| |
| import sun.swing.*; |
| |
| /** |
| * BasicTableHeaderUI implementation |
| * |
| * @author Alan Chung |
| * @author Philip Milne |
| */ |
| public class BasicTableHeaderUI extends TableHeaderUI { |
| |
| private static Cursor resizeCursor = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR); |
| |
| // |
| // Instance Variables |
| // |
| |
| /** The JTableHeader that is delegating the painting to this UI. */ |
| protected JTableHeader header; |
| protected CellRendererPane rendererPane; |
| |
| // Listeners that are attached to the JTable |
| protected MouseInputListener mouseInputListener; |
| |
| // The column header over which the mouse currently is. |
| private int rolloverColumn = -1; |
| |
| // The column that should be highlighted when the table header has the focus. |
| private int selectedColumnIndex = 0; // Read ONLY via getSelectedColumnIndex! |
| |
| private static FocusListener focusListener = new FocusListener() { |
| public void focusGained(FocusEvent e) { |
| repaintHeader(e.getSource()); |
| } |
| |
| public void focusLost(FocusEvent e) { |
| repaintHeader(e.getSource()); |
| } |
| |
| private void repaintHeader(Object source) { |
| if (source instanceof JTableHeader) { |
| JTableHeader th = (JTableHeader)source; |
| BasicTableHeaderUI ui = |
| (BasicTableHeaderUI)BasicLookAndFeel. |
| getUIOfType(th.getUI(), |
| BasicTableHeaderUI.class); |
| if (ui == null) { |
| return; |
| } |
| |
| th.repaint(th.getHeaderRect(ui.getSelectedColumnIndex())); |
| } |
| } |
| }; |
| |
| /** |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of {@code BasicTableHeaderUI}. |
| */ |
| public class MouseInputHandler implements MouseInputListener { |
| |
| private int mouseXOffset; |
| private Cursor otherCursor = resizeCursor; |
| |
| public void mouseClicked(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| if (e.getClickCount() % 2 == 1 && |
| SwingUtilities.isLeftMouseButton(e)) { |
| JTable table = header.getTable(); |
| RowSorter sorter; |
| if (table != null && (sorter = table.getRowSorter()) != null) { |
| int columnIndex = header.columnAtPoint(e.getPoint()); |
| if (columnIndex != -1) { |
| columnIndex = table.convertColumnIndexToModel( |
| columnIndex); |
| sorter.toggleSortOrder(columnIndex); |
| } |
| } |
| } |
| } |
| |
| private TableColumn getResizingColumn(Point p) { |
| return getResizingColumn(p, header.columnAtPoint(p)); |
| } |
| |
| private TableColumn getResizingColumn(Point p, int column) { |
| if (column == -1) { |
| return null; |
| } |
| Rectangle r = header.getHeaderRect(column); |
| r.grow(-3, 0); |
| if (r.contains(p)) { |
| return null; |
| } |
| int midPoint = r.x + r.width/2; |
| int columnIndex; |
| if( header.getComponentOrientation().isLeftToRight() ) { |
| columnIndex = (p.x < midPoint) ? column - 1 : column; |
| } else { |
| columnIndex = (p.x < midPoint) ? column : column - 1; |
| } |
| if (columnIndex == -1) { |
| return null; |
| } |
| return header.getColumnModel().getColumn(columnIndex); |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| header.setDraggedColumn(null); |
| header.setResizingColumn(null); |
| header.setDraggedDistance(0); |
| |
| Point p = e.getPoint(); |
| |
| // First find which header cell was hit |
| TableColumnModel columnModel = header.getColumnModel(); |
| int index = header.columnAtPoint(p); |
| |
| if (index != -1) { |
| // The last 3 pixels + 3 pixels of next column are for resizing |
| TableColumn resizingColumn = getResizingColumn(p, index); |
| if (canResize(resizingColumn, header)) { |
| header.setResizingColumn(resizingColumn); |
| if( header.getComponentOrientation().isLeftToRight() ) { |
| mouseXOffset = p.x - resizingColumn.getWidth(); |
| } else { |
| mouseXOffset = p.x + resizingColumn.getWidth(); |
| } |
| } |
| else if (header.getReorderingAllowed()) { |
| TableColumn hitColumn = columnModel.getColumn(index); |
| header.setDraggedColumn(hitColumn); |
| mouseXOffset = p.x; |
| } |
| } |
| |
| if (header.getReorderingAllowed()) { |
| int oldRolloverColumn = rolloverColumn; |
| rolloverColumn = -1; |
| rolloverColumnUpdated(oldRolloverColumn, rolloverColumn); |
| } |
| } |
| |
| private void swapCursor() { |
| Cursor tmp = header.getCursor(); |
| header.setCursor(otherCursor); |
| otherCursor = tmp; |
| } |
| |
| public void mouseMoved(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| if (canResize(getResizingColumn(e.getPoint()), header) != |
| (header.getCursor() == resizeCursor)) { |
| swapCursor(); |
| } |
| updateRolloverColumn(e); |
| } |
| |
| public void mouseDragged(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| int mouseX = e.getX(); |
| |
| TableColumn resizingColumn = header.getResizingColumn(); |
| TableColumn draggedColumn = header.getDraggedColumn(); |
| |
| boolean headerLeftToRight = header.getComponentOrientation().isLeftToRight(); |
| |
| if (resizingColumn != null) { |
| int oldWidth = resizingColumn.getWidth(); |
| int newWidth; |
| if (headerLeftToRight) { |
| newWidth = mouseX - mouseXOffset; |
| } else { |
| newWidth = mouseXOffset - mouseX; |
| } |
| mouseXOffset += changeColumnWidth(resizingColumn, header, |
| oldWidth, newWidth); |
| } |
| else if (draggedColumn != null) { |
| TableColumnModel cm = header.getColumnModel(); |
| int draggedDistance = mouseX - mouseXOffset; |
| int direction = (draggedDistance < 0) ? -1 : 1; |
| int columnIndex = viewIndexForColumn(draggedColumn); |
| int newColumnIndex = columnIndex + (headerLeftToRight ? direction : -direction); |
| if (0 <= newColumnIndex && newColumnIndex < cm.getColumnCount()) { |
| int width = cm.getColumn(newColumnIndex).getWidth(); |
| if (Math.abs(draggedDistance) > (width / 2)) { |
| |
| mouseXOffset = mouseXOffset + direction * width; |
| header.setDraggedDistance(draggedDistance - direction * width); |
| |
| //Cache the selected column. |
| int selectedIndex = |
| SwingUtilities2.convertColumnIndexToModel( |
| header.getColumnModel(), |
| getSelectedColumnIndex()); |
| |
| //Now do the move. |
| cm.moveColumn(columnIndex, newColumnIndex); |
| |
| //Update the selected index. |
| selectColumn( |
| SwingUtilities2.convertColumnIndexToView( |
| header.getColumnModel(), selectedIndex), |
| false); |
| |
| return; |
| } |
| } |
| setDraggedDistance(draggedDistance, columnIndex); |
| } |
| |
| updateRolloverColumn(e); |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| setDraggedDistance(0, viewIndexForColumn(header.getDraggedColumn())); |
| |
| header.setResizingColumn(null); |
| header.setDraggedColumn(null); |
| |
| updateRolloverColumn(e); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| updateRolloverColumn(e); |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| if (!header.isEnabled()) { |
| return; |
| } |
| int oldRolloverColumn = rolloverColumn; |
| rolloverColumn = -1; |
| rolloverColumnUpdated(oldRolloverColumn, rolloverColumn); |
| } |
| // |
| // Protected & Private Methods |
| // |
| |
| private void setDraggedDistance(int draggedDistance, int column) { |
| header.setDraggedDistance(draggedDistance); |
| if (column != -1) { |
| header.getColumnModel().moveColumn(column, column); |
| } |
| } |
| } |
| |
| // |
| // Factory methods for the Listeners |
| // |
| |
| /** |
| * Creates the mouse listener for the JTableHeader. |
| */ |
| protected MouseInputListener createMouseInputListener() { |
| return new MouseInputHandler(); |
| } |
| |
| // |
| // The installation/uninstall procedures and support |
| // |
| |
| public static ComponentUI createUI(JComponent h) { |
| return new BasicTableHeaderUI(); |
| } |
| |
| // Installation |
| |
| public void installUI(JComponent c) { |
| header = (JTableHeader)c; |
| |
| rendererPane = new CellRendererPane(); |
| header.add(rendererPane); |
| |
| installDefaults(); |
| installListeners(); |
| installKeyboardActions(); |
| } |
| |
| /** |
| * Initializes JTableHeader properties such as 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(header, "TableHeader.background", |
| "TableHeader.foreground", "TableHeader.font"); |
| LookAndFeel.installProperty(header, "opaque", Boolean.TRUE); |
| } |
| |
| /** |
| * Attaches listeners to the JTableHeader. |
| */ |
| protected void installListeners() { |
| mouseInputListener = createMouseInputListener(); |
| |
| header.addMouseListener(mouseInputListener); |
| header.addMouseMotionListener(mouseInputListener); |
| header.addFocusListener(focusListener); |
| } |
| |
| /** |
| * Register all keyboard actions on the JTableHeader. |
| */ |
| protected void installKeyboardActions() { |
| InputMap keyMap = (InputMap)DefaultLookup.get(header, this, |
| "TableHeader.ancestorInputMap"); |
| SwingUtilities.replaceUIInputMap(header, |
| JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keyMap); |
| LazyActionMap.installLazyActionMap(header, BasicTableHeaderUI.class, |
| "TableHeader.actionMap"); |
| } |
| |
| // Uninstall methods |
| |
| public void uninstallUI(JComponent c) { |
| uninstallDefaults(); |
| uninstallListeners(); |
| uninstallKeyboardActions(); |
| |
| header.remove(rendererPane); |
| rendererPane = null; |
| header = null; |
| } |
| |
| protected void uninstallDefaults() {} |
| |
| protected void uninstallListeners() { |
| header.removeMouseListener(mouseInputListener); |
| header.removeMouseMotionListener(mouseInputListener); |
| |
| mouseInputListener = null; |
| } |
| |
| /** |
| * Unregisters default key actions. |
| */ |
| protected void uninstallKeyboardActions() { |
| SwingUtilities.replaceUIInputMap(header, JComponent.WHEN_FOCUSED, null); |
| SwingUtilities.replaceUIActionMap(header, null); |
| } |
| |
| /** |
| * Populates TableHeader's actions. |
| */ |
| static void loadActionMap(LazyActionMap map) { |
| map.put(new Actions(Actions.TOGGLE_SORT_ORDER)); |
| map.put(new Actions(Actions.SELECT_COLUMN_TO_LEFT)); |
| map.put(new Actions(Actions.SELECT_COLUMN_TO_RIGHT)); |
| map.put(new Actions(Actions.MOVE_COLUMN_LEFT)); |
| map.put(new Actions(Actions.MOVE_COLUMN_RIGHT)); |
| map.put(new Actions(Actions.RESIZE_LEFT)); |
| map.put(new Actions(Actions.RESIZE_RIGHT)); |
| map.put(new Actions(Actions.FOCUS_TABLE)); |
| } |
| |
| // |
| // Support for mouse rollover |
| // |
| |
| /** |
| * Returns the index of the column header over which the mouse |
| * currently is. When the mouse is not over the table header, |
| * -1 is returned. |
| * |
| * @see #rolloverColumnUpdated(int, int) |
| * @return the index of the current rollover column |
| * @since 1.6 |
| */ |
| protected int getRolloverColumn() { |
| return rolloverColumn; |
| } |
| |
| /** |
| * This method gets called every time when a rollover column in the table |
| * header is updated. Every look and feel that supports a rollover effect |
| * in a table header should override this method and repaint the header. |
| * |
| * @param oldColumn the index of the previous rollover column or -1 if the |
| * mouse was not over a column |
| * @param newColumn the index of the new rollover column or -1 if the mouse |
| * is not over a column |
| * @see #getRolloverColumn() |
| * @see JTableHeader#getHeaderRect(int) |
| * @since 1.6 |
| */ |
| protected void rolloverColumnUpdated(int oldColumn, int newColumn) { |
| } |
| |
| private void updateRolloverColumn(MouseEvent e) { |
| if (header.getDraggedColumn() == null && |
| header.contains(e.getPoint())) { |
| |
| int col = header.columnAtPoint(e.getPoint()); |
| if (col != rolloverColumn) { |
| int oldRolloverColumn = rolloverColumn; |
| rolloverColumn = col; |
| rolloverColumnUpdated(oldRolloverColumn, rolloverColumn); |
| } |
| } |
| } |
| |
| // |
| // Support for keyboard and mouse access |
| // |
| private int selectNextColumn(boolean doIt) { |
| int newIndex = getSelectedColumnIndex(); |
| if (newIndex < header.getColumnModel().getColumnCount() - 1) { |
| newIndex++; |
| if (doIt) { |
| selectColumn(newIndex); |
| } |
| } |
| return newIndex; |
| } |
| |
| private int selectPreviousColumn(boolean doIt) { |
| int newIndex = getSelectedColumnIndex(); |
| if (newIndex > 0) { |
| newIndex--; |
| if (doIt) { |
| selectColumn(newIndex); |
| } |
| } |
| return newIndex; |
| } |
| |
| /** |
| * Selects the specified column in the table header. Repaints the |
| * affected header cells and makes sure the newly selected one is visible. |
| */ |
| void selectColumn(int newColIndex) { |
| selectColumn(newColIndex, true); |
| } |
| |
| void selectColumn(int newColIndex, boolean doScroll) { |
| Rectangle repaintRect = header.getHeaderRect(selectedColumnIndex); |
| header.repaint(repaintRect); |
| selectedColumnIndex = newColIndex; |
| repaintRect = header.getHeaderRect(newColIndex); |
| header.repaint(repaintRect); |
| if (doScroll) { |
| scrollToColumn(newColIndex); |
| } |
| return; |
| } |
| /** |
| * Used by selectColumn to scroll horizontally, if necessary, |
| * to ensure that the newly selected column is visible. |
| */ |
| private void scrollToColumn(int col) { |
| Container container; |
| JTable table; |
| |
| //Test whether the header is in a scroll pane and has a table. |
| if ((header.getParent() == null) || |
| ((container = header.getParent().getParent()) == null) || |
| !(container instanceof JScrollPane) || |
| ((table = header.getTable()) == null)) { |
| return; |
| } |
| |
| //Now scroll, if necessary. |
| Rectangle vis = table.getVisibleRect(); |
| Rectangle cellBounds = table.getCellRect(0, col, true); |
| vis.x = cellBounds.x; |
| vis.width = cellBounds.width; |
| table.scrollRectToVisible(vis); |
| } |
| |
| private int getSelectedColumnIndex() { |
| int numCols = header.getColumnModel().getColumnCount(); |
| if (selectedColumnIndex >= numCols && numCols > 0) { |
| selectedColumnIndex = numCols - 1; |
| } |
| return selectedColumnIndex; |
| } |
| |
| private static boolean canResize(TableColumn column, |
| JTableHeader header) { |
| return (column != null) && header.getResizingAllowed() |
| && column.getResizable(); |
| } |
| |
| private int changeColumnWidth(TableColumn resizingColumn, |
| JTableHeader th, |
| int oldWidth, int newWidth) { |
| resizingColumn.setWidth(newWidth); |
| |
| Container container; |
| JTable table; |
| |
| if ((th.getParent() == null) || |
| ((container = th.getParent().getParent()) == null) || |
| !(container instanceof JScrollPane) || |
| ((table = th.getTable()) == null)) { |
| return 0; |
| } |
| |
| if (!container.getComponentOrientation().isLeftToRight() && |
| !th.getComponentOrientation().isLeftToRight()) { |
| JViewport viewport = ((JScrollPane)container).getViewport(); |
| int viewportWidth = viewport.getWidth(); |
| int diff = newWidth - oldWidth; |
| int newHeaderWidth = table.getWidth() + diff; |
| |
| /* Resize a table */ |
| Dimension tableSize = table.getSize(); |
| tableSize.width += diff; |
| table.setSize(tableSize); |
| |
| /* If this table is in AUTO_RESIZE_OFF mode and |
| * has a horizontal scrollbar, we need to update |
| * a view's position. |
| */ |
| if ((newHeaderWidth >= viewportWidth) && |
| (table.getAutoResizeMode() == JTable.AUTO_RESIZE_OFF)) { |
| Point p = viewport.getViewPosition(); |
| p.x = Math.max(0, Math.min(newHeaderWidth - viewportWidth, |
| p.x + diff)); |
| viewport.setViewPosition(p); |
| return diff; |
| } |
| } |
| return 0; |
| } |
| |
| // |
| // Baseline |
| // |
| |
| /** |
| * 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); |
| int baseline = -1; |
| TableColumnModel columnModel = header.getColumnModel(); |
| for(int column = 0; column < columnModel.getColumnCount(); |
| column++) { |
| TableColumn aColumn = columnModel.getColumn(column); |
| Component comp = getHeaderRenderer(column); |
| Dimension pref = comp.getPreferredSize(); |
| int columnBaseline = comp.getBaseline(pref.width, height); |
| if (columnBaseline >= 0) { |
| if (baseline == -1) { |
| baseline = columnBaseline; |
| } |
| else if (baseline != columnBaseline) { |
| baseline = -1; |
| break; |
| } |
| } |
| } |
| return baseline; |
| } |
| |
| // |
| // Paint Methods and support |
| // |
| |
| public void paint(Graphics g, JComponent c) { |
| if (header.getColumnModel().getColumnCount() <= 0) { |
| return; |
| } |
| boolean ltr = header.getComponentOrientation().isLeftToRight(); |
| |
| Rectangle clip = g.getClipBounds(); |
| Point left = clip.getLocation(); |
| Point right = new Point( clip.x + clip.width - 1, clip.y ); |
| TableColumnModel cm = header.getColumnModel(); |
| int cMin = header.columnAtPoint( ltr ? left : right ); |
| int cMax = header.columnAtPoint( ltr ? right : left ); |
| // 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 = cm.getColumnCount()-1; |
| } |
| |
| TableColumn draggedColumn = header.getDraggedColumn(); |
| int columnWidth; |
| Rectangle cellRect = header.getHeaderRect(ltr ? cMin : cMax); |
| TableColumn aColumn; |
| if (ltr) { |
| for(int column = cMin; column <= cMax ; column++) { |
| aColumn = cm.getColumn(column); |
| columnWidth = aColumn.getWidth(); |
| cellRect.width = columnWidth; |
| if (aColumn != draggedColumn) { |
| paintCell(g, cellRect, column); |
| } |
| cellRect.x += columnWidth; |
| } |
| } else { |
| for(int column = cMax; column >= cMin; column--) { |
| aColumn = cm.getColumn(column); |
| columnWidth = aColumn.getWidth(); |
| cellRect.width = columnWidth; |
| if (aColumn != draggedColumn) { |
| paintCell(g, cellRect, column); |
| } |
| cellRect.x += columnWidth; |
| } |
| } |
| |
| // Paint the dragged column if we are dragging. |
| if (draggedColumn != null) { |
| int draggedColumnIndex = viewIndexForColumn(draggedColumn); |
| Rectangle draggedCellRect = header.getHeaderRect(draggedColumnIndex); |
| |
| // Draw a gray well in place of the moving column. |
| g.setColor(header.getParent().getBackground()); |
| g.fillRect(draggedCellRect.x, draggedCellRect.y, |
| draggedCellRect.width, draggedCellRect.height); |
| |
| draggedCellRect.x += header.getDraggedDistance(); |
| |
| // Fill the background. |
| g.setColor(header.getBackground()); |
| g.fillRect(draggedCellRect.x, draggedCellRect.y, |
| draggedCellRect.width, draggedCellRect.height); |
| |
| paintCell(g, draggedCellRect, draggedColumnIndex); |
| } |
| |
| // Remove all components in the rendererPane. |
| rendererPane.removeAll(); |
| } |
| |
| private Component getHeaderRenderer(int columnIndex) { |
| TableColumn aColumn = header.getColumnModel().getColumn(columnIndex); |
| TableCellRenderer renderer = aColumn.getHeaderRenderer(); |
| if (renderer == null) { |
| renderer = header.getDefaultRenderer(); |
| } |
| |
| boolean hasFocus = !header.isPaintingForPrint() |
| && (columnIndex == getSelectedColumnIndex()) |
| && header.hasFocus(); |
| return renderer.getTableCellRendererComponent(header.getTable(), |
| aColumn.getHeaderValue(), |
| false, hasFocus, |
| -1, columnIndex); |
| } |
| |
| private void paintCell(Graphics g, Rectangle cellRect, int columnIndex) { |
| Component component = getHeaderRenderer(columnIndex); |
| rendererPane.paintComponent(g, component, header, cellRect.x, cellRect.y, |
| cellRect.width, cellRect.height, true); |
| } |
| |
| private int viewIndexForColumn(TableColumn aColumn) { |
| TableColumnModel cm = header.getColumnModel(); |
| for (int column = 0; column < cm.getColumnCount(); column++) { |
| if (cm.getColumn(column) == aColumn) { |
| return column; |
| } |
| } |
| return -1; |
| } |
| |
| // |
| // Size Methods |
| // |
| |
| private int getHeaderHeight() { |
| int height = 0; |
| boolean accomodatedDefault = false; |
| TableColumnModel columnModel = header.getColumnModel(); |
| for(int column = 0; column < columnModel.getColumnCount(); column++) { |
| TableColumn aColumn = columnModel.getColumn(column); |
| boolean isDefault = (aColumn.getHeaderRenderer() == null); |
| |
| if (!isDefault || !accomodatedDefault) { |
| Component comp = getHeaderRenderer(column); |
| int rendererHeight = comp.getPreferredSize().height; |
| height = Math.max(height, rendererHeight); |
| |
| // Configuring the header renderer to calculate its preferred size |
| // is expensive. Optimise this by assuming the default renderer |
| // always has the same height as the first non-zero height that |
| // it returns for a non-null/non-empty value. |
| if (isDefault && rendererHeight > 0) { |
| Object headerValue = aColumn.getHeaderValue(); |
| if (headerValue != null) { |
| headerValue = headerValue.toString(); |
| |
| if (headerValue != null && !headerValue.equals("")) { |
| accomodatedDefault = true; |
| } |
| } |
| } |
| } |
| } |
| return height; |
| } |
| |
| private Dimension createHeaderSize(long width) { |
| // None of the callers include the intercell spacing, do it here. |
| if (width > Integer.MAX_VALUE) { |
| width = Integer.MAX_VALUE; |
| } |
| return new Dimension((int)width, getHeaderHeight()); |
| } |
| |
| |
| /** |
| * Return the minimum size of the header. The minimum width is the sum |
| * of the minimum widths of each column (plus inter-cell spacing). |
| */ |
| public Dimension getMinimumSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = header.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getMinWidth(); |
| } |
| return createHeaderSize(width); |
| } |
| |
| /** |
| * Return the preferred size of the header. The preferred height is the |
| * maximum of the preferred heights of all of the components provided |
| * by the header renderers. The preferred width is the sum of the |
| * preferred widths of each column (plus inter-cell spacing). |
| */ |
| public Dimension getPreferredSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = header.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getPreferredWidth(); |
| } |
| return createHeaderSize(width); |
| } |
| |
| /** |
| * Return the maximum size of the header. The maximum width is the sum |
| * of the maximum widths of each column (plus inter-cell spacing). |
| */ |
| public Dimension getMaximumSize(JComponent c) { |
| long width = 0; |
| Enumeration enumeration = header.getColumnModel().getColumns(); |
| while (enumeration.hasMoreElements()) { |
| TableColumn aColumn = (TableColumn)enumeration.nextElement(); |
| width = width + aColumn.getMaxWidth(); |
| } |
| return createHeaderSize(width); |
| } |
| |
| private static class Actions extends UIAction { |
| public static final String TOGGLE_SORT_ORDER = |
| "toggleSortOrder"; |
| public static final String SELECT_COLUMN_TO_LEFT = |
| "selectColumnToLeft"; |
| public static final String SELECT_COLUMN_TO_RIGHT = |
| "selectColumnToRight"; |
| public static final String MOVE_COLUMN_LEFT = |
| "moveColumnLeft"; |
| public static final String MOVE_COLUMN_RIGHT = |
| "moveColumnRight"; |
| public static final String RESIZE_LEFT = |
| "resizeLeft"; |
| public static final String RESIZE_RIGHT = |
| "resizeRight"; |
| public static final String FOCUS_TABLE = |
| "focusTable"; |
| |
| public Actions(String name) { |
| super(name); |
| } |
| |
| public boolean isEnabled(Object sender) { |
| if (sender instanceof JTableHeader) { |
| JTableHeader th = (JTableHeader)sender; |
| TableColumnModel cm = th.getColumnModel(); |
| if (cm.getColumnCount() <= 0) { |
| return false; |
| } |
| |
| String key = getName(); |
| BasicTableHeaderUI ui = |
| (BasicTableHeaderUI)BasicLookAndFeel.getUIOfType(th.getUI(), |
| BasicTableHeaderUI.class); |
| if (ui != null) { |
| if (key == MOVE_COLUMN_LEFT) { |
| return th.getReorderingAllowed() |
| && maybeMoveColumn(true, th, ui, false); |
| } else if (key == MOVE_COLUMN_RIGHT) { |
| return th.getReorderingAllowed() |
| && maybeMoveColumn(false, th, ui, false); |
| } else if (key == RESIZE_LEFT || |
| key == RESIZE_RIGHT) { |
| return canResize(cm.getColumn(ui.getSelectedColumnIndex()), th); |
| } else if (key == FOCUS_TABLE) { |
| return (th.getTable() != null); |
| } |
| } |
| } |
| return true; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| JTableHeader th = (JTableHeader)e.getSource(); |
| BasicTableHeaderUI ui = |
| (BasicTableHeaderUI)BasicLookAndFeel. |
| getUIOfType(th.getUI(), |
| BasicTableHeaderUI.class); |
| if (ui == null) { |
| return; |
| } |
| |
| String name = getName(); |
| if (TOGGLE_SORT_ORDER == name) { |
| JTable table = th.getTable(); |
| RowSorter sorter = table == null ? null : table.getRowSorter(); |
| if (sorter != null) { |
| int columnIndex = ui.getSelectedColumnIndex(); |
| columnIndex = table.convertColumnIndexToModel( |
| columnIndex); |
| sorter.toggleSortOrder(columnIndex); |
| } |
| } else if (SELECT_COLUMN_TO_LEFT == name) { |
| if (th.getComponentOrientation().isLeftToRight()) { |
| ui.selectPreviousColumn(true); |
| } else { |
| ui.selectNextColumn(true); |
| } |
| } else if (SELECT_COLUMN_TO_RIGHT == name) { |
| if (th.getComponentOrientation().isLeftToRight()) { |
| ui.selectNextColumn(true); |
| } else { |
| ui.selectPreviousColumn(true); |
| } |
| } else if (MOVE_COLUMN_LEFT == name) { |
| moveColumn(true, th, ui); |
| } else if (MOVE_COLUMN_RIGHT == name) { |
| moveColumn(false, th, ui); |
| } else if (RESIZE_LEFT == name) { |
| resize(true, th, ui); |
| } else if (RESIZE_RIGHT == name) { |
| resize(false, th, ui); |
| } else if (FOCUS_TABLE == name) { |
| JTable table = th.getTable(); |
| if (table != null) { |
| table.requestFocusInWindow(); |
| } |
| } |
| } |
| |
| private void moveColumn(boolean leftArrow, JTableHeader th, |
| BasicTableHeaderUI ui) { |
| maybeMoveColumn(leftArrow, th, ui, true); |
| } |
| |
| private boolean maybeMoveColumn(boolean leftArrow, JTableHeader th, |
| BasicTableHeaderUI ui, boolean doIt) { |
| int oldIndex = ui.getSelectedColumnIndex(); |
| int newIndex; |
| |
| if (th.getComponentOrientation().isLeftToRight()) { |
| newIndex = leftArrow ? ui.selectPreviousColumn(doIt) |
| : ui.selectNextColumn(doIt); |
| } else { |
| newIndex = leftArrow ? ui.selectNextColumn(doIt) |
| : ui.selectPreviousColumn(doIt); |
| } |
| |
| if (newIndex != oldIndex) { |
| if (doIt) { |
| th.getColumnModel().moveColumn(oldIndex, newIndex); |
| } else { |
| return true; // we'd do the move if asked |
| } |
| } |
| |
| return false; |
| } |
| |
| private void resize(boolean leftArrow, JTableHeader th, |
| BasicTableHeaderUI ui) { |
| int columnIndex = ui.getSelectedColumnIndex(); |
| TableColumn resizingColumn = |
| th.getColumnModel().getColumn(columnIndex); |
| |
| th.setResizingColumn(resizingColumn); |
| int oldWidth = resizingColumn.getWidth(); |
| int newWidth = oldWidth; |
| |
| if (th.getComponentOrientation().isLeftToRight()) { |
| newWidth = newWidth + (leftArrow ? -1 : 1); |
| } else { |
| newWidth = newWidth + (leftArrow ? 1 : -1); |
| } |
| |
| ui.changeColumnWidth(resizingColumn, th, oldWidth, newWidth); |
| } |
| } |
| } // End of Class BasicTableHeaderUI |
