JTable Drag and Drop von mehreren Zellen

[pyr0t0n]

Hallo zusammen,

ich muss in einem JTable einen Drag and Drop von mehreren Zellen bewerkstelligen.
Drag and Drop für eine Zelle habe ich über einen Table Handler und Überschreiben der Methoden

protected Transferable createTransferable(JComponent c)

und

 public boolean importData(JComponent comp, Transferable t)

bereits hinbekommen, ich kann zwar in der Funktion createTransferable meine makierten Zellen auslesen aber diese ja dann nicht an importData übergeben da ich kein Array von Transferable Objekten dahin übertragen kann.

Wie kann ich das ganze nun Lösen?

Danke schonmal für eure Hilfe.

 

[miffi]

Howdie.

Für solche Sachen bieten sich eigene Transfer-Objekte an, dann bist du flexibel damit, was genau du per DnD verschiebst. Vermutlich hast du das Transferable-Interface momentan bei den Objekten in der Tabelle implementiert. Das lässt sich dann auf eine einzige Klasse beschränken. Hier ein Beispiel:

public class TestTransfer implements Transferable{

	private DataFlavor[]   dataFlavors = new DataFlavor[]{new TestFlavor()};
	private ArrayList<TestObject>  testObjectList = null;
	
	public TestTransfer(ArrayList<TestObject> testObjectList){
		this.testObjectList = testObjectList;
	}
	
	public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
		return this.testObjectList;
	}

	public boolean isDataFlavorSupported(DataFlavor flavor){
		for (DataFlavor dataFlavor : this.dataFlavors) {
			if(dataFlavor.equals(flavor)){
				return true;
			}
		}
		return false;
	}

	public DataFlavor[] getTransferDataFlavors() {
		return this.dataFlavors;
	}
}

Dann kannst du im Transferhandler einfach ein solches Transfer-Objekt mit gesammelten Tabellen-Einträgen zusammenschieben:

protected Transferable createTransferable(JComponent c) {
		ArrayList<TestObject> toList = new ArrayList<TestObject>();
		int[] selectedRows = this.myTable.getSelectedRows();
		for (int i : selectedRows) {
			Object selectedObject = this.myTable.getValueAt(i, 0);
			if (selectedObject instanceof TestObject) {
				toList.add((TestObject)selectedObject);
			}
		}
		return new TestTransfer(toList);
	}

Gruß
miffi

 

[pyr0t0n]

Hallo,

ja so ähnlich habe ich das ja, also ich habe einen Transfer Handler bzw. eine Klasse die von TransferHandler extended wird.

Hier mal die Klasse.

public class TableHandler extends TransferHandler
{
  JTable  myTable;
  int row_old = 0;
  int col_old = 0;
  
  public TableHandler(JTable table)
  {
    myTable = table;
    myTable.setTransferHandler(this);
    myTable.setDragEnabled(true);
  }

    @Override
  public boolean canImport(JComponent comp, DataFlavor[] transferFlavors)
  {
    if (myTable != comp) return false;
    // eventuell DataFlavor noch prüfen
    return true;
  }

    @Override
  protected Transferable createTransferable(JComponent c)
  {
    if (c == myTable)
    {
      int row = myTable.getSelectedRow();
      int col = myTable.getSelectedColumn();
      row_old = row;
      col_old = col;
      Object value = myTable.getModel().getValueAt(row, col);
      return new TransferableObject(value);
    }
    else
    {
      return super.createTransferable(c);
    }
  }

    @Override
  public boolean importData(JComponent comp, Transferable t)
  {
    if (comp == myTable)
    {
      try
      {
        Object value = t.getTransferData(TransferableObject.FLAVOR);
        int row = myTable.getSelectedRow();
        int col = myTable.getSelectedColumn();
        myTable.getModel().setValueAt(value,row, col);
        Event ev = (Event)myTable.getModel().getValueAt(row, col);
        if(ev.getDauerTage() > 1) {
            for(int i = 1; i < ev.getDauerTage(); i++) {
                myTable.getModel().setValueAt(myTable.getModel().getValueAt(row_old, col_old + i), row, col + i);
                myTable.getModel().setValueAt(null, row_old, col_old + i);
            }
        }
        ev.setRow(row);
        myTable.getModel().setValueAt(null, row_old, col_old);
        return true;
      }
      catch (Exception e)
      {
      }
    }
    return super.importData(comp, t);
  }

    @Override
  public int getSourceActions(JComponent c)
  {
    if (myTable == c) return DnDConstants.ACTION_MOVE;
    else return super.getSourceActions(c);
  }

}

Und überschreibe da ja die beiden oben genannten Methoden.
Doch wenn ich diese ändere das Array zurückgegeben und übergeben werden kann ich ja nicht mehr hingehen und die Original Methode des TransferHandlers überschreiben.

Ich hoffe du verstehst meine Problematik, wobei ich mittlerweile fast glaube das es da einen einfacheren Weg gibt.