Introdução
SwingX é uma extensão da API Swing pelas pessoas que trabalham na equipe de Swing.O código é liberado como open source em Sun SwingLabs . Partes da API que são maduros devem aparecer em Java 7 É uma ótima maneira de obter um sneak peek em novos componentes e tecnologias que a equipe do balanço está trabalhando, mas não está pronto para um lançamento oficial, o que leva tempo , etc
Uma das maiores mudanças com a API SwingX é de uso de pintores. Normalmente, se você quisesse criar novos componentes em Swing, você teria que mexer com a aparência ea API. Pintores dar-lhe a capacidade de usar o código Java2D para definir rapidamente a aparência do seu componente.
JXPanel
SwingX vem com seu próprio gerente repaint costume (que substitui a implementação padrão usado pelo balanço, não só pode ser um ativo em determinado momento). Este gerente repaint costume respeita a transparência de uma SwingX recipiente de nível superior - por exemplo, JXPanel. Ao contrário de um JPanel, quando você coloca um JButton em uma JXPanel, e definir a transparência do botão, ele irá reter é a transparência, mesmo quando você clicar no botão. No caso do JPanel, quando o JButton aparece pela primeira vez, vai ser transparente, mas assim que você clicar nele, ele vai se tornar opaco. Você pode fazer coisas como alterar a transparência de todos os componentes em um JXPanel por exemplo, e muitos outros efeitos interessantes. Você pode amarrar isso no TimingFramework e muito rapidamente criar animações muito legais em sua interface de usuário (como alterar a transparência de seus componentes, alterando a propriedade "alpha" de 0.0f para 1.0f a desvanecer-se em um painel).
Pintores
Os pintores API é agradável e simples. Todo o código Java2D que você deseja usar para pintar o componente, que de outra forma iriam em uma subclasse de um componente Swing que é paint () ou o método paintComponent () você substituído, é colocado em uma classe que implementa o pintor <T > de interface, que é definido da seguinte maneira:1: public void paint(Graphics2D g, T object, int width, int height);Os pintores API
Fora da caixa, SwingX vem com um rico conjunto de implementações do pintor, alguns dos quais estão listados aqui:
- GlossPainter - isso pinta um efeito de brilho em seu componente, você pode escolher o brilho da pintura objeto ea posição gloss (superior / inferior). O efeito gloss é pintado como um arco cheio que destaca o componente com qualquer cor que você forneceu. A pintura objeto que é usado para pintar o efeito de brilho pode ser uma cor simples, ou um gradiente ou uma textura.
- ImagePainter - isso pinta um BufferedImage em seu componente. Você tem controle sobre como você deseja que a imagem pintada. Você pode optar por tê-lo escalado para o local da área que precisa ser pintado, ou você pode tê-lo lado a lado ou centralizado. Há muitas opções de layout que você pode escolher.
- MattePainter - este usa uma pintura objeto para pintar seu componente. Isto pode ser utilizado para encher a área do componente com uma cor, o gradiente ou textura.
- PinstripePainter - este pinta riscas em seu componente, e você pode controlar o ângulo, largura, distância entre si, e cor ( pintura objeto) dessas listras. Em vez de usar uma cor, você pode usar um gradiente ou textura, etc
- CompoundPainter - isso permite que você adicione várias implementações pintor a um componente. Os pintores serão processados na ordem em que são adicionados ao CompoundPainter . Ele pode ser usado para criar rapidamente efeitos legais.
- RectanglePainter - isso pinta um retângulo em seu componente. Você pode selecionar um preenchimento pintura objeto e fundo da pintura do objeto. Há muitas outras opções como tamanho da borda e cantos arredondados.
Existem outros pintores como ShapePainter, TextPainter, URLPainter, CheckerboardPainter e BusyPainter. Você pode estender AbstractPainter para criar o seu próprio. Os exemplos de código a seguir irá começar a usar pintores; experiência com a API e criar seus próprios efeitos usando os pintores prestados, e combiná-las usando CompoundPainter.
Fonte exemplo de código 1
No exemplo a seguir, eu vou criar um JXLabel e definir um pintor fundo composto nele. Aqui está o que parece:
Aqui está o código que produziu este pintor:
1: /**
2: * this compound painter composites a bunch of different painters.
3: */
4: private Painter getPainter() {
5: // set the background painter
6: MattePainter mp = new MattePainter(Colors.LightBlue.alpha(0.5f));
7: GlossPainter gp = new GlossPainter(Colors.White.alpha(0.3f),
8: GlossPainter.GlossPosition.TOP);
9: PinstripePainter pp = new PinstripePainter(Colors.Gray.alpha(0.2f),
10: 45d);
11: return (new CompoundPainter(mp, pp, gp));
12: }
Neste exemplo, eu crio três pintores e combiná-las e aplicá-las ao JXLabel (que é a classe rótulo SwingX):
- MattePainter - Eu encho o componente com uma cor azul clara translúcida (50% transparente).
- GlossPainter - I aplicar um verniz branco (30% transparente) para a parte superior da etiqueta.
- PinstripePainter - aplico um (50% transparente) cor cinza com o rótulo.
Esses pintores são aplicadas na ordem em que são adicionados ao CompoundPainter - primeiro MattePainter, então PinstripePainter e, finalmente GlossPainter. Se você olhar para a imagem, você vai ver que as riscas estão por trás do efeito Gloss. Além disso, observe que o texto "Exemplo Pintor 1" está na frente dos pintores, uma vez que são todos os pintores de fundo. Se você deseja adicionar texto atrás de um pintor, então use o TextPainter e certifique-se de adicioná-lo na ordem correta em sua CompositePainter.
Aqui está o código fonte completo listando para este exemplo:
1: import org.jdesktop.swingx.*;
2: import org.jdesktop.swingx.painter.*;
3:
4: import javax.swing.*;
5: import java.awt.*;
6:
7: /**
8: * PainterExample1
9: *
10: * @author Nazmul Idris
11: * @version 1.0
12: * @since Dec 25, 2007, 3:54:13 PM
13: */
14: public class PainterExample1 {
15:
16: /**
17: * simple main driver for this class
18: */
19: public static void main(String[] args) {
20: SwingUtilities.invokeLater(new Runnable() {
21: public void run() {
22: new PainterExample1();
23: }
24: });
25: }
26:
27: /**
28: * creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame.
29: */
30: public PainterExample1(){
31: JFrame frame = new JFrame("Painter Example 1");
32:
33: // add the panel to this frame
34: frame.add(doInit());
35:
36: // when you close the frame, the app exits
37: frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
38:
39: // center the frame and show it
40: frame.setLocationRelativeTo(null);
41: frame.pack();
42: frame.setVisible(true);
43: }
44:
45: /**
46: * creates a JXLabel and attaches a painter to it.
47: */
48: private Component doInit() {
49: JXPanel panel = new JXPanel();
50: panel.setLayout(new BorderLayout());
51:
52: JXLabel label = new JXLabel();
53: label.setFont(new Font("Segoe UI", Font.BOLD, 14));
54: label.setText("Painter Example 1");
55: label.setHorizontalAlignment(JXLabel.CENTER);
56: label.setBackgroundPainter(getPainter());
57:
58: panel.add(label, BorderLayout.CENTER);
59:
60: panel.setPreferredSize(new Dimension(250,100));
61:
62: return panel;
63: }
64:
65: /**
66: * this compound painter composites a bunch of different painters.
67: */
68: private Painter getPainter() {
69: // set the background painter
70: MattePainter mp = new MattePainter(Colors.LightBlue.alpha(0.5f));
71: GlossPainter gp = new GlossPainter(Colors.White.alpha(0.3f),
72: GlossPainter.GlossPosition.TOP);
73: PinstripePainter pp = new PinstripePainter(Colors.Gray.alpha(0.2f),
74: 45d);
75: return (new CompoundPainter(mp, pp, gp));
76: }
77: }//end class PainterExample1
A outra classe interessante é a enumeração cores, que torna mais fácil para trabalhar com as cores. Vou escrever um tutorial sobre enumerações java5 e como torná-la realmente fácil de criar constantes de tipo seguro, e muito mais. Ele permite que você trabalhe facilmente com cores personalizadas que você criou, e você pode obter cores translúcidas convenientemente, e você pode obter HEX codificado cordas para usar em HTML. Aqui está uma lista do enum Cor:
1: import java.awt.*;
2:
3: /**
4: * Colors is an enumeration class that makes it easier to work with colors. Methods are provided for
5: * conversion to hex strings, and for getting alpha channel colors.
6: *
7: * @author Nazmul Idris
8: * @version 1.0
9: * @since Apr 21, 2007, 12:55:24 PM
10: */
11: public enum Colors {
12:
13: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
14: // various colors in the pallete
15: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
16: Pink(255, 175, 175),
17: Green(159, 205, 20),
18: Orange(213, 113, 13),
19: Yellow(Color.yellow),
20: Red(189, 67, 67),
21: LightBlue(208, 223, 245),
22: Blue(Color.blue),
23: Black(0, 0, 0),
24: White(255, 255, 255),
25: Gray(Color.gray.getRed(), Color.gray.getGreen(), Color.gray.getBlue());
26:
27: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
28: // constructors
29: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
30:
31: Colors(Color c) {
32: _myColor = c;
33: }
34:
35: Colors(int r, int g, int b) {
36: _myColor = new Color(r, g, b);
37: }
38:
39: Colors(int r, int g, int b, int alpha) {
40: _myColor = new Color(r, g, b, alpha);
41: }
42:
43: Colors(float r, float g, float b, float alpha) {
44: _myColor = new Color(r, g, b, alpha);
45: }
46:
47: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
48: // data
49: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
50:
51: private Color _myColor;
52:
53: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
54: // methods
55: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
56:
57: public Color alpha(float t) {
58: return new Color(_myColor.getRed(), _myColor.getGreen(), _myColor.getBlue(), (int) (t * 255f));
59: }
60:
61: public static Color alpha(Color c, float t) {
62: return new Color(c.getRed(), c.getGreen(), c.getBlue(), (int) (t * 255f));
63: }
64:
65: public Color color() { return _myColor; }
66:
67: public Color color(float f) {
68: return alpha(f);
69: }
70:
71: public String toString() {
72: StringBuilder sb = new StringBuilder();
73: sb.append("r=")
74: .append(_myColor.getRed())
75: .append(", g=")
76: .append(_myColor.getGreen())
77: .append(", b=")
78: .append(_myColor.getBlue())
79: .append("\n");
80: return sb.toString();
81: }
82:
83: public String toHexString() {
84: Color c = _myColor;
85: StringBuilder sb = new StringBuilder();
86: sb.append("#");
87: sb.append(Integer.toHexString(_myColor.getRed()));
88: sb.append(Integer.toHexString(_myColor.getGreen()));
89: sb.append(Integer.toHexString(_myColor.getBlue()));
90: return sb.toString();
91: }
92:
93: }//end enum ColorsFonte exemplo de código 2
Neste segundo exemplo, vou mostrar-lhe como usar um pintor diferente para desenhar um preenchimento gradiente em um componente, e alterá-lo de transparência usando JXLabel. Aqui está uma imagem:
Aqui está o código para o pintor:
1: /** this painter draws a gradient fill */
2: public Painter getPainter() {
3: int width = 100;
4: int height = 100;
5: Color color1 = Colors.White.color(0.5f);
6: Color color2 = Colors.Gray.color(0.5f);
7:
8: LinearGradientPaint gradientPaint =
9: new LinearGradientPaint(0.0f, 0.0f, width, height,
10: new float[]{0.0f, 1.0f},
11: new Color[]{color1, color2});
12: MattePainter mattePainter = new MattePainter(gradientPaint);
13: return mattePainter;
14: }
O MattePainter usa um objeto Paint, que atrai um preenchimento de gradiente (usando a classe LinearGradientPaint).
A seguinte linha de código faz com que o JXPanel e tudo dentro dele 50% transparente:
1: // set the transparency of the JXPanel to 50% transparent 2: panel.setAlpha(0.5f);
Aqui está a listagem de código completo para este exemplo:
1: import org.jdesktop.swingx.*;
2: import org.jdesktop.swingx.painter.*;
3:
4: import javax.swing.*;
5: import java.awt.*;
6:
7: /**
8: * PainterExample2
9: *
10: * @author Nazmul Idris
11: * @version 1.0
12: * @since Dec 25, 2007, 3:54:13 PM
13: */
14: public class PainterExample2 {
15:
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 PainterExample2();
21: }
22: });
23: }
24:
25: /** creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame. */
26: public PainterExample2() {
27: JFrame frame = new JFrame("Painter Example 2");
28:
29: // add the panel to this frame
30: frame.add(doInit());
31:
32: // when you close the frame, the app exits
33: frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
34:
35: // center the frame and show it
36: frame.setLocationRelativeTo(null);
37: frame.pack();
38: frame.setVisible(true);
39: }
40:
41: /** creates a JXLabel and attaches a painter to it. */
42: private Component doInit() {
43: JXPanel panel = new JXPanel();
44: panel.setLayout(new BorderLayout());
45:
46: JXLabel label = new JXLabel();
47: label.setFont(new Font("Segoe UI", Font.BOLD, 14));
48: label.setText("Painter Example 2");
49: label.setHorizontalAlignment(JXLabel.CENTER);
50: label.setBackgroundPainter(getPainter());
51:
52: // set the transparency of the JXPanel to 50% transparent
53: panel.setAlpha(0.5f);
54:
55: panel.add(label, BorderLayout.CENTER);
56: panel.setPreferredSize(new Dimension(250, 100));
57:
58: return panel;
59: }
60:
61: /** this painter draws a gradient fill */
62: public Painter getPainter() {
63: int width = 100;
64: int height = 100;
65: Color color1 = Colors.White.color(0.5f);
66: Color color2 = Colors.Gray.color(0.5f);
67:
68: LinearGradientPaint gradientPaint =
69: new LinearGradientPaint(0.0f, 0.0f, width, height,
70: new float[]{0.0f, 1.0f},
71: new Color[]{color1, color2});
72: MattePainter mattePainter = new MattePainter(gradientPaint);
73: return mattePainter;
74: }
75:
76: }//end class PainterExample2Faça o download do código
Você pode baixar a versão 0.9.1 do SwingX aqui :
- Binários - https://swingx.dev.java.net/files/documents/2981/76227/swingx-0.9.1.zip
- Fontes - https://swingx.dev.java.net/files/documents/2981/76229/swingx-0.9.1-src.zip
- JavaDocs - https://swingx.dev.java.net/files/documents/2981/76228/swingx-0.9.1-javadoc.zip
Você pode baixar o código-fonte deste tutorial, que inclui as bibliotecas SwingX, juntamente com projetos de idéia para o código aqui .
0 comentários :
Postar um comentário