Desenvolvedor e Analista de Sistemas | IFPA

quarta-feira, 13 de agosto de 2014

SwingX Tutorial - Etiqueta Busy (JXBusyLabel)

com 0 Comentário

O que é um rótulo ocupado?

O ícone é utilizado para descrever uma tarefa que está em execução, que é de comprimento indeterminado. A tarefa pode demorar 10 minutos ou 10 segundos, não há nenhuma maneira de saber, eo usuário não pode realmente ter uma expectativa de quanto tempo esperar.
SwingX fornece uma implementação dessa funcionalidade na forma de JXBusyLabel e BusyPainter . Você pode usar o rótulo ocupado apenas como você faria com um normal, JXLabel , exceto que você pode adicionar um pintor a ele, que controla a pintura e animação do próprio rótulo ocupado.
Se você estiver usando versão v0.9.1 marco, então você ainda terá JXBusyLabel, mas um monte de funcionalidade descrita neste tutorial não estará disponível para você. Por que você deve baixar a última versão da API SwingX. Não se preocupe, uma compilação que trabalha está incluída nos arquivos do projeto que você pode baixar no final deste tutorial .

Exemplo de código fonte

No exemplo a seguir, vou criar dois componentes JXBusyLabel, que eu vou colocar em um JXPanel. Um irá trabalhar com versões mais antigas SwingX (a etiqueta simples) eo rótulo complexo vai exigir mais recente lançamento SwingX (após 0.9.1). Aqui está o que parece:
Este exemplo cria dois rótulos ocupado, uma simples e outra complexa. O rótulo simples ocupado irá trabalhar com versões mais antigas do SwingX (0.9.1), mas a um complexo requer compilações posteriores. Ambos os rótulos ocupadas começar desativado, e como você pode ver na imagem, que mistura no fundo quando eles são desativados. Quando você clica no botão "Start / Stop", que permite que os rótulos, e chama setBusy (true) sobre eles. Isto faz com que comece a girar e ficar animado. Quando você clica no botão novamente, o setBusy (false) método é chamado, parando a animação;eles ainda estão ativadas, mas não animado.

Etiqueta simples ocupado

Aqui está o código para criar um JXBusyLabel simples:

  1. público JXBusyLabel createSimpleBusyLabel () {  
  2.   Etiqueta JXBusyLabel = new JXBusyLabel ();  
  3.   label.setToolTipText ( "label simples ocupado" );  
  4.   retornar etiqueta;  
  5. }  
O código é muito simples. É como criar um JLabel simples. Note que não é possível definir o tamanho deste JXBusyLabel usando esse construtor. Na verdade, esta é uma das razões pelas quais você deve usar a última versão do SwingX, que adiciona um novo construtor e muito mais funcionalidades para este componente. Com esse código resulta em um rótulo ocupado que se parece com isso:
imagem

Rótulo complexo ocupado

