[Java] Progress Bar

[max246]

Ho un problema, devo fae un progeress bar per far vedere che il programma Java mi sta aprendo ( siccome va a leggere la AD di diversi domini .. perciò ci mette un po... ). Ma per mia sfortunata la barra appare quando il programma è caricato, invece la finestra quando apro il programma.

Inoltre vorrei fare la stessa cosa quando faccio una operazione un pò lunga, tanto per far vedere che il programma non è crashato.

ecco il mio codice:

public class Caricamento {
    private JFrame frame;
    private JProgressBar progress;
    /** Creates a new instance of Caricamento */
    public Caricamento(int g) {
        frame = new JFrame("Caricamento");
        progress = new JProgressBar(0, g);
        frame.getContentPane().add(progress);
        int width = 300;
        int height = 60;
        progress.setValue(10);
        progress.setIndeterminate(true);
        frame.setSize(width, height);
        frame.setVisible(true);
    }
    public void SetLoading(int i) {
        progress.setValue(i);
    }
    public void Invisibile() {
        frame.setVisible(false);
    }
    public void Visibile() {
        frame.setVisible(true);
    }
}

Ho provato a creare l'oggetto nel main, poi per il mio secondo scopo renderla visibile.. ma la creazione della barra viene visualizzata solamente dopo la conclusione delle operazioni.

C'è un modo per forzare PRIMA il caricamento della barra POI il resto del programma?

[Oceans11]

in attesa che passi di qui qualcuno più bravo....

io avevo lo stesso problema e ho risolto con Runnable...avevo in pratica 3 thread che gestivano

1) la barra
2) il programma
3) la gui

e li avvi nell'ordine...il 2 ed il 3 magari usando SwingUtilities.invokeLater()

certo che come soluzione probabilmente fa schifo...ma intanto...

[max246]

Helppp un esempio!!!!

[PGI-Bis]

Due classi, una in coda all'altra, nello stesso sorgente...per pigrizia

Il Main crea e mostra una barra di progresso divisa in 100 sezioni. Simula il progredire dell'inizializzazione e al termine dei 100 passi chiude la finestra della barra e apre quella del programma principale.

Ho commentato lo stretto necessario. Se hai domande, dubbi, curiosità, non esitare a chiedere.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;

public class Main {
	public static void main(String[] args) {
		ProgressFrameManager progressFrame;
		/** Tenta di creare un ProgressFrameManager... */
		try {
			progressFrame = ProgressFrameManager.newInstance();
		} catch(InterruptedException ex) {
			/** Se il Thread è stato interrotto allora il progress frame potrebbe
			non essere ancora correttamente inizializzato: zona pericolo,
			non va. */
			System.err.println("UI Initialization interrupted");
			return;
		}
		
		/** Tutto ok, John. Si parte. */
		progressFrame.show();
		
		/** Simula l'esecuzione dei 100 passaggi di inizializzazione */
		for(int i = 0; i < 100; i++) {
			executeInitializationStep();
			/* Al termine di ogni passaggio fa avanzare la barra */
			progressFrame.advance();
		}
		
		/** Chiude la finestra con la barra di progresso */
		progressFrame.hide();
		
		/** E apre la finestra del programma principale. */
		openProgramWindow();
	}
	
	/** Simula un passo necessario per l'avvio del programma */
	private static void executeInitializationStep() {
		try {
			Thread.sleep(100);
		} catch(InterruptedException ex) {
			System.err.println("waitus interruptus!");
			System.exit(1);
		}
	}
	
	/** Apra un simulacro della finestra principale sullo schermo. */
	private static void openProgramWindow() {
		SwingUtilities.invokeLater(new Runnable() { public void run() {
			JFrame window = new JFrame("Finestra principale");
			window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
			window.setSize(640, 480);
			window.setLocationRelativeTo(null);
			window.setVisible(true);
		}});
	}
}

