[JAVA] Creazione Alberi Grafici

[franksisca]

Ragazzi, devo, in preatica, creare un albero, senza specifiche sul nujmero di figli e sul numero di livelli, tutto modificabile in esecuzione.

Praticamente parto da una root e poi aggiungo un livello con n nodi, e così via.

Non ho idea di come farlo in java, ho trovato gambit, sarebbe proprio quello che serve a me, chi mi aiuta???

[PGI-Bis]

Mhhhh... devi/vuoi farlo da zero zero? Perchè di già pronto c'è DefaultTreeModel con i suoi DefaultMutableTreeNode.

[franksisca]

Mhhhh... devi/vuoi farlo da zero zero? Perchè di già pronto c'è DefaultTreeModel con i suoi DefaultMutableTreeNode.
dici dici.....praticamente la mia tesi è anche su questo.....

[PGI-Bis]

Ok, non ho capito niente :D.

Viso pallido volere usare DefaultTreeModel e DefaultMutableTreeNode? O dovere fare tutto a manina santa? :D

[lovaz]

Senti PGI, ma perché non scrivi un libro o qualcosa del genere?
Seriamente, penso che in questo forum (e anche fuori) tu sia l'unico
che sa tutto delle swing, di java, ecc. :D

Vedendo i tuoi post mi sembra che la voglia di scrivere non ti manchi... ;)

[franksisca]

Senti PGI, ma perché non scrivi un libro o qualcosa del genere?
Seriamente, penso che in questo forum (e anche fuori) tu sia l'unico
che sa tutto delle swing, di java, ecc. :D

Vedendo i tuoi post mi sembra che la voglia di scrivere non ti manchi... ;)
non male come idea......:D:D:D:D:D:D:D:D:D

Comunque non conoscendo la differenza non è che protesti darmi esempi di qualsiasi genere???


Comunque ho del codice sottomano, adesso vedo e vi faccio sapere.

[PGI-Bis]

Diciamo – in Java – che quello che vogliamo ottenere è:

public interface TreeControl {
void addNode(String parent, String child);

java.awt.Component getTreeComponent();
}

getTreeComponent() serve per "vedere" e addNode per accrescere l'albero. Supponiamo anche che la radice abbia un valore noto a priori ("radice", tiè :D). Uso:

TreeControl tree = qualcosa:
tree.addNode("radice", "pippo"); //a radice attacchiamo pippo
tree.addNode("pippo", "giulio"); //a pippo attacco giulio
tree.addNode("radice", "franco"); //a radice attacco franco

Trattasi d'un raro esemplare della specie "alberus minimus sindacalis" :D. Come si TreeControl-la. Be', commento il codice anzichè blaterare ma è veramente semplicissimo.

import javax.swing.*;
import javax.swing.tree.*;

public class MyTree implements TreeControl {
//questa è la radice del modello dell'albero
private DefaultMutableTreeNode root = new DefaultMutableTreeNode("radice");
//questo è il modello dell'albero
private DefaultTreeModel treeModel = new DefaultTreeModel(root);
//questo è il componente che visualizza l'albero
private JTree tree = new JTree(treeModel);

//aggiunge child a parent
public void addNode(String parent, String child) {
//prima troviamo il nodo il cui valore è parent
DefaultMutableTreeNode parentNode = findNode(parent);
//se c'è...
if(parentNode != null) {
//creiamo un nuovo nodo che contiene child
DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(child);
//attacchiamo il nuovo nodo al nodo genitore
parentNode.add(newNode);
//informiamo il modello dell'albero che qualcosa è cambiato a
//a partire da parentNode, incluso
treeModel.reload(parentNode);
//"apriamo" l'albero
expandAll();
} else {
System.out.println("No node for: " + parent);
}
}

/* restituisce il componente Swing di tipo JTree che visualizza i dati
del modello dell'albero */
public java.awt.Component getTreeComponent() {
return tree;
}

/* Trova il nodo che contiene il valore value. */
private DefaultMutableTreeNode findNode(String value) {
//un compito arduo... :D Per ogni nodo...
java.util.Enumeration<?> nodes = root.breadthFirstEnumeration();
while(nodes.hasMoreElements()) {
DefaultMutableTreeNode node =
(DefaultMutableTreeNode)nodes.nextElement();
//se il valore del nodo è una stringa (rendo la cosa esplicitamente)
String nodeValue = (String)node.getUserObject();
//...e quella stringa vale "value"
if(nodeValue.equals(value)) {
//...allora il nodo è quello che cerchiamo
return node;
}
}
//se no, ciccia
return null;
}

/* Espande l'albero riga per riga. Le righe di getRowCount sono solo quelle
visibili. Espandendo una riga è possibile che si rivelino altre righe che
potrebbero a loro volta essere espanse. In pratica continuo ad espandere
fintantochè due espansioni consecutive non producano un numero di righe
identiche: in quel caso, l'albero sarà completamente "aperto" */
private void expandAll() {
int expandedRows = 0;
while(expandedRows != tree.getRowCount()) {
expandedRows = tree.getRowCount();
for(int i = 0; i < expandedRows; i++) {
tree.expandRow(i);
}
}
}
}