Aqui está o código para criar um JXBusyLabel mais complexa:

  1. public JXBusyLabel createComplexBusyLabel() {  
  2.   // this will not work in the 0.9.1 release of SwingX (need later builds)  
  3.   JXBusyLabel label = new JXBusyLabel(new Dimension(3838));  
  4.   BusyPainter painter = new BusyPainter(  
  5.       new Rectangle2D.Float(008.0f, 8.0f),  
  6.       new Rectangle2D.Float(5.5f, 5.5f, 27.0f, 27.0f));  
  7.   painter.setTrailLength(4);  
  8.   painter.setPoints(8);  
  9.   painter.setFrame(-1);  
  10.   painter.setBaseColor(Colors.LightBlue.color());  
  11.   painter.setHighlightColor(Colors.Orange.color());  
  12.   label.setPreferredSize(new Dimension(3838));  
  13.   label.setIcon(new EmptyIcon(3838));  
  14.   label.setBusyPainter(painter);  
  15.   label.setToolTipText("complex busy label");  
  16.   return label;  
Há um par de coisas a notar sobre este código:
  1. Quando você cria o JXBusyLabel, você pode passar um objeto Dimension com ele, para especificar o tamanho da etiqueta ocupado.
  2. A fim de mudar o visual padrão do rótulo ocupado, você tem que aproveitar a classe BusyPainter, que na verdade controla o que o rótulo ocupado parece (fundo de destaque e cores, formato das entranhas de etiquetas, etc), e como ele anima (animação velocidade, etc). A boa notícia é que você não tem que codificar isso com a mão! Jan Haderka foi gentil o suficiente para fornecer um programa que permite que você configure tudo isso visualmente, e depois ele simplesmente cospe o código que você precisa inserir no seu programa! Eu recomendo que você jogar com o programa de Janeiro e tentar coisas diferentes; você vai se surpreender os diferentes tipos de rótulos ocupados você pode vir até com ... ele é limitado pela sua imaginação.
  3. Você pode alterar as cores utilizadas pelo pintor ocupado usando setBaseColor () e setHighlightColor (). A cor base é a "base" cor da etiqueta ocupado, ea cor de destaque é o que é pintado sobre ele periodicamente. Então, se você usar uma cor de base de luz azul, e cor de destaque de laranja, você começa algo como isto:

Resto do código

Além dos rótulos ocupados, não há outra JXLabel usado neste exemplo que usa um pintor e um ícone:
imagem
Aqui está o código que torna isso possível:

  1. public JXLabel createLabel() {  
  2.   JXLabel label = new JXLabel();  
  3.   label.setBorder(BorderFactory.createEmptyBorder(5555));  
  4.   label.setFont(new Font("Segoe UI", Font.BOLD, 14));  
  5.   label.setText("<html>BusyLabel Example...<br>click start/stop button</html>");  
  6.   label.setIcon(Images.NetworkDisconnected.getIcon(4040));  
  7.   label.setHorizontalAlignment(JXLabel.LEFT);  
  8.   label.setBackgroundPainter(getPainter());  
  9.   return label;  
  10. }  
  11. /** this painter draws a gradient fill */  
  12. public Painter getPainter() {  
  13.   int width = 100;  
  14.   int height = 100;  
  15.   Color color1 = Colors.White.color(0.5f);  
  16.   Color color2 = Colors.Gray.color(0.5f);  
  17.   LinearGradientPaint gradientPaint =  
  18.       new LinearGradientPaint(0.0f, 0.0f, width, height,  
  19.                               new float[]{0.0f, 1.0f},  
  20.                               new Color[]{color1, color2});  
  21.   MattePainter mattePainter = new MattePainter(gradientPaint);  
  22.   return mattePainter;  
Há algumas coisas a notar sobre este código:
  1. Eu costumava HTML para definir o texto deste rótulo, para que eu pudesse inserir uma quebra de linha.
  2. O pintor que serve para tornar o fundo desta etiqueta usa um simples gradiente linear 2 stop.
  3. Eu usei um EmptyBorder em torno da etiqueta para dar mais espaço ao redor do texto e imagem.

Lista completa fonte


  1. import org.jdesktop.swingx.*;  
  2. import org.jdesktop.swingx.icon.*;  
  3. import org.jdesktop.swingx.painter.*;  
  4. import javax.swing.*;  
  5. import java.awt.*;  
  6. import java.awt.event.*;  
  7. import java.awt.geom.*;  
  8. /** 
  9. * BusyLabelExample 
  10. * 
  11. * @author Nazmul Idris 
  12. * @version 1.0 
  13. * @since Feb 2, 2008, 2:43:30 PM 
  14. */  
  15. public class BusyLabelExample {  
  16. /** simple main driver for this class */  
  17. public static void main(String[] args) {  
  18.   SwingUtilities.invokeLater(new Runnable() {  
  19.     public void run() {  
  20.       new BusyLabelExample();  
  21.     }  
  22.   });  
  23. }  
  24. /** creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame. */  
  25. public BusyLabelExample() {  
  26.   JFrame frame = new JFrame("JXBusyLabel Example");  
  27.   // add the panel to this frame  
  28.   frame.add(doInit());  
  29.   // when you close the frame, the app exits  
  30.   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  31.   // center the frame and show it  
  32.   frame.setLocationRelativeTo(null);  
  33.   frame.pack();  
  34.   frame.setVisible(true);  
  35. }  
  36. /** creates a JXLabel and attaches a painter to it. */  
  37. private Component doInit() {  
  38.   JXPanel panel = new JXPanel();  
  39.   panel.setLayout(new BorderLayout());  
  40.   // create a busylabel  
  41.   final JXBusyLabel busylabel1 = createSimpleBusyLabel();  
  42.   final JXBusyLabel busylabel2 = createComplexBusyLabel();  
  43.   busylabel1.setEnabled(false);  
  44.   busylabel2.setEnabled(false);  
  45.   // create a label  
  46.   final JXLabel label = createLabel();  
  47.   // create a button  
  48.   JButton button = new JButton("start/stop");  
  49.   button.addActionListener(new ActionListener() {  
  50.     public void actionPerformed(ActionEvent e) {  
  51.       if (!busylabel1.isEnabled()){  
  52.         busylabel1.setEnabled(true);  
  53.         busylabel2.setEnabled(true);  
  54.       }  
  55.       if (busylabel1.isBusy()) {  
  56.         label.setText("BusyLabel stopped");  
  57.         busylabel1.setBusy(false);  
  58.         busylabel2.setBusy(false);  
  59.       }  
  60.       else {  
  61.         label.setText("BusyLabel started");  
  62.         busylabel1.setBusy(true);  
  63.         busylabel2.setBusy(true);  
  64.       }  
  65.     }  
  66.   });  
  67.   // set the transparency of the JXPanel to 50% transparent  
  68.   panel.setAlpha(0.7f);  
  69.   // add the label, busylables, and button to the panel  
  70.   panel.add(label, BorderLayout.NORTH);  
  71.   JXPanel busylabels = new JXPanel(new FlowLayout(FlowLayout.CENTER, 405));  
  72.   busylabels.add(busylabel1);  
  73.   busylabels.add(busylabel2);  
  74.   panel.add(busylabels, BorderLayout.CENTER);  
  75.   panel.add(button, BorderLayout.SOUTH);  
  76.   panel.setPreferredSize(new Dimension(250125));  
  77.   return panel;  
  78. }  
  79. public JXBusyLabel createSimpleBusyLabel(){  
  80.   JXBusyLabel label = new JXBusyLabel();  
  81.   label.setToolTipText("simple busy label");  
  82.   return label;  
  83. }  
  84. public JXBusyLabel createComplexBusyLabel() {  
  85.   // this will not work in the 0.9.1 release of SwingX (need later builds)  
  86.   JXBusyLabel label = new JXBusyLabel(new Dimension(3838));  
  87.   BusyPainter painter = new BusyPainter(  
  88.       new Rectangle2D.Float(008.0f, 8.0f),  
  89.       new Rectangle2D.Float(5.5f, 5.5f, 27.0f, 27.0f));  
  90.   painter.setTrailLength(4);  
  91.   painter.setPoints(8);  
  92.   painter.setFrame(-1);  
  93.   painter.setBaseColor(Colors.LightBlue.color());  
  94.   painter.setHighlightColor(Colors.Orange.color());  
  95.   label.setPreferredSize(new Dimension(3838));  
  96.   label.setIcon(new EmptyIcon(3838));  
  97.   label.setBusyPainter(painter);  
  98.   label.setToolTipText("complex busy label");  
  99.   return label;  
  100. }  
  101. public JXLabel createLabel() {  
  102.   JXLabel label = new JXLabel();  
  103.   label.setBorder(BorderFactory.createEmptyBorder(5555));  
  104.   label.setFont(new Font("Segoe UI", Font.BOLD, 14));  
  105.   label.setText("<html>BusyLabel Example...<br>click start/stop button</html>");  
  106.   label.setIcon(Images.NetworkDisconnected.getIcon(4040));  
  107.   label.setHorizontalAlignment(JXLabel.LEFT);  
  108.   label.setBackgroundPainter(getPainter());  
  109.   return label;  
  110. }  
  111. /** this painter draws a gradient fill */  
  112. public Painter getPainter() {  
  113.   int width = 100;  
  114.   int height = 100;  
  115.   Color color1 = Colors.White.color(0.5f);  
  116.   Color color2 = Colors.Gray.color(0.5f);  
  117.   LinearGradientPaint gradientPaint =  
  118.       new LinearGradientPaint(0.0f, 0.0f, width, height,  
  119.                               new float[]{0.0f, 1.0f},  
  120.                               new Color[]{color1, color2});  
  121.   MattePainter mattePainter = new MattePainter(gradientPaint);  
  122.   return mattePainter;  
  123. }  
  124. }//end class BusyLabelExample
Há algumas coisas a notar sobre este código:
  1. A JXPanel é usado para conter todos os componentes (etiquetas, botões, etc). E é a transparência é definida para 70% opaco, 30% claro. É por isso que o programa de amostra tem um olhar muito silenciado / mole para ele.
  2. Certifique-se de lançar o seu programa no balanço do EDT e não o fio que está sendo executado através de seu método main ().
  3. Uma chamada para setLocationRelativeTo do JFrame (null) centra o JFrame na tela do computador.

O código-fonte de download

Para fazer o download dos projetos ideia para exemplo de código fonte deste tutorial, clique aqui .

+1

0 comentários :

Postar um comentário

Total de visualizações