Visión de conjunto: En este artículo vamos a discutir acerca de la transparencia y las diferentes ventanas en forma de Java. En java 7 oscilación admite esta función y la fabricación de componentes de interfaz de usuario de swing más flexible y fácil de usar.
Introducción: En alguna aplicación, ventana transparente es un requisito para apoyar su funcionalidad. Ahora en Java, la transparencia puede ser implementado. Una ventana translúcida se crea mediante la alteración de su opacidad mediante la implementación de un método llamado setOpacity en un componente JFrame. Pero debemos entender que una ventana translúcida sólo es posible si el sistema operativo subyacente lo admite. Y también tenemos que asegurarnos de que la ventana no está decorada. Para hacer que una ventana sin decorar, necesita llamar setUndecorated (verdadero) método. Algún tiempo también se requiere para cambiar la forma de una interfaz de usuario ventana. Para ponerlo en práctica, tenemos que llamar al método setShape dentro del método componentResized. Se volverá a calcular la forma cuando se cambia el tamaño de la ventana.
Segundo plano: En java UI, apoyo para la ventana de translucidez y forma fue un largo tiempo, la demanda de componentes Swing / AWT. Para acceder desarrollo nativo de estas propiedades se encuentran en mucho tiempo atrás. Pero no se podía acceder a los componentes básicos de Java. En Java6 adelante, soporte para translucidez y la ventana en forma de está disponible. Incluso por transparencia a nivel de píxel también se apoya en Java7.
Tipo de apoyo para la translucidez y transparencia: Java 7 compatible con los siguientes tres tipos de apoyo.
TRANSLÚCIDO: En esta función la ventana puede tener diferentes colores, pero con el mismo nivel de opacidad. Entonces, el valor alfa es el mismo para todos los píxeles. Este efecto es adecuado para desvanecen frente a una ventana y luego disminuye gradualmente y aumenta el valor alfa.
PERPIXEL_TRANSLUCENT: Esta propiedad admite diferentes valores alfa dentro de la propia ventana. Esto se utiliza a desvanecerse región seleccionada de la ventana.
PERPIXEL_TRANSPARENT: Esta propiedad admite diferentes formas de las ventanas en lugar de rectangular tradicional. Si por la transparencia píxel se apoya entonces diferentes formas como círculo, triángulo puede ser creado.
Antes de usar cualquiera de las propiedades anteriores tenemos que probar el apoyo de menos de mentir sistema operativo. La prueba se puede hacer mediante el método isWindowTranslucencySupported perteneciente a la clase java.awt.GraphicsDevice. Se necesita el tipo de transparencia como entrada y devuelve true / false para indicar el apoyo.
Vamos a ver un ejemplo de código para implementar la función de transparencia. En este ejemplo hemos creado una ventana translúcida rectangular en un área de texto. En primer lugar hemos desactivado el modo de decoración para conseguir el efecto de transparencia. Luego de haber verificado si el sistema operativo subyacente lo admite o no. Si se admite que el efecto es visible en la ventana de marco.
Listing1: Muestra translucidez que muestra una ventana 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 clase TransRecFrame se extiende JFrame {
/**
* Crear un marco rectangular transparente con 85% transparencia
*/
público TransRecFrame() {
súper(“Marco rectangular traslúcido”);
//Establecer layout
setLayout(nuevo GridBagLayout());
//Crear un área de texto
final JTextArea txtArea = nuevo JTextArea(5, 50);
txtArea.setBackground(Color.CIAN);
añadir(txtArea);
//Llame para desactivar la decoración
setUndecorated(verdadero);
//Llame setShape para redimensionar la forma cuando Widnow se redimensiona
addComponentListener(nuevo ComponentAdapter() {
@ Override
público anular componentResized(ComponentEvent y) {
setShape(nuevo Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Haga la ventanilla 85% transparente
setOpacity(0.85F);
//Establezca otros parámetros
setLocationRelativeTo(cero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(verdadero);
}
público estático anular principal(Cadena[] args) {
//Crear entorno gráfico
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Compruebe si OS compatible Transparencia
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLÚCIDO)) {
System.out.println(“OS soporta translucidez”);
nuevo TransRecFrame();
}
}
}
Funciones de apoyo a la translucidez y la forma: En Java7 hay principalmente tres características disponibles para apoyar la transparencia y la forma de una ventana.
- Ventana completa transparencia: En este enfoque ventana completa es translúcido.
- Por pixel Translucency: En este enfoque, una parte de la ventana es translúcida
- Ventanas en forma de: Hacer diferentes ventanas con forma oval, círculo, rectangular etc.
Por pixel Translucency:
Ya hemos visto cómo hacer que una ventana completa translúcida en el ejemplo anterior. Ahora vamos a hablar de la segunda parte de hacer un conjunto de píxeles transparentes con su color de fondo. Hay algunas limitaciones para la aplicación de este escenario. La ventana no debe ser de plena pantalla y el sistema debe ser compatible con la translucidez nivel de píxel. El resto del procedimiento es similar al ejemplo anterior.
En el siguiente ejemplo vamos a ver cómo translucidez nivel de píxel se encuentra en un marco de.
LISTING2: Muestra mostrar apoyo translucidez nivel de píxel.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.event.ActionEvent;
importar java.awt.event.ActionListener;
público clase PixelTranslucency se extiende JFrame {
público PixelTranslucency() {
súper(“Establecer translucidez nivel de píxel”);
//Establecer el tamaño del JFrame
setSize(250, 250);
//Establecer diseñar
getContentPane().setLayout(nuevo GridLayout(6, 6));
//Convocatoria de ajuste de píxeles
para(int i = 0; yo < 16; i ){
añadir(nuevo Panel píxeles(255 – yo * 12));
}
//Conjunto de fondo y otras propiedades
setBackground(nuevo Color(0, 0, 0, 0));
setLocationRelativeTo(cero);
setVisible(verdadero);
}
público estático anular principal(Cadena[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Compruebe si soporta ventana translucidez
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.fuera.println(“OS soporta translucidez”);
nuevo PixelTranslucency();
}
} privado clase Panel píxeles se extiende JPanel {
privado Panel píxeles(int pixl) {
súper();
setBackground(nuevo Color(0, 0, 255, pixl));
}
}
}
Ventanas de forma:
Ahora vamos a hablar sobre otra característica importante apoyado por la ventana en forma de Java7.The soporta todos los tipos de formas Cualquiera que sea la exigencia del usuario. Esta característica le ayuda a crear cualquier forma como círculo, triángulo, polígono o cualquier forma compleja posible. El método setShape de la clase de ventana está disponible para establecer la propiedad. Pero una vez más tenemos que recordar que el modo de pantalla completa no se debe permitir y el sistema operativo es compatible con translucidez.
El ejemplo siguiente muestra el uso de la ventana en forma de.
Listing3: El código de ejemplo que muestra el uso de la ventana en forma de.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.geom.Ellipse2D;
importar java.awt.geom.GeneralPath;
público clase JavaShapedWindow se extiende JFrame {
público JavaShapedWindow() {
súper(“Establezca ventana en forma de”);
//Ajuste sin decorar OFF para conseguir un efecto
setUndecorated(verdadero);
//Establecer el tamaño
setSize(nuevo Dimensión(250, 250));
//Definición de las propiedades del polígono
Polígono Polígono = nuevo Polígono();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Establezca los valores de la forma
Ellipse2D.Double newCircle = nuevo Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Definición de las propiedades generales trayectoria
GeneralPath gpath = nuevo GeneralPath();
gpath.append(polígono, verdadero);
gpath.append(newCircle, verdadero);
//Establecer la ruta
setShape(gpath);
//Establecer boxlayout
getContentPane().setLayout(nuevo BoxLayout(getContentPane(), BoxLayout.X_AXIS));
añadir(Caja.createHorizontalGlue());
//Crear propiedades de etiqueta y establecer
JLabel newlabel = nuevo JLabel(“Java ventana en forma de”);
newlabel.setForeground(Color.blanco);
añadir(newlabel);
añadir(Caja.createHorizontalGlue());
//Establezca contenido del panel color de fondo
getContentPane().setBackground(Color.cian);
//Para ajustar la posición
setLocationRelativeTo(cero);
setVisible(verdadero);
}
público estático anular principal(Cadena[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Comprobar compatibilidad con sistemas operativos para esta propiedad
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.fuera.println(“OS soporta translucidez”);
nuevo JavaShapedWindow();
}
}
}
También se puede aplicar una combinación de dos características como ventana de translucidez y forma. Para implementar este, llamar al método setOpacity a su marco. La ventana de resultados mostrará el efecto combinado. Pero debemos recordar que el sistema operativo subyacente debe admitir translucidez nivel de píxel y la transparencia a nivel de píxel.
Conclusión:
En este artículo hemos cubierto algunas nuevas características de la translucencia java7.The y características de la ventana en forma de son realmente interesantes y hacer que los componentes Java de interfaz de usuario más flexible. Pero al mismo tiempo debemos recordar que el sistema operativo subyacente debe apoyar todas estas propiedades. De lo contrario el efecto no será visible. Así que en la propia aplicación, comprobamos la compatibilidad con sistemas operativos y luego aplicamos el efecto. La última característica de Java permite a los desarrolladores crear diferentes tipos de efectos en la parte de interfaz de usuario. Como todos sabemos que el aspecto y el ambiente es un aspecto importante de cualquier aplicación basada en la interfaz de usuario. Así que el desarrollador está equipado con herramientas para hacer que la interfaz de usuario más agradable y atractivo.
