图片拖拽问题（急！！！）

Question

图片移动，复制，
图片drawing 在Label上
左边是tree
面板Layout 是 FlowLayouthttp://javaprogram.5d6d.com/thread-309-1-1.html先谢谢了！！！

Answer 1

import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import javax.swing.*;public class DragListDemo extends JPanel {
    ArrayListTransferHandler arrayListHandler;    public DragListDemo() {
        arrayListHandler = new ArrayListTransferHandler();
        JList list1, list2;        DefaultListModel list1Model = new DefaultListModel();
        list1Model.addElement("0 (list 1)");
        list1Model.addElement("1 (list 1)");
        list1Model.addElement("2 (list 1)");
        list1Model.addElement("3 (list 1)");
        list1Model.addElement("4 (list 1)");
        list1Model.addElement("5 (list 1)");
        list1Model.addElement("6 (list 1)");
        list1 = new JList(list1Model);
        list1.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        list1.setTransferHandler(arrayListHandler);
        list1.setDragEnabled(true);
        JScrollPane list1View = new JScrollPane(list1);
        list1View.setPreferredSize(new Dimension(200, 100));
        JPanel panel1 = new JPanel();
        panel1.setLayout(new BorderLayout());
        panel1.add(list1View, BorderLayout.CENTER);
        panel1.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));        DefaultListModel list2Model = new DefaultListModel();
        list2Model.addElement("0 (list 2)");
        list2Model.addElement("1 (list 2)");
        list2Model.addElement("2 (list 2)");
        list2Model.addElement("3 (list 2)");
        list2Model.addElement("4 (list 2)");
        list2Model.addElement("5 (list 2)");
        list2Model.addElement("6 (list 2)");
        list2 = new JList(list2Model);
        list2.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        list2.setTransferHandler(arrayListHandler);
        list2.setDragEnabled(true);
        JScrollPane list2View = new JScrollPane(list2);
        list2View.setPreferredSize(new Dimension(200, 100));
        JPanel panel2 = new JPanel();
        panel2.setLayout(new BorderLayout());
        panel2.add(list2View, BorderLayout.CENTER);
        panel2.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));        setLayout(new BorderLayout());
        add(panel1, BorderLayout.LINE_START);
        add(panel2, BorderLayout.LINE_END);
        setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
    }    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("DragListDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        //Create and set up the content pane.
        DragListDemo demo = new DragListDemo();
        frame.setContentPane(demo);        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

Answer 2

import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import javax.swing.*;public class ArrayListTransferHandler extends TransferHandler {
    DataFlavor localArrayListFlavor, serialArrayListFlavor;
    String localArrayListType = DataFlavor.javaJVMLocalObjectMimeType +
                                ";class=java.util.ArrayList";
    JList source = null;
    int[] indices = null;
    int addIndex = -1; //Location where items were added
    int addCount = 0;  //Number of items added    public ArrayListTransferHandler() {
        try {
            localArrayListFlavor = new DataFlavor(localArrayListType);
        } catch (ClassNotFoundException e) {
            System.out.println(
             "ArrayListTransferHandler: unable to create data flavor");
        }
        serialArrayListFlavor = new DataFlavor(ArrayList.class,
                                              "ArrayList");
    }    public boolean importData(JComponent c, Transferable t) {
        JList target = null;
        ArrayList alist = null;
        if (!canImport(c, t.getTransferDataFlavors())) {
            return false;
        }
        try {
            target = (JList)c;
            if (hasLocalArrayListFlavor(t.getTransferDataFlavors())) {
                alist = (ArrayList)t.getTransferData(localArrayListFlavor);
            } else if (hasSerialArrayListFlavor(t.getTransferDataFlavors())) {
                alist = (ArrayList)t.getTransferData(serialArrayListFlavor);
            } else {
                return false;
            }
        } catch (UnsupportedFlavorException ufe) {
            System.out.println("importData: unsupported data flavor");
            return false;
        } catch (IOException ioe) {
            System.out.println("importData: I/O exception");
            return false;
        }        //At this point we use the same code to retrieve the data
        //locally or serially.        //We'll drop at the current selected index.
        int index = target.getSelectedIndex();        //Prevent the user from dropping data back on itself.
        //For example, if the user is moving items #4,#5,#6 and #7 and
        //attempts to insert the items after item #5, this would
        //be problematic when removing the original items.
        //This is interpreted as dropping the same data on itself
        //and has no effect.
        if (source.equals(target)) {
            if (indices != null && index >= indices[0] - 1 &&
                  index <= indices[indices.length - 1]) {
                indices = null;
                return true;
            }
        }        DefaultListModel listModel = (DefaultListModel)target.getModel();
        int max = listModel.getSize();
        if (index < 0) {
            index = max; 
        } else {
            index++;
            if (index > max) {
                index = max;
            }
        }
        addIndex = index;
        addCount = alist.size();
        for (int i=0; i < alist.size(); i++) {
            listModel.add(index++, alist.get(i));
        }
        return true;
    }    protected void exportDone(JComponent c, Transferable data, int action) {
        if ((action == MOVE) && (indices != null)) {
            DefaultListModel model = (DefaultListModel)source.getModel();            //If we are moving items around in the same list, we
            //need to adjust the indices accordingly since those
            //after the insertion point have moved.
            if (addCount > 0) {
                for (int i = 0; i < indices.length; i++) {
                    if (indices[i] > addIndex) {
                        indices[i] += addCount;
                    }
                }
            }
            for (int i = indices.length -1; i >= 0; i--)
                model.remove(indices[i]);
        }
        indices = null;
        addIndex = -1;
        addCount = 0;
    }    private boolean hasLocalArrayListFlavor(DataFlavor[] flavors) {
        if (localArrayListFlavor == null) {
            return false;
        }        for (int i = 0; i < flavors.length; i++) {
            if (flavors[i].equals(localArrayListFlavor)) {
                return true;
            }
        }
        return false;
    }    private boolean hasSerialArrayListFlavor(DataFlavor[] flavors) {
        if (serialArrayListFlavor == null) {
            return false;
        }        for (int i = 0; i < flavors.length; i++) {
            if (flavors[i].equals(serialArrayListFlavor)) {
                return true;
            }
        }
        return false;
    }    public boolean canImport(JComponent c, DataFlavor[] flavors) {
        if (hasLocalArrayListFlavor(flavors))  { return true; }
        if (hasSerialArrayListFlavor(flavors)) { return true; }
        return false;
    }    protected Transferable createTransferable(JComponent c) {
        if (c instanceof JList) {
            source = (JList)c;
            indices = source.getSelectedIndices();
            Object[] values = source.getSelectedValues();
            if (values == null || values.length == 0) {
                return null;
            }
            ArrayList alist = new ArrayList(values.length);
            for (int i = 0; i < values.length; i++) {
                Object o = values[i];
                String str = o.toString();
                if (str == null) str = "";
                alist.add(str);
            }
            return new ArrayListTransferable(alist);
        }
        return null;
    }    public int getSourceActions(JComponent c) {
        return COPY_OR_MOVE;
    }    public class ArrayListTransferable implements Transferable {
        ArrayList data;        public ArrayListTransferable(ArrayList alist) {
            data = alist;
        }        public Object getTransferData(DataFlavor flavor)
                                 throws UnsupportedFlavorException {
            if (!isDataFlavorSupported(flavor)) {
                throw new UnsupportedFlavorException(flavor);
            }
            return data;
        }        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[] { localArrayListFlavor,
                                      serialArrayListFlavor };
        }        public boolean isDataFlavorSupported(DataFlavor flavor) {
            if (localArrayListFlavor.equals(flavor)) {
                return true;
            }
            if (serialArrayListFlavor.equals(flavor)) {
                return true;
            }
            return false;
        }
    }
}

