Drag Drop

[texerasmo]

Ciao a tutti

Ho una web-application scritta in java-jsp ora devo implentare nella mia applicazione una funzione drag-drop ma non so da dove iniziare potete darmi una mano?

[sottovento]

I package interessati sono essenzialmente java.awt.datatransfer e java.awt.dnd.

Supponiamo che hai un JTree da cui vuoi fare il DRAG. Avrai bisogno di una classe che implementi DragGestureListener, la quale e' preposta ad "ascoltare" i drag e decidere se dare inizio o meno all'operazione in questione.

Farai questa operazione in
void dragGestureRecognized(DragGestureEvent e)

Una volta hai stabilito che quel nodo/item/quello che vuoi puo' essere draggato, chiamerai e.startDrag(), dove e e' l'oggetto DragGestureEvent di cui sopra.

Quando chiami questa procedura, dovrai specificare
- I dati che vuoi trasferire;
- Il loro "flavor". E' qualcosa simile ad il tipo (per esempio, se e' un file, se e' un testo, ecc.).

La procedura di drag avra' quindi inizio. Ovviamente avrai bisogno di implementare anche il drop (qualcuno che sia disposto ad accettare i dati che stai trasportando), ma questo post sta diventando troppo lungo, per cui ne parleremo nel caso ce ne sia bisogno

High Flying
Sottovento

[texerasmo]

stavo vedendo anche webdav
http://www.thethirdbridge.com/doItYourself/index.html

ho fatto come dice nel sito ma non mi funziona

[sottovento]

Originariamente inviato da texerasmo

stavo vedendo anche webdav
http://www.thethirdbridge.com/doItYourself/index.html

ho fatto come dice nel sito ma non mi funziona

Ho guardato il link in questione ma non ho trovato le info di cui parli.
Pensavo che dovessi implementare una soluzione simile in Java...

[texerasmo]

si dovrei fare un cosa del genere.
Stavo vedendo se webdav mi ritorna utile.
Tu che ne pensi?
mi conviene fare un cosa tutta mia?
hai degli esempi...



Per vedere webdav dovevo fare

devo fare da Internet Explorer File-->APRI--->IP:8080 chek cartellaweb e funziona

[sottovento]

Originariamente inviato da texerasmo

si dovrei fare un cosa del genere.
Stavo vedendo se webdav mi ritorna utile.
Tu che ne pensi?
mi conviene fare un cosa tutta mia?
hai degli esempi...



Per vedere webdav dovevo fare

devo fare da Internet Explorer File-->APRI--->IP:8080 chek cartellaweb e funziona

Purtroppo non so cosa sia webdav, per cui non so valutare se ti convenga fare una cosa tua oppure utilizzare questo strumento.

Di esempi su Internet ce ne sono centinaia. Purtroppo, quando si comincia ad affrontare un argomento come questo, e' sempre un po' difficile per cui ti posso aiutare (meglio: ti possiamo, qui nel forum c'e' tanta gente in grado di aiutarti).

Cmq, come avevo accennato, nel caso tu voglia affrontare il problema attraverso l'uso delle classi standard Java, ti conviene fare un passo alla volta: Drag e Drop sono operazioni affrontabili separatamente. Comincia dalla prima.

High Flying
Sottovento

[PGI-Bis]

Neanche a farlo apposta, ho ancora il codice di mini-framework creato per "semplificare" un certo uso del drag-and-drop (mini-mini, è una classe ). Sono 180 linee per cui prima di affligerti con il codice direi di vedere se è attinente al tuo problema.

Quello che ho è un modello per trasferire un certo tipo di oggetti da uno o più componenti AWT/Swing verso uno o più componenti AWT/Swing attraverso il drag and drop. E' applicabile nel caso in cui il client sia un Applet o un'applicazione AWT/Swing, non nel caso di un thin client per applicazioni web. Richiede inoltre Java 5.

Se credi faccia al caso tuo, posso incollare il codice .

[franksisca]

