Folgendes Applet ist »unsichtbar« in
eine HTML-Seite eingebunden:
public class TransparentAppletDemo extends Applet {
Image background; // Hintergrundbild
Font f; // Textfont
FontMetrics fm; // FontMetrics zu obigem Font
int x,y; // Textposition
final String text = "How to make an applet transparent!";
public void init () {
// Laden des Hintergrundbildes
MediaTracker tracker = new MediaTracker(this);
background = getImage(
getCodeBase(),"images/background_grey.gif");
tracker.addImage(background, 0);
try {
tracker.waitForID(0);
}
catch (InterruptedException e) {
e.printStackTrace();
}
// Erzeugen und setzen des Fonts
f = new Font("SansSerif", Font.PLAIN, 30);
setFont(f);
}
public void paint(Graphics g) {
// Auslegen des Applets mit dem Bild 'background'
tiling(g, background, 0, 0,
getSize().width, getSize().height, 0, 0);
// Zentrieren der Schrift
fm = getFontMetrics(g.getFont());
x = (int)(getSize().width -
fm.stringWidth(text)) / 2;
y = (int)(getSize().height -
fm.getHeight()) / 2 + fm.getAscent();
// Schrift ausgeben
g.drawString(text, x, y);
}
public void tiling(Graphics g, Image background,
int x, int y, int width, int height,
int deltax, int deltay) {
// Speichern der Bildgröße
int imagewidth = background.getWidth(this);
int imageheight = background.getHeight(this);
// Berechnen der Position der ersten Bildkachel
int aktx = -((imagewidth - deltax) % imagewidth) + x;
int akty = -((imageheight - deltay) % imageheight) + y;
// Setzen des neuen Zeichenbereiches
g.setClip(x, y, width, height);
// Kacheln des Zeichenbereiches
while((akty - y) < height) {
while ((aktx - x) < width) {
g.drawImage(background, aktx, akty, this);
aktx += imagewidth;
}
akty += imageheight;
aktx = -((imagewidth - deltax) % imagewidth) + x;
}
}
}
Die Fläche, die das Applet auf der HTML-Seite belegt, wird
fliesenartig mit einem bestimmten Hintergrundbild ausgelegt.
Die Methode tiling() besitzt die Hauptfunktion.
tiling()
erwartet mehrere Parameter:
- g
Ist das Graphics-Objekt der Komponente, die mit dem Hintergrundbild
ausgelegt werden soll.
- background
Ist das Bild, mit dem die Komponente ausgelegt wird.
- x, y, width, height
Definieren das Rechteck innerhalb des Grafikkontexts der Komponente,
das ausgelegt werden soll.
- deltax, deltay
Bilden den Versatz in Pixel, um den die einzelnen Bilder verschoben werden.
deltax und deltay werden relativ zu x und y angegeben.
Werden nun dieser Methode das gewünschte Hintergrundbild, das Graphics-Objekt des
Applets und die Ausmaße des Applets übergeben,
wird das komplette Applet mit dem Hintergrund ausgelegt:
tiling(g, background, 0, 0,
getSize().width, getSize().height, 0, 0);
Diese Methode funktioniert allerdings nur, wenn das Muster keine
signifikanten Übergänge besitzt. Ist dies nicht gegeben,
muss man durch Angabe des Versatzes das Muster innerhalb des
Applets an das Muster auf der Seite anpassen.
Um
das Auslegen auch auf einen Teilbereich eines Graphics-Objekts
beschränken zu können, wird in der Methode tiling()
mit setClip() gearbeitet:
g.setClip(x, y, width, height);
Mit setClip()
wird ein Bereich innerhalb des Grafikkontexts
ausgewählt, in den gezeichnet werden darf. Zeichnet man über ihn
hinaus, dann wird die Zeichnung an den Rändern des angegebenen Bereichs
abgeschnitten.
Per Voreinstellung ist dieser Bereich
auf die gesamte Größe der Komponente gesetzt. Die Angabe der Koordinaten an
die Zeichenmethoden wie z. B. drawLine(), erfolgt
immer relativ zu der linken obere Ecke des Bereichs, der setClip() übergeben
wurde.
Abbildung 12.2: Ein »unsichtbares« Applet in einem Browser
 |
Das hier vorgestellte Beispiel kann mit der Texturfüllung der Java 2D-API
etwas einfacher implementiert werden.
Folgende Implementierung der Methode tiling() wurde mit
dem Java-2D-API erstellt:
public void tiling(Graphics g, Image back,
int x, int y, int width, int height,
int deltax, int deltay) {
// Breite und Höhe einer Kachel merken
int w = back.getWidth(this)+deltax;
int h = back.getHeight(this)+deltay;
BufferedImage bi;
// Kachel erzeugen
bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D big = bi.createGraphics();
big.drawImage(back, 0, 0, this);
big.dispose();
Rectangle r = new Rectangle(0, 0, w, h);
Graphics2D g2 = (Graphics2D)g;
// Füllung einstellen
TexturePaint tp = new TexturePaint(bi, r);
g2.setPaint(tp);
g.setClip(x, y, width, height);
// Texturfüllung anwenden
g2.fillRect(0, 0, width, height);
}
Zunächst muss eine Kachel erzeugt werden, die das Applet ausfüllen soll.
Hierzu benötigt man ein Exemplar der Klasse BufferedImage.
BufferedImage stellt ein Bild dar, das im Speicher gehalten wird.
Es kann als Grundlage für so genannte Offscreen-Images verwendet werden.
Ein BufferedImage wird mit einer vordefinierten Höhe und Breite, sowie
einer speziellen Speicherungsform der Bildpunkte initialisiert. In diesem
Beispiel wird die Speicherungsform TYPE_INT_ARGB gewählt. Bei dieser
Form werden Rot, Grün, Blau und der Alphawert
eines Pixels in einem int-Wert gespeichert.
In der Klasse BufferedImage sind noch weitere Konstanten für andere
Speicherungsformen definiert.
