[JAVA]

[julianross1983]

NON RIESCO AD IMPLEMENTARE IL "TABLECELLEDITOR",PER GESTIRE IL TRASCINAMENTO DI UNA JLABEL CONTENUTA IN PANNELLO CHE A SUA VOLTA E' CONTENUTO IN UNA CELLA DI UNA JTABLE.....COME SI PUO' RISOLVERE?ESEMPIO!GRAZIE

[PGI-Bis]

Come dissi nell'altro thread, passare per l'editor è una delle soluzioni. L'altra, che propongo qui, usa l'intera tabella come sorgente e destinazione di eventi drag and drop.

L'esempio è molto specifico e meccanicamente inutile al tuo problema. Inutile perchè il trasferimento dipende dai componenti concretamente coinvolti e, in particolare, dalla distribuzione degli spazi nella tabella e nei pannelli contenuti come celle di quella tabella.

Dovresti comunque essere in grado di applicare un modello simile alla tua situazione concreta.

package tab;

import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;

/** Proietta una cella il cui valore è un JPanel usando lo stesso
JPanel come proiettore */
public class PanelRenderer implements TableCellRenderer {

public Component getTableCellRendererComponent(
JTable table,
Object value,
boolean isSelected,
boolean hasFocus,
int row,
int column)
{
return (JPanel)value;
}
}

package tab;

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

/** Un pannello che contiene tre JLabel */
public class TriLabel extends JPanel {
private JLabel nameLabel = new JLabel();
private JLabel surnameLabel = new JLabel();
private JLabel roleLabel = new JLabel();

/** Inizializza un TriLabel assegnando alle tre etichette
i testi name, surnam e role */
public TriLabel(String name, String surname, String role) {
super(new GridLayout(3, 1, 2, 2));
nameLabel.setText(name);
surnameLabel.setText(surname);
roleLabel.setText(role);
add(nameLabel);
add(surnameLabel);
add(roleLabel);
}

/** Restituisce l'etichetta che occupa la regione di
spazio a cui appartiene il punto p. */
public JLabel getLabelAt(Point p) {
/* Il layout è un GridLayout. L'altezza di ogni
etichetta è uguale a circa un terzo dell'altezza
di tutto il pannello. */
Dimension dim = getPreferredSize();
/* La divisione intera p.y / (altezza di un singolo elemento)
restituisce l'indice (da 0 a 2 estremi inclusi) dell'etichetta.
0 è nameLabel (perchè è la prima inserita nel pannello)
1 è surnameLabel(perchè è la seconda inserita nel pannello)
2 è roleLabe (perchè è la terza inserita nel pannello) */
int labelIndex = p.y / (dim.height / 3);
return
labelIndex == 0 ?
nameLabel :
labelIndex == 1 ?
surnameLabel :
roleLabel;
}
}

package tab;

import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;

public class MyTable extends JTable {
private PanelRenderer panelRenderer = new PanelRenderer();

/** Se la cella in posizione (row, column) contiene un JPanel,
restituisce un panelRenderer (uno per tutte). Altrimenti
restituisce il proiettore predefinito da JTable */
public TableCellRenderer getCellRenderer(int row, int column) {
Object value = getValueAt(row, column);
return
value instanceof JPanel ?
panelRenderer :
super.getCellRenderer(row, column);
}

/** L'altezza delle righe è pari all'altezza della più alta
delle righe. Alcune celle possono (dovrebbero) contentere
dei componenti. In questo caso l'altezza esaminata è l'altezza
preferita di quel componente. Il conto è particolarmente
dispendioso e andrebbe affrontato in modo diverso (un caching
del valore ed un nuovo calcolo solo se intervengano mutazioni
di un componente appartenente al modello sarebbe già meglio) */
public int getRowHeight() {
int height = super.getRowHeight();
/* Non sapendo in che colonna ed in quali righe si trovino
i JPanel devo esaminarle tutte. */
for(int row = 0; row < getRowCount(); row++) {
for(int col = 0; col < getColumnCount(); col++) {
Object value = getValueAt(row, col);
if(value instanceof Component) {
Component comp = (Component)value;
Dimension dim = comp.getPreferredSize();
if(dim.height > height) {
height = dim.height;
}
}
}
}
return height;
}

/** Per semplicità rendo insensibili tutte le celle al
sistema predefinito di mutazione del valore (il doppio click) */
public boolean isCellEditable(int row, int col) {
return false;
}
}

