[java]System.out.println() e GUI

[NeoNum6]

...salve amici...
ho creato un programma che alla fine di una serie di elaborazioni stampa a video il risultato con il noto System.out.println();...
ora vorrei fare una semplice interfaccia grafica per lo stesso...
ed ecco che nasce il problema....c'è un modo per far sì che ciò che si stampa a video 'da terminale' venga stampato nell'interfaccia grafica???
...l'alternativa sarebbe riscrivere tutte le linee di codice e dare un return di Stringhe ma è moolto penoso...

[Blackat]

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/System.html#setOut(java.io.PrintStream)


Basta che ti scrivi il tuo PrintStream che ti stampa su una bella interfaccia grafica e lo cambi con quello di default di sistema. :D

[NeoNum6]

indi devo dirottare il System.out.println() su un PrintStream con il metodo load...e poi devo trovare il modo di stampare il PrintStream sulla mia interfaccia(come?)....

[MEMon]

come "interfaccia grafica" cosa usi? Un JTextArea?

Comunque fai una cosa semplicissima...ti fai un metodo al quale passi la stringa da stampare che provvederà sia a fare il System.out.println() sia a fare l'aoutput sulla tua interfaccia:

public void stampa(String s){
System.out.println(s);
JTextArea.append(s);
}

[NeoNum6]

come "interfaccia grafica" cosa usi? Un JTextArea?

Comunque fai una cosa semplicissima...ti fai un metodo al quale passi la stringa da stampare che provvederà sia a fare il System.out.println() sia a fare l'aoutput sulla tua interfaccia:

public void stampa(String s){
System.out.println(s);
JTextArea.append(s);
}

ma questo nomo mi comporta la modifica di tutte le System.out.println in stampa() ...io invece avrei voluto non metter mano al codice...

[MEMon]

Bhe si, credevo non fosse un problema, in tal caso segi il consiglio che ti han già dato.

[NeoNum6]

Bhe si, credevo non fosse un problema, in tal caso segi il consiglio che ti han già dato.

...no perchè se devo andare a modificare il codice basterebbe sostituire a ogni System.out.println() un return di tipo stringa

[PGI-Bis]

E' più facile a farsi che a dirsi. Connetti un OutputStream ad un InputStream tramite java.nio.channels.Pipe. Poi attacchi un BufferedReader all'InputStream e un PrintStream all'OutputStream. A questo incolli all'input stream una pompa che drena linee di testo e le sputa su un Document. Quindi crei un esecutore che piglia il nome di una classe che si spera abbia un metodo main e gli fai:

1. creare un'area di testo
2. aprire una finestra con dentro l'area di testo
3. creare la pompa in emissione sul documento dell'area di testo
4. redirigere lo standard output sulla pompa
5. lanciare il metodo main della classe prescelta

Ad esempio, la pompa potrebbe essere:

import javax.swing.*;
import javax.swing.text.*;
import java.awt.*;
import java.io.*;
import java.nio.channels.*;

public class IOPump implements Runnable {
private Thread runner;
//segnale di esaurimento (IOPump è eseguibileuna sola volta)
private volatile boolean exau = false;
private volatile boolean execute = false;
private PrintStream out;
private BufferedReader lineReader;
private Document document;

public IOPump(Document doc) throws IOException {
document = doc;
//crea la connessione tra input e output
Pipe pipe = Pipe.open();
InputStream pin = Channels.newInputStream(pipe.source());
OutputStream pout = Channels.newOutputStream(pipe.sink());
//attacca un BufferedReader e un PrintStream ai flussi connessi
out = new PrintStream(pout);
InputStreamReader inReader = new InputStreamReader(pin);
lineReader = new BufferedReader(inReader);
/* A questo punto ciò che è scritto in "out" è disponibile in lettura
attraverso "lineReader" */
}

public PrintStream getOutputStream() {
return out;
}

public synchronized void start() {
if(exau) {
throw new RuntimeException("IOPump cannot be started twice");
} else {
execute = exau = true;
runner = new Thread(this);
//Daemon, muore "insieme all'evocatore"
runner.setDaemon(true);
runner.start();
}
}

public synchronized void stop() {
try {
lineReader.close();
} catch(IOException ex) { } finally {
execute = false;
}
}

public void run() {
while(execute) {
String line = null;
try {
line = lineReader.readLine();//legge una linea di testo
} catch(IOException ex) {
break;
}
if(line != null) {
swingPrint(line + "\n");
}
}
}

/* Accoda il testo usando l'AWT Event Dispatcher Thread */
private void swingPrint(final String line) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
rawPrint(line);
}
});
}