Originariamente inviato da PGI-Bis

Neanche a farlo apposta, ho ancora il codice di mini-framework creato per "semplificare" un certo uso del drag-and-drop (mini-mini, è una classe ). Sono 180 linee per cui prima di affligerti con il codice direi di vedere se è attinente al tuo problema.

Quello che ho è un modello per trasferire un certo tipo di oggetti da uno o più componenti AWT/Swing verso uno o più componenti AWT/Swing attraverso il drag and drop. E' applicabile nel caso in cui il client sia un Applet o un'applicazione AWT/Swing, non nel caso di un thin client per applicazioni web. Richiede inoltre Java 5.

Se credi faccia al caso tuo, posso incollare il codice .

non è che potresti mandarlo anche a me, visto che sono mooolto interessato.

[PGI-Bis]

Lo incollo perchè più o meno è in argomento ma sottolineo che potrebbe non essere quello che serve a texerasmo.

EasyDND

package it.easydnd;

import java.awt.*;
import java.awt.dnd.*;
import java.awt.datatransfer.*;
import java.io.IOException;
import java.util.*;

public class EasyDND<T> extends DropTargetAdapter 
	implements DragGestureListener {
	/* Identifica il genere di dati trasferibili attraverso questo meccanismo */
	private DataFlavor transferFlavor = 
		new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType, null);
		
	/* Collegamento al gestore dei prelevamenti e dei depositi di 
	valori trasferibili */
	private DNDSystem<T> dndSystem;
	
	private EasyDND(DNDSystem<T> d) {
		dndSystem = d;
	}
	
	/** @inheritDoc */
	public void dragGestureRecognized(DragGestureEvent e) {
		T value = dndSystem.dragRequest(e.getComponent(), e.getDragOrigin());
		if(value != null) {
			e.startDrag(DragSource.DefaultMoveDrop, 
				new EasyTransferable(value, e.getComponent()));
		}
	}
	
	/** @inheritDoc */
	public void drop(DropTargetDropEvent e) {
		if(isValidDropEvent(e)) 
			processDrop(e);
		else
			e.rejectDrop();
	}
	
	public void dragExit(DropTargetEvent e)  {
		e.getDropTargetContext().getDropTarget().setActive(false);
	}
	
	/* Richiede al DNDSystem l'autorizzazione al rilascio del valore */
	private boolean dropAllowed(DataPack pack, DropTargetDropEvent e) {
		return dndSystem.dropRequest(
			pack.data,
			e.getDropTargetContext().getComponent(),
			e.getLocation(),
			pack.component);
	}
	
	/* Informa il DNDSystem che il rilascio è terminato */
	private void notifyDropComplete(DataPack pack, DropTargetDropEvent e) {
		e.dropComplete(true);
		dndSystem.dropCompleteNotify(
			pack.data, 
			e.getDropTargetContext().getComponent(), 
			e.getLocation(), 
			pack.component);
	}
	
	private DataPack extractDataPack(DropTargetDropEvent e) throws Exception {
		Transferable t = e.getTransferable();
		return (DataPack)t.getTransferData(transferFlavor);
	}
	
	/** true per un trasferimento intra jvm di un oggetto java */
	private boolean isValidDropEvent(DropTargetDropEvent e) {
		return e.isLocalTransfer() && e.isDataFlavorSupported(transferFlavor);
	}
	
	/* estrae i dati trasferiti e dialoga con DNDSystem per il rilascio */
	private void processDrop(DropTargetDropEvent e) {
		e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
		try {
			DataPack pack = extractDataPack(e);
			if(dropAllowed(pack, e))
				notifyDropComplete(pack, e);
			else
				e.dropComplete(false);
		} catch(Exception ex) {
			System.err.println(ex.getMessage());
			e.dropComplete(false);
		}
	}
	
	/* Coppia di valori (Component, T) */
	private class DataPack {
		private Component component;
		private T data;
		
		private DataPack(T d, Component c) {
			data = d;
			component = c;
		}
	};
	
	/* Tipo di dato trasferibile usato dal sistema: trasporta un DataPack */
	private class EasyTransferable implements Transferable {
		private DataPack dataPack;
		
		private EasyTransferable(T data, Component source) {
			dataPack = new DataPack(data, source);
		}
		
		public DataPack getTransferData(DataFlavor f) 
			throws UnsupportedFlavorException {
			if(!isDataFlavorSupported(f)) 
				throw new UnsupportedFlavorException(f);
			return dataPack;
		}
		
		public DataFlavor[] getTransferDataFlavors() {
			return new DataFlavor[] { transferFlavor };
		}
		
		public boolean isDataFlavorSupported(DataFlavor f) {
			return f.equals(transferFlavor);
		}

	};
	
	/** Genera i collegamenti necessari al funzionamento del sistema di 
	drag and drop.
	@param dndSys centro di controllo dei trasferimenti
	@param dragComponents insieme dei componenti sorgente di eventi 
	di trascinamento
	@param dropComponents insieme dei componenti bersaglio di eventi 
	di rilascio */
	public static <E> void createDNDContext(
		DNDSystem<E> dndSys,
		Collection<? extends Component> dragComponents, 
		Collection<? extends Component> dropComponents) 
	{
		EasyDND<E> dnd = new EasyDND<E>(dndSys);
		DragSource ds = DragSource.getDefaultDragSource();
		for(Component c : dragComponents) {
			DragGestureRecognizer dgr = ds.createDefaultDragGestureRecognizer(
				c, DnDConstants.ACTION_COPY_OR_MOVE, dnd);
		}
		for(Component c: dropComponents) {
			DropTarget dt = new DropTarget(c, dnd);
		}
	}
	
	/** Interfaccia concretizzata da chi voglia controllare il sistema di 
	drag and drop costruito attraverso il metodo createDNDContext di EasyDND */
	public static interface DNDSystem<E> {
		
		/** Notifica di drop completato
		@param value il valore rilasciato
		@param target il componente bersaglio del rilascio
		@param location il punto di rilascio su target
		@param origin il componente da cui è partito il trascinamento */
		void dropCompleteNotify(
			E value, Component target, Point location, Component origin);
		
		/** Richiesta di un valore da trasferire.
		@param source il componente da cui parte il trascinamento
		@param origin il punto di partenza del trascinamento
		@return E il valore da trasferire o null */
		E dragRequest(Component source, Point origin);
		
		/** Richiesta di rilascio di un valore in trasferimento.
		@param value il valore trasferito
		@param target il componente bersaglio del rilascio
		@param location il punto di rilascio sul componente target
		@param origin il componente da cui è partito il drag and drop */
		boolean dropRequest(
			E value, Component target, Point location, Component origin);
	};
}

