[JAVA] Aumentare jFrame con i thread

[miao84]

ciao vorrei ottimizzare la mia precedente soluzione di ingrandire un jFrame. Prima aumentavo la dimensione dello stesso tramite un semplice for ora vorrei utilizzare i thread. Ho abbozzato un po di codice ma non sono riuscito a farlo funzionare...

public class Amministrazione extends javax.swing.JFrame {
    .....
    .....


    public Amministrazione() {
       initComponents();
       .....
    }


    class AutoRefreshFrame extends JFrame implements Runnable {

		private boolean isAlive = false;

		public void start() {
			Thread t = new Thread();
			isAlive = true;
			t.start();
		}

		public void run() {
			int x = 375;
			while (isAlive) {
				try {
                                        this.setSize(x++, 704);
					Thread.sleep(1000);
					if (x == 670) {
						isAlive = false;
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

	}
......

private void jButtonIngrandisciActionPerformed(java.awt.event.ActionEvent evt) { 
   if (this.getWidth()==375){
        Amministrazione.AutoRefreshFrame refresh=new Amministrazione.AutoRefreshFrame();
        refresh.start();
        refresh.run();
        ......

Nel momento in cui pigio il bottone dovrebbe aumentare il frame. Non ho nessun errore ma non va, e l'errore è sicuramente mio!....

[banryu79]

La chiamata a refresh.run() è eseguita nel metodo actionPerformed.
Il metodo actionPerformed viene chiamato dall'EDT percui quando poi vai a invocare una sleep sul thread corrente in refresh.run() il thread corrente è l'EDT... (L'EDT è il thread che consuma la coda degli eventi di AWT/Swing: finchè lo tieni occupato a fare varie operazioni non può chiaramente processare la grafica. Nel tuo caso siccome x vale 375 e bisogna aspettare che arrivi a valere 704 perchè si esca dal ciclo, hai che 704-375=329 chiamate a Thread.sleep per la durata di circa un sec., ovvero devi aspettare 329 secondi per vedere il tuo frame crescere di colpo. Infatti le chiamate a setSize() vengono effettivamente accodate nella coda degli eventi, solo che il povero EDT è diligentemente impegnato a eseguire il tuo ciclo).

[miao84]

mmm, quindi mi sconsigli di usare i thread per ingrandire il frame? perchè io in realtà vorrei distenderlo fino alla grandezza massima (670px) in modo graduale non di botto

[banryu79]

No, non ti sconsiglio di utilizzare i thread, perchè per fare quello che vuoi tu devi proprio utilizzare i thread!
(Beh, non è proprio così, vedi in calce al post, ma il succo della questione è che in casi come questo entrano in gioco almeno due thread, dunque non si scappa).

Solo che devi usarli correttamente:

1) Considerato che i metodi dei vari listener vengono chiamati non dal tuo codice ma dal framework AWT/Swing nel thread noto come EDT, e che quindi devi stare attento a non tenerlo impegnato con operazioni troppo lunghe, devi neccessariamente creare e avviare un altro thread per eseguire il tuo codice.

2) E in più, se nel tuo codice, ad un certo punto, devi eseguire chiamate a metodi che mutano lo stato di oggetti grafici (tipo la chiamata a setSize su un componente) devi assicurarti che queste chiamate non vengano eseguite dal tuo thread appena lanciato, ma di nuovo dall'EDT, perchè l'architettura di AWT/Swing è a thread singolo e appunto solo l'EDT deve accedere e manipolare i componenti grafici.

Ricapitolando con un'immagine:


Per il punto (1) la questione si risolve implementando un Runnable che esegua le computazioni costose in un thread che verrà creato e avviato dall'EDT, nel tuo caso, in risposta all'actionPerformed del listener.

Per il punto (2), nel tuo caso hai la chiamata a setSize da far eseguire all'EDT.
Puoi ottenere questo effetto "pubblicando" l'operazione da eseguire nella Event Queue di AWT/Swing, in modo che prima o poi l'EDT (che nel frattempo è tornato libero proprio di processare la event queue) se la ritrovi tra le mani e la esegua.
L'operazione da pubblicare può anche questa volta essere implementata con un Runnable, istanziata e quindi infilata nella coda degli eventi passandola come argomento al metodo SwingUtilities.invokeLater().

Per fare un esempio con il tuo caso, diciamo che per implentare ciò che è descritto al punto (1) definiamo un Runnable che chiamiamo ResizeAnimator.
ResizeAnimator opera su un JFrame quindi per essere istanziato bisognerà passargli un riferimento al frame sul quale eseguire l'"animazione".
Per il punto (2) definiamo un secondo Runnable che chiamiamo DoResize e che implementa solo la chiamata a setSize da mandare nella coda degli eventi perchè venga eseguita dall'EDT. DoResize verrà usato da ResizeAnimator che ne creerà un'istanza e la pubblicherà sulla Event Queue ogni volta che vorrà eseguire una operazione di resize sul frame.

class ResizeAnimator implements Runnable 
{
    final JFrame FRAME;
    final int HEIGHT;
    final int MAX_W;
   
    ResizeAnimator(JFrame frame, int toWidth) {
        FRAME = frame;
        HEIGHT = frame.getHeight();
        MAX_W= toWidth;
    }
    
    public void run() {
        int w = FRAME.getWidth();
        while (w < MAX_W) {
            w++;
            SwingUtilities.invokeLater(new DoResize(w));
            try { Thread.sleep(1000); } 
            catch (InterruptedException ignored) {}
        }
    }
    
    class DoResize implements Runnable  
    {
        final int WIDTH;
        
        DoResize(int width) {
            WIDTH = width;
        }
        
        public void run() {
            FRAME.setSize(WIDTH, HEIGHT);
        }
    }
}

per poi usare ResizeAnimator così:

...
    public void actionPerformed() {
        // This method is call on the EDT!
        Thread t = new Thread(new ResizeAnimator(myFrame, 670));
        t.start();
       // now the EDT is again free to go & process the event queue
    }
...

disclaimer: codice non scritto in un IDE ne compilato e testato: può contenere errori.

P.S.: l'alternativa alle "acrobazie" qui sopra è usare la classe javax.swing.SwingWorker.
P.P.S.: Inoltre considerando che in pratica devi eseguire sempre la stessa azione ogni tot. tempo potresti forse cambiare stategia per la tua soluzione e considerare l'uso di un timer (javax.swing.Timer).

@EDIT: se può farti comodo ti consiglio questo tutorial breve ed efficace a Swing

[miao84]

ti ringrazio molto, sopratutto per la spiegazione! il codice funziona (anche se ha delle prestazioni un po scadenti!) deduco che sei un esperto del linguaggio....mi sapresti consigliare come diventare padrone del linguaggio? Io mi dedico facendo dei piccoli esperimenti per conto mio ma mi accorgo che, come in questo caso, devo ricorrere a internet per cose a volte anche semplici. Mi sapresti consigliare un buon manuale? Ne ho visti alcuni in libreria ma non ne ho mai acquistato alcuno poichè non li ritenevo abbastanza "avanzati" e completi dal punto di vista pratico

[banryu79]

Originariamente inviato da miao84

ti ringrazio molto, sopratutto per la spiegazione! il codice funziona (anche se ha delle prestazioni un po scadenti!) deduco che sei un esperto del linguaggio....mi sapresti consigliare come diventare padrone del linguaggio?

Prego, è un piacere essere strumento per l'apprendimento altrui.
Per quanto riguarda l'esperto, è meglio se non ti fai ingannare dalle apparenze
Anche se in passato ho usato Java per un progetto di lavoro alla fine sono solo un hobbista del linguaggio e di alcune sue librerie. In concreto non ho l'effettiva esperienza di un professionista alla luce della quale uno può essere considerato "esperto"; però conosco i concetti base del framework Swing, smanettandoci da anni.

Originariamente inviato da miao84

Io mi dedico facendo dei piccoli esperimenti per conto mio ma mi accorgo che, come in questo caso, devo ricorrere a internet per cose a volte anche semplici. Mi sapresti consigliare un buon manuale? Ne ho visti alcuni in libreria ma non ne ho mai acquistato alcuno poichè non li ritenevo abbastanza "avanzati" e completi dal punto di vista pratico

La "bibbia" per il framework Swing è "Java Swing" (seconda edizione) della O'Reilly.
Per cominciare però potresti leggere il tutorial scritto da PGI-Bis che ho in firma: 50 paginette scritte veramente bene che non impegnano più di qualche oretta e danno tanto in termini di chiarezza e immediatezza.
Poi ci sarebbero (sempre online) i Java Tutorial sul sito della Oracle.
In particola per Swing ci sono queste due trail (la prima è introduttiva, il succo è nella seconda e nei vari capitoletti "How To...")
Trail: Graphical User Interfaces
Trail: Creating a GUI With JFC/Swing

Link al compendio dei tutorial:
The Really Big Index

EDIT: per quanto riguarda le prestazioni scadenti, vedi un po' cosa succede se nel ciclo di ResizeAnimator alla Thread.sleep passi solo 50 millisec invece di 1000

ARI-EDIT: e, forse è scontato ma è meglio dirlo: se programmi abitualmente in Java allora devi assolutamente scaricarti una copia in locale dei Javadoc del JDK e tenerteli appicicati come le mosche alla... ehm, al miele

[banryu79]

Ciao,
se sei ancora interessato, ho provato a parametrizzare ResizeAnimator e a implementare un test (ero curioso di vederlo girare per controllare l'effetto visivo della cosa).

Ora l'effetto di animazione di ResizeAnimator è parametrizzabile nel senso che permette di definire uno "step temporale" (quanti millisecondi passano tra un resize e l'altro) e uno "step in pixel" (incremento in pixel provocato ad ogni resize).

ResizeAnimator:

package resizeanimator;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;

/**
 * Class ResizeAnimator...
 * @author Francesco Baro
 */
class ResizeAnimator implements Runnable
{
    final JFrame FRAME;
    final int HEIGHT;
    final int MAX_W;
    long millis = 20;
    long pixelStep = 5;

    ResizeAnimator(JFrame frame, int toWidth) {
        FRAME = frame;
        HEIGHT = frame.getHeight();
        MAX_W= toWidth;
    }

    public void setTimeStep(long millis) {
        this.millis = (millis > 20) ? millis : 20;
    }

    public void setPixelStep(int pixels) {
        this.pixelStep = (pixels > 0) ? pixels :1;
    }

    @Override public void run() {
        int w = FRAME.getWidth();
        while (w < MAX_W) {
            w += pixelStep;
            SwingUtilities.invokeLater(new DoResize(w));
            try { Thread.sleep(millis); }
            catch (InterruptedException ignored) {}
        }
    }

    class DoResize implements Runnable
    {
        final int WIDTH;

        DoResize(int width) {
            WIDTH = width;
        }

        @Override public void run() {
            FRAME.setSize(WIDTH, HEIGHT);
        }
    }
}

Classe per il test:

package resizeanimator;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

/**
 * Class ResizeTest...
 * @author Francesco Baro
 */
public class ResizeTest implements ActionListener
{
    private final JFrame FRAME;
    private ResizeAnimator animator;

    public ResizeTest(int w, int h) {
        FRAME = new JFrame("Resize animation test");
        FRAME.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

        JPanel panel = new JPanel();
        panel.setBackground(Color.darkGray);
        panel.setPreferredSize(new Dimension(w, h));
        FRAME.add(panel);


        JButton bClose = new JButton("Close");
        bClose.addActionListener(this);
        JButton bResize = new JButton("Resize");
        bResize.addActionListener(this);
        JPanel bPan = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        bPan.add(bResize);
        bPan.add(bClose);
        FRAME.add(bPan, BorderLayout.SOUTH);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();

        if ("Close".equals(command)) {
            WindowEvent closing = new WindowEvent(FRAME, WindowEvent.WINDOW_CLOSING);
            FRAME.dispatchEvent(closing);
        }

        if ("Resize".equals(command)) {
            final int TO_WIDTH = FRAME.getWidth() + 50;
            animator = new ResizeAnimator(FRAME, TO_WIDTH);
            animator.setTimeStep(20);
            Thread t = new Thread(animator);
            t.start();
        }
    }

    public void show() {
        SwingUtilities.invokeLater(new Runnable() {
            @Override public void run() {
                FRAME.pack();
                FRAME.setLocationRelativeTo(null);
                FRAME.setVisible(true);
            }
        });
    }

    public static void main(String[] args) {
        ResizeTest test = new ResizeTest(640, 480);
        test.show();
    }
}