/* Tanto per evitare di mettere tremila livelli di indentazione in
swingPrint */
private void rawPrint(String line) {
try {
document.insertString(document.getLength(), line, null);
} catch(BadLocationException ex) {
throw new RuntimeException(ex);
}
}
}

e il pippo che lancia tutto:

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.lang.reflect.*;

public class TrickTrock {

private JFrame window = new JFrame("TrickTrockConsole");
private IOPump ioPump;

private void initWindow() {
JTextArea ta = new JTextArea();
ta.setEditable(false);
ta.setLineWrap(true);
try {
ioPump = new IOPump(ta.getDocument());
} catch(IOException ex) {
throw new RuntimeException(ex);
}
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.add(new JScrollPane(ta), BorderLayout.CENTER);
window.setSize(400, 400);
window.setVisible(true);
}

public static void main(String[] args) {
String className = args[0];
final TrickTrock tt = new TrickTrock();
ClassLoader c = TrickTrock.class.getClassLoader();
Method thatMain = null;
Class<?> thatClass = null;
try {
thatClass = c.loadClass(className);
thatMain = thatClass.getMethod("main", String[].class);
} catch(Exception ex) {
throw new RuntimeException(ex);
}
swingStart(thatMain, thatClass, tt);
}

private static void swingStart(final Method m, final Class<?> c,
final TrickTrock t)
{
SwingUtilities.invokeLater(new Runnable() {
public void run() {
try {
//APRE LA FINESTRA (INIZIALIZZA LA POMPA)
t.initWindow();
//REDIRIGE L'OUTPUT STANDARD VERSO LA POMPA
System.setOut(t.ioPump.getOutputStream());
//AVVIA LA POMPA
t.ioPump.start();
Object[] args = { new String[]{} };
//INVOCA IL METODO MAIN DELLA CLASSE SCELTA
m.invoke(null, args);
} catch(Exception ex) {
throw new RuntimeException(ex);
}
}
});
}
}

Con questo due di picche in mano, puoi lanciare il programma:

java TrickTrock pim.pum.pam.NomeClassColMainDellAltroProgramma

al che si apre la finestrella e ciò che è scritto con System.out finisce nell'area di testo.

Non è una cosa bella da fare. Di solito prima di iniziare a scrivere un programma, scrivi un meccanismo di "logging" (cosa di poche righe) e nel tuo programma, al posto di scrivere System.out.println, fai una cosa tipo:

Logger.getInstance().println("la vispa teresa...");

dove l'istanza di Logger restituita da getInstance() è caricata a partire da una proprietà di sistema (quelle che crei con -D per capirsi). Così puoi rimpiazzare l'output senza pasticciare con System.out. La ragione per cui non si dovrebbe fare quel che si è fatto è che l'uso di System.out per dare informazioni di testo è solo convenzionale. Dal punto di vista meccanico System.out lascia la porta aperta ad ogni nefandezza – tutte quelle che possono essere commesse scrivendo un byte in un canale – mentre un Logger è normalmente fornito di metodi esplicitamente destinati a comunicare messaggi di testo.

Dico in generale. Nel caso in cui il codice sorgente sia nella disponibilità di un altro puffo non possiamo far altro che tentare di estrarre degli assi da maniche sempre più consumate.

[NeoNum6]

il fatto delle System.out.println() è che io in ogni caso volevo sia un tool grafico sia uno da terminale...in ogni caso:
:eek:
grazie PGI-Bis!!!!!
provo ad applicare quello scritto da te e ti faccio sapere :D