A questo punto mi è parso che ci si potesse concentrare sul dato da trasferire anzichè sulla meccanica del trasferimento. Ho anche un applicazione di prova che si occupa di trasferire degli oggetti BimBum (il nome la dice lunga) da un pannello ad un altro.

BimBum.java

package it.easydnd;

import java.util.Calendar;

public class BimBum {
	private String note;
	private Calendar date;
	
	public BimBum(String noteValue, Calendar dateValue) {
		note = noteValue;
		date = dateValue;
	}
	
	public String getNote() {
		return note;
	}
	
	public Calendar getDate() {
		return date;
	}
}

Test.java

package it.easydnd;

import static it.easydnd.EasyDND.DNDSystem;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;

public class Test extends JPanel implements DNDSystem<BimBum> {
	private JPanel dragPanel = new JPanel(new GridLayout(3, 1));
	private JPanel dropPanel = new JPanel(new GridLayout(3, 1));
	private JPanel separator = new JPanel();
	
	public Test() {
		super(new BorderLayout());
		EasyDND.<BimBum>createDNDContext(this, 
			Arrays.asList(dragPanel), 
			Arrays.asList(dropPanel));
		JLabel one = format(new JLabel("One"));
		JLabel two = format(new JLabel("Two"));
		JLabel three = format(new JLabel("Three"));
		format(dragPanel);
		format(dropPanel);
		dragPanel.add(one);
		dragPanel.add(two);
		dragPanel.add(three);
		dragPanel.setPreferredSize(new Dimension(100, 20));
		dropPanel.setPreferredSize(new Dimension(100, 20));
		separator.setPreferredSize(new Dimension(20, 20));
		add(dragPanel, BorderLayout.LINE_END);
		add(dropPanel, BorderLayout.LINE_START);
		add(separator, BorderLayout.CENTER);
	}
	