/** Questa classe gestisce una finestra "splash" che propone una barra
di progresso. L'interazione con la barra di progresso è predisposta per
l'uso in contesti concorrenti. */
class ProgressFrameManager {
	/** Questo metodo crea e restituisce un ProgressFrameManager. La
	creazione del componente è affidata all'AWT Event Dispatcher Thread.
	L'invocazione di questo metodo blocca (con rientro) il Thread invocante
	finchè l'AWT Event Dispatcher Thread non abbia terminato
	l'inizializzazione. */
	public static ProgressFrameManager newInstance() 
		throws InterruptedException
	{
		ProgressFrameManager pfm = new ProgressFrameManager();
		pfm.init();
		return pfm;
	}
	
	/** La finestra che proietta la barra di prgresso */
	private JFrame window;
	/** Il modello della barra di progresso */
	private BoundedRangeModel progressModel;
	
	/** Serratura rientrante per il controllo dell'inizializzazione */
	private Lock initLock = new ReentrantLock();
	/** Condizione di attesa per l'inizializzazione */
	private Condition initCondition = initLock.newCondition();
	/** Valore di controllo per l'avvenuta inizializzazione */
	private final AtomicBoolean initialized = new AtomicBoolean();
	
	
	
	/** Compito dell'EDT per l'inizializzazione */
	private final Runnable initializer = new Runnable() {
		public void run() {
			/** Crea la finestra */
			window = new JFrame("Progress monitor");
			/** Crea il modello della barra di progresso */
			progressModel = new DefaultBoundedRangeModel(0, 0, 0, 100);
			/** Crea la barra di progresso usando il modello */
			JProgressBar progressBar = new JProgressBar(progressModel);
			/** Aggiunge la barra di progresso alla finestra */
			window.add(progressBar);
			/** Toglie il bordo e il titolo alla finestra (tipo splash)*/
			window.setUndecorated(true);
			/** Convalida l'avvenuta inizializzazione... */
			initialized.set(true);
			
			/** E la notifica ai Thread bloccati */
			initLock.lock();
			try {
				initCondition.signal();
			} finally {
				initLock.unlock();
			}
		}
	};
	
	/** Compito dell'EDT : aggiornamento della barra di progresso. */
	private final Runnable progressUpdater = new Runnable() {
		public void run() {
			int value = progressModel.getValue();
			int max = progressModel.getMaximum();
			if(value < max) {
				value++;
				progressModel.setValue(value);
			}
		}
	};
	
	/** Compito dell'EDT : chiusura della finestra della barra di
	progresso */
	private final Runnable frameDisposer = new Runnable() {
		public void run() {
			window.dispose();
		}
	};
	
	/** Compito dell'EDT: proiezione della finestra sullo schermo. */
	private final Runnable frameProjector = new Runnable() {
		public void run() {
			window.pack();
			window.setLocationRelativeTo(null);
			window.setVisible(true);
		}
	};
	
	/** Il costruttore privato impedisce la maggior parte delle scempiaggini
	*/
	private ProgressFrameManager() {}
	
	/* Inizializza l'istanza corrente di ProgressFrameManager */
	private void init() throws InterruptedException {
		if(SwingUtilities.isEventDispatchThread()) {
			initializer.run();
		} else {
			SwingUtilities.invokeLater(initializer);
			initLock.lock();
			try {
				while(!initialized.get()) {
					initCondition.await();
				}
			} finally {
				initLock.unlock();
			}
		}
	}
		
	/** Fa avanzare di un  passo la barra di progresso */
	public void advance() {
		if(!initialized.get()) {
			throw new IllegalStateException("UI Not initialized");
		}
		if(SwingUtilities.isEventDispatchThread()) {
			progressUpdater.run();
		} else {
			SwingUtilities.invokeLater(progressUpdater);
		}
	}
	
	/** Chiude la finestra della barra di progresso */
	public void hide() {
		if(!initialized.get()) {
			throw new IllegalStateException("UI Not initialized");
		}
		if(SwingUtilities.isEventDispatchThread()) {
			frameDisposer.run();
		} else {
			SwingUtilities.invokeLater(frameDisposer);
		}
	}
	
	/** Mostra sullo schermo la finestra della barra di progresso */
	public void show() {
		if(!initialized.get()) {
			throw new IllegalStateException("UI Not initialized");
		}
		if(SwingUtilities.isEventDispatchThread()) {
			frameProjector.run();
		} else {
			SwingUtilities.invokeLater(frameProjector);
		}
	}
}

