Netbeans 6.0 utilizando o ProgressBar para processamento, como implementar!

[rockstorm]

Bom dia,
Criei um projeto Swing no Netbeans com Java Desktop Application e ele cria um JFrame inicial para mim. Neste Frame já vem o JProgressBar implantado.
Estou precisando implementar no meu sistema, pois o mesmo realiza um processamento de geração de boletos bancarios.

o trecho corresponde ao que o Netbeans criou:

        // status bar initialization - message timeout, idle icon and busy animation, etc
        ResourceMap resourceMap = getResourceMap();
        int messageTimeout = resourceMap.getInteger("StatusBar.messageTimeout");
        messageTimer = new Timer(messageTimeout, new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                statusMessageLabel.setText("");
            }
        });
        messageTimer.setRepeats(false);
        int busyAnimationRate = resourceMap.getInteger("StatusBar.busyAnimationRate");
        for (int i = 0; i < busyIcons.length; i++) {
            busyIcons[i] = resourceMap.getIcon("StatusBar.busyIcons[" + i + "]");
        }
        busyIconTimer = new Timer(busyAnimationRate, new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                busyIconIndex = (busyIconIndex + 1) % busyIcons.length;
                statusAnimationLabel.setIcon(busyIcons[busyIconIndex]);
            }
        });
        idleIcon = resourceMap.getIcon("StatusBar.idleIcon");
        statusAnimationLabel.setIcon(idleIcon);
        progressBar.setVisible(false);

        // connecting action tasks to status bar via TaskMonitor
        TaskMonitor taskMonitor = new TaskMonitor(getApplication().getContext());
        taskMonitor.addPropertyChangeListener(new java.beans.PropertyChangeListener() {
            public void propertyChange(java.beans.PropertyChangeEvent evt) {
                String propertyName = evt.getPropertyName();
                if ("started".equals(propertyName)) {
                    if (!busyIconTimer.isRunning()) {
                        statusAnimationLabel.setIcon(busyIcons[0]);
                        busyIconIndex = 0;
                        busyIconTimer.start();
                    }
                    progressBar.setVisible(true);
                    progressBar.setIndeterminate(true);
                } else if ("done".equals(propertyName)) {
                    busyIconTimer.stop();
                    statusAnimationLabel.setIcon(idleIcon);
                    progressBar.setVisible(false);
                    progressBar.setValue(0);
                } else if ("message".equals(propertyName)) {
                    String text = (String)(evt.getNewValue());
                    statusMessageLabel.setText((text == null) ? "" : text);
                    messageTimer.restart();
                } else if ("progress".equals(propertyName)) {
                    int value = (Integer)(evt.getNewValue());
                    progressBar.setVisible(true);
                    progressBar.setIndeterminate(false);
                    progressBar.setValue(value);
                }
            }
        });

Como eu implementaria isso para que mostrasse o status do meu processamento de geração de boletos???

grato

[maior_abandonado]

vc uso o matisse né???

eu mesmo não sou muito apegado a ele por que tenho dificuldade em editar o codigo gerado por ele (da pra fazer isso mais eu não sou muito bom nisso…)

bom… codificando tudo no dedo mesmo, vc faz o seguinte:

vc vai ter que colocar um numero total pra barra:

progresso.setMaximum(100);

depois disso chame a sua outra classe que faz o boleto, seu respectivo metodo, etc…

feito isso, na sua classe que faz o boleto, vc vai ter que ir atualizando a JProgressBar, usando o metodo setValue(x), onde x é o valor de quanto do processamento ja foi feito.

exemplo bem geral:

[code]
…
public JProgressBar progresso=new JProgressBar();

progresso.setMaximum(100); //100 ésó um exemplo, pode ser o tamanho do seu boleto, ou 100 mesmo pra porcentagem
progresso.setValue(0);
…

//crie 2 threads, uma para chamar sua classe Boleto, e outra para atualizar a JProgressBar

//

//thread 1

synchronized(this) {
notify();
progresso.setValue(Boleto.status);
}

//thread 2

Boleto b=new Boleto(); //pro exemplo a chamei assim
b.geraBoleto();

//na sua outra classe boleto, cria um int status, controlando ele pra ter a porcentagem de quanto ja foi feito, ou seja, um numero de 1 a 100, assim ir atualizando pela thread 1 ali em cima, no passado ao fazer isso, deixei esse int ai estatico, por facilidade, caso vc não o fizer, vc vai ter que chamar a variavel status do objeto que vc chamou…[/code]

o matisse tem opções de gerar codigo antes ou depois do objeto selecionado… acho que isso te seria util nas partes de inicializa o valor JProgressBar…

bom… espero ter ajudado

[LG11]

eu poderia usar um thread no progressbar?

[maior_abandonado]

como assim uma thread no jprogressbar???

