Visão global: Neste artigo vamos discutir sobre a transparência e as diferentes janelas em forma em Java. Em java 7 balanço suporta esta função e fabrico de componentes de interface do usuário do balanço mais flexível e fácil de usar.
Introdução: Em alguns aplicativos, janela transparente é uma exigência para apoiar a sua funcionalidade. Agora em Java, transparência pode ser implementado. Uma janela transparente é criada pela alteração da sua opacidade pela implementação de um método chamado setOpacity num componente JFrame. Mas devemos entender que uma janela translúcida só é possível se o sistema operacional subjacente suporta. E também precisa ter certeza de que a janela não está decorado. Para fazer com que uma janela sem decoração, você precisa chamar setUndecorated (verdadeiro) método. Algum tempo que também é necessário para alterar a forma de uma janela de UI. Para implementá-lo, precisamos chamar o método setShape dentro do método componentResized. Ele irá recalcular a forma quando a janela é redimensionada.
Back ground: Em java UI, apoio à janela translucidez e forma era uma demanda muito tempo para componentes Swing / AWT. Para ter acesso desenvolvimento nativo para essas propriedades estão disponíveis há muito tempo atrás. Mas não era acessível aos componentes do núcleo de Java. Em Java6 em diante, apoio a translucidez e janela em forma está disponível. Mesmo por nível de translucidez do pixel é também apoia em Java7.
Tipo de suporte para translucidez e transparência: Java 7 suporta os três tipo de apoio seguinte.
TRANSLUCENT: Neste aspecto da janela pode ter cores diferentes, mas com o mesmo nível de opacidade. Assim, o valor de alfa é o mesmo para todos os pixels. Este efeito é adequado para desbotar fora de uma janela e depois diminui gradualmente e aumenta o valor de alfa.
PERPIXEL_TRANSLUCENT: Esta propriedade oferece suporte a diferentes valores de alfa dentro da própria janela. Isto é usado para desaparecer região selecionada da janela.
PERPIXEL_TRANSPARENT: Esta propriedade oferece suporte a diferentes formas de janelas ao invés de retângulo tradicional. Se transparência por pixel é suportado, em seguida, diferentes formas como círculo, triângulo pode ser criada.
Antes de usar qualquer uma das propriedades acima precisamos testar o apoio de mentir sob sistema operacional. O teste pode ser feito usando o método isWindowTranslucencySupported pertencente à classe java.awt.GraphicsDevice. Leva o tipo de transparência como entrada e retorna true / false para indicar o apoio.
Vamos verificar um exemplo de código para implementar a funcionalidade de translucidez. Neste exemplo, criamos uma janela translúcida retangular em uma área de texto. Primeiro vamos ter desabilitado o modo de decoração para obter o efeito de transparência. Então, temos verificado se o sistema operacional subjacente suporta ou não. Se for suportado o efeito é visível na janela do quadro.
Listing1: Exemplo mostrando Translucency de uma janela JFrame
importar java.awt.Color;
importar java.awt.GraphicsDevice;
importar java.awt.GraphicsEnvironment;
importar java.awt.GridBagLayout;
importar java.awt.event.ComponentAdapter;
importar java.awt.event.ComponentEvent;
importar java.awt.geom.Rectangle2D;
importar javax.swing.JFrame;
importar javax.swing.JTextArea;
importar javax.swing.SwingUtilities;
público classe TransRecFrame estende-se JFrame {
/**
* Criar um quadro retangular transparente com 85% transparência
*/
público TransRecFrame() {
super(“Quadro retangular translúcido”);
//Definir o layout
SetLayout(novo GridBagLayout());
//Criar uma área de texto
final JTextArea txtArea = novo JTextArea(5, 50);
txtArea.setBackground(Cor.CYAN);
adicionar(txtArea);
//Chamada para desativar decoração
setUndecorated(verdadeiro);
//Chame setShape para redimensionar a forma quando widnow é redimensionada
addComponentListener(novo ComponentAdapter() {
@ Override
público invalidar componentResized(ComponentEvent e) {
setShape(novo Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Faça a janela 85% transparente
setOpacity(0.85f);
//Definir outros parâmetros
setLocationRelativeTo(zero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(verdadeiro);
}
público estático invalidar principal(Corda[] args) {
//Criar ambiente gráfico
Geração MudaMundo GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Verifique se o sistema operacional suporta Translucidez
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCENT)) {
System.out.println(“OS suporta translucidez”);
novo TransRecFrame();
}
}
}
Recursos para apoiar translucidez e forma: Em Java7 existem essencialmente três funções disponíveis para suportar translucidez e forma de uma janela.
- Janela completa translucidez: Nesta abordagem janela completa é translúcido.
- Por pixel translucidez: Nesta abordagem, uma parte do vidro é translúcida
- Janelas em forma: Faça diferentes janelas em forma como ovale, círculo, retangular etc.
Por pixel translucidez:
Nós já vimos como fazer uma janela translúcida completa no exemplo anterior. Agora vamos discutir a segunda parte da tomada de um conjunto de pixels transparentes usando sua cor de fundo. Existem algumas limitações para implementar este cenário. A janela não deve ser em tela cheia eo sistema deve suportar nível de translucidez pixels. O resto do procedimento é semelhante ao exemplo acima,.
No exemplo a seguir, veremos como nível de translucidez pixel é definido em um quadro.
Listing2: Exemplo mostrando apoio translucidez nível de pixel.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.event.ActionEvent;
importar java.awt.event.ActionListener;
público classe PixelTranslucency estende-se JFrame {
público PixelTranslucency() {
super(“Definir nível de pixel translucidez”);
//Defina o tamanho do JFrame
setSize(250, 250);
//Definir lay out
getContentPane().SetLayout(novo GridLayout(6, 6));
//Chamada para definição de pixels
para(int i = 0; Eu < 16; i ){
adicionar(novo Painel Pixel(255 – Eu * 12));
}
//Definir fundo e outras propriedades
setBackground(novo Cor(0, 0, 0, 0));
setLocationRelativeTo(zero);
setVisible(verdadeiro);
}
público estático invalidar principal(Corda[] args) {
Geração MudaMundo GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Verifique se a janela apoia translucidez
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.fora.println(“OS suporta translucidez”);
novo PixelTranslucency();
}
} privado classe Painel Pixel estende-se JPanel {
privado Painel Pixel(int pixl) {
super();
setBackground(novo Cor(0, 0, 255, pixl));
}
}
}
Janelas em forma:
Agora vamos discutir sobre outra característica importante apoiado por Java7.The janela em forma suporta todos os tipos de formas Qualquer que seja a exigência do usuário. Este recurso ajuda a criar toda a forma como um círculo, triângulo, polígono ou qualquer forma complexa possível. O método setShape da classe de janela está disponível para a configuração da propriedade. Mas, novamente, temos que lembrar que o modo de tela cheia não deve ser permitido eo sistema operacional suporta translucidez.
O exemplo seguinte mostra o uso em forma de janela.
Listing3: O código de exemplo mostrando o uso da janela em forma.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.geom.Ellipse2D;
importar java.awt.geom.GeneralPath;
público classe JavaShapedWindow estende-se JFrame {
público JavaShapedWindow() {
super(“Definir a janela em forma”);
//Definir undecorated OFF para obter um efeito
setUndecorated(verdadeiro);
//Defina o tamanho
setSize(novo Dimensão(250, 250));
//Definir as propriedades de polígonos
Polígono polígono = novo Polígono();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Definir os valores da forma
Ellipse2D.Double newCircle = novo Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Definir as propriedades de caminho gerais
GeneralPath GPath = novo GeneralPath();
gpath.append(polígono, verdadeiro);
gpath.append(newCircle, verdadeiro);
//Defina o caminho
setShape(GPath);
//Definir layout da caixa
getContentPane().SetLayout(novo BoxLayout(getContentPane(), BoxLayout.X_AXIS));
adicionar(Caixa.createHorizontalGlue());
//Criar rótulo e definir propriedades
JLabel newlabel = novo JLabel(“Janela em forma de Java”);
newlabel.setForeground(Cor.branco);
adicionar(newlabel);
adicionar(Caixa.createHorizontalGlue());
//Definir conteúdo do painel cor de fundo
getContentPane().setBackground(Cor.ciano);
//Definir local
setLocationRelativeTo(zero);
setVisible(verdadeiro);
}
público estático invalidar principal(Corda[] args) {
Geração MudaMundo GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Verifique suporte OS para esta propriedade
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.fora.println(“OS suporta translucidez”);
novo JavaShapedWindow();
}
}
}
Podemos também implementar uma combinação de dois recursos como a janela translucidez e em forma. Para implementar esta, chamar o método setOpacity para o seu quadro. A janela de resultado irá mostrar o efeito combinado. Mas devemos lembrar do sistema operacional subjacente deve suportar nível de translucidez de pixel e transparência nível de pixel.
Conclusão:
Neste artigo, nós cobrimos algumas novidades em translucidez java7.The e recursos de janela em forma são realmente interessantes e fazer componentes Java UI mais flexível. Mas, ao mesmo tempo, devemos lembrar que o sistema operacional subjacente devem apoiar todas estas propriedades. Caso contrário, o efeito não será visível. Assim, no próprio aplicativo, verificar o suporte do sistema operacional e, em seguida, implementar o efeito. O recurso mais recente do Java permite que os desenvolvedores para criar diferentes tipos de efeitos do lado da UI. Como todos nós sabemos que a aparência é um aspecto importante de qualquer aplicativo baseado na interface do usuário. Assim, o desenvolvedor está agora equipado com ferramentas para fazer a interface do usuário mais agradável e atraente.
