Panoramica: In questo articolo andremo a discutere circa la trasparenza e diverse finestre sagomate in Java. In java 7 altalena supporti questa funzione e rendendo i componenti dell'interfaccia utente a battente più flessibile e facile da usare.
Introduzione: In alcune applicazioni, finestra trasparente è un requisito per sostenere la sua funzionalità. Ora in Java, trasparenza può essere implementato. Una finestra traslucida è creata alterando la sua opacità implementando un metodo chiamato setOpacity su un componente JFrame. Ma dobbiamo capire che una finestra traslucida è possibile solo se il sistema operativo sottostante lo supporta. E dobbiamo anche fare in modo che la finestra non è decorato. Per fare una finestra non decorato, è necessario chiamare setUndecorated (vero) Metodo. Qualche volta è necessario anche per cambiare la forma di una finestra di interfaccia utente. Per attuarla, abbiamo bisogno di chiamare il metodo setShape all'interno del metodo componentResized. Si ricalcolerà la forma quando la finestra viene ridimensionata.
Torna a terra: In java UI, supporto per la finestra di traslucenza e forma è stata una domanda molto tempo per componenti Swing / AWT. Per l'accesso allo sviluppo nativo di queste proprietà sono disponibili da molto tempo indietro. Ma non era accessibile ai componenti core di Java. In java6 in poi, sostegno per traslucenza e la finestra a forma di è disponibile. Anche a livello di traslucenza pixel è inoltre supporta in Java7.
Tipo di supporto per la traslucenza e la trasparenza: Java 7 supporta i tre tipi di supporto seguente.
TRANSLUCENT: In questa caratteristica la finestra può avere colori differenti ma con lo stesso livello di opacità. Quindi il valore alfa è uguale per tutti i pixel. Questo effetto è adatto per dissolvenza fuori una finestra e poi diminuisce gradualmente e aumenta il valore alfa.
PERPIXEL_TRANSLUCENT: Questa proprietà supporta valori alfa diversi all'interno della finestra stessa. Questo è utilizzato per sfumare regione selezionata della finestra.
PERPIXEL_TRANSPARENT: Questa proprietà supporta diverse forme di finestre piuttosto che rettangolo tradizionale. Se per la trasparenza dei pixel è supportato quindi diverse forme come il cerchio, triangolo può essere creato.
Prima abbiamo usato nessuna delle proprietà di cui sopra abbiamo bisogno di testare il supporto di nel sistema operativo lying. Il test può essere fatto utilizzando il metodo isWindowTranslucencySupported appartenente alla classe java.awt.GraphicsDevice. Prende il tipo di trasparenza come input e restituisce true / false per indicare il supporto.
Cerchiamo di controllare un codice di esempio per implementare la funzionalità di traslucenza. In questo esempio abbiamo creato una finestra rettangolare traslucido su un area di testo. In primo luogo abbiamo disattivato la modalità di decorazione per ottenere l'effetto di trasparenza. Poi abbiamo controllato se il sistema operativo sottostante lo supporta o no. Se supportato l'effetto è visibile nella finestra di telaio.
Listing1: Esempio che mostra traslucenza di una finestra JFrame
importare java.awt.Color;
importare java.awt.GraphicsDevice;
importare java.awt.GraphicsEnvironment;
importare java.awt.GridBagLayout;
importare java.awt.event.ComponentAdapter;
importare java.awt.event.ComponentEvent;
importare java.awt.geom.Rectangle2D;
importare javax.swing.JFrame;
importare javax.swing.JTextArea;
importare javax.swing.SwingUtilities;
pubblico classe TransRecFrame estende JFrame {
/**
* Creare una cornice rettangolare trasparente con 85% trasparenza
*/
pubblico TransRecFrame() {
Super(“Translucent Cornice Rettangolare”);
//Imposta layout di
setLayout(nuovo GridBagLayout());
//Creare un'area di testo
finale JTextArea txtArea = nuovo JTextArea(5, 50);
txtArea.setBackground(Colore.CIANO);
aggiungi(txtArea);
//Chiama per disabilitare decorazione
setUndecorated(vero);
//Chiama setShape per ridimensionare la forma quando widnow viene ridimensionato
addComponentListener(nuovo ComponentAdapter() {
@ Override
pubblico invalidare componentResized(ComponentEvent e) {
setShape(nuovo Rectangle2D.Double(0, 0, getWidth(), getAltezza()));
}
});
//Rendere la finestra 85% trasparente
setOpacity(0.85f);
//Impostare gli altri parametri
setLocationRelativeTo(pari a zero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(vero);
}
pubblico statica invalidare principale(Stringa[] args) {
//Creare l'ambiente grafico
Gioventù Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Controllare se OS supporta Traslucenza
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCENT)) {
System.out.println(“OS supporta traslucenza”);
nuovo TransRecFrame();
}
}
}
Caratteristiche per sostenere traslucenza e la forma: In Java7 ci sono principalmente tre funzioni disponibili per supportare la traslucenza e la forma di una finestra.
- Finestra traslucenza completa: In questo approccio completo finestra è traslucido.
- Per pixel traslucenza: In questo approccio una parte della finestra è traslucido
- Finestre a forma di: Fai diverse finestre a forma ovale, cerchio, rettangolare ecc.
Per pixel traslucenza:
Abbiamo già visto come creare una finestra traslucida completo dell'esempio precedente. Ora discuteremo la seconda parte di fare una serie di pixel traslucidi utilizzando il loro colore di sfondo. Ci sono alcune limitazioni per implementare questo scenario. La finestra non deve essere pieno schermo e il sistema deve supportare traslucenza livello di pixel. Il resto della procedura è simile al precedente esempio.
Nel seguente esempio vedremo come livello di traslucenza di pixel si trova in una cornice.
Listing2: Esempio che mostra il livello di supporto di pixel traslucenza.
importare javax.swing.*;
importare java.awt. *;
importare java.awt.event.ActionEvent;
importare java.awt.event.ActionListener;
pubblico classe PixelTranslucency estende JFrame {
pubblico PixelTranslucency() {
Super(“Impostare il livello di pixel traslucenza”);
//Impostare la dimensione del JFrame
setSize(250, 250);
//Impostare il layout
getContentPane().setLayout(nuovo GridLayout(6, 6));
//Chiama per il valore di pixel
per(int i = 0; i < 16; i ){
aggiungi(nuovo Pixel del pannello(255 – i * 12));
}
//Impostare sfondo e altre proprietà
setBackground(nuovo Colore(0, 0, 0, 0));
setLocationRelativeTo(pari a zero);
setVisible(vero);
}
pubblico statica invalidare principale(Stringa[] args) {
Gioventù Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Controllare se la finestra supporta traslucenza
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.fuori.println(“OS supporta traslucenza”);
nuovo PixelTranslucency();
}
} privato classe Pixel del pannello estende JPanel {
privato Pixel del pannello(int pixl) {
Super();
setBackground(nuovo Colore(0, 0, 255, pixl));
}
}
}
Finestre di forma:
Ora parleremo di un altro importante caratteristica supportata da Java7.The finestra a forma supporta tutti i tipi di forme qualunque sia l'esigenza dell'utente. Questa funzione consente di creare qualsiasi forma come cerchio, triangolo, poligono o ogni possibile forma complessa. Il metodo setShape della classe finestra è disponibile per l'impostazione della proprietà. Ma ancora una volta dobbiamo ricordare che la modalità a schermo intero non dovrebbe essere consentito e il sistema operativo supporta traslucenza.
L'esempio seguente mostra l'utilizzo della finestra di forma.
Listing3: Il codice di esempio che mostra l'uso della finestra a forma di.
importare javax.swing.*;
importare java.awt. *;
importare java.awt.geom.Ellipse2D;
importare java.awt.geom.GeneralPath;
pubblico classe JavaShapedWindow estende JFrame {
pubblico JavaShapedWindow() {
Super(“Impostare a forma di finestra”);
//Impostare undecorated OFF per ottenere un effetto
setUndecorated(vero);
//Imposta dimensione
setSize(nuovo Dimension(250, 250));
//Impostare le proprietà dei poligoni
Poligono poligono = nuovo Poligono();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Impostare i valori della forma
Ellipse2D.Double newCircle = nuovo Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Impostare le proprietà del percorso generali
GeneralPath gpath = nuovo GeneralPath();
gpath.append(poligono, vero);
gpath.append(newCircle, vero);
//Impostare il percorso
setShape(gpath);
//Imposta layout di scatola
getContentPane().setLayout(nuovo BoxLayout(getContentPane(), BoxLayout.X_AXIS));
aggiungi(Box.createHorizontalGlue());
//Creare etichette e impostare le proprietà
JLabel newlabel = nuovo JLabel(“Finestra a forma di Java”);
newlabel.setForeground(Colore.bianco);
aggiungi(newlabel);
aggiungi(Box.createHorizontalGlue());
//Impostare contenuto del riquadro colore di sfondo
getContentPane().setBackground(Colore.ciano);
//Imposta posizione
setLocationRelativeTo(pari a zero);
setVisible(vero);
}
pubblico statica invalidare principale(Stringa[] args) {
Gioventù Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Controllare il supporto del sistema operativo per questo immobile
se (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.fuori.println(“OS supporta traslucenza”);
nuovo JavaShapedWindow();
}
}
}
Possiamo anche realizzare una combinazione di due caratteristiche come finestra traslucenza e sagomati. Per implementare questo, chiamare il metodo setOpacity al telaio. La finestra dei risultati visualizzerà l'effetto combinato. Ma dobbiamo ricordare il sistema operativo sottostante deve supportare traslucenza livello di pixel e pixel di trasparenza di livello.
Conclusione:
In questo articolo abbiamo coperto alcune nuove caratteristiche in traslucenza java7.The e le caratteristiche finestre a forma di sono davvero interessanti e di fare componenti UI Java più flessibile. Ma allo stesso tempo dobbiamo ricordare che il sistema operativo sottostante dovrebbe sostenere tutte queste proprietà. Altrimenti l'effetto non sarà visibile. Così nella richiesta stessa, controlliamo il supporto del sistema operativo e quindi implementare l'effetto. L'ultima caratteristica di Java permette agli sviluppatori di creare diversi tipi di effetti sul lato interfaccia utente. Come tutti sappiamo che guardare e sentire è un aspetto importante di qualsiasi applicazione basata su interfaccia utente. Quindi, lo sviluppatore è ora dotato di strumenti per rendere l'interfaccia utente più piacevole e attraente.
