Vue d'ensemble: Dans cet article nous allons discuter de la transparence et de différentes fenêtres en forme Java. En java 7 balançoire charge cette fonctionnalité et la fabrication de composants de l'interface utilisateur de swing plus souple et convivial.
Présentation: Dans certaines applications,, fenêtre transparente est une exigence pour soutenir sa fonctionnalité. Maintenant en Java, transparence peut être mis en œuvre. Une fenêtre translucide est créé en modifiant son opacité en mettant en œuvre une méthode appelée setOpacity sur un composant JFrame. Mais nous devons comprendre que une fenêtre translucide n'est possible que si le système d'exploitation sous-jacent prend en charge. Et nous devons aussi veiller à ce que la fenêtre n'est pas décoré. Pour faire une fenêtre sans décor, vous devez appeler setUndecorated (vrai) méthode. Certain temps, il est également nécessaire de changer la forme d'une interface utilisateur de la fenêtre. Pour mettre en œuvre, nous devons appeler la méthode SetShape dans la méthode componentResized. Il recalcule la forme lorsque la fenêtre est redimensionnée.
Retour au sol: En Java UI, soutien à la fenêtre de la translucidité et la forme était une demande de longue date pour les composants Swing / AWT. Pour l'accès au développement natif pour ces propriétés sont disponibles depuis longtemps derrière. Mais ce n'était pas accessible aux composants Java de base. En java6 en avant, Prise en charge de la translucidité et la fenêtre en forme est disponible. Même par la translucidité de niveau pixel est également en charge de java7.
Type de support pour la translucidité et la transparence: Java 7 soutient les trois type de support suivant.
TRANSLUCIDE: Dans cette fonction, la fenêtre peut avoir des couleurs différentes mais avec le même niveau d'opacité. Ainsi, la valeur de alpha est identique pour tous les pixels. Cet effet est adapté à s'estomper sur une vitre, puis diminue progressivement et augmente la valeur de l'alpha.
PERPIXEL_TRANSLUCENT: Cette propriété prend en charge différentes valeurs alpha au sein de la fenêtre elle-même. Cela permet d'enchaîner région sélectionnée de la fenêtre.
PERPIXEL_TRANSPARENT: Cette propriété prend en charge différentes formes de fenêtres plutôt que de rectangle traditionnel. Si par la transparence du pixel est pris en charge, puis les différentes formes comme cercle, triangle peut être créé.
Avant d'utiliser l'une des propriétés ci-dessus, nous devons tester le support des sous système d'exploitation couché. Le test peut être effectué en utilisant la méthode isWindowTranslucencySupported appartenant à la classe java.awt.GraphicsDevice. Il prend le type de transparence en entrée et renvoie true / false pour indiquer le soutien.
Laissez-nous vérifier un exemple de code pour implémenter la fonctionnalité de translucidité. Dans cet exemple, nous avons créé une fenêtre translucide rectangulaire sur une zone de texte. D'abord, nous avons désactivé le mode de décoration pour obtenir l'effet de transparence. Ensuite, nous avons vérifié si le système d'exploitation sous-jacent prend en charge ou non. Si supporté l'effet est visible sur la fenêtre de cadre.
Listing1: Exemple de translucidité montrant d'une fenêtre JFrame
importer java.awt.Color;
importer java.awt.GraphicsDevice;
importer java.awt.GraphicsEnvironment;
importer java.awt.GridBagLayout;
importer java.awt.event.ComponentAdapter;
importer java.awt.event.ComponentEvent;
importer java.awt.geom.Rectangle2D;
importer javax.swing.JFrame;
importer javax.swing.JTextArea;
importer javax.swing.SwingUtilities;
publique classe TransRecFrame s'étend JFrame {
/**
* Créer un cadre rectangulaire transparent avec 85% transparence
*/
publique TransRecFrame() {
Super(“Translucide cadre rectangulaire”);
//Réglez disposition
setLayout(nouveau GridBagLayout());
//Créer une zone de texte
finale JTextArea txtArea = nouveau JTextArea(5, 50);
txtArea.setBackground(Couleur.CYAN);
ajouter(txtArea);
//Appel à désactiver décoration
setUndecorated(vrai);
//Appelez SetShape pour redimensionner la forme lorsque widnow est redimensionnée
addComponentListener(nouveau ComponentAdapter() {
@ Override
publique annulera componentResized(ComponentEvent et) {
SetShape(nouveau Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Rendre la fenêtre 85% transparent
setOpacity(0.85f);
//Définissez d'autres paramètres
setLocationRelativeTo(zéro);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(vrai);
}
publique statique annulera principale(Chaîne[] args) {
//Créer un environnement graphique
GraphicsEnvironment genv = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Vérifiez si OS prend en charge Translucidité
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCIDE)) {
System.out.println(“OS prend en charge la translucidité”);
nouveau TransRecFrame();
}
}
}
Caractéristiques de soutenir la translucidité et la forme: En java7 il existe principalement trois fonctions disponibles pour soutenir la translucidité et la forme d'une fenêtre.
- Fenêtre translucide plein: Dans cette approche pleine fenêtre translucide.
- Par translucidité de pixel: Dans cette approche, une partie de la fenêtre est translucide
- Fenêtres en forme: Assurez différentes fenêtres en forme ovale, cercle, rectangulaire, etc.
Par translucidité de pixel:
Nous avons déjà vu comment faire une fenêtre translucide complète dans l'exemple précédent. Maintenant, nous allons discuter de la deuxième partie de faire un ensemble de pixels translucides en utilisant leur couleur de fond. Il ya quelques limitations pour mettre en œuvre ce scénario. La fenêtre ne doit pas être plein écran et le système doit prendre en charge la translucidité du niveau du pixel. Le reste de la procédure est similaire à l'exemple ci-dessus.
Dans l'exemple suivant, nous verrons comment la translucidité de niveau pixel est situé dans un cadre.
Listing2: Exemple montrant le soutien de transparence au niveau du pixel.
importer javax.swing.*;
importer java.awt. *;
importer java.awt.event.ActionEvent;
importer java.awt.event.ActionListener;
publique classe PixelTranslucency s'étend JFrame {
publique PixelTranslucency() {
Super(“Réglez la translucidité du niveau de pixel”);
//Régler la taille de la JFrame
setSize(250, 250);
//Réglez exposer
getContentPane().setLayout(nouveau GridLayout(6, 6));
//Appel pour le réglage des pixels
pour(int i = 0; Je < 16; i ){
ajouter(nouveau Panneau de Pixels(255 – Je * 12));
}
//Réglez fond et d'autres propriétés
setBackground(nouveau Couleur(0, 0, 0, 0));
setLocationRelativeTo(zéro);
setVisible(vrai);
}
publique statique annulera principale(Chaîne[] args) {
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Vérifiez si la fenêtre prend en charge translucidité
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Système.sur.println(“OS prend en charge la translucidité”);
nouveau PixelTranslucency();
}
} privé classe Panneau de Pixels s'étend JPanel {
privé Panneau de Pixels(int pixl) {
Super();
setBackground(nouveau Couleur(0, 0, 255, pixl));
}
}
}
Fenêtres en forme:
Maintenant, nous allons discuter sur une autre caractéristique importante soutenue par la fenêtre en forme de Java7.The supporte tous les types de formes quelle que soit l'exigence de l'utilisateur. Cette fonctionnalité vous permet de créer n'importe quelle forme comme le cercle, triangle, polygone ou une forme complexe possible. Procédé SetShape de la classe de fenêtre est disponible pour le réglage de la propriété. Mais encore une fois, nous devons nous rappeler que le mode plein écran ne devrait pas être autorisé et le système d'exploitation prend en charge la translucidité.
L'exemple suivant montre l'utilisation de la fenêtre en forme.
Listing3: L'exemple de code montrant l'utilisation de la fenêtre en forme.
importer javax.swing.*;
importer java.awt. *;
importer java.awt.geom.Ellipse2D;
importer java.awt.geom.GeneralPath;
publique classe JavaShapedWindow s'étend JFrame {
publique JavaShapedWindow() {
Super(“Ensemble fenêtre en forme”);
//Réglez undecorated OFF pour obtenir un effet
setUndecorated(vrai);
//Régler la taille
setSize(nouveau Dimension(250, 250));
//Définir les propriétés des polygones
Polygone = Polygone nouveau Polygon();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Définissez les valeurs de la forme
Ellipse2D.Double newCircle = nouveau Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Définir les propriétés générales de chemin
GeneralPath gpath = nouveau GeneralPath();
gpath.append(polygone, vrai);
gpath.append(newCircle, vrai);
//Définissez le chemin
SetShape(gpath);
//Définir le plan de la boîte
getContentPane().setLayout(nouveau BoxLayout(getContentPane(), BoxLayout.X_AXIS));
ajouter(Box.createHorizontalGlue());
//Créer des propriétés de l'étiquette et ensemble
JLabel newlabel = nouveau JLabel(“Fenêtre en forme Java”);
newlabel.setForeground(Couleur.blanc);
ajouter(newlabel);
ajouter(Box.createHorizontalGlue());
//Définir le contenu volet couleur de fond
getContentPane().setBackground(Couleur.cyan);
//Définir l'emplacement
setLocationRelativeTo(zéro);
setVisible(vrai);
}
publique statique annulera principale(Chaîne[] args) {
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Vérifiez support de cette propriété
si (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Système.sur.println(“OS prend en charge la translucidité”);
nouveau JavaShapedWindow();
}
}
}
Nous pouvons également mettre en œuvre une combinaison de deux fonctions comme la fenêtre de la translucidité et la forme. Pour mettre en œuvre cette, appeler la méthode de setOpacity à votre image. La fenêtre des résultats affiche l'effet combiné. Mais nous ne devons pas oublier le système d'exploitation sous-jacente doit prendre en charge la translucidité de niveau du pixel et la transparence au niveau du pixel.
Conclusion:
Dans cet article, nous avons couvert quelques nouvelles fonctionnalités dans translucidité java7.The et les caractéristiques des fenêtres en forme sont vraiment intéressants et fabriquer des composants java interface utilisateur plus flexible. Mais en même temps nous devons nous rappeler que le système d'exploitation sous-jacent devrait soutenir toutes ces propriétés. Sinon, l'effet ne sera pas visible. Ainsi, dans l'application elle-même, nous vérifions le support OS et ensuite mettre en œuvre l'effet. La dernière caractéristique de Java permet aux développeurs de créer différents types d'effet sur le côté UI. Comme nous savons tous ce regard et la sensation est un aspect important de toute application basée sur l'interface utilisateur. Ainsi, le développeur est maintenant équipé d'outils pour rendre l'interface plus agréable et attrayante.
