[Java][Pillola] Progress Bar che si interfaccia al task

[dekdek]

Una classe e una semplice interfaccia che consentono di controllare una Progress Bar senza dover stare a definire ogni volta timer e cose simili.

Cominciamo dall'interfaccia, che non ha bisogno di commenti. E' richiesto che il task fornisca lo stato iniziale, attuale e finale dell'operazione.

/*
 * DeKTaskObserver.java
 *
 * Created on 5 aprile 2005, 22.17
 */

package dek;

/**
 * La classe che implementa <code>DeKTaskObserver</code> si 
 * impegna a fornire informazioni sullo stato di avanzamento
 * di un task in esecuzione nel suo contesto.

 * In particolare, una chiamata a <code>taskStatus()</code> mentre 
 * il task non e' ancora iniziato dovrebbe equivalere a
 * <code>taskStatus(Bounds.MIN)</code>, mentre una chiamata a
 * task completato dovrebbe equivalere a <code>taskStatus(Bounds.MAX)</code>

 * Cio' potrebbe essere difficile da ottenere, nel senso che lo
 * stato di task completato potrebbe coincidere con quello di
 * task (successivo) non ancora iniziato.
 *
 * @author DeK
 */
public interface DeKTaskObserver {
    
    /**
     * Costanti per indicare il valore iniziale e finale
     * dello stato del task.
     */
    enum Bounds {MIN, MAX};
    
    /**
     * Ritorna lo stato attuale del task sottoforma di un valorei intero.

     * Il valore dovra' essere compreso fra i due estremi
     * ritornati dall'altro metodo: 
     * @see #taskStatus(Bounds)
     */
    public int taskStatus();
    
    /**
     * Ritorna il valore iniziale (MIN) o finale (MAX)
     * dello stato del task.

     * Dovra' essere: <code>taskStatus(Bounds.MIN) &lt;= taskStatus(Bounds.MAX)</code>

     * Un'implementazione standard puo' essere ottenuta ritornando
     * 0 per il minimo e 100 per il massimo: 
     * <code>return (b==Bounds.MIN)? 0 : 100;</code>
     */
    public int taskStatus (Bounds b);
    
}

[dekdek]

Questa e' la classe:

/*
 * DeKProgressBar.java
 *
 * Created on 10 aprile 2005, 18.38
 */

package dek;

import static dek.DeKTaskObserver.Bounds;

import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

/**
 * @version 1.1
 * @author DeK
 */

public class DeKProgressBar extends JProgressBar {
    
    private DeKTaskObserver monitorDPB;
    private Timer updater;
    private int milli;

    private final Azione setProgress = new Azione();
    public static final int DEFAULT_TIME = 500; // Timer di default a mezzo secondo
    
    public DeKProgressBar() {
        this(DEFAULT_TIME);
    }
    
    public DeKProgressBar(int milliseconds) {
        this(milliseconds, null);
    }
    
    public DeKProgressBar(DeKTaskObserver dto) {
        this(DEFAULT_TIME, dto);
    }
    
    public DeKProgressBar(int milliseconds, DeKTaskObserver task) {
        super();
        setTaskObserver(task);
        setMillis(milliseconds);
    }
    
    private void createUpdater() {
        updater = new UpdatePB();
    }
    
    public void setTaskObserver(DeKTaskObserver dto) {
        monitorDPB = dto;
        createUpdater();
    }
    
    public DeKTaskObserver getTaskObserver() {
        return monitorDPB;
    }
    
    public void setMillis(int t) {
        milli = t;
    }
    
    public int getMillis() {
        return milli;
    }
    
    private void start() {
        setMinimum(getTaskObserver().taskStatus(Bounds.MIN));
        setMaximum(getTaskObserver().taskStatus(Bounds.MAX));
        run();
        updater.start();
    }
    
    private void stop() {
        updater.stop();
        run();
    }
    
    public boolean setRunning(boolean flag) {
        if (updater==null)
            return false;
        assert (monitorDPB != null);
        if (flag && !updater.isRunning())
            start();
        else if (!flag && updater.isRunning())
            stop();
        else return false;
        return true;
    }
    