Answer 3

这个两个List控件之间的拖动。不知道是否对你有帮助

Answer 4

xuzhenqinandy 
  这两个例子我都有,可是没有整明白原理,所以没法应用到我项目中去解决问题!!!
   谢谢了,嗯,还是要好好思考一下!!!

Answer 5

我觉得这个还是比较有意思，自己试这写了个
package test.trans;import java.awt.Point;
import java.awt.datatransfer.Transferable;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.TransferHandler;
import javax.swing.event.MouseInputAdapter;/**
 * 
 * @author QiznZf
 *
 */
public class DragTransferHelper { private Map<Integer, DraggedComponent> comps = new HashMap<Integer, DraggedComponent>(); // public void registeDragAdapter(JComponent source,JComponent target){
// this.registeDragAdapter(source, target, null);
// } public void registeDragAdapter(JComponent source, JComponent target,
DragHandler handler) { if (source == null) {
return;
}
int hashCode = source.hashCode();
if (comps.get(hashCode) == null) {
MouseDragInputListener ml = new MouseDragInputListener();
source.addMouseListener(ml);
source.addMouseMotionListener(ml);
comps.put(hashCode, new DraggedComponent(source, handler));
}
comps.get(hashCode).registOneTarget(target);
} public void unregisteDragAdapter(JComponent comp) {
DraggedComponent dc = comps.remove(comp.hashCode());
if (dc != null) {
dc.src.removeMouseListener(dc.lis);
dc.src.removeMouseMotionListener(dc.lis);
dc.targets.clear();
dc.targets = null;
}
} private class DraggedComponent {
JComponent src;
MouseDragInputListener lis;
DragHandler handler;
List<JComponent> targets = new Vector<JComponent>(); DraggedComponent(JComponent src, DragHandler handler) {
this.src = src;
this.handler = handler;
} protected void registOneTarget(JComponent comp) {
if (comp != null && !this.targets.contains(comp)) {
this.targets.add(comp);
}
}
} private class MouseDragInputListener extends MouseInputAdapter { boolean isDrag = false; @Override
public void mousePressed(MouseEvent e) {
isDrag = false;
} @Override
public void mouseDragged(MouseEvent e) {
if (!isDrag && SwingUtilities.isLeftMouseButton(e)) {
int code = e.getSource().hashCode();
DraggedComponent dc = comps.get(code);
if (dc != null) {
                    dc.handler.beginDrag(dc.src, e);
}
isDrag = true;
}
} @Override
public void mouseReleased(MouseEvent e) {
if (isDrag && SwingUtilities.isLeftMouseButton(e)) {
int code = e.getSource().hashCode();
DraggedComponent dc = comps.get(code);
if (dc != null) {
for (JComponent comp : dc.targets) {
Point p = SwingUtilities.convertPoint(dc.src, e.getX(),
e.getY(), comp);
if (comp.contains(p)) {
if (dc.handler != null) {
dc.handler.onDragFisinsh(dc.src, SwingUtilities
.convertMouseEvent(dc.src, e, comp),
comp);
} else if (comp instanceof Transferable) {
Transferable t = (Transferable) comp;
TransferHandler th = comp.getTransferHandler();
if (th.canImport(dc.src, t
.getTransferDataFlavors())) {
th.importData(dc.src, (Transferable) comp);
}
}
break;
}
}
                dc.handler.endDrag(dc.src, e);
}
}
isDrag = false;
} } public interface DragHandler {
public void beginDrag(JComponent source, MouseEvent e); public void endDrag(JComponent source, MouseEvent e); public void onDragFisinsh(JComponent source, MouseEvent e,
JComponent target);
}
}
package test.trans;import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.MouseEvent;import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;import test.trans.DragTransferHelper.DragHandler;/**
 * 
 * @author QiznZf
 *
 */
