Overzicht: In dit artikel zullen we discussiëren over de transparantie en de verschillende gevormde ramen in Java. In java 7 swing deze functie ondersteunt en het maken van swing UI-componenten meer flexibel en gebruiksvriendelijk.
Introductie: In een toepassing, transparant venster is een vereiste om de functionaliteit te ondersteunen. Nu in Java, transparantie kan worden uitgevoerd. Een doorschijnend venster wordt gemaakt door het veranderen van de dekking door het implementeren van een methode genaamd setOpacity op een JFrame component. Maar wij moeten begrijpen dat een doorschijnend venster is alleen mogelijk als het onderliggende besturingssysteem dit ondersteunt. En we moeten er ook voor zorgen dat het venster niet is ingericht. Om een venster onversierde, je moet bellen setUndecorated (waar) methode. Enige tijd moet ook de vorm van een venster UI wijzigen. Om het te implementeren, we moeten setShape methode aan te roepen binnen de componentResized methode. Het herberekent de vorm wanneer het venster wordt aangepast.
Achtergrond: In java UI, ondersteuning van doorschijnendheid en gevormd venster was lange tijd de vraag naar Swing / AWT componenten. Voor inheemse toegang ontwikkeling van deze eigenschappen zijn beschikbaar vanaf lange tijd terug. Maar het was niet toegankelijk voor kern java componenten. In java6 verder, ondersteuning van doorschijnendheid en gevormd venster is beschikbaar. Zelfs per pixel niveau doorschijnendheid is ook steunt in Java7.
Soort ondersteuning voor de doorschijnendheid en transparantie: Java 7 ondersteunt de volgende drie soort ondersteuning.
TRANSLUCENT: In deze functie kan het raam verschillende kleuren, maar met dezelfde mate van ondoorzichtigheid hebben. Dus de alfa-waarde is gelijk voor alle pixels. Dit effect is geschikt voor het verdwijnen uit een raam en daarna geleidelijk afneemt en verhoogt de alpha-waarde.
PERPIXEL_TRANSLUCENT: Deze eigenschap ondersteunt verschillende alpha-waarden binnen het raam zelf. Hiermee wordt gekozen gebied van het scherm verdwijnen.
PERPIXEL_TRANSPARENT: Deze eigenschap ondersteunt verschillende vormen van vensters in plaats van de traditionele rechthoek. Als per pixel transparant dan weer ondersteund verschillende vormen, zoals cirkel, driehoek kan worden gecreëerd.
Voordat we gebruik maken van een van de bovengenoemde eigenschappen moeten we de steun van de testen onder liggende besturingssysteem. De test kan worden uitgevoerd volgens methode isWindowTranslucencySupported behoren tot de klasse java.awt.GraphicsDevice. Het neemt de vorm van transparantie als invoer en retourneert true / false om de steun aan te geven.
Laten we eerst controleren een voorbeeldcode om de functie doorschijnendheid implementeren. In dit voorbeeld hebben we een rechthoekig doorschijnend venster gemaakt op een tekstgebied. Eerst hebben we de inrichting bedrijfswijze het transparant effect krijgen. Vervolgens hebben we gekeken of het onderliggende besturingssysteem dit ondersteunt of niet. Indien daarbij het effect zichtbaar op framevenster.
Listing1: Monster dat doorschijnendheid van een JFrame venster
importeren java.awt.Color;
importeren java.awt.GraphicsDevice;
importeren java.awt.GraphicsEnvironment;
importeren java.awt.GridBagLayout;
importeren java.awt.event.ComponentAdapter;
importeren java.awt.event.ComponentEvent;
importeren java.awt.geom.Rectangle2D;
importeren javax.swing.JFrame;
importeren javax.swing.JTextArea;
importeren javax.swing.SwingUtilities;
publiek klasse TransRecFrame verlengt JFrame {
/**
* Maak een transparant rechthoekig frame met 85% doorzichtigheid
*/
publiek TransRecFrame() {
super(“Doorschijnend Rechthoekige Frame”);
//Set layout
setLayout(nieuw GridBagLayout());
//Maak een tekst gebied
finale JTextArea txtArea = nieuw JTextArea(5, 50);
txtArea.setBackground(Kleur.CYAN);
toevoegen(txtArea);
//Oproep om decoratie uitschakelen
setUndecorated(waar);
//Bel setShape aan de vorm verandert wanneer widnow wordt aangepast
addComponentListener(nieuw ComponentAdapter() {
@ Override
publiek vervallen componentResized(ComponentEvent en) {
setShape(nieuw Rectangle2D.Double(0, 0, getWidth(), GetHeight()));
}
});
//Maak het venster 85% transparant
setOpacity(0.85f);
//Stel andere parameters
setLocationRelativeTo(nul);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(waar);
}
publiek statisch vervallen hoofd-(Snaar[] args) {
//Maak grafische omgeving
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Controleer of OS ondersteunt Doorschijnendheid
indien (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCENT)) {
System.out.println(“OS ondersteunt doorschijnendheid”);
nieuw TransRecFrame();
}
}
}
Functies om doorschijnendheid en vorm te ondersteunen: In Java7 zijn er hoofdzakelijk drie functies die beschikbaar zijn om doorschijnendheid en de vorm van een raam te ondersteunen.
- Volledige venster doorschijnendheid: In deze benadering volledig venster doorschijnend.
- Per pixel doorschijnendheid: In deze benadering een deel van het venster is doorschijnend
- Gevormde ramen: Maak verschillende gevormde ramen zoals ovale, cirkel, rechthoekig etc..
Per pixel doorschijnendheid:
We hebben al gezien hoe je een compleet raam doorzichtig maken in het vorige voorbeeld. Nu zullen we het tweede deel van het maken van een reeks pixels doorschijnend bespreken met de achtergrondkleur. Er zijn een aantal beperkingen aan dit scenario te implementeren. Het raam moet het volledige scherm niet en het systeem moet pixelniveau doorschijnendheid ondersteunen. De rest van de procedure is vergelijkbaar met het bovenstaande voorbeeld.
In het volgende voorbeeld zullen we zien hoe pixelniveau doorschijnendheid is gevestigd in een frame.
Listing2: Monster met pixelniveau doorschijnendheid ondersteuning.
importeren javax.swing.*;
importeren java.awt. *;
importeren java.awt.event.ActionEvent;
importeren java.awt.event.ActionListener;
publiek klasse PixelTranslucency verlengt JFrame {
publiek PixelTranslucency() {
super(“Stel pixelniveau doorschijnendheid”);
//Stel grootte van de JFrame
setSize(250, 250);
//Stel de lay-out
getContentPane().setLayout(nieuw GridLayout(6, 6));
//Bel voor resolutie-instelling
voor(int i = 0; ik < 16; i ){
toevoegen(nieuw Pixel Panel(255 – ik * 12));
}
//Stel achtergrond en andere eigenschappen
setBackground(nieuw Kleur(0, 0, 0, 0));
setLocationRelativeTo(nul);
setVisible(waar);
}
publiek statisch vervallen hoofd-(Snaar[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Controleer of venster ondersteunt doorschijnendheid
indien (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Systeem.uit.println(“OS ondersteunt doorschijnendheid”);
nieuw PixelTranslucency();
}
} prive- klasse Pixel Panel verlengt JPanel {
prive- Pixel Panel(int pixl) {
super();
setBackground(nieuw Kleur(0, 0, 255, pixl));
}
}
}
Shaped Windows:
Nu zullen we discussiëren over een ander belangrijk kenmerk ondersteund door Java7.The gevormd venster ondersteunt alle soorten vormen, ongeacht de eis van de gebruiker worden. Deze functie helpt u om het even welke vorm, zoals cirkel te maken, driehoek, veelhoek of eventuele complexe vorm. De setShape methode van het venster klasse is beschikbaar voor het instellen van de eigenschap. Maar we moeten weer aan herinneren dat het volledige scherm niet moet worden toegestaan en het besturingssysteem ondersteunt doorschijnendheid.
Het volgende voorbeeld toont het gebruik van gevormde venster.
Listing3: De voorbeeldcode toont het gebruik van gevormde venster.
importeren javax.swing.*;
importeren java.awt. *;
importeren java.awt.geom.Ellipse2D;
importeren java.awt.geom.GeneralPath;
publiek klasse JavaShapedWindow verlengt JFrame {
publiek JavaShapedWindow() {
super(“Set vormige Window”);
//Stel onversierde OFF om een effect te krijgen
setUndecorated(waar);
//Set maat
setSize(nieuw Dimensie(250, 250));
//Set veelhoek eigenschappen
Polygoon veelhoek = nieuw Veelhoek();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Stel de waarden van de vorm
Ellipse2D.Double newcircle = nieuw Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Stel algemene pad panden
GeneralPath gpath = nieuw GeneralPath();
gpath.append(veelhoek, waar);
gpath.append(newcircle, waar);
//Stel het pad
setShape(gpath);
//Set box layout
getContentPane().setLayout(nieuw BoxLayout(getContentPane(), BoxLayout.XAXIS));
toevoegen(Doos.createHorizontalGlue());
//Maak label en eigenschappen
JLabel newlabel = nieuw JLabel(“Java Shaped venster”);
newlabel.setForeground(Kleur.wit);
toevoegen(newlabel);
toevoegen(Doos.createHorizontalGlue());
//Stel inhoudsdeelvenster achtergrondkleur
getContentPane().setBackground(Kleur.cyaan);
//Set locatie
setLocationRelativeTo(nul);
setVisible(waar);
}
publiek statisch vervallen hoofd-(Snaar[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Controleer OS ondersteuning voor deze woning
indien (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Systeem.uit.println(“OS ondersteunt doorschijnendheid”);
nieuw JavaShapedWindow();
}
}
}
We kunnen ook de uitvoering van een combinatie van twee functies, zoals doorschijnendheid en gevormd venster. Om dit te implementeren, bel setOpacity methode om je frame. Het venster resultaat zal het gecombineerde effect weer te geven. Maar we moeten niet vergeten het onderliggende besturingssysteem moet pixelniveau doorschijnendheid en pixelniveau transparantie ondersteunen.
Conclusie:
In dit artikel hebben we een aantal nieuwe features die in java7.The doorschijnendheid en gevormd venster functies zijn echt interessant en maakt Java UI-componenten flexibeler. Maar tegelijkertijd moeten we bedenken dat het onderliggende besturingssysteem al deze eigenschappen moeten ondersteunen. Anders wordt het effect zal niet zichtbaar zijn. Dus in de applicatie zelf controleren we de steun OS en vervolgens de uitvoering van het effect. De nieuwste functie van java kan de ontwikkelaars om verschillende soorten effect op de gebruikersinterface kant. Zoals we allemaal weten dat de look en feel is een belangrijk aspect van een UI gebaseerde applicatie. Dus de ontwikkelaar is nu uitgerust met tools om de UI aangenamer en aantrekkelijker te maken.
