[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]

Originariamente inviato da PGI-Bis

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 .

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

[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.

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

[franksisca]

Originariamente inviato da 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.

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

non male come idea......

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è ). 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" . 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.