public class TestTrans { public static void main(String[] args) {
TestTrans tt = new TestTrans();
JFrame f = tt.createFrame();
f.setVisible(true); } private DragTransferHelper dth = new DragTransferHelper(); private JFrame createFrame() {
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel p = new JPanel();
p.setLayout(new GridLayout(2, 1));
JComponent left = this.leftComp();
JComponent right = this.rightComp(); DragHandler handler = new DragHandler() { public void onDragFisinsh(JComponent source, MouseEvent e,
JComponent target) {
if (target instanceof JLabel && source instanceof JLabel) {
JLabel t = (JLabel) target;
JLabel s = (JLabel) source;
String ttext = t.getText();
t.setText(s.getText());
s.setText(ttext);
} else {
if (target instanceof JTree && source instanceof JLabel) {
JTree tree = (JTree) target;
JLabel s = (JLabel) source;
String text=s.getText();
TreePath path = tree.getPathForLocation(e.getX(), e
.getY());
if (path != null&&text.trim().length()>0) {
Object ob = path.getLastPathComponent();
TreeModel model = tree.getModel();
if (ob instanceof DefaultMutableTreeNode
&& model instanceof DefaultTreeModel) {
DefaultTreeModel dModel = (DefaultTreeModel) model;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) ob;
DefaultMutableTreeNode cNode=new DefaultMutableTreeNode(text);
node.add(cNode);
s.setText("");
dModel.nodeStructureChanged(node);
}
}
}
if (source instanceof JTree && target instanceof JLabel) {
JTree tree = (JTree) source;
JLabel s = (JLabel) target;
Object ob = tree.getSelectionPath()
.getLastPathComponent();
TreeModel model = tree.getModel();
if (ob instanceof DefaultMutableTreeNode
&& model instanceof DefaultTreeModel) {
DefaultTreeModel dModel = (DefaultTreeModel) model;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) ob;
if (node.isLeaf()) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node
.getParent();
parent.remove(node);
s.setText(node.getUserObject().toString());
dModel.nodeStructureChanged(parent);
}
}
}
}
} public void beginDrag(JComponent source, MouseEvent e) {
} public void endDrag(JComponent source, MouseEvent e) {
}
}; p.add(left);
p.add(right);
JTree tree = new JTree();
JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
new JScrollPane(tree), p);
f.add(sp); dth.registeDragAdapter(left, right, handler);
dth.registeDragAdapter(right, left, handler);
dth.registeDragAdapter(left, tree, handler);
dth.registeDragAdapter(tree, left, handler); f.pack();
return f;
} private JComponent leftComp() {
JLabel l = new JLabel("left");
l.setBorder(BorderFactory.createLineBorder(Color.RED));
return l;
} private JComponent rightComp() {
JLabel l = new JLabel("right");
l.setBorder(BorderFactory.createLineBorder(Color.RED));
return l;
}}