Übersicht: In diesem Artikel werden wir über die Transparenz und unterschiedlich geformten Fenstern in Java diskutieren. In java 7 Schwingen diese Funktion unterstützt und macht Swing UI Komponenten flexibler und benutzerfreundlicher.
Einführung: In einigen Anwendungen, transparentes Fenster ist eine Voraussetzung, um seine Funktionalität zu unterstützen. Jetzt in Java, Transparenz umgesetzt werden. Eine lichtdurchlässige Fenster, indem Sie dessen Opazität durch die Implementierung einer Methode namens setOpacity auf einem JFrame Komponente erstellt. Aber wir müssen verstehen, dass eine transluzente Fenster nur möglich ist, wenn das zugrunde liegende Betriebssystem unterstützt. Und wir müssen auch sicherstellen, dass das Fenster nicht eingerichtet. Um ein Fenster schmucklosen, Sie müssen rufen setUndecorated (wahr) Verfahren. Einige Zeit ist es auch erforderlich, um die Form eines Fensters UI ändern. Um sie umzusetzen, müssen wir SetShape Methode innerhalb der componentResized Methode aufrufen. Es berechnet die Form, wenn das Fenster verkleinert.
Back Boden: In Java UI, Unterstützung für Transparenz und geformte Fenster war eine lange Zeit, die Nachfrage für Swing / AWT-Komponenten. Für systemeigene Entwicklung Zugriff auf diese Eigenschaften sind von langer Zeit wieder verfügbar. Aber es war nicht zugänglich Core Java-Komponenten. In Java6 Weiterreise, Unterstützung für Transparenz und geformte Fenster ist. Auch pro Pixel-Ebene Transluzenz unterstützt auch in Java7.
Art der Unterstützung für Transparenz und Transparenz: Java 7 unterstützt die folgenden drei Arten von Unterstützung.
TRANSLUCENT: In dieser Funktion kann das Fenster verschiedene Farben haben, aber mit dem gleichen Maß an Opazität. So ist der Alpha-Wert für alle Pixel gleichzeitig. Dieser Effekt eignet sich für verblassen off ein Fenster und dann allmählich abnimmt und erhöht die Alpha-Wert.
PERPIXEL_TRANSLUCENT: Diese Eigenschaft unterstützt verschiedene Alpha-Werte innerhalb des Fensters selbst. Dies wird verwendet, um ausgewählte Bereich des Fensters verblassen.
PERPIXEL_TRANSPARENT: Diese Eigenschaft unterstützt verschiedene Formen der Fenster statt der traditionellen Rechteck. Wenn Transparenz pro Pixel wird dann verschiedenen Formen wie Kreis unterstützt, Dreieck erzeugt werden.
Bevor wir eine der oben genannten Eigenschaften verwenden wir brauchen, um die Unterstützung der unter liegenden Betriebssystem testen. Der Test kann durch Verfahren erfolgen isWindowTranslucencySupported Zugehörigkeit zur Klasse java.awt.GraphicsDevice. Es nimmt die Art von Transparenz als Eingabe und gibt true / false, um die Unterstützung geben.
Prüfen wir ein Beispiel-Code, um die Funktion zu implementieren Transluzenz. In diesem Beispiel haben wir eine rechteckige transluzente Fenster auf einem Textbereich erstellt. Zuerst haben wir die Dekoration deaktiviert, um die Wirkung der Transparenz erhalten. Dann haben wir überprüft, ob das zugrunde liegende Betriebssystem unterstützt wird oder nicht. Falls unterstützt die Wirkung ist auf die Frame-Fenster sichtbar.
Listing1: Beispiel zeigt Translucency eines JFrame Fenster
importieren java.awt.Color;
importieren java.awt.GraphicsDevice;
importieren java.awt.GraphicsEnvironment;
importieren java.awt.GridBagLayout;
importieren java.awt.event.ComponentAdapter;
importieren java.awt.event.ComponentEvent;
importieren java.awt.geom.Rectangle2D;
importieren javax.swing.JFrame;
importieren javax.swing.JTextArea;
importieren javax.swing.SwingUtilities;
Öffentlichkeit Klasse TransRecFrame erstreckt JFrame {
/**
* Erstellen eines transparenten rechteckigen Rahmen mit 85% Transparenz
*/
Öffentlichkeit TransRecFrame() {
Super(“Translucent rechteckiger Rahmen”);
//Festlegen des Layouts
setLayout(neue GridBagLayout());
//Erstellen Sie einen Textbereich
Finale JTextArea txtArea = neue JTextArea(5, 50);
txtArea.setBackground(Farbe.CYAN);
hinzufügen(txtArea);
//Aufruf zur Dekoration deaktivieren
setUndecorated(wahr);
//Rufen SetShape um die Form ändern, wenn widnow geändert wird
addComponentListener(neue ComponentAdapter() {
@ Override
Öffentlichkeit ungültig componentResized(ComponentEvent und) {
SetShape(neue Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Machen Sie das Fenster 85% transparent
setOpacity(0.85f);
//Stellen Sie die anderen Parameter
setLocationRelativeTo(null);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(wahr);
}
Öffentlichkeit statische ungültig Haupt(Schnur[] args) {
//Neues Grafik-Umgebung
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Prüfen Sie, ob OS unterstützt Translucency
wenn (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.TRANSLUCENT)) {
System.out.println(“OS unterstützt Transluzenz”);
neue TransRecFrame();
}
}
}
Merkmale zur Durchsichtigkeit und Form unterstützt: In Java7 gibt es hauptsächlich drei Funktionen zur Verfügung Durchsichtigkeit und Form eines Fensters unterstützt.
- Volle Transparenz Fenster: Bei diesem Ansatz voller Fenster ist durchscheinend.
- Per Pixel Transluzenz: In diesem Ansatz wird ein Teil des Fensters ist durchscheinend
- Shaped Fenster: Stellen unterschiedlich geformten Fenstern wie ovale, Kreis, rechteckig usw..
Per Pixel Transluzenz:
Wir haben bereits gesehen, wie man ein komplettes Fenster durchscheinend im vorherigen Beispiel machen. Jetzt werden wir den zweiten Teil, einen Satz von Pixeln lichtdurchlässig, indem sie ihre Hintergrundfarbe diskutieren. Es gibt einige Einschränkungen, um dieses Szenario zu implementieren. Das Fenster sollte nicht dem ganzen Bildschirm sein und das System muss Pixel-Ebene Transparenz unterstützt. Der Rest des Verfahrens ist ähnlich zu dem obigen Beispiel.
Im folgenden Beispiel werden wir sehen, wie Pixel-Ebene Lichtdurchlässigkeit in einem Rahmen gesetzt.
Listing2: Beispiel zeigt Pixel-Ebene Transluzenz Unterstützung.
importieren javax.swing.*;
importieren java.awt. *;
importieren java.awt.event.ActionEvent;
importieren java.awt.event.ActionListener;
Öffentlichkeit Klasse PixelTranslucency erstreckt JFrame {
Öffentlichkeit PixelTranslucency() {
Super(“Set Pixel-Ebene Transluzenz”);
//Set Größe des JFrame
setSize(250, 250);
//Stellen auslegen
getContentPane().setLayout(neue GridLayout(6, 6));
//Rufen Sie für die Pixel-Einstellung
für(int i = 0; ich < 16; i ){
hinzufügen(neue PixelPanel(255 – ich * 12));
}
//Hintergrund Set und andere Eigenschaften
setBackground(neue Farbe(0, 0, 0, 0));
setLocationRelativeTo(null);
setVisible(wahr);
}
Öffentlichkeit statische ungültig Haupt(Schnur[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Prüfen Sie, ob Fenster unterstützt Lichtdurchlässigkeit
wenn (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
System.heraus.println(“OS unterstützt Transluzenz”);
neue PixelTranslucency();
}
} Private Klasse PixelPanel erstreckt JPanel {
Private PixelPanel(int pixl) {
Super();
setBackground(neue Farbe(0, 0, 255, pixl));
}
}
}
Shaped Windows-:
Jetzt werden wir über ein weiteres wichtiges Merkmal von Java7.The förmigen Fenster unterstützt diskutieren unterstützt alle Arten von Formen, was die Anforderung des Benutzers. Diese Funktion hilft Ihnen, jede beliebige Form wie Kreis zu erstellen, Dreieck, Polygon oder eine mögliche komplexe Form. Die SetShape Methode der Fenster-Klasse ist für die Einstellung der Eigenschaft verfügbar. Aber auch wir müssen uns daran erinnern, dass Vollbildmodus nicht erlaubt sein sollte und das Betriebssystem unterstützt Transluzenz.
Das folgende Beispiel zeigt die Verwendung von geformten Fenster.
Listing3: Der Beispielcode zeigt die Verwendung von geformten Fenster.
importieren javax.swing.*;
importieren java.awt. *;
importieren java.awt.geom.Ellipse2D;
importieren java.awt.geom.GeneralPath;
Öffentlichkeit Klasse JavaShapedWindow erstreckt JFrame {
Öffentlichkeit JavaShapedWindow() {
Super(“Set förmigen Fenster”);
//Set schmucklosen OFF, um eine Wirkung zu erzielen
setUndecorated(wahr);
//Set Größe
setSize(neue Dimension(250, 250));
//Set Polygon Eigenschaften
Polygon Polygon = neue Polygon();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Legen Sie die Werte der Form
Ellipse2D.Double newCircle = neue Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Set allgemeinen Pfadeigenschaften
GeneralPath GPath = neue GeneralPath();
gpath.append(Polygon, wahr);
gpath.append(newCircle, wahr);
//Legen Sie den Pfad
SetShape(GPath);
//Set-Box-Layout
getContentPane().setLayout(neue BoxLayout(getContentPane(), BoxLayout.X_AXIS));
hinzufügen(Box.createHorizontalGlue());
//Neues Label und Eigenschaften
JLabel newlabel = neue JLabel(“Java Shaped Fenster”);
newlabel.setForeground(Farbe.weiß);
hinzufügen(newlabel);
hinzufügen(Box.createHorizontalGlue());
//Set Inhaltsbereich Hintergrundfarbe
getContentPane().setBackground(Farbe.cyan);
//Ort festlegen
setLocationRelativeTo(null);
setVisible(wahr);
}
Öffentlichkeit statische ungültig Haupt(Schnur[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Prüfen Sie OS-Unterstützung für diese Unterkunft
wenn (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
System.heraus.println(“OS unterstützt Transluzenz”);
neue JavaShapedWindow();
}
}
}
Wir können auch umzusetzen eine Kombination von zwei Funktionen wie Transparenz und geformte Fenster. Um dies zu implementieren, rufen setOpacity Verfahren an den Rahmen. Das Ergebnis-Fenster zeigt die kombinierte Wirkung. Aber wir sollten nicht vergessen, das zugrunde liegende Betriebssystem muss Pixel-Ebene Transluzenz und Transparenz unterstützt Pixel-Ebene.
Fazit:
In diesem Artikel haben wir einige neue Features in java7.The Lichtdurchlässigkeit bedeckt und geformte Fenster Features sind wirklich interessant und machen Java UI-Komponenten flexibler. Aber gleichzeitig müssen wir daran erinnern, dass das zugrunde liegende Betriebssystem sollten alle diese Eigenschaften unterstützen. Ansonsten ist die Wirkung nicht sichtbar. So in der Anwendung selbst prüfen wir die OS-Unterstützung und Implementieren Sie die Wirkung. Das neueste Feature von Java ermöglicht die Entwickler auf verschiedene Arten von Auswirkungen auf die UI Seite erstellen. Wie wir alle wissen, dass Aussehen und fühlen, ist ein wichtiger Aspekt jeder UI-basierte Anwendung. So wird der Entwickler nun mit Werkzeugen ausgestattet, um die UI angenehmer und attraktiver.
