Objekt kopieren

[profiler84]

Hallo,

Ich möchte ein Objekt von einem Frame in den anderen kopieren, zurzeit wird er nur ausgeschnitten.
Hat jemand einen vorschlag? Dies wird zurzeit mit folgendem Code realisiert:

package Draganddrop;

import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import javax.swing.*;

import Draganddrop.ChooseDropActionDemo.ToTransferHandler;
import Draganddrop.IconDnD.DragMouseAdapter;

import java.awt.event.*;
public class DragDrop implements DragGestureListener, 
DragSourceListener,
        DropTargetListener, Transferable {

    static final DataFlavor[] supportedFlavors = {null};
    

    static {
        try {
            supportedFlavors[0] = new 
            DataFlavor(DataFlavor.javaJVMLocalObjectMimeType);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    Object object;
    // Transferable methods.
    public Object getTransferData(DataFlavor flavor) {
        if (flavor.isMimeTypeEqual
            (DataFlavor.javaJVMLocalObjectMimeType)) {
            return object;
        } else {
            return null;
        }
    }

    public DataFlavor[] getTransferDataFlavors() {
        return supportedFlavors;
    }

    public boolean isDataFlavorSupported(DataFlavor flavor) {
        return flavor.isMimeTypeEqual
        (DataFlavor.javaJVMLocalObjectMimeType);
    }
    // DragGestureListener method.
    public void dragGestureRecognized(DragGestureEvent ev) {
        ev.startDrag(DragSource.DefaultCopyDrop, this, this);
    }
    // DragSourceListener methods.
    public void dragDropEnd(DragSourceDropEvent ev) {
    }

    public void dragEnter(DragSourceDragEvent ev) {
    }

    public void dragExit(DragSourceEvent ev) {
    }

    public void dragOver(DragSourceDragEvent ev) {
        object = ev.getSource();
    }

    public void dropActionChanged(DragSourceDragEvent ev) {
    }
    // DropTargetListener methods.
    public void dragEnter(DropTargetDragEvent ev) {
    }

    public void dragExit(DropTargetEvent ev) {
    }

    public void dragOver(DropTargetDragEvent ev) {
        dropTargetDrag(ev);
    }

    public void dropActionChanged(DropTargetDragEvent ev) {
        dropTargetDrag(ev);
    }

    void dropTargetDrag(DropTargetDragEvent ev) {
        ev.acceptDrag(ev.getDropAction());
    }

    public void drop(DropTargetDropEvent ev) {
    	 if (((ev.getDropAction() & DnDConstants.ACTION_COPY) == 0))
    		     {
    		         ev.rejectDrop();
    		         System.out.println(DnDConstants.ACTION_COPY);
    		         System.out.println(ev.getDropAction());
    		         System.out.println(ev.isDataFlavorSupported(DataFlavor.stringFlavor));
    		         return;
    		     }

        try {
        	ev.acceptDrop(DnDConstants.ACTION_COPY);
            Transferable tr = ev.getTransferable();
            //String s = (String) tr.getTransferData(DataFlavor.stringFlavor);      

            //System.out.println("####"+s);
            Object target = ev.getSource();
            Object source = ev.getTransferable().getTransferData
                            (supportedFlavors[0]);
            Component component = ((DragSourceContext) 
                                    source).getComponent();
            Container oldContainer = component.getParent();
            Container container = (Container) ((DropTarget) 
                                   target).getComponent();
            //System.out.println(oldContainer.getComponentCount());
            container.add(component);
            //System.out.println(oldContainer.getComponentCount()); //add(component);
  
            oldContainer.validate();
            oldContainer.repaint();
            container.validate();
            container.repaint();
        } 
        catch (Exception ex) {
            ex.printStackTrace();
        }
        ev.dropComplete(true);
    }

    public static void main(String[] arg) {
        JButton button = new JButton("Drag this button");

        JFrame source = new JFrame("Source Frame");
        source.setLayout(new FlowLayout());
        source.add(button);

        //button.setTransferHandler(new ToTransferHandler(TransferHandler.COPY));
        JFrame target = new JFrame("Target Frame");
        target.setLayout(new FlowLayout());

        DragDrop dndListener = new DragDrop();
        //button.setTransferHandler(TransferHandler.COPY));
        
        DragSource dragSource = new DragSource();
        DropTarget dropTarget1 = new DropTarget(source, 
        DnDConstants.ACTION_COPY, dndListener);
        DropTarget dropTarget2 = new DropTarget(target, 
        DnDConstants.ACTION_COPY, 
                dndListener);
        DragGestureRecognizer dragRecognizer1 = dragSource.
                createDefaultDragGestureRecognizer(button, 
                DnDConstants.ACTION_COPY, dndListener);

        source.setBounds(0, 200, 200, 200);
        target.setBounds(220, 200, 200, 200);
        source.pack();
        source.setVisible(true);
        target.pack();
        target.setVisible(true);
        
        
    }

    
  public class ToTransferHandler extends TransferHandler {
        int action;
        
        public ToTransferHandler(int action) {
            this.action = action;
        }
        
        public boolean canImport(TransferHandler.TransferSupport support) {
            // for the demo, we'll only support drops (not clipboard paste)
            if (!support.isDrop()) {
                return false;
            }

            // we only import Strings
            if (!support.isDataFlavorSupported(DataFlavor.stringFlavor)) {
                return false;
            }

            boolean actionSupported = (action & support.getSourceDropActions()) == action;
            if (actionSupported) {
                support.setDropAction(action);
                return true;
            }

            return false;
        }

        public boolean importData(TransferHandler.TransferSupport support) {
            // if we can't handle the import, say so
            if (!canImport(support)) {
                return false;
            }

            // fetch the drop location
            JList.DropLocation dl = (JList.DropLocation)support.getDropLocation();

            int index = dl.getIndex();

            // fetch the data and bail if this fails
            String data;
            try {
                data = (String)support.getTransferable().getTransferData(DataFlavor.stringFlavor);
            } catch (UnsupportedFlavorException e) {
                return false;
            } catch (java.io.IOException e) {
                return false;
            }

            JList list = (JList)support.getComponent();
            DefaultListModel model = (DefaultListModel)list.getModel();
            model.insertElementAt(data, index);

            Rectangle rect = list.getCellBounds(index, index);
            list.scrollRectToVisible(rect);
            list.setSelectedIndex(index);
            list.requestFocusInWindow();

            return true;
        }  
    }
}

 

[Marco13]

Eine GUI-Component zu kopieren ist grundsätzlich schwierig. IMHO ist es in letzter Konsequenz sogar unmöglich: Soll man die Listener mitkopieren? Was, wenn der Listener ein JFrame ist? Der eine Datenbankanbindung enthält? Oder irgendeine gespeicherte Instanz von einem Singleton? :autsch:

Es gibt Ansätze, um sowas zu realisieren (hier im Forum gibt es da ein paar Versuche mit Reflection, Serialization & Co), aber die haben alle ihre Grenzen. Du kannst diese Ansätze ausprobieren, oder versuchen, das, was du vorhast, anders zu erreichen als über eine Kopie einer Component (und ich würde dir zu letzterem raten...)

 

[profiler84]

Vielen Dank für den Rat, ich werde mal bisschen experimentieren