Colorare JLabel in base ad una risposta

[Sampy84]

Salve a tutti, ho un piccolo problemino che non riesco a risolvere e come al solito dopo mille tentativi mi rivolgo a voi.
Il mio programma java consiste in una gui in cui ho messo delle caselle ( JLabel con una sigla al centro ), alla pressione di un JButton vado a richiamare un'altra classe che fa il suo lavoro e alla fine mi restituisce una stringa, ora devo andare a colorare le caselle in base al tipo di risposta che ricevo. Il problema è che una volta ritornata la risposta non riesco a far colorare le caselle ( Che sono delle JLabel ), ho provato ad impostare l'opacità a true ma niente da fare.
Ho provato a sostituire le label con dei piccoli JPanel ma il risultato è lo stesso.
Nella classe gui ho implementato un thread, dopo aver visto i suggerimenti e gli esempi di andbin, che è sempre disponibilissimo per cui lo ringrazio infinitamente..., che dovrebbe farlo ma niente, svolge tutto il contenuto del run() ma non colora...

public class colora implements Runnable {
public void run() {
initComponents();
System.out.println("dovrei colorare");
Pannello.setOpaque(true);
Pannello.setBackground(Color.red);
Label.setopaque(true);
Label..setBackground(Color.red);

}
}

Mi viene solo stampata a schermo la stringa.....
Come mai??? Grazie mille !!!

[andbin]

Originariamente inviato da Sampy84
Nella classe gui ho implementato un thread

Quindi quel run() che vedo viene eseguito nel contesto di un altro thread (che non è il EDT)?? Non è appropriato "accedere" (salvo casi particolari) alla interfaccia utente da un altro thread che non è il EDT.

E comunque il codice è poco ... non si capisce bene dove, quando fai partire il thread.

[Sampy84]

questo è il codice ho tolto alcuni metodi che intanto non sarebbero chiamati in causa:

Ho utilizzato 2 costruttori:

// Questo è il primo costruttore della gui richiamato dal Main

public SwitchboardGui() {
initComponents();
}

// Questo è il secondo costrutore che dovrebbe far partire il thread per la colorazione

public SwitchboardGui(String risposta) {
initComponents();
System.out.println("Risposta arrivata alla gui e' "+risposta);

Thread col = new Thread(new colora());
col.start();
}

////////////////////////////////////////////////////////////////////////

//////Questo è cio che viene eseguito con la pressione del JButton

private void Attuazione9VButtActionPerformed(java.awt.event.Act ionEvent evt) {
Thread send = new Thread(new send9v());
send.start();

}

private class send9v implements Runnable {
public void run() {
logwriter=new LogWriter(SerialNumberVisualization.getText());
logwriter.write("Rilevata pressione del tasto Attuazione 9V");

setpar=new Setpar(switchboard);
setpar.senddefault9v();

logwriter.write("Settaggio centralina con parametri di default e modalità 9V");
SwitchboardArea.append("Settaggio centralina con parametri di default e modalità 9V");
SwitchboardArea.append("\n");
System.out.println("Effettuato settaggio di default e modalià 9V");

getpar=new Getpar(switchboard);
getpar.send();

testcmd[0]="C0";
testcmd[1]="80";

setcmd=new Setcmd(jig);
setcmd.send2(testcmd[0]);
logwriter.write("Comando apertura valvole inviato...");
SwitchboardArea.append("Comando apertura valvole inviato...");
SwitchboardArea.append("\n");

System.out.println("Apertura inviata");

try {
Thread.sleep(10000);
}
catch (Exception ex) {
System.out.println("No!!!");
}

setcmd=new Setcmd(jig);
setcmd.send2(testcmd[1]);

SwitchboardArea.append("Comando chiusura valvole inviato...");
SwitchboardArea.append("\n");

logwriter.write("Comando chiusura valvole inviato...");
logwriter.close();
System.out.println("Chiusura inviata");
}
}

/////////////////////////////////////////////////////////////////////////////

In pratica viene mandato un comando ad una periferica connessa tramite portaseriale,
L'eventListener connesso a tale porta memorizza la risposta inviata dalla periferica
e me la fa ritornare alla classe gui tramite il secondo costruttore( Quello che prende
come parametro una stringa): e fin qui ci sono perche tale risposta la faccio stampare ed è giusta, a questo punto quel costruttore dovrebbe andare a colorare le caselle in base alla risposta ottenuta ( Questo controllo ancora non è implementato) ma intanto non colora comunque.


