Visió de conjunt: En aquest article anem a discutir sobre la transparència i les diferents finestres en forma de Java. En java 7 oscil · lació admet aquesta funció i la fabricació de components d'interfície d'usuari de swing més flexible i fàcil d'usar.
Introducció: En alguna aplicació, finestra transparent és un requisit per recolzar la seva funcionalitat. Ara en Java, la transparència pot ser implementat. Una finestra translúcida es crea mitjançant l'alteració de la seva opacitat mitjançant la implementació d'un mètode anomenat setOpacity en un component JFrame. Però hem d'entendre que una finestra translúcida només és possible si el sistema operatiu subjacent ho admet. I també hem d'assegurar que la finestra no està decorada. Per fer que una finestra sense decorar, necessita trucar setUndecorated (veritable) mètode. Algun temps també es requereix per canviar la forma d'una interfície d'usuari finestra. Per posar-lo en pràctica, hem de cridar al mètode setShape dins del mètode componentResized. Es tornarà a calcular la forma quan es canvia la mida de la finestra.
Segon pla: En java UI, suport per a la finestra en forma de translucidesa i va ser molt de temps, la demanda de components Swing / AWT. Per accedir desenvolupament natiu d'aquestes propietats es troben en molt de temps enrere. Però no es podia accedir als components bàsics de Java. En java6 endavant, per donar suport a la translucidesa i la finestra està disponible en forma de. Fins i tot per translucència nivell de píxel també és compatible en Java7.
Tipus de suport per a la translucidesa i transparència: Java 7 compatible amb els següents tres tipus de suport.
TRANSLÚCID: En aquesta funció la finestra pot tenir diferents colors, però amb el mateix nivell d'opacitat. Llavors, el valor alfa és el mateix per a tots els píxels. Aquest efecte és adequat per s'esvaeixen davant d'una finestra i després disminueix gradualment i augmenta el valor alfa.
PERPIXEL_TRANSLUCENT: Aquesta propietat admet diferents valors alfa dins de la pròpia finestra. Això s'utilitza a esvair regió seleccionada de la finestra.
PERPIXEL_TRANSPARENT: Aquesta propietat admet diferents formes de les finestres en lloc de rectangular tradicional. Si la transparència per píxel és compatible llavors diferents formes com cercle, triangle pot ser creat.
Abans d'usar qualsevol de les propietats anteriors hem de provar el suport de mentir sota sistema operatiu. La prova es pot fer mitjançant el mètode isWindowTranslucencySupported pertanyent a la classe java.awt.GraphicsDevice. Es necessita el tipus de transparència com a entrada i retorna true / false per indicar el suport.
Anem a veure un exemple de codi per implementar la funció de transparència. En aquest exemple hem creat una finestra translúcida rectangular en una àrea de text. En primer lloc hem desactivat la manera de decoració per aconseguir l'efecte de transparència. Després d'haver verificat si el sistema operatiu subjacent ho admet o no. Si s'admet que l'efecte és visible a la finestra de marc.
Listing1: Mostra translucidesa que mostra una finestra 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úblic classe TransRecFrame s'estén JFrame {
/**
* Crear un marc rectangular transparent amb 85% transparència
*/
públic TransRecFrame() {
súper(“Marc rectangular translúcid”);
//Establir layout
setLayout(nou GridBagLayout());
//Crear una àrea de text
final JTextArea txtArea = nou JTextArea(5, 50);
txtArea.setBackground(Color.CIAN);
afegir(txtArea);
//Truqui per desactivar la decoració
setUndecorated(veritable);
//Truqui setShape per redimensionar la forma quan Widnow es redimensiona
addComponentListener(nou ComponentAdapter() {
@ Override
públic anul · lar componentResized(ComponentEvent i) {
setShape(nou Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Fer la finestra 85% transparent
setOpacity(0.85F);
//Establiu altres paràmetres
setLocationRelativeTo(zero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(veritable);
}
públic estàtic anul · lar principal(Cadena[] args) {
//Crear entorn gràfic
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Comproveu si OS compatible Transparència
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLÚCID)) {
System.out.println(“OS suporta translucidesa”);
nou TransRecFrame();
}
}
}
Funcions de suport a la translucidesa i la forma: En Java7 hi ha principalment tres característiques disponibles per donar suport a la transparència i la forma d'una finestra.
- Finestra completa transparència: En aquest enfocament finestra completa és translúcid.
- Per pixel translucency: En aquest enfocament, una part de la finestra és translúcida
- Finestres en forma de: Fer diferents finestres amb forma oval, cercle, rectangular etc.
Per pixel translucency:
Ja hem vist com fer que una finestra completa translúcida en l'exemple anterior. Ara parlarem de la segona part de fer un conjunt de píxels transparents amb el seu color de fons. Hi ha algunes limitacions per a l'aplicació d'aquest escenari. La finestra no ha de ser de plena pantalla i el sistema ha de ser compatible amb la translucidesa nivell de píxel. La resta del procediment és similar a l'exemple anterior.
En el següent exemple veurem com translucidesa nivell de píxel es troba en un marc de.
LISTING2: Mostrar mostrar suport translucidesa nivell de píxel.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.event.ActionEvent;
importar java.awt.event.ActionListener;
públic classe PixelTranslucency s'estén JFrame {
públic PixelTranslucency() {
súper(“Establir translucidesa nivell de píxel”);
//Establir la grandària del JFrame
setSize(250, 250);
//Establir dissenyar
getContentPane().setLayout(nou GridLayout(6, 6));
//Convocatòria d'ajust de píxels
per(int i = 0; jo < 16; i ){
afegir(nou Panell píxels(255 – jo * 12));
}
//Conjunt de fons i altres propietats
setBackground(nou Color(0, 0, 0, 0));
setLocationRelativeTo(zero);
setVisible(veritable);
}
públic estàtic anul · lar principal(Cadena[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Comproveu si suporta finestra translucidesa
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.fora.println(“OS suporta translucidesa”);
nou PixelTranslucency();
}
} privat classe Panell píxels s'estén JPanel {
privat Panell píxels(int pixl) {
súper();
setBackground(nou Color(0, 0, 255, pixl));
}
}
}
Finestres de forma:
Ara anem a parlar sobre una altra característica important suport de la finestra en forma de Java7.The suporta tot tipus de formes Qualsevol que sigui l'exigència de l'usuari. Aquesta característica us ajuda a crear qualsevol forma com cercle, triangle, polígon o qualsevol forma complexa possible. El mètode setShape de la classe de finestra està disponible per establir la propietat. Però una vegada més hem de recordar que la manera de pantalla completa no s'ha de permetre i el sistema operatiu és compatible amb translucidesa.
L'exemple següent mostra l'ús de la finestra en forma de.
Listing3: El codi d'exemple que mostra l'ús de la finestra en forma de.
importar javax.swing.*;
importar java.awt. *;
importar java.awt.geom.Ellipse2D;
importar java.awt.geom.GeneralPath;
públic classe JavaShapedWindow s'estén JFrame {
públic JavaShapedWindow() {
súper(“Establiu finestra en forma d'”);
//Ajust sense decorar OFF per aconseguir un efecte
setUndecorated(veritable);
//Establir la mida
setSize(nou Dimensió(250, 250));
//Definició de les propietats del polígon
Polígon Polígon = nou Polígon();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Definiu els valors de la forma
Ellipse2D.Double newCircle = nou Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Definició de les propietats generals trajectòria
GeneralPath gpath = nou GeneralPath();
gpath.append(polígon, veritable);
gpath.append(newCircle, veritable);
//Establir la ruta
setShape(gpath);
//Establir boxlayout
getContentPane().setLayout(nou BoxLayout(getContentPane(), BoxLayout.X_AXIS));
afegir(Caixa.createHorizontalGlue());
//Crear propietats d'etiqueta i establir
JLabel newlabel = nou JLabel(“Java finestra en forma d'”);
newlabel.setForeground(Color.blanc);
afegir(newlabel);
afegir(Caixa.createHorizontalGlue());
//Establiu contingut del plafó color de fons
getContentPane().setBackground(Color.cien);
//Per ajustar la posició
setLocationRelativeTo(zero);
setVisible(veritable);
}
públic estàtic anul · lar principal(Cadena[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Comprovar compatibilitat amb sistemes operatius per a aquesta propietat
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.fora.println(“OS suporta translucidesa”);
nou JavaShapedWindow();
}
}
}
També es pot aplicar una combinació de dues característiques com a finestra de translucidesa i forma. Per implementar aquest, cridar al mètode setOpacity al seu marc. La finestra de resultats mostrarà l'efecte combinat. Però hem de recordar que el sistema operatiu subjacent ha d'admetre translucidesa nivell de píxel i la transparència a nivell de píxel.
Conclusió:
En aquest article hem cobert algunes noves característiques de la translucència java7.The i característiques de la finestra en forma de són realment interessants i fer que els components Java d'interfície d'usuari més flexible. Però al mateix temps hem de recordar que el sistema operatiu subjacent ha de donar suport totes aquestes propietats. En cas contrari l'efecte no serà visible. Així que en la mateixa aplicació, comprovem la compatibilitat amb sistemes operatius i després apliquem l'efecte. L'última característica de Java permet als desenvolupadors crear diferents tipus d'efectes a la part d'interfície d'usuari. Com tots sabem que l'aspecte i l'ambient és un aspecte important de qualsevol aplicació basada en la interfície d'usuari. Així que el desenvolupador està equipat amb eines per fer que la interfície d'usuari més agradable i atractiu.