vc vai ter a thread principal do seu programa, que se nao me engano se chama main.

neste caso que eu exemplifiquei vc vai ter outra thread que vai chamar a classe que faz o processamento demorado (essa operação esta sendo feita em outra thread, pq se for feita na mesma que foi criado o ambiente grafico, ao chamar esse processamento demorado, a tela irá travar até que o processamento termine, pois o processo irá cuidar primeiro da regra de negocio e depois vai atualizar a tela).

na outra thread que atualiza a jprogressbar, deve ser colocada em um loop que va atualizando a barra até que ela esteja cheia e depois saia do loop (eu nunca tentei fazer isso, mais se colocarmos essa atualização na thread main, sendo chamada pelo mesmo evento que manda a outra thread chama o processamento, ai acredito eu que esse loop tb vai trava a sua janela, pois o processo vai ficar no loop té sair dele, ou seja, em atualiza a barra para que só depois de sair desse loop, atualize a janela

essa atualização esta sendo colocada em outra thread pois caso contrario a unica coisa que funcionaria no ambiente grafico é barra ( por isso tal pratica seria util caso vc quisesse que o usuario não fizesse “NADA” até o processamento terminar, mais assim mesmo ele veria o status… seria legal nesse caso coloca um botão de cancelar pro kra não precisar esperar caso demore mto…algo assim)

[LG11]

eh pra um screen que abre na frente do programa. :-o
ela tem um progressbar. dai queria daber se dava pra implementar o sleep.

enrola a pessoa um poco pra pensa que o programa eh pesado. (na verdade ta grande… mas qro fazer isso pra faze-lo esperar)
xD

[maior_abandonado]

bom…eu tinha feito um exemplo pra coloca aqui… acho que te é util.

//imports gerais
public class Janela extends JFrame implements Runnable{

        public JProgressBar progresso=new JProgressBar();

        public static void main(String args[]){
                Janela j = new Janela();  

                verifica=new Thread(j);//verifica é a minha regra de negocio, o processamento em si
                verifica.setName("verifica");
                atualiza=new Thread(j);
                atualiza.setName("atualiza");

                j.montaJanela();
        }

        public Janela() {
                super("nome da janela");
        }


        public void montaJanela(){

        //...

        progresso.setBounds(x,y,largura,tamanho);//no lugar de x, y etc coloque os valores inteiros
        //progresso.setIndeterminate(true); <<-- barrinha igual a do windows

        progresso.setStringPainted(true);
        //progresso.setValue(50);
        tela.add(progresso); //tela é o nome q dei ao meu container
        progresso.setVisible(true);

        ...
        }

        public void run(){
                while(true){

                    //System.out.println(Thread.currentThread().getName());

                    if (Thread.currentThread().getName().equals("verifica")){

                                //chama minha classe que faz o processamento

                    }else{


                        progresso.setMaximum(CopiarArquivo.tamanho);//copiararquivo é minha classe de processamento, tamanho é um atributo estatico (acessivel sem precisa instancia), que contem o tamanho do arquivo, assim o valor maximo da barra
                        acao.setText(CopiarArquivo.label);
                        progresso.setValue(CopiarArquivo.status);//assim eu pego quanto ja foi copiado, pelo int status tb estatico , e jogo no valor da barra, ele sobe essa porcentagem e escreve o mesmo

                        try {// .sleep é pra nao trava a cpu
                            Thread.currentThread().sleep(100);
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }	

                    }
                }

        }

}

se vc quer enrola a pessoa, vc pode fazer como eu tinha falado, coloca o loop de atualiza a barra dentro da emsma thread que cria a janela, no ActionListener que manda a outra thread executa o processamento, eu costumo coloca isso dentro do metodo criaJanela…

se vc quer coloca essa barra em uma outra janela e dexa a anterior de lado, vc pode da um setVisible(false) na outra e dexa só a janela da barra (o que vai ser uma sacanagem com o usuario…kkkkkkkkkkkk), chamando uma JDesktopPane, algo assim, com a barra até que ela termine e ve se não esquece de da o setVisible(true) depois que acabar… deixe essa linha depois da que chama o processamento pra garantir que só apareça depois do processamento acaba e ai vc mata a janela da barra…

vc googando direitinho vc encontra exemplo pronto de um JFrame só com a barra de atualização (experiencia propria pois no passado fiz isso )…

pra muda pra otro tipo nao é dificil…

[hlds]

Legal, eu tive duvidas qto a isso.

So 1 pergunta, esse negocio de setar o status de andamento do processamento da tarefa (demorada) no proprio codigo dessa tarefa, n tem como setar em outro canto ne? Pq acheio meio “feio” colocar esse status dentro do codigo, pq cria uma certa dependencia do codigo do processo ter q setar o status, mas eu acho q n tem p onde correr msm.