[max246]

Ho provato a mettere questo codice:

    public static void main(String[] args) {
        Caricamento load = new Caricamento(100);
        load.Visibile();
        for (int x = 0;x < 20;x++) {
        executeInitializationStep();
        }
       
        SwingUtilities.invokeLater(new Runnable() { public void run() {
        String nativeLF = UIManager.getSystemLookAndFeelClassName();
        
        // Install the look and feel
        try {
            UIManager.setLookAndFeel(nativeLF);
        } catch (InstantiationException e) {
        } catch (ClassNotFoundException e) {
        } catch (UnsupportedLookAndFeelException e) {
        } catch (IllegalAccessException e) {
        }
        
                new Main().setVisible(true);
           
       }});
        
         load.Invisibile();
    }

Però mi appare la barra e mi scompare dopo il for, non aspetta che il main è caricato... come posso fare?

[PGI-Bis]

Il metodo executeInitializationStep, invocato nel ciclo, è lì come simulacro dell'inizializzazione reale.

Quello che devi fare è sostituire a quel simulacro l'effettiva inizializzazione.

mostra la barra di avanzamento
avvia l'inizializzazione
+per ogni passo di inizializzazione fai avanzare la barra
chiudi la barra di avanzamento
apri l'interfaccia principale

Non è sufficiente avere una procedura di inizializzazione per poter mostrarne i passaggi in una barra di avanzamento. Occorre che quella procedura sia realizzata in modo tale da poter comunicare a qualcuno (nel nostro caso alla barra di progresso):

1. quanti passaggi occorrono
2. quanti passaggi sono stati compiuti
3. quando termina un passaggio

La tua procedura di inizializzazione del programma ha queste proprietà? Se non le ha devi dargliele. Una volta dotata di queste caratteristiche, la tua procedura di inizializzazione potrà dialogare con la barra "di avviamento" e, insieme, i due elementi riprodurranno l'effetto che vuoi ottenere.

[max246]

Sarebbe facile se il main non fosse static :P
Non posso richiamare delle variabili che ho creato nella classe main, come faccio?

[lovaz]

Dò anche io la mia versione che sto usando in un'app, così me la controllate

Il mio splash screen ha un'etichetta e una progress bar:

public class Splash
	extends JWindow
{
	private final JLabel label = new JLabel();
	private final JProgressBar progress = new JProgressBar();
	private final JPanel content = new JPanel();
	
	private final int tasks;
	private int currentTask;
	
	public Splash(int tasks)
	{
		this.tasks = tasks;
		currentTask = 0;

		label.setPreferredSize( new Dimension(200,30) );
		label.setHorizontalAlignment( JLabel.CENTER );

		...	// disegna la label e la pbar sul pannello content

		setContentPane( content );
		pack();

		// centra sullo schermo
		Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setLocation(screenSize.width/2 - (getWidth()/2),
        		screenSize.height/2 - (getHeight()/2) );
	}

il parametro tasks dice quanti task ci sono in tutto (in quante parti dividere la pbar).

Si fa "partire" con il metodo:

	public void start()
	{
		setVisible(true);
	}

prima di cominciare a creare l'interfaccia, e si ferma con:

	public void stop()
	{
		dispose();
	}

dopo aver finito.

I task si aggiungono con:

	public void startingTask(String message)
	{
		label.setText( message );
		progress.setValue( currentTask * 100 / tasks );

		currentTask++;
		
		content.paintImmediately( 0, 0, content.getWidth(), content.getHeight());
	}

in cui message è un messaggio del tipo "Initializing Color palette".

Tutto questo va fatto sull'EDT.

[max246]

Bello ma non mi aiuti :P
Cioè io vorrei solo un'aiutino per creare questa stupidissima progress bar per aspettare che il programmi si apri, ma se sono nello static void non posso modificare una variabile fuori da quell funzione

Help!

[lovaz]

Cioè ti serve una referenza allo splash screen?

[max246]

Originariamente inviato da lovaz

Cioè ti serve una referenza allo splash screen?

Devo fare un loading.. qualcosa per far vedere che il programma sta caricando e non che non hai aperto il file.