    private void run() {
        SwingUtilities.invokeLater(setProgress);
    }
    
    // Timer
    private final class UpdatePB extends Timer {
        
        public UpdatePB() {
            super(DeKProgressBar.this.getMillis(), setProgress);
        }
    }
    
    // Callback Action
    private class Azione extends AbstractAction implements Runnable {
        
        public void run() {
            setValue(getTaskObserver().taskStatus());
        }
        
        public void actionPerformed(ActionEvent e) {
            run();
        }
    }
    
}

La classe UpdatePB forse non serve piu'. Inizialmente conteneva... praticamente tutto il codice!!!

[dekdek]

E questo e' un esempio veloce veloce...

package dek;

import javax.swing.JFrame;

// NON SI SCRIVONO COSI' I PROGRAMMI!!!!!! ^___^

public class Prova extends JFrame implements DeKTaskObserver, Runnable {
    
    int t=0;
    final static int LUNG = 10000;
    DeKProgressBar barra;
    
    public Prova() {
        super("Prova DeKProgressBar");
        barra = new DeKProgressBar(200, this);
        getContentPane().add(barra);
        pack();
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Thread t = new Thread(this);
        t.start();
    }
    
    public static void main(String[] args) {
        Prova prova = new Prova();
    }

    // Implementazione dei metodi di Runnable
    
    public void run() {
        barra.setRunning(true);
        while (t<LUNG) {
            int delta =(int)(Math.random()*200);
            try { // Questo serve perche' ho usato sleep... Uff...
                Thread.sleep(100); // Fa (finta di fare) qualcosa
            } catch (Throwable t) {}
            t+=delta;
        }
        barra.setRunning(false);
    }
    
    // Implementazione dei metodi di DeKTaskObserver
    
    public int taskStatus(Bounds b) {
        if (b==Bounds.MIN)
            return 0;
        return LUNG;
    }
    
    public int taskStatus() {
        return t;
    }
    
}

[maurizio2]

Ma cosa dovrebbe fare questo programma?
Come posso metterlo in funzione per capirlo??

[dekdek]

Ma cosa dovrebbe fare questo programma?

Effettivamente mi sono sprecato nelle spiegazioni, eh?
In pratica e' una Progress Bar (le barre che si riempiono man mano che un task viene completato, come quella del browser mentre carica una pagina)
Grazie ad un'interfaccia, preleva lo stato di avanzamento direttamente da un oggetto (che puo' essere il task stesso) piuttosto che essere coordinato da un terzo elemento.
Si usa il metodo setTaskObserver () per fornire tale oggetto alla barra, e setMillis() per definire l'intervallo fra un aggiornamento e l'altro della barra.
Quindi si attiva la barra con setRunning(true).
Con setRunning(false) la si disattiva.

Come posso metterlo in funzione per capirlo??

Metti tutti e tre i file in un package di nome dek.
Dovrebbe bastare.

[ale500]

scusa ma sei sicuro che enum sia un tipo valido???
a me da un super errore...

questo enum mi ricorda VB....

[netarrow]

Originariamente inviato da ale500
scusa ma sei sicuro che enum sia un tipo valido???
a me da un super errore...

questo enum mi ricorda VB....

devi avere Java 5 o superiore.

[dekdek]

E' il cosiddetto typesafe enum. Esiste dalla JDK5.0 in poi. E' typesafe perche' l'inserimento di un parametro che non fa parte della classe (in effetti enum definisce una classe) puo' essere individuato a tempo di compilazione.

Sempre a tempo di compilazione, l'enum viene trasformato in una Enum. Solo che i dettagli, appunto, sono lasciati al compilatore.

Puoi sostituirlo con due valori qualsiasi...

[ale500]

ma non poteva essere sostituito con dei classici getValoreMax o setValoreMax se ti serviva per essere conmpatibili con tutti...

visto che ancora la SDK 5.0 non è considerata l'ufficiale o cmq non è l'unica consigliata?

[dekdek]

Beh, mi sa che sto un po' abusando delle nuove caratteristiche, ma d'altronde le modifiche sono semplici da implementare.