# mehrfachauswahl



## Guest (13. Jul 2005)

Hi, 
ich möchte mehrere selektierte Objekte gleichzietig per Darg and Drop verschieben.

Meine Dragsource bzw mein Droptarget sind sowohl ein JTree und eine JList.
Mit multipleSelection funktionierts nichts, denn sobald ich den cursor dragge wird nur das eine Element genommen wo sich der Cursor grad befindet!

Außerdem schaff ichs nicht, wenn die JList die Dragsource ist, beim Draggen das Object anzuzeigen, welches grad verschoben wird.

Irgend ne Idee?


----------



## mic_checker (13. Jul 2005)

Du willst was aus ner JList auswählen und in nen JTree verschieben oder wie soll ich das verstehen ? 

Hast du schon Code ? Falls ja poste mal.


----------



## Guest (13. Jul 2005)

ich will von ner liste in einen baum verschieben und auch umgekehrt.


```
public abstract class DndListTransferHandler implements DropTargetListener,
        DragSourceListener, DragGestureListener {

    /**
     * importiert das DropTarget
     */
    protected DropTarget dropTarget;

    /**
     * importiert die DragSource
     */
    protected DragSource dragSource;

    /**
     * Konstruktor
     * 
     * @param list
     */
    public DndListTransferHandler(DndList list) {
        dropTarget = new DropTarget(list, this);
        dragSource = new DragSource();
        dragSource.createDefaultDragGestureRecognizer(list,
                DnDConstants.ACTION_MOVE, this);
    }

    /**
     * erstellt transferable je nachdem was selektiert ist 
     * ist nichts selektiert wird null zurück geliefert
     * 
     * @return node Drag-Objekt
     */
    protected abstract Transferable getTransferable();

    /**
     * Erledigt das Löschen der Komponente nach dem Drag
     * 
     * @param event
     * @throws Exception
     */
    protected abstract void handleDrag(DragSourceDropEvent event)
            throws Exception;

    /**
     * Erledigt das Droppen der Komponente nach dem Drag
     * 
     * @param transferable
     * @param event
     * @throws Exception
     */
    protected abstract void handleDrop(Transferable transferable,
            DropTargetDropEvent event) throws Exception;

    /**
     * holt sich die unterstützten Transferitems
     * 
     * @return SupportedDataFlavors
     */
    protected abstract DataFlavor[] getSupportedDataFlavors();

    /**
     * gibt zurück ob eine Transfer möglich ist
     * 
     * @param t
     * @return true, false
     */
    private boolean isTransferableSupported(Transferable t) {
        DataFlavor[] flavors = getSupportedDataFlavors();
        for (int i = 0; i < flavors.length; i++) {
            if (t.isDataFlavorSupported(flavors[i]))
                return true;
        }
        return false;
    }

    /**
     * wird aufgerufen, wenn der Benutzer bei gedrückter Maustaste den
     * Mauszeiger bewegt
     * 
     * @param event
     *  
     */
    public void dragGestureRecognized(DragGestureEvent event) {

        Transferable trans = getTransferable();
        Cursor dragIcon = getDragCursor(event);

        if (trans != null) {
            dragSource.startDrag(event, dragIcon, trans, this);
        } else {
            System.out.println("nichts selektiert");
        }
    }

    /**
     * wird aufgerufen, wenn die Maustaste losgelassen (Drop) wird
     * 
     * @param event
     *  
     */
    public void drop(DropTargetDropEvent event) {

        try {
            Transferable transferable = event.getTransferable();

            if (isTransferableSupported(transferable)) {
                event.acceptDrop(event.getDropAction());
                handleDrop(transferable, event);
                event.getDropTargetContext().dropComplete(true);

            } else {
                event.rejectDrop();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Drop Exception" + e.getMessage());
            event.rejectDrop();
        }

    }

    /**
     * wird aufgerufen, wenn von außen ein hinübergezogenes Objekt die
     * Komponente erreicht
     * 
     * @param event
     */
    public void dragEnter(DropTargetDragEvent event) {
        int action = event.getDropAction();
        event.acceptDrag(action);
    }

    /**
     * wird aufgerufen, wenn der gedrückte Mauszeiger die Komponente verlässt
     * 
     * @param event
     */
    public void dragExit(DropTargetEvent event) {
    }

    /**
     * wird aufgerufen, wenn die gedrückte Maus über die Komponente gezogen wird
     * 
     * @param event
     */
    public void dragOver(DropTargetDragEvent event) {
    }

    /**
     * wird aufgerufen wenn die gewünschte Aktion (Kopieren, Verschieben oder
     * Verknüpfen) geändert wurde
     * 
     * @param event
     */
    public void dropActionChanged(DropTargetDragEvent event) {
    }

    /**
     * liefert den Cursor zum Starten des Dargvorgangs
     * 
     * @param event
     * @return CURSOR
     */
    protected Cursor getDragCursor(DragGestureEvent event) {
        if (event.getDragAction() == DnDConstants.ACTION_MOVE) {
            return DragSource.DefaultMoveDrop;
        }
        if (event.getDragAction() == DnDConstants.ACTION_COPY_OR_MOVE) {
            return DragSource.DefaultCopyDrop;
        } else {
            return Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
        }
    }

    /**
     * wird aufgerufen wenn ein Drag & Drop beendet wurde
     * 
     * @param event
     *  
     */
    public void dragDropEnd(DragSourceDropEvent event) {
        if (event.getDropSuccess()) {
            try {
                handleDrag(event);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * wird aufgerufen, wenn von außen ein hinübergezogenes Objekt die
     * Komponente erreicht
     * 
     * @param dsde
     */
    public void dragEnter(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

    /**
     * wird aufgerufen, wenn der gedrückte Mauszeiger die Komponente verlässt
     * 
     * @param dse
     */
    public void dragExit(DragSourceEvent dse) {
        dse.getDragSourceContext().setCursor(DragSource.DefaultMoveNoDrop);
    }

    /**
     * 
     * wird aufgerufen, wenn die gedrückte Maus über die Komponente gezogen wird
     * 
     * @param dsde
     */
    public void dragOver(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

    /**
     * wird aufgerufen wenn die gewünschte Aktion (Kopieren, Verschieben oder
     * Verknüpfen) geändert wurde
     * 
     * @param dsde
     */
    public void dropActionChanged(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

}
```