Immancabile interfaccina Swing:


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

public class TreeGui {
private JFrame window = new JFrame("Tree");
private TreeControl tree;
private JTextField parentField, childField;

public void setupAndShow() {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
createGui();
window.setSize(500, 500);
window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
window.setVisible(true);
}
});
}

private void createGui() {
JLabel parentLabel = new JLabel("Parent: ", JLabel.RIGHT);
JLabel childLabel = new JLabel("Child:", JLabel.RIGHT);
JTextField parentField = new JTextField(20);
JTextField childField = new JTextField(20);
JButton accept = new JButton("add Child to Parent");
MyTree tree = new MyTree();
JScrollPane treeScroller = new JScrollPane(tree.getTreeComponent());

GridBagLayout lay = new GridBagLayout();
GridBagConstraints lim = new GridBagConstraints();
lim.insets = new Insets(4, 4, 4, 4);
lim.fill = GridBagConstraints.HORIZONTAL;
lim.gridx = 0;
lim.gridy = 0;
lay.setConstraints(parentLabel, lim);
lim.gridx = 1;
lim.gridy = 0;
lim.weightx = 1;
lay.setConstraints(parentField, lim);
lim.weightx = 0;
lim.gridx = 0;
lim.gridy = 1;
lay.setConstraints(childLabel, lim);
lim.weightx = 0;
lim.gridx = 1;
lim.gridy = 1;
lay.setConstraints(childField, lim);
lim.weightx = 0;
lim.gridx = 2;
lim.gridy = 0;
lim.gridheight = 2;
lim.fill = GridBagConstraints.NONE;
lim.anchor = GridBagConstraints.NORTHWEST;
lay.setConstraints(accept, lim);

JLabel filler = new JLabel();
lim.gridx = 3;
lim.gridy = 0;
lim.weightx = 1;
lay.setConstraints(filler, lim);

JPanel topContainer = new JPanel(lay);
topContainer.add(parentLabel);
topContainer.add(childLabel);
topContainer.add(parentField);
topContainer.add(childField);
topContainer.add(accept);
topContainer.add(filler);

JPanel container = new JPanel(new BorderLayout());
container.add(topContainer, BorderLayout.NORTH);
container.add(treeScroller, BorderLayout.CENTER);

window.setContentPane(container);

accept.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
createNewNode();
}
});

this.tree = tree;
this.parentField = parentField;
this.childField = childField;
}

private void createNewNode() {
String parentName = parentField.getText();
String childName = childField.getText();
tree.addNode(parentName, childName);
childField.setText("");
}

}

In alto ci sono due campi di testo e un pulsante. Nel campo di testo etichettato "Parent" si scrive il nome del nodo a cui si vuole aggiungere un figlio. Nel campo di testo etichettato "Child" si scrive il nome del nodo che si vuole aggiungere. Si preme il pulsante "add Child to Parent" e un nodo dell'albero riceverà un figliolo. Non commento il codice dell'interfaccia per volontà di sintesi. Spiegare i parametri del solo GridBagLayout richiederebbe parecchie pagine e mi sembra che non sia questo il "punto focale" della discussione. Manca il main:

public class Main {

public static void main(String[] args) {
new TreeGui().setupAndShow();
}
}

Naturalmente JTree è una classe un tantinello più versatile di quanto si vede in ciò che ho scritto. Ma basta un'abbrivio: una volta che si ha per le mani un principio di programma, con qualche esperimento (e la javadoc) ci si può sbizzarrire.

[franksisca]

naturalmente adesso provo e ti faccio sapere;)

comunque grazie mille.