我在滚动窗格中有一个包含许多元素的列表，并且我已经在列表中实现了拖放操作。当我从列表中选择一个项目并将其拖动到列表的底部时，只要我将鼠标靠近边缘，列表就会自动向下滚动。这在Windows上运行正常，但在Linux上，列表会滚动一个元素然后停止。
这是一个显示此错误的简短程序：
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import javax.swing.DropMode;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import javax.swing.TransferHandler;
import javax.swing.WindowConstants;
public class JListAutoscroll {
protected static Container createUI() {
JList<String> jlist = new JList<>(generateData(100));
setDragAndDrop(jlist);
JScrollPane scrollPane = new JScrollPane(jlist);
JPanel panel = new JPanel(new BorderLayout());
panel.add(scrollPane, BorderLayout.CENTER);
return panel;
}
private static void setDragAndDrop(JList<String> jlist) {
jlist.setDragEnabled(true);
jlist.setDropMode(DropMode.INSERT);
jlist.setTransferHandler(new ListTransferHandler());
}
private static String[] generateData(int nRows) {
String rows[] = new String[nRows];
for (int i = 0; i < rows.length; i++) {
rows[i] = "element " + i;
}
return rows;
}
private static class ListTransferHandler extends TransferHandler {
@Override
public int getSourceActions(JComponent component) {
return COPY_OR_MOVE;
}
@Override
protected Transferable createTransferable(JComponent component) {
return new ListItemTransferable((JList)component);
}
@Override
public boolean canImport(TransferHandler.TransferSupport support) {
return true;
}
@Override
public boolean importData(TransferHandler.TransferSupport support) {
return true;
}
}
private static class ListItemTransferable implements Transferable {
private String item;
public ListItemTransferable(JList<String> jlist) {
item = jlist.getSelectedValue();
}
@Override
public DataFlavor[] getTransferDataFlavors() {
return new DataFlavor[] { DataFlavor.stringFlavor };
}
@Override
public boolean isDataFlavorSupported(DataFlavor flavor) {
return flavor.equals(DataFlavor.stringFlavor);
}
@Override
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if(!isDataFlavorSupported(flavor)) {
throw new UnsupportedFlavorException(flavor);
}
return item;
}
}
public static void main(String args[]) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
JFrame frame = new JFrame("JList Autoscroll");
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
frame.setContentPane(createUI());
frame.setPreferredSize(new Dimension(400, 600));
frame.pack();
frame.setVisible(true);
}
});
}
}
我已经实现了一个简单的TransferHandler，它在拖放时什么都不做，但足以在拖动到列表边缘时显示问题。
这似乎是JDK中的一个已知错误，最好在this report中进行描述。我已经看到了一些建议的解决方法，例如this one或this one，
但我不清楚如何实施它们。在我看来，我必须创建一个DropTarget子类，我使用它的组件应该实现Autoscroll接口。但JList没有实现它！另外，如果我在列表中设置DropTarget而不是TransferHandler，我不会失去TransferHandler实现的所有默认拖放行为？
那么如何修改我的程序来解决这个错误呢？
答案 0 :(得分：3)
正如bug description中所提到的，有两个类可以处理拖放：
DropTargetAutoScroller，java.awt.dnd.DropTarget的成员类，负责支持实施Autoscroll界面的组件;DropHandler，javax.swing.TransferHandler的成员类，可自动对实现Scrollable界面的组件进行自动滚动。
因此，确实，解决方法不适用于JList，它实现Scrollable而不是Autoscroll。但是，如果您查看DropTarget和TransferHandler的源代码，您会注意到自动滚动代码基本相同，并且在两种情况下都是错误的。解决方法也与DropTarget代码非常相似，只添加了几行。基本上，解决方案是将鼠标光标的位置从组件坐标系转换为屏幕坐标系。这样，当检查鼠标是否移动时，使用绝对坐标。因此，我们可以从TransferHandler复制代码并添加这几行。
那很好......但是我们把这段代码放在哪里？我们如何调用它？
如果我们查看setTransferHandler()，我们会发现它实际上设置了DropTarget，这是一个名为SwingDropTarget的包 - 私有静态类，来自TransferHandler 1}}类。它将拖放事件委托给名为DropTargetListener的私有静态 DropHandler。这个类完成拖放过程中发生的所有魔法，当然它还使用TransferHandler中的其他私有方法。这意味着我们不能只设置自己的DropTarget而不会丢失TransferHandler中已实现的所有内容。我们可以用添加的几行来重写TransferHandler（大约1800行）以修复错误，但这不太现实。
更简单的解决方案是编写DropTargetListener，我们只需复制DropHandler（也实现此接口）的自动滚动相关代码，并添加我们的行。这是班级：
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.dnd.DropTargetDragEvent;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.dnd.DropTargetEvent;
import java.awt.dnd.DropTargetListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.TooManyListenersException;
import javax.swing.JComponent;
import javax.swing.Scrollable;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
public class AutoscrollWorkaround implements DropTargetListener, ActionListener {
private JComponent component;
private Point lastPosition;
private Rectangle outer;
private Rectangle inner;
private Timer timer;
private int hysteresis = 10;
private static final int AUTOSCROLL_INSET = 10;
public AutoscrollWorkaround(JComponent component) {
if (!(component instanceof Scrollable)) {
throw new IllegalArgumentException("Component must be Scrollable for autoscroll to work!");
}
this.component = component;
outer = new Rectangle();
inner = new Rectangle();
Toolkit t = Toolkit.getDefaultToolkit();
Integer prop;
prop = (Integer)t.getDesktopProperty("DnD.Autoscroll.interval");
timer = new Timer(prop == null ? 100 : prop.intValue(), this);
prop = (Integer)t.getDesktopProperty("DnD.Autoscroll.initialDelay");
timer.setInitialDelay(prop == null ? 100 : prop.intValue());
prop = (Integer)t.getDesktopProperty("DnD.Autoscroll.cursorHysteresis");
if (prop != null) {
hysteresis = prop.intValue();
}
}
@Override
public void dragEnter(DropTargetDragEvent e) {
lastPosition = e.getLocation();
SwingUtilities.convertPointToScreen(lastPosition, component);
updateRegion();
}
@Override
public void dragOver(DropTargetDragEvent e) {
Point p = e.getLocation();
SwingUtilities.convertPointToScreen(p, component);
if (Math.abs(p.x - lastPosition.x) > hysteresis
|| Math.abs(p.y - lastPosition.y) > hysteresis) {
// no autoscroll
if (timer.isRunning()) timer.stop();
} else {
if (!timer.isRunning()) timer.start();
}
lastPosition = p;
}
@Override
public void dragExit(DropTargetEvent dte) {
cleanup();
}
@Override
public void drop(DropTargetDropEvent dtde) {
cleanup();
}
@Override
public void dropActionChanged(DropTargetDragEvent e) {
}
private void updateRegion() {
// compute the outer
Rectangle visible = component.getVisibleRect();
outer.setBounds(visible.x, visible.y, visible.width, visible.height);
// compute the insets
Insets i = new Insets(0, 0, 0, 0);
if (component instanceof Scrollable) {
int minSize = 2 * AUTOSCROLL_INSET;
if (visible.width >= minSize) {
i.left = i.right = AUTOSCROLL_INSET;
}
if (visible.height >= minSize) {
i.top = i.bottom = AUTOSCROLL_INSET;
}
}
// set the inner from the insets
inner.setBounds(visible.x + i.left,
visible.y + i.top,
visible.width - (i.left + i.right),
visible.height - (i.top + i.bottom));
}
@Override
public void actionPerformed(ActionEvent e) {
updateRegion();
Point componentPosition = new Point(lastPosition);
SwingUtilities.convertPointFromScreen(componentPosition, component);
if (outer.contains(componentPosition) && !inner.contains(componentPosition)) {
autoscroll(componentPosition);
}
}
private void autoscroll(Point position) {
Scrollable s = (Scrollable) component;
if (position.y < inner.y) {
// scroll upward
int dy = s.getScrollableUnitIncrement(outer, SwingConstants.VERTICAL, -1);
Rectangle r = new Rectangle(inner.x, outer.y - dy, inner.width, dy);
component.scrollRectToVisible(r);
} else if (position.y > (inner.y + inner.height)) {
// scroll downard
int dy = s.getScrollableUnitIncrement(outer, SwingConstants.VERTICAL, 1);
Rectangle r = new Rectangle(inner.x, outer.y + outer.height, inner.width, dy);
component.scrollRectToVisible(r);
}
if (position.x < inner.x) {
// scroll left
int dx = s.getScrollableUnitIncrement(outer, SwingConstants.HORIZONTAL, -1);
Rectangle r = new Rectangle(outer.x - dx, inner.y, dx, inner.height);
component.scrollRectToVisible(r);
} else if (position.x > (inner.x + inner.width)) {
// scroll right
int dx = s.getScrollableUnitIncrement(outer, SwingConstants.HORIZONTAL, 1);
Rectangle r = new Rectangle(outer.x + outer.width, inner.y, dx, inner.height);
component.scrollRectToVisible(r);
}
}
private void cleanup() {
timer.stop();
}
}
（你会发现基本上只有SwingUtilities.convertXYZ（）调用来自TransferHandler代码）
接下来，我们可以在设置DropTarget时将此侦听器添加到已安装的TransferHandler。 （请注意，常规DropTarget只接受一个侦听器，如果添加了另一个侦听器，则会抛出异常。SwingDropTarget使用DropHandler，但幸运的是它也增加了对其他侦听器的支持）< / p>
所以，让我们将这个静态工厂方法添加到AutoscrollWorkaround类，它为我们这样做：
public static void applyTo(JComponent component) {
if (component.getTransferHandler() == null) {
throw new IllegalStateException("A TransferHandler must be set before calling this method!");
}
try {
component.getDropTarget().addDropTargetListener(new AutoscrollWorkaround(component));
} catch (TooManyListenersException e) {
throw new IllegalStateException("Something went wrong! DropTarget should have been " +
"SwingDropTarget which accepts multiple listeners", e);
}
}
通过仅调用此方法，这提供了一种简单且非常方便的方法，将变通方法应用于任何遭受此错误的组件。只需确保在组件上有setTransferHandler()后调用它。所以，我们只需要在原始程序中添加一行：
private static void setDragAndDrop(JList<String> jlist) {
jlist.setDragEnabled(true);
jlist.setDropMode(DropMode.INSERT);
jlist.setTransferHandler(new ListTransferHandler());
AutoscrollWorkaround.applyTo(jlist); // <--- just this line added
}
autoscroll现在可以在Windows和Linux上正常运行。 （虽然在Linux上，在自动滚动工作之前，不会重新绘制掉落位置的行，但是很好。）
此解决方法也适用于JTable（我已测试），JTree以及可能实现Scrollable的任何组件。