```
public class DndTreeTransferHandler implements DragGestureListener,
        DragSourceListener, DropTargetListener {

    /**
     * importiert DndTree
     */
    private DndTree tree;

    /**
     * importiert die DragSource
     */
    private DragSource dragSource;

    /**
     * importiert das DropTarget
     */
    private DropTarget dropTarget;

    /**
     * draggedNode
     */
    private static VDM_TreeNode draggedNode;

    /**
     * draggedNodeParrent
     */
    private VDM_TreeNode draggedNodeParent;

    /**
     * image
     */
    private static BufferedImage image = null;

    /**
     * Rectangle
     */
    private Rectangle rect2D = new Rectangle();

    /**
     * drawImage
     */
    private boolean drawImage;

    /**
     * Konstruktor
     * 
     * @param tree
     * @param action
     * @param drawIcon
     */
    protected DndTreeTransferHandler(DndTree tree, int action, boolean drawIcon) {
        this.tree = tree;
        drawImage = drawIcon;
        dragSource = new DragSource();
        dragSource.createDefaultDragGestureRecognizer(tree, action, this);
        dropTarget = new DropTarget(tree, action, this);
    }

    /**
     * wird aufgerufen wenn ein Drag & Drop beendet wurde
     * 
     * @param dsde
     *  
     */
    public void dragDropEnd(DragSourceDropEvent dsde) {

        if (dsde.getDropSuccess()
                && dsde.getDropAction() == DnDConstants.ACTION_MOVE) {
            ((DefaultTreeModel) tree.getModel())
                    .nodeStructureChanged(draggedNodeParent);
            tree.expandPath(new TreePath(draggedNodeParent.getPath()));
        }
    }

    /**
     * wird aufgerufen, wenn von außen ein hinübergezogenes Objekt die
     * Komponente erreicht
     * 
     * @param dsde
     */
    public final void dragEnter(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

    /**
     * 
     * wird aufgerufen, wenn die gedrückte Maus über die Komponente gezogen wird
     * 
     * @param dsde
     */
    public final void dragOver(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

    /**
     * wird aufgerufen wenn die gewünschte Aktion (Kopieren, Verschieben oder
     * Verknüpfen) geändert wurde
     * 
     * @param dsde
     */
    public final void dropActionChanged(DragSourceDragEvent dsde) {
        int action = dsde.getDropAction();
        if (action == DnDConstants.ACTION_COPY) {
            dsde.getDragSourceContext().setCursor(DragSource.DefaultCopyDrop);
        } else {
            if (action == DnDConstants.ACTION_MOVE) {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveDrop);
            } else {
                dsde.getDragSourceContext().setCursor(
                        DragSource.DefaultMoveNoDrop);
            }
        }
    }

    /**
     * wird aufgerufen, wenn der gedrückte Mauszeiger die Komponente verlässt
     * 
     * @param dse
     */
    public final void dragExit(DragSourceEvent dse) {
        dse.getDragSourceContext().setCursor(DragSource.DefaultMoveNoDrop);
    }

    /**
     * wird aufgerufen, wenn der Benutzer bei gedrückter Maustaste den
     * Mauszeiger bewegt
     * 
     * @param dge
     *  
     */
    public final void dragGestureRecognized(DragGestureEvent dge) {
        TreePath path = tree.getSelectionPath();
        if (path != null) {
            draggedNode = (VDM_TreeNode) path.getLastPathComponent();
            draggedNodeParent = (VDM_TreeNode) draggedNode.getParent();
            if (drawImage) {
                Rectangle pathBounds = tree.getPathBounds(path);
                JComponent lbl = (JComponent) tree.getCellRenderer()
                        .getTreeCellRendererComponent(
                                tree,
                                draggedNode,
                                false,
                                tree.isExpanded(path),
                                ((DefaultTreeModel) tree.getModel())
                                        .isLeaf(path.getLastPathComponent()),
                                0, false);
                lbl.setBounds(pathBounds);
                image = new BufferedImage(lbl.getWidth(), lbl.getHeight(),
                        java.awt.image.BufferedImage.TYPE_INT_ARGB_PRE);
                Graphics2D graphics = image.createGraphics();
                graphics.setComposite(AlphaComposite.getInstance(
                        AlphaComposite.SRC_OVER, 0.5f));

                lbl.setOpaque(false);
                lbl.paint(graphics);
                graphics.dispose();
            }
            if (!draggedNode.isRoot()) {
                dragSource.startDrag(dge, DragSource.DefaultMoveDrop, image,
                        new Point(0, 0), new TransferableNode(draggedNode),
                        this);
            }
        }
    }

    /**
     * wird aufgerufen, wenn von außen ein hinübergezogenes Objekt die
     * Komponente erreicht
     * 
     * @param dtde
     */
    public final void dragEnter(DropTargetDragEvent dtde) {
        Point pt = dtde.getLocation();
        int action = dtde.getDropAction();
        if (drawImage) {
            paintImage(pt);
        }
        if (canPerformAction(tree, draggedNode, action, pt)) {
            dtde.acceptDrag(action);
        } else {
            dtde.rejectDrag();
        }
    }

    /**
     * wird aufgerufen, wenn der gedrückte Mauszeiger die Komponente verlässt
     * 
     * @param dte
     */
    public final void dragExit(DropTargetEvent dte) {
        if (drawImage) {
            clearImage();
        }
    }

    /**
     * wird aufgerufen, wenn die gedrückte Maus über die Komponente gezogen wird
     * 
     * @param dtde
     */
    public final void dragOver(DropTargetDragEvent dtde) {
        Point pt = dtde.getLocation();
        int action = dtde.getDropAction();
        if (drawImage) {
            paintImage(pt);
        }
        if (canPerformAction(tree, draggedNode, action, pt)) {
            dtde.acceptDrag(action);
        } else {
            dtde.rejectDrag();
        }
    }

    /**
     * wird aufgerufen wenn die gewünschte Aktion (Kopieren, Verschieben oder
     * Verknüpfen) geändert wurde
     * 
     * @param dtde
     */
    public final void dropActionChanged(DropTargetDragEvent dtde) {
        Point pt = dtde.getLocation();
        int action = dtde.getDropAction();
        if (drawImage) {
            paintImage(pt);
        }
        if (canPerformAction(tree, draggedNode, action, pt)) {
            dtde.acceptDrag(action);
        } else {
            dtde.rejectDrag();
        }
    }

    /**
     * wird aufgerufen, wenn die Maustaste losgelassen (Drop) wird
     * 
     * @param dtde
     *  
     */
    public final void drop(DropTargetDropEvent dtde) {
        try {
            if (drawImage) {
                clearImage();
            }
            int action = dtde.getDropAction();
            Transferable transferable = dtde.getTransferable();
            Point pt = dtde.getLocation();
            if (transferable
                    .isDataFlavorSupported(TransferableNode.NODE_FLAVOR)
                    && canPerformAction(tree, draggedNode, action, pt)) {
                TreePath pathTarget = tree
                        .getClosestPathForLocation(pt.x, pt.y);
                VDM_TreeNode node = (VDM_TreeNode) transferable
                        .getTransferData(TransferableNode.NODE_FLAVOR);
                VDM_TreeNode newParentNode = (VDM_TreeNode) pathTarget
                        .getLastPathComponent();

                if (executeDrop(tree, node, newParentNode, action)) {
                    dtde.acceptDrop(DnDConstants.ACTION_MOVE);
                    dtde.getDropTargetContext().dropComplete(true);
                    return;
                }
            }
            dtde.rejectDrop();
            dtde.dropComplete(false);
        } catch (Exception e) {
            System.out.println(e);
            dtde.rejectDrop();
            dtde.dropComplete(false);
        }
    }

    /**
     * zeichnet das Image
     * 
     * @param pt
     */
    private final void paintImage(Point pt) {
        tree.paintImmediately(rect2D.getBounds());
        rect2D.setRect((int) pt.getX(), (int) pt.getY(), image.getWidth(),
                image.getHeight());
        tree.getGraphics().drawImage(image, (int) pt.getX(), (int) pt.getY(),
                tree);
    }

    /**
     * löscht das Image
     * 
     *  
     */
    private final void clearImage() {
        tree.paintImmediately(rect2D.getBounds());
    }

    /**
     * liefert zurück ob Drag & Drop möglich ist
     * 
     * @param target
     * @param draggedNode
     * @param action
     * @param location
     * @return true, false
     */
    public boolean canPerformAction(DndTree target, VDM_TreeNode draggedNode,
            int action, Point location) {
        TreePath pathTarget = target.getPathForLocation(location.x, location.y);
        if (pathTarget == null) {
            target.setSelectionPath(null);
            return (false);
        } else if (action == DnDConstants.ACTION_MOVE) {
            VDM_TreeNode parentNode = (VDM_TreeNode) pathTarget
                    .getLastPathComponent();
            if (parentNode == draggedNode.getParent()) {
                return (false);
            } else {
                return (true);
            }
        } else {
            return (false);
        }
    }

    /**
     * setzt die darggedNode an eine neue Position
     * 
     * @param target
     * @param draggedNode
     * @param newParentNode
     * @param action
     * @return true, false
     */
    public boolean executeDrop(DndTree target, VDM_TreeNode draggedNode,
            VDM_TreeNode newParentNode, int action) {
        if (action == DnDConstants.ACTION_MOVE) {
            ((DefaultTreeModel) target.getModel()).insertNodeInto(draggedNode,
                    newParentNode, newParentNode.getChildCount());
            TreePath treePath = new TreePath(draggedNode.getPath());
            target.scrollPathToVisible(treePath);
            target.setSelectionPath(treePath);
            return (true);
        }
        return (false);
    }
}
```


----------



## Guest (13. Jul 2005)

innerhalb des trees zeichnet er auch den gedraggedten knoten
bei der liste krieg ichs net hin

und halt das verschieben von mehreren elementen


----------



## Guest (13. Jul 2005)

Hab ich euch jetzt mit meinen code hier verschreckt?
Ist halt extrem lang um alles zu berücksichtigen.


----------