package tab;

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

public class DNDManager {
private JTable table;

/* Il metodo dragGestureRecognized di questo
DragGestureListener è invocato quando la piattaforma
rilevi un tentativo di trascinamento */
private DragGestureListener dragHandler = new DragGestureListener() {

public void dragGestureRecognized(DragGestureEvent e) {
/* Il componente registrato come "attivatore" del trascinamento
è la tabella intera. Noi dobbiamo verificare se il punto da cui
parte il trascinamento corrisponda ad una cella che contiene un
TriLabel */
Point origin = e.getDragOrigin();
int row = table.rowAtPoint(origin);
int col = table.columnAtPoint(origin);
TriLabel component = getTriLabelAt(row, col);

if(component != null) {
/* Nel punto di trascinamento c'è un TriLabel */
/* Ora dobbiamo prendere l'etichetta del TriLabel che
si trova nel punto di trascinamento */
Point p = convertToCellPoint(origin, row, col);
JLabel label = component.getLabelAt(p);
/* Trovata l'etichetta trasciniamo il suo testo */
startTextDrag(e, label.getText());
}
}
};

/* Il metodo drop di questo DropTargetAdapter è invocato quando la
piattaforma rilevi un tentativo di rilascio */
private DropTargetListener dropHandler = new DropTargetAdapter() {
public void drop(DropTargetDropEvent e) {
/* Il componente registrato come "attivatore" del rilascio è
la tabella. Noi dobbiamo verificare se il punto in cui si
verifica il rilascio corrisponda ad una cella che contiene
un TriLabel */
Point destination = e.getLocation();
int row = table.rowAtPoint(destination);
int col = table.columnAtPoint(destination);
TriLabel component = getTriLabelAt(row, col);
if(component != null && e.isDataFlavorSupported(DataFlavor.stringFlavor)) {
/* Nel punto di rilascio c'è un TriLabel e i dati rilasciati
sono di un tipo testo: possiamo iniziare il rilascio */
e.acceptDrop(DnDConstants.ACTION_COPY);
/* Dal punto di rilascio relativo alla tabella passiamo
al punto di rilascio relativo al pannello contenuto nella
cella della tabella */
Point p = convertToCellPoint(destination, row, col);
/* Iniziamo il trasferimento del testo */
startTextDrop(e, p, component, row, col);
} else {
/* Nel punto di rilascio non c'è un TriLabel o i dati non sono
di tipo testo: rifiutiamo il rilascio */
e.rejectDrop();
}
}
};

/* Restituisce un punto che rappresenta le coordinate di p
nello spazio di coordinate della cella (row, col) */
private Point convertToCellPoint(Point p, int row, int col) {
Rectangle cellRect = table.getCellRect(row, col, true);
return new Point(
p.x - cellRect.x,
p.y - cellRect.y);
}

/* Restituisce il TriLabel corrispondente alla cella (row, col)
o null se quella cella non contenga un TriLabel */
private TriLabel getTriLabelAt(int row, int col) {
TriLabel result = null;
Object value = table.getValueAt(row, col);
if(value instanceof TriLabel) {
result = (TriLabel)value;
}
return result;
}

/* Tenta di rilasciare il testo contenuto nel transferable
associato a dropEvent. Il punto dropPoint è relativo
all'origine del componente destination. I valori row e col
sono gli indici della cella in cui è contenuto il componente
destination e servono per costringere la tabella ad aggiornare
il contenuto di quella cella una volta che il trascinamento
sia completato. L'invocazione di questo metodo presuppone che
il tipo di dato trasferito sia compatibile con
DataFlavor.stringFlavor */
private void startTextDrop(DropTargetDropEvent dropEvent,
Point dropPoint, TriLabel destination, int row, int col)
{
/* Un "drop" termina con una notifica di completamento
avvenuto con o senza successo. Questo valore è usato al
termine di questo metodo per notificare l'esito del
rilascio. */
boolean success = false;
try {
/* Ottiene la capsula dei dati che si vorrebbero
rilasciare */
Transferable t = dropEvent.getTransferable();
/* In accordo alla precondizione di compatibilità con
DataFlavor.stringFlavor, ottiene i dati trasferiti. Qui
può (ma non dovrebbe) prodursi un UnsupportedFlavorException
ed un ClassCastException. */
String text = (String)t.getTransferData(DataFlavor.stringFlavor);
/* Ottiene dal TriLabel destination l'etichetta che si
trova nel punto dropPoint (che è relativo alla posizione del
componente nella tabella e non all'origine della tabella) */
JLabel label = destination.getLabelAt(dropPoint);
/* Imposta il testo di quell'etichetta */
label.setText(text);
/* A questo punto deve far si che la tabella aggiorni la
proiezione della cella (row, col). Per farlo passa attraverso
il modello: imposta per la cella (row, col) lo stesso valore
che c'era prima (lo stesso TriLabel). Come conseguenza di un
setValueAt, anche se il valore è lo stesso di prima, il modello
notifica alla vista-tabella che qualcosa è cambiato e la
vista-tabella è responsabile dell'aggiornamento visivo
di quella cella. */
Object value = table.getValueAt(row, col);
DefaultTableModel model = (DefaultTableModel)table.getModel();
model.setValueAt(value, row, col);
/* A questo punto possiamo ritenere completato con
successo il trasferimento */
success = true;
} catch(UnsupportedFlavorException ex) {
success = false;
} catch(ClassCastException ex) {
success = false;
} catch(java.io.IOException ex) {
success = false;
} finally {
dropEvent.dropComplete(success);
}
}

/* Crea uno StringSelection (un Transferable per String) e
notifica l'inizio di un evento di trascinamento che trasporta
il testo text */
private void startTextDrag(DragGestureEvent e, String text) {
StringSelection transferable = new StringSelection(text);
e.startDrag(DragSource.DefaultCopyDrop, transferable);
}

/** Attiva questo gestore del drag and drop per il MyTable in
argomento. */
public void bind(MyTable table) {
/* Crea e connette un attivatore degli eventi "drag". Questo
fa sì che quando la piattaforma rilevi un tentativo di trascinamento
che interessi (per posizione) la tabella "table" sia invocato il metodo
dragGestureRecognized del DragGestureListener "dragHandler" */
DragSource ds = DragSource.getDefaultDragSource();
ds.createDefaultDragGestureRecognizer(
table,
DnDConstants.ACTION_COPY,
dragHandler);

/* Crea e connette un attivatore degli eventi "drop". Questo
fa sì che quando la piattaforma rilevi un tentativo di
rilascio che interessi (per posizione) la tabella "table"
sia invocato il metodo "dropt" del DropTargetListener
"dropHandler" */
DropTarget dt = new DropTarget(table, dropHandler);
this.table = table;
}
}

