Visión global: Neste artigo imos discutir sobre a transparencia e as distintas fiestras en forma en Java. En java 7 balance admite esta función e fabricación de compoñentes de interface de usuario do balance máis flexible e fácil de usar.
Introdución: Nalgúns programas, ventá transparente é unha esixencia para apoiar a súa función. Agora en Java, transparencia pode ser aplicado. Unha xanela transparente é creada pola modificación da súa opacidade pola implementación dun método chamado setOpacity nun compoñente JFrame. Pero debemos entender que unha xanela transparente só é posible se o sistema operativo subxacente soporta. E tamén ten que estar seguro de que o diálogo non está decorado. Para facer que unha fiestra sen decoración, ten que chamar setUndecorated (certo) método. Algún tempo que tamén é necesario para cambiar a forma dunha fiestra de UI. Para implementar lo, necesitamos chamar ao método setShape dentro do método componentResized. Ha recalcular o xeito cando a xanela é reescalala.
Back ground: En java UI, apoio á fiestra transparencia e forma era unha demanda moito tempo para compoñentes Swing / AWT. Para ter acceso desenvolvemento nativo para esas propiedades están dispoñibles hai moito tempo atrás. Pero non era accesible aos compoñentes do núcleo de Java. En java6 en diante, apoio a transparencia e diálogo en forma dispoñible. Aínda por nivel de transparencia do pixel é tamén apoia en Java7.
Tipo de soporte para transparencia e transparencia: Java 7 soporta os tres tipo de apoio seguinte.
TRANSLUCENT: Neste aspecto da fiestra pode ter cores diferentes, pero co mesmo nivel de opacidade. Así, o valor de alfa é a mesma para todos os píxeles. Este efecto é adecuado para desbotar fora dunha fiestra e despois diminúe gradualmente e aumenta o valor de alfa.
PERPIXEL_TRANSLUCENT: Esta propiedade ofrece soporte a distintos valores de alfa dentro da propia xanela. Isto úsase para desaparecer rexión seleccionada do diálogo.
PERPIXEL_TRANSPARENT: Esta propiedade ofrece soporte a diferentes formas de fiestras en vez de rectángulo tradicional. Se transparencia por pixel está soportado, a continuación, distintas formas como círculo, triángulo pode ser creada.
Antes de utilizar calquera das propiedades enriba necesitamos examinar apoio de mentir baixo sistema operativo. A proba pode ser feito empregando o método isWindowTranslucencySupported pertencente á clase java.awt.GraphicsDevice. Leva o tipo de transparencia como entrada e retorna true / false para indicar apoio.
Imos comprobar un exemplo de código para aplicar a función de transparencia. Neste exemplo, creamos unha xanela transparente rectangular nunha área de texto. Primeiro imos deshabilitado o modo de decoración para obter o efecto de transparencia. Entón, temos comprobado que o sistema operativo subxacente soporta ou non. Se o admite o efecto é visible na ventá do cadro.
Listing1: Exemplo mostra Translucency dunha fiestra JFrame
descargar java.awt.Color;
descargar java.awt.GraphicsDevice;
descargar java.awt.GraphicsEnvironment;
descargar java.awt.GridBagLayout;
descargar java.awt.event.ComponentAdapter;
descargar java.awt.event.ComponentEvent;
descargar java.awt.geom.Rectangle2D;
descargar javax.swing.JFrame;
descargar javax.swing.JTextArea;
descargar javax.swing.SwingUtilities;
público clase TransRecFrame esténdese a JFrame {
/**
* Crear un marco rectangular transparente con 85% transparencia
*/
público TransRecFrame() {
super(“Marco rectangular transparentes”);
//Axustar o esquema
SetLayout(novo GridBagLayout());
//Crear unha área de texto
final JTextArea txtArea = novo JTextArea(5, 50);
txtArea.setBackground(Cor.Cyan);
engadir(txtArea);
//Chamada para desactivar decoración
setUndecorated(certo);
//Chama setShape para cambiar o tamaño da forma cando widnow é redimensionada
addComponentListener(novo ComponentAdapter() {
@ Override
público invalidar componentResized(ComponentEvent e) {
setShape(novo Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Fai o diálogo 85% transparente
setOpacity(0.85f);
//Definir outros parámetros
setLocationRelativeTo(cero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(certo);
}
público estático invalidar principal(Corda[] args) {
//Crear ambiente gráfico
Xeración MudaMundo GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Asegúrese de que o sistema operativo é compatible Transparencia
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCENT)) {
System.out.println(“OS soporta transparencia”);
novo TransRecFrame();
}
}
}
Recursos para apoiar transparencia e forma: En Java7 existen esencialmente tres funcións dispoñibles para soportar transparencia e forma dunha fiestra.
- Ventá completa transparencia: Nesta visión fiestra completa é traslúcido.
- Por pixel transparencia: Nesta visión, unha parte do vidro é transparente
- Fiestras en forma: Fai distintas fiestras en forma ovale, círculo, rectangular etc.
Por pixel transparencia:
Xa vimos como facer unha xanela transparente completa no exemplo anterior. Agora imos discutir a segunda parte da toma de un conxunto de píxeles transparentes usando a súa cor de fondo. Existen algunhas limitacións para aplicar este escenario. A xanela non debe ser a pantalla completa eo sistema debe soportar nivel de transparencia píxeles. O resto do procedemento é similar ao exemplo anterior,.
No exemplo a seguir, veremos como nivel de transparencia píxeles defínese nun cadro.
Listing2: Exemplo mostrando apoio transparencia nivel de pixel.
descargar javax.swing.*;
descargar java.awt. *;
descargar java.awt.event.ActionEvent;
descargar java.awt.event.ActionListener;
público clase PixelTranslucency esténdese a JFrame {
público PixelTranslucency() {
super(“Definir nivel de pixel transparencia”);
//Define o tamaño do JFrame
setSize(250, 250);
//Establecer lay out
getContentPane().SetLayout(novo GridLayout(6, 6));
//Chamada a definición de píxeles
a(int i = 0; Eu < 16; i ){
engadir(novo Panel Pixel(255 – Eu * 12));
}
//Establecer fondo e outras propiedades
setBackground(novo Cor(0, 0, 0, 0));
setLocationRelativeTo(cero);
setVisible(certo);
}
público estático invalidar principal(Corda[] args) {
Xeración MudaMundo GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Asegúrese de que a fiestra apoia transparencia
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.fóra.println(“OS soporta transparencia”);
novo PixelTranslucency();
}
} privado clase Panel Pixel esténdese a JPanel {
privado Panel Pixel(int pixl) {
super();
setBackground(novo Cor(0, 0, 255, pixl));
}
}
}
Fiestras en forma:
Agora imos discutir sobre outra característica importante apoiado por Java7.The ventá en forma soporta todo tipo de formas Calquera que sexa a demanda do usuario. Este recurso axuda a crear toda forma como un círculo, triángulo, polígono ou calquera forma complexa posible. O método setShape da clase de fiestra está dispoñible para a configuración da propiedade. Pero, de novo, hai que recordar que o modo de pantalla completa non debe ser permitido eo sistema operativo soporta transparencia.
O exemplo seguinte mostra o seu uso en forma de ventá.
Listing3: O código de exemplo que mostra a utilización do diálogo en forma.
descargar javax.swing.*;
descargar java.awt. *;
descargar java.awt.geom.Ellipse2D;
descargar java.awt.geom.GeneralPath;
público clase JavaShapedWindow esténdese a JFrame {
público JavaShapedWindow() {
super(“Establecer o diálogo en forma”);
//Establecer undecorated OFF para obter un efecto
setUndecorated(certo);
//Permite definir o tamaño
setSize(novo Dimensión(250, 250));
//Definir as propiedades de polígonos
Polígono polígono = novo Polígono();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Establecer os valores da forma
Ellipse2D.Double newCircle = novo Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Definir as propiedades camiño xeral
GeneralPath GPath = novo GeneralPath();
gpath.append(polígono, certo);
gpath.append(newCircle, certo);
//Define o camiño
setShape(GPath);
//Establecer esquema da caixa
getContentPane().SetLayout(novo BoxLayout(getContentPane(), BoxLayout.X_AXIS));
engadir(Caixa.createHorizontalGlue());
//Crear etiqueta e establecer propiedades
JLabel newlabel = novo JLabel(“Ventá en forma de Java”);
newlabel.setForeground(Cor.branco);
engadir(newlabel);
engadir(Caixa.createHorizontalGlue());
//Establecer contido do panel cor de fondo
getContentPane().setBackground(Cor.ciano);
//Establecer local
setLocationRelativeTo(cero);
setVisible(certo);
}
público estático invalidar principal(Corda[] args) {
Xeración MudaMundo GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Comprobe soporte VOS para esta propiedade
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.fóra.println(“OS soporta transparencia”);
novo JavaShapedWindow();
}
}
}
Tamén podemos aplicar unha combinación de dous recursos como a fiestra transparencia e en forma. Para aplicar esta, chamar ao método setOpacity ao seu cadro. A fiestra de resultados amosará o efecto combinado. Pero hai que lembrar do sistema operativo subxacente debe soportar nivel de transparencia de píxeles e transparencia nivel de pixel.
Conclusión:
Neste artigo, nós Cubrimos algunhas novidades en transparencia java7.The e recursos de ventá en forma son realmente interesantes e facer compoñentes Java UI máis flexible. Pero, á vez, hai que recordar que o sistema operativo subxacente deben apoiar todas estas propiedades. En caso contrario, o efecto non será visible. Así, o propio programa, comprobar o soporte do sistema operativo e, a continuación, aplicar o efecto. A característica máis recente de Java permite aos desenvolvedores para crear diferentes tipos de efectos do lado da UI. Como todos sabemos que a aparencia é un aspecto importante de calquera aplicación baseado na interface de usuario. Así, o creador está agora equipado con ferramentas para facer a interface de usuario máis agradable e atractivo.