public class colora implements Runnable {
public void run() {
initComponents();
System.out.println("dovrei colorare");
jPanel.setopaque(true);
jPanel3.setBackground(Color.red);
Label1..setOpaque(true);
Label1.setBackground(Color.red);

}
}

// e questo infine è il metodo main

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new SwitchboardGui().setVisible(true);


}
});
}

[Sampy84]

Ciao andbin, scusami se ti disturbo
questo è il codice, ho scritto uan boiata???

[Sampy84]

Ciao andbin non riesco proprio a capire dov'è il problema, se faccio colorare i componenti in qualsiasi altra parte del codice viene esguito con successo....
Il problema è che devo colorarli in base all'analisi di una risposta che ricevo da un dispositivo connesso alla porta seriale, avevo pensato di passare i riferimenti delle label alla classe che riceve la risposta ma siccome sulla gui ho ben 48 label ho creduto bene che non era la soluzione migliore...
Come posso fare??? Ti prego dammi una mano sono 2 giorni che mi ci sto arrovellando il cervello... Ti ringrazio in anticipo grazie...!!! e Buon Lavoro

[andbin]

Originariamente inviato da Sampy84
non riesco proprio a capire dov'è il problema

Hai fatto 2 costruttori. Ma tu hai 1 istanza principale di SwitchboardGui .... quella che hai istanziato nel run del Runnable nel main(). Se per avviare colora istanzi un nuovo SwitchboardGui .... che ti serve??? E appunto non vedrai nulla perché hai istanziato un altro SwitchboardGui che non ti serve e tutto quello che fai al suo interno lo fai su questa nuova istanza .... non sulla "vera" interfaccia visualizzata dalla prima istanza.

[Sampy84]

Ho tolto quel secondo costruttore, ho inserito nella classe in cui ottengo la risposta un metodino che me la restituisce String getrisposta().
Questo lo invoco su un oggetto di quella classe creato nella gui ma questo non mi restituisce il valore aggiornato della risposta bensi il valore a cui l'avevo inizializzata.

Mi spiego meglio, La classe Tester è quella che riceve la risposta della periferica, in questa classe ho inizializzato una variabile String risposta inizializzata a "".
C'è un metodo della classe Tester che si occupa di aggiornare tale variabile con la risposta che arriva dalla periferica e questo viene esguito perfettamente.

Il metodo getrisposta() implementato in Tester non fa altro che ritornare quella variabile, ma allora perche quando lo vado ad invocare nella classe gui mi ritorna sempre il valore "" e non il valore aggiornato ? Il metodo getrisposta() lo invoco nella classe gui su un oggetto di tipo Tester dopo un certo tempo di sleep, tempo in cui il listener connesso alla porta aggiorna la variabile risposta.

[Sampy84]

ciao, credo di aver risolto facendo una semplice estenzione della classe switchboardgui nella clesse tester Tester extends SwitchboardGui.
Nella classe Tester ho spostato il metodo main, da questa vado a creare una sola istanza della gui e su quella vado ad invocare il metodo colora definito nella classe SwitchboardGui passandogli la risposta e sembra funzionare.
è una soluzione valida a livello prestazionale???

[andbin]

Originariamente inviato da Sampy84
ciao, credo di aver risolto facendo una semplice estenzione della classe switchboardgui nella clesse tester Tester extends SwitchboardGui.
Nella classe Tester ho spostato il metodo main, da questa vado a creare una sola istanza della gui e su quella vado ad invocare il metodo colora definito nella classe SwitchboardGui passandogli la risposta e sembra funzionare.
è una soluzione valida a livello prestazionale???

Non capisco il senso (e l'utilità) di questa estensione Tester extends SwitchboardGui.

[Sampy84]

Ah gia' è vero... Ma allora bastava soltanto spostare il metodo main nella classe tester, con il suo avvio creare un oggetto SwitchboardGui e renderlo visibile e poi andare a lavorare sempre e solo su quella istanza creata dal main... e lasciare definiti i metodi della SwitchboardGui nella sua classe... é corretto?