package tab;

import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;

public class Main {

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
start();
}
});
}

public static void start() {
/* Un po' di stringhe e un po di JPanel con etichette */
Object[][] data = {
{ "Barcamena Spa", new TriLabel("Mario", "Rossi", "Scafista"), },
{ new TriLabel("Franco", "Neri", "Estorsore"), "Taglieggio Srl", },
{ "Zompo scarl", "Nessuno", },
};
Object[] headers = {
"A", "B",
};

/** Creo una tabella con un DefaultTableModel contenente
i dati su generati */
MyTable table = new MyTable();
TableModel model = new DefaultTableModel(data, headers);
table.setModel(model);

/* JTable usa il mouse per selezionare le celle. Il DragAndDrop
usa gli stessi eventi per il trascinamento, lo spostamento e il
rilascio. Uno dei due sistemi deve essere modificato. Escludo
in toto quelli di JTable */
table.setCellSelectionEnabled(false);
table.setRowSelectionAllowed(false);

/** Creo un gestore del drag and drop per questo particolare
tipo di tabella e lo "attivo" */
new DNDManager().bind(table);

JScrollPane scroller = new JScrollPane(table);
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.add(scroller, BorderLayout.CENTER);
frame.pack();
frame.setVisible(true);
}
}

L'esempio propone una tabella in cui alcune celle sono dei TriLabel. Un TriLabel è un JPanel che contiene tre JLabel. Le stringhe presentate dalle etichette contenute in questi TriLabel sono mutabili attraverso il drag and drop.