Översikt: I denna artikel kommer vi att diskutera om öppenhet och olika formade fönster i Java. I java 7 swing stöder denna funktion och göra swing UI komponenter mer flexibelt och användarvänligt.
Inledning: I vissa program, transparent fönster är ett krav för att stödja dess funktionalitet. Nu i Java, öppenhet kan genomföras. Ett genomskinligt fönster skapas genom att ändra dess opacitet genom att implementera en metod som kallas setOpacity på en JFrame komponent. Men vi måste förstå att ett genomskinligt fönster är endast möjligt om det underliggande operativsystemet stöder det. Och vi måste också se till att fönstret inte är inrett. För att göra ett fönster undecorated, du behöver ringa setUndecorated (sant) metod. Någon gång är det också för att ändra formen på ett fönster UI. För att genomföra det, vi behöver ringa setShape metod inom componentResized metoden. Det kommer att räkna formen när fönstret ritas om.
Tillbaka marken: I java UI, stöd för genomskinlighet och formade fönster var länge efterfrågan på Swing / AWT-komponenter. För infödda utveckling tillgång till dessa egenskaper är tillgängliga från lång tid tillbaka. Men det var inte tillgängligt för centrala Java komponenter. I java6 onward, stöd för genomskinlighet och formade fönster finns. Även per pixel nivå genomskinlighet är också stöd i Java7.
Typ av stöd för genomskinlighet och öppenhet: Java 7 stöder följande tre typer av stöd.
GENOMLYSANDE: I denna funktion fönstret kan ha olika färger men med samma nivå av opacitet. Så alfavärdet är samma för alla pixlar. Denna effekt är lämplig för blekna bort en fönster och sedan gradvis minskar och ökar alfavärde.
PERPIXEL_TRANSLUCENT: Denna fastighet stöder olika alfavärden inom själva fönstret. Detta används för att tona utvald region av fönstret.
PERPIXEL_TRANSPARENT: Denna fastighet stöder olika former av fönster snarare än traditionella rektangel. Om per pixel insyn stöds sedan olika former som cirkel, triangel kan skapas.
Innan vi använder någon av ovanstående egenskaper som vi behöver för att testa stöd av ramen liggande operativsystem. Testet kan göras genom att använda metod isWindowTranslucencySupported tillhör java.awt.GraphicsDevice klassen. Det tar typ av öppenhet som indata och returnerar true / false för att ange stöd.
Låt oss ta ett exempel på kod för att implementera genomskinlighet funktionen. I detta exempel har vi skapat ett rektangulärt genomskinligt fönster på en text område. Först har vi inaktiverat dekoration läge för att få effekten av öppenhet. Då vi har kontrollerat om det underliggande operativsystemet stödjer det eller inte. Om det stöds effekten syns på ramen fönstret.
Listing1: Prov visar Genomskinlighet av en JFrame fönster
importera java.awt.Color;
importera java.awt.GraphicsDevice;
importera java.awt.GraphicsEnvironment;
importera java.awt.GridBagLayout;
importera java.awt.event.ComponentAdapter;
importera java.awt.event.ComponentEvent;
importera java.awt.geom.Rectangle2D;
importera javax.swing.JFrame;
importera javax.swing.JTextArea;
importera javax.swing.SwingUtilities;
offentlig klass TransRecFrame sträcker JFrame {
/**
* Skapa en transparent rektangulär ram med 85% öppenhet
*/
offentlig TransRecFrame() {
super(“Translucent rektangulär ram”);
//Ställ layout
setLayout(ny GridBagLayout());
//Skapa en text område
slutlig JTextArea txtArea = ny JTextArea(5, 50);
txtArea.setBackground(Färg.CYAN);
lägg(txtArea);
//Ring för att inaktivera dekoration
setUndecorated(sant);
//Ring setShape att ändra storlek på formen när widnow storlek ändras
addComponentListener(ny ComponentAdapter() {
@ Åsidosätt
offentlig ogiltig componentResized(ComponentEvent och) {
setShape(ny Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Gör fönstret 85% transparent
setOpacity(0.85f);
//Ställ in andra parametrar
setLocationRelativeTo(noll);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(sant);
}
offentlig statisk ogiltig main(String[] args) {
//Skapa grafik miljön
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Kontrollera om OS stöder Genomskinlighet
om (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.GENOMLYSANDE)) {
System.out.println(“OS stöder genomskinlighet”);
ny TransRecFrame();
}
}
}
Funktioner som stöder genomskinlighet och form: I Java7 finns i huvudsak tre funktioner som är tillgängliga för att stödja genomskinlighet och form av ett fönster.
- Full fönster genomskinlighet: I detta tillvägagångssätt hela fönstret är genomskinlig.
- Per pixel genomskinlighet: I detta tillvägagångssätt en del av fönstret är genomskinlig
- Formade fönster: Gör olika formade fönster som ovale, cirkel, rektangulär etc..
Per pixel genomskinlighet:
Vi har redan sett hur man gör en komplett fönster genomskinlig i föregående exempel. Nu kommer vi att diskutera den andra delen av att göra en uppsättning pixlar genomskinliga med hjälp av deras bakgrundsfärg. Det finns vissa begränsningar för att genomföra detta scenario. Fönstret ska inte vara full skärm och systemet måste stödja pixelnivå genomskinlighet. Resten av förfarandet är liknande exemplet ovan.
I följande exempel kommer vi att se hur pixelnivå genomskinlighet ligger i en ram.
Listing2: Prov visar pixelnivå translucency stöd.
importera javax.swing.*;
importera java.awt. *;
importera java.awt.event.ActionEvent;
importera java.awt.event.ActionListener;
offentlig klass PixelTranslucency sträcker JFrame {
offentlig PixelTranslucency() {
super(“Ange genomskinlighet pixelnivå”);
//Ange storlek JFrame
setSize(250, 250);
//Ställ lägga ut
getContentPane().setLayout(ny GridLayout(6, 6));
//Ring för pixelinställning
för(int i = 0; Jag < 16; i ){
lägg(ny Pixel Panel(255 – Jag * 12));
}
//Ange bakgrund och andra egenskaper
setBackground(ny Färg(0, 0, 0, 0));
setLocationRelativeTo(noll);
setVisible(sant);
}
offentlig statisk ogiltig main(String[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Kontrollera om fönstret stöder translucens
om (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
System.ut.println(“OS stöder genomskinlighet”);
ny PixelTranslucency();
}
} privat klass Pixel Panel sträcker JPanel {
privat Pixel Panel(int Pixl) {
super();
setBackground(ny Färg(0, 0, 255, Pixl));
}
}
}
Formade Windows:
Nu kommer vi att diskutera om en annan viktig funktion som stöds av Java7.The formade fönster stöder alla typer av former oavsett vara kravet på användaren. Denna funktion hjälper dig att skapa någon form som cirkel, triangel, polygon eller eventuella komplex form. Den setShape för fönstret klassen är tillgänglig för inställning av egenskapen. Men återigen måste vi komma ihåg att fullskärmsläge inte bör tillåtas och operativsystemet stöder genomskinlighet.
Följande exempel visar användningen av formade fönster.
Listing3: Den exempelkod som visar användningen av formade fönster.
importera javax.swing.*;
importera java.awt. *;
importera java.awt.geom.Ellipse2D;
importera java.awt.geom.GeneralPath;
offentlig klass JavaShapedWindow sträcker JFrame {
offentlig JavaShapedWindow() {
super(“Ställ formad Fönster”);
//Ställ odekorerade OFF för att få en effekt
setUndecorated(sant);
//Ange storlek
setSize(ny Dimension(250, 250));
//Ställ polygon egenskaper
Polygon polygon = ny Polygon();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Ställ in värdena i form
Ellipse2D.Double newCircle = ny Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Ställ allmänna väg egenskaper
GeneralPath gpath = ny GeneralPath();
gpath.append(polygon, sant);
gpath.append(newCircle, sant);
//Ange sökvägen
setShape(gpath);
//Ställ box layout
getContentPane().setLayout(ny BoxLayout(getContentPane(), BoxLayout.X_AXIS));
lägg(Låda.createHorizontalGlue());
//Skapa etikett och ange egenskaper
JLabel newlabel = ny JLabel(“Java Formad fönster”);
newlabel.setForeground(Färg.vit);
lägg(newlabel);
lägg(Låda.createHorizontalGlue());
//Satt innehåll färg panelen bakgrund
getContentPane().setBackground(Färg.cyan);
//Ange plats
setLocationRelativeTo(noll);
setVisible(sant);
}
offentlig statisk ogiltig main(String[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Kontrollera OS-stöd för den här egenskapen
om (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
System.ut.println(“OS stöder genomskinlighet”);
ny JavaShapedWindow();
}
}
}
Vi kan också genomföra en kombination av två funktioner som genomskinlighet och formade fönster. För att genomföra detta, ringa setOpacity metod för att din ram. Resultatet fönster kommer att visa den kombinerade effekten. Men vi bör komma ihåg det underliggande operativsystemet måste stödja pixelnivå genomskinlighet och pixelnivå öppenhet.
Slutsats:
I denna artikel har vi täckt några nya funktioner i java7.The genomskinlighet och formade fönster funktioner är riktigt intressant och göra java UI-komponenter mer flexibla. Men samtidigt måste vi komma ihåg att det underliggande operativsystemet bör stödja alla dessa egenskaper. Annars effekten inte kommer att vara synlig. Så i själva ansökan vi kontrollerar OS-stöd och sedan genomföra effekten. Den senaste funktionen av java tillåter utvecklare att skapa olika typer av effekter på UI sidan. Som vi alla vet att utseendet är en viktig aspekt av alla UI baserad applikation. Så utvecklaren är nu utrustad med verktyg för att göra användargränssnittet mer trivsam och attraktiv.