	/** EasyDND notifica a questo DNDSystem una richiesta di prelievo che
	interessa il componente source con punto di prelievo origin. Questo
	DNSystem autorizza il prelievo, restituendo il dato prelevando, o non
	autorizza il prelievo, restituendo null */
	public BimBum dragRequest(Component source, Point location) {
		if(source == dragPanel) {
			Component c = dragPanel.getComponentAt(location);
			if(c instanceof JLabel) {
				return new BimBum(((JLabel)c).getText(), 
					Calendar.getInstance());
			}
		}
		return null;
	}
	
	/** EasyDND notifica a questo DNDSystem una richiesta di rilascio del valore
	dropValue, proveniente da origin, sul componente target nel punto
	location. Il boolean restituito significa autorizzo (true) o non autorizzo
	(false) il rilascio. */
	public boolean dropRequest(BimBum dropValue, Component target, 
		Point location, Component origin) {
		if(origin == dragPanel) {
			JLabel l = format(new JLabel(dropValue.getNote()));
			dropPanel.add(l);
			dropPanel.validate();
			dropPanel.repaint();
			return true;
		} else {
			return false;
		}
	}
	
	/** EasyDND notifica a questo DNSystem il completamento di un'operazione
	drag-and-drop */
	public void dropCompleteNotify(BimBum droppedBum, Component target, 
		Point location, Component origin)
	{
		assert(origin instanceof Container);
		Container cont = (Container)origin;
		Component[] comps = cont.getComponents();
		for(Component c : comps) {
			if(c instanceof JLabel) {
				JLabel l = (JLabel)c;
				if(l.getText().equals(droppedBum.getNote())) {
					cont.remove(c);
				}
			}
		}
		origin.validate();
		origin.repaint();
	}
	
	/** Applica un formato predefinto ad un JComponent (le etichette in
	quest'applicazione */
	private <T extends JComponent> T format(T target) {
		target.setBorder(new CompoundBorder(
			new EmptyBorder(2, 2, 2, 2), new LineBorder(Color.BLACK)));
		target.setOpaque(true);
		target.setBackground(Color.WHITE);
		return target;
	}
	
	/** Punto d'entrata dell'applicazione */
	public static void main(String...args) {
		final JFrame f = new JFrame("DND Test");
		f.add(new Test());
		f.setSize(400, 400);
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				f.setVisible(true);
			}
		});
	}
}

Il "drag" è tradotto in: un certo componente riceve una richiesta di prelievo a partire dal punto P; se in quel punto e per quel componente, secondo lo stato dell'applicazione, esista qualcosa di trascinabile, un DNDSystem lo restituisce. Altrimenti restituisce null (dropRequest).

Il "drop" è diviso in due parti. Una richiesta di rilascio ed una notifica di rilascio andato a buon fine. Se alla richiesta di rilascio (dropAllowed) DNDSystem restituisca true, l'operazione si conclude con la notifica da parte di EasyDND del completamento delle operazioni (dropCompleteNotify).

[texerasmo]

Grazie...
Questa cosa dovrei implementarla in una mi web-application.
Il nostro prodotto è un cms
L'utente deve poter uplodare un serie di file in certe dir.
cmq ora la provo spero che mi possa essere d'aiuto

Thka

[franksisca]

grazie mille.