Java在列表中拖放图像

我正在寻找一种以水平顺序显示一系列图片（带图像的JPanel，可能还有其他一些小组件）的方法

用户应该能够通过拖放来重新排列图像的顺序。 我该怎么做？JList是否具有一些定制组件和D&D功能？

---

需要考虑的一些问题（我听说组件具有相同的维度会提高性能）。

？

创建一个包含图像的列表模型

创建一个显示它们的ListCellRenderer，并将其设置为列表的渲染器。您可以在渲染器中使用JLabel，以便轻松设置图像

创建知道如何处理DataFlavor.imageFlavor的TransferHandler。StanislavL引用的例子是一个开始

---

设置列表的transferHandler属性。

以下示例演示如何在列表中水平显示图像，并使用拖放对其重新排序。如果空间不足，列表将水平换行

import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.io.Serializable;

public class ImagePreviewListTest {

    public static void main(String[] args) throws Exception {
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        JFrame frame = new JFrame("Image panel");
        frame.setSize(800, 300);
        frame.setLocationByPlatform(true);
        JList imageList = createImageList();
        frame.getContentPane().add(new JScrollPane(imageList));
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    private static JList createImageList() {

        JList imageList = new JList(createModel());
        imageList.setCellRenderer(new ImageCellRenderer());
        imageList.setLayoutOrientation(JList.HORIZONTAL_WRAP);
        imageList.setVisibleRowCount(-1);
        imageList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        imageList.setFixedCellWidth(240);
        imageList.setFixedCellHeight(120);

        imageList.setDragEnabled(true);
        imageList.setDropMode(DropMode.INSERT);
        imageList.setTransferHandler(new ImageTransferHandler(imageList));

        return imageList;
}

    private static DefaultListModel createModel() {
        DefaultListModel model = new DefaultListModel();
        model.addElement(new ColorIcon(Color.RED));
        model.addElement(new ColorIcon(Color.GREEN));
        model.addElement(new ColorIcon(Color.BLACK));
        model.addElement(new ColorIcon(Color.BLUE));
        model.addElement(new ColorIcon(Color.MAGENTA));
        model.addElement(new ColorIcon(Color.PINK));
        model.addElement(new ColorIcon(Color.YELLOW));
        model.addElement(new ColorIcon(Color.ORANGE));
        return model;
    }

    static class ImageTransferHandler extends TransferHandler {

        private static final DataFlavor DATA_FLAVOUR = new DataFlavor(ColorIcon.class, "Images");

        private final JList previewList;
        private boolean inDrag;

        ImageTransferHandler(JList previewList) {
            this.previewList = previewList;
        }

        public int getSourceActions(JComponent c) {
            return TransferHandler.MOVE;
        }

        protected Transferable createTransferable(JComponent c) {
            inDrag = true;
            return new Transferable() {
                public DataFlavor[] getTransferDataFlavors() {
                    return new DataFlavor[] {DATA_FLAVOUR};
                }

                public boolean isDataFlavorSupported(DataFlavor flavor) {
                    return flavor.equals(DATA_FLAVOUR);
                }

                public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
                    return previewList.getSelectedValue();
                }
            };
        }

        public boolean canImport(TransferSupport support) {
            if (!inDrag || !support.isDataFlavorSupported(DATA_FLAVOUR)) {
                return false;
            }

            JList.DropLocation dl = (JList.DropLocation)support.getDropLocation();
            if (dl.getIndex() == -1) {
                return false;
            } else {
                return true;
            }
        }

        public boolean importData(TransferSupport support) {
            if (!canImport(support)) {
                return false;
            }

            Transferable transferable = support.getTransferable();
            try {
                Object draggedImage = transferable.getTransferData(DATA_FLAVOUR);

                JList.DropLocation dl = (JList.DropLocation)support.getDropLocation();
                DefaultListModel model = (DefaultListModel)previewList.getModel();
                int dropIndex = dl.getIndex();
                if (model.indexOf(draggedImage) < dropIndex) {
                    dropIndex--;
                }
                model.removeElement(draggedImage);
                model.add(dropIndex, draggedImage);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }

        protected void exportDone(JComponent source, Transferable data, int action) {
            super.exportDone(source, data, action);
            inDrag = false;
        }
    }

    static class ImageCellRenderer extends JPanel implements ListCellRenderer {

        DefaultListCellRenderer defaultListCellRenderer = new DefaultListCellRenderer();
        JLabel imageLabel = new JLabel();
        JLabel descriptionLabel = new JLabel();

        ImageCellRenderer() {
            setLayout(new BorderLayout());
            Border emptyBorder = BorderFactory.createEmptyBorder(5, 5, 5, 5);
            imageLabel.setBorder(emptyBorder);
            descriptionLabel.setBorder(emptyBorder);
            add(imageLabel, BorderLayout.CENTER);
            add(descriptionLabel, BorderLayout.SOUTH);
        }

        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
            defaultListCellRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
            setBorder(defaultListCellRenderer.getBorder());
            setBackground(defaultListCellRenderer.getBackground());
            imageLabel.setIcon((Icon)value);
            descriptionLabel.setText("Description");
            return this;
        }
    }

    static class ColorIcon implements Icon, Serializable {
        private Color color;

        ColorIcon(Color color) {
            this.color = color;
        }

        public void paintIcon(Component c, Graphics g, int x, int y) {
            g.setColor(color);
            g.fillRect(x, y, getIconWidth(), getIconHeight());
        }

        public int getIconWidth() {
            return 200;
        }

        public int getIconHeight() {
            return 100;
        }

        public boolean equals(Object o) {
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            return color.equals(((ColorIcon)o).color);
        }

    }
}

import javax.swing.*；
导入javax.swing.border.border；
导入java.awt.*；
导入java.awt.datatransfer.DataFlavor；
导入java.awt.datatransfer.transfer；
导入java.awt.datatransfer.UnsupportedFlavorException；
导入java.io.IOException；
导入java.io.Serializable；
公共类ImagePreviewListTest{
公共静态void main（字符串[]args）引发异常{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
JFrame=新的JFrame（“图像面板”）；
框架设置尺寸（800300）；
frame.setLocationByPlatform（真）；
JList imageList=createImageList（）；
frame.getContentPane（）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setVisible（true）；
}
私有静态JList createImageList（）{
JList imageList=新的JList（createModel（））；
setCellRenderer（新的ImageCellRenderer（））；
imageList.setLayoutOrientation（JList.HORIZONTAL_WRAP）；
imageList.setVisibleRowCount（-1）；
imageList.setSelectionMode（ListSelectionModel.SINGLE_选择）；
imageList.setFixedCellWidth（240）；
imageList.setFixedCellHeight（120）；
imageList.setDragEnabled（true）；
设置DropMode（DropMode.INSERT）；
setTransferHandler（新的ImageTransferHandler（imageList））；
返回图像列表；
}
私有静态DefaultListModel createModel（）{
DefaultListModel=新的DefaultListModel（）；
model.addElement（新的颜色图标（Color.RED））；
model.addElement（新颜色图标（Color.GREEN））；
model.addElement（新的颜色图标（Color.BLACK））；
model.addElement（新颜色图标（Color.BLUE））；
model.addElement（新颜色图标（Color.MAGENTA））；
model.addElement（新颜色图标（Color.PINK））；
model.addElement（新颜色图标（Color.YELLOW））；
model.addElement（新颜色图标（Color.ORANGE））；
收益模型；
}
静态类ImageTransferHandler扩展了TransferHandler{
私有静态最终DataFlavor数据_Flavor=新DataFlavor（ColorIcon.class，“图像”）；
私人最终JList预览列表；
私有布尔索引；
ImageTransferHandler（JList预览列表）{
this.previewList=预览列表；
}
public int getSourceActions（JComponent c）{
返回TransferHandler.MOVE；
}
受保护的可转让组件（JComponent c）{
inDrag=正确；
返回新的可转让文件（）{
公共DataFlavor[]getTransferDataFlavors（）{
返回新的DataFlavor[]{DATA_flavor}；
}
支持公共布尔值IsDataFlavor（DataFlavor）{
返回味道。等于（数据味道）；
}
公共对象getTransferData（DataFlavor flavor）引发不受支持的LavorException、IOException{
返回previewList.getSelectedValue（）；
}
};
}
公共布尔值canImport（传输支持）{
如果（！inDrag | |！support.isDataFlavorSupported（数据味道））{
返回false；
}
JList.DropLocation dl=（JList.DropLocation）support.getDropLocation（）；
if（dl.getIndex（）=-1）{
返回false；
}否则{
返回true；
}
}
公共布尔输入数据（传输支持）{
如果（！canImport（支持））{
返回false；
}
可转移=support.getTransferable（）；
试一试{
Object draggedImage=transferable.getTransferData（数据）；
JList.DropLocation dl=（JList.DropLocation）support.getDropLocation（）；
DefaultListModel=（DefaultListModel）previewList.getModel（）；
int dropIndex=dl.getIndex（）；
if（型号索引OF（draggedImage）