Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 16 Grafikprogrammierung
|  | 16.1 Grundlegendes zum Zeichnen
|  |  | 16.1.1 Die paint()-Methode für das AWT-Frame
|  |  | 16.1.2 Zeichen von Inhalten mit JFrame
|  |  | 16.1.3 Auffordern zum Neuzeichnen mit repaint()
|  |  | 16.1.4 Grundbegriffe: Koordinaten, Punkte, Pixel
|  |  | 16.1.5 Die ereignisorientierte Programmierung ändert Fensterinhalte
|  |  | 16.1.6 Java 2D-API
|  | 16.2 Einfache Zeichenfunktionen
|  |  | 16.2.1 Linien
|  |  | 16.2.2 Rechtecke
|  |  | 16.2.3 Ovale und Kreisbögen
|  |  | 16.2.4 Polygone und Polylines
|  | 16.3 Zeichenketten schreiben und Fonts
|  |  | 16.3.1 Zeichenfolgen schreiben
|  |  | 16.3.2 Die Font-Klasse
|  |  | 16.3.3 Einen neuen Font aus einem gegebenen Font ableiten
|  |  | 16.3.4 Zeichensätze des Systems ermitteln
|  |  | 16.3.5 Neue TrueType-Fonts in Java nutzen
|  |  | 16.3.6 Font-Metadaten durch FontMetrics
|  | 16.4 Geometrische Objekte
|  |  | 16.4.1 Die Schnittstelle Shape
|  |  | 16.4.2 Kreisförmiges
|  |  | 16.4.3 Kurviges
|  |  | 16.4.4 Area und die konstruktive Flächengeometrie
|  |  | 16.4.5 Pfade
|  |  | 16.4.6 Punkt in Form, Schnitt von Linien, Abstand Punkt/Linie und Weiteres
|  | 16.5 Das Innere und Äußere einer Form
|  |  | 16.5.1 Farben und die Paint-Schnittstelle
|  |  | 16.5.2 Farben mit der Klasse Color
|  |  | 16.5.3 Die Farben des Systems über SystemColor
|  |  | 16.5.4 Composite und Xor
|  |  | 16.5.5 Dicke und Art der Linien von Formen bestimmen über Stroke
|  | 16.6 Bilder
|  |  | 16.6.1 Eine Übersicht über die Bilder-Bibliotheken
|  |  | 16.6.2 Bilder mit ImageIO lesen
|  |  | 16.6.3 Ein Bild zeichnen
|  |  | 16.6.4 Programm-Icon/Fenster-Icon setzen
|  |  | 16.6.5 Splash-Screen
|  |  | 16.6.6 Bilder im Speicher erzeugen
|  |  | 16.6.7 Pixel für Pixel auslesen und schreiben
|  |  | 16.6.8 Bilder skalieren
|  |  | 16.6.9 Schreiben mit ImageIO
|  |  | 16.6.10 Asynchrones Laden mit getImage() und dem MediaTracker
|  |  | 16.6.11 Selbst definierte Cursor
|  |  | 16.6.12 VolatileImage
|  | 16.7 Weitere Eigenschaften von Graphics
|  |  | 16.7.1 Eine Kopie von Graphics erstellen
|  |  | 16.7.2 Koordinatensystem verschieben
|  |  | 16.7.3 Beschnitt (Clipping)
|  | 16.8 Zeichenhinweise durch RenderingHints
|  | 16.9 Transformationen mit einem AffineTransform-Objekt
|  | 16.10 Drucken
|  |  | 16.10.1 Drucken der Inhalte
|  |  | 16.10.2 Bekannte Drucker
|  | 16.11 Grafikverarbeitung ohne grafische Oberfläche
|  |  | 16.11.1 Xvfb-Server
|  |  | 16.11.2 Pure Java AWT Toolkit (PJA)
|  | 16.12 Zum Weiterlesen
## 16.3 Zeichenketten schreiben und Fonts Java kann Zeichenketten in verschiedenen Zeichensätzen (engl. fonts) auf die Zeichenfläche bringen. Zum Zeichnen gibt es unterschiedliche Methoden, von denen in jeder Java-Version Varianten und Klassen hinzukamen. Nicht viel besser ist es mit den Font-Informationen; auch dafür gibt es verwirrend viele Möglichkeiten zur Repräsentation der Meta-Daten. ### 16.3.1 Zeichenfolgen schreiben Die Funktion drawString() bringt eine Unicode-Zeichenkette mit so genannten Glyphen, das sind konkrete grafische Darstellungen eines Zeichens, auf den Bildschirm – die Darstellung von Zeichen übernimmt in Java der Font-Renderer. Die Parameter von drawString() beschreiben die zu schreibende Zeichenkette sowie die x- und y-Koordinate. Die Koordinaten bestimmen die Position der Schriftlinie – auch Grundlinie genannt (engl. baseline) –, auf der die Buchstaben stehen.
    abstract class java.awt.Graphics
abstract void drawString( String s, int x, int y ) Schreibt einen String in der aktuellen Farbe und dem aktuellen Zeichensatz. abstract void drawString( AttributedCharacterIterator iterator, int x, int y ) Schreibt einen String, der durch den Attribut-Iterator gegeben ist. abstract void drawChars( char[] data, int offset, int length, int x, int y ) abstract void drawBytes( byte[] data, int offset, int length, int x, int y ) Schreibt die Zeichenkette und bezieht die Daten aus einem Char- bzw. Byte-Feld.
Hinweis Die Klasse TextLayout bietet weitergehende Möglichkeiten, etwa Farbhervorhebung, Cursor-Funktionalität oder über TextHitInfo Tests, welches Zeichen sich an welcher Koordinate befindet, was bei Mausklicks nützlich ist. Ein draw() vom TextLayout bringt den Textbaustein auf den Schirm. Die Dokumentation listet etwas Quellcode zur Verdeutlichung auf.
### 16.3.2 Die Font-Klasse Die Funktion drawString() verwendet immer den aktuellen Zeichensatz. Um diesen zu ändern, benutzen wir auf dem aktuellen Graphics-Objekt die Funktion setFont(). Der Übergabeparameter ist ein Font-Objekt, das wir von woanders erfragen oder vorher erzeugen müssen. Der Konstruktor von Font ist durch verschiedene Parameter definiert. Hier klicken, um das Bild zu vergrößern
    class java.awt.Font
    implements Serializable
Font( String name, int style, int size ) Erzeugt ein Font-Objekt mit einem gegebenen Namen, Stil und Größe. Für den Stil deklariert die Font-Klasse drei symbolische Konstanten: Font.PLAIN, Font. ITALIC und Font.BOLD, sodass keine Ganzzahlen als Argumente zu übertragen sind. Die Stil-Attribute können mit dem binären Oder oder dem arithmetischen Plus verbunden werden; ein fetter und kursiver Zeichensatz erreicht Font.BOLD | Font.ITALIC (beziehungsweise Font.BOLD + Font.ITALIC). Die Größe ist in Punkt angegeben, wobei ein Punkt 1/72 Zoll (in etwa 0,376 mm) entspricht. Der Name des Zeichensatzes ist entweder physikalisch (zum Beispiel »Verdana« oder »Geneva«) oder logisch mit Font-Konstanten DIALOG, DIALOG_INPUT, SANS_SERIF, SERIF und MONOSPACED, die später auf die physikalischen Font-Namen übertragen werden. [Die Webseite http://java.sun.com/javase/6/docs/technotes/guides/intl/fontconfig.html beschreibt diese Umsetzung. ]
Beispiel Ein Font-Objekt erzeugen:
    Font f = new Font( Font.SERIF, Font.PLAIN, 14 );
Häufig wird dieses Zeichensatz-Objekt sofort in setFont() genutzt, so wie:
    setFont( new Font( "Verdana", Font.BOLD, 20 ) );
Hinweis Die Dokumentation spricht zwar von »Punkt«, in Java sind aber Punkt und Pixel bisher identisch. Würde das Grafiksystem wirklich in Punkt arbeiten, müsste es die Bild- schirmauflösung und den Monitor mit berücksichtigen.
Ist im Programm der aktuell verwendete Zeichensatz nötig, können wir getFont() von der Graphics-Klasse verwenden:
    abstract class java.awt.Graphics
abstract Font getFont() Liefert den aktuellen Zeichensatz. abstract Font setFont( Font f ) Setzt den Zeichensatz für das Graphics-Objekt. ### 16.3.3 Einen neuen Font aus einem gegebenen Font ableiten Steht ein Font zur Verfügung. Soll ausgehend von diesem ein neues Font-Objekt mit einer kleinen Änderung etwa in der Größe oder im Attribut (fett, kursiv) hergestellt werden, so lassen sich die deriveFont()-Funktionen einsetzen.
Beispiel Ausgehend von einem existierenden Font-Objekt f soll ein neuer Font mit dem gleichen Zeichensatz und Stil abgeleitet werden, der jedoch 20 Punkt groß ist:
    Font font = f.deriveFont( 20f );
    class java.awt.Font
    implements Serializable
Font deriveFont( int style ) Wie der Originalzeichensatz, nur mit einem neuen Stil. Font deriveFont( float size ) Wie der Originalzeichensatz, nur mit einer neuen Größe. Der Parameter ist vom Typ float, damit Verwechslungen mit deriveFont(int) – das liefert einen neuen Font in normal, fett und/oder kursiv – ausgeschlossen sind. Font deriveFont( int style, float size ) Wie der Originalzeichensatz, nur mit einer neuen Größe und einem neuen Stil. Font deriveFont( AffineTransformation trans ) Erzeugt ein neues Font-Objekt, das über ein Transformationsobjekt modifiziert ist. Liefert ein neues Zeichensatzobjekt in der Größe von einem Punkt und keinem besonderen Stil. ### 16.3.4 Zeichensätze des Systems ermitteln Um herauszufinden, welche Zeichensätze auf einem System installiert sind, liefert getAvail-ableFontFamilyNames() auf einem GraphicsEnvironment ein Feld mit Font-Objekten. Ein Objekt vom Typ GraphicsEnvironment beschreibt die Zeichensätze des Systems und GraphicsDevice-Objekte. Ein GraphicsDevice ist eine Malfläche, also das, worauf das System zeichnen kann. Das kann der Bildschirm sein, aber auch ein Drucker oder eine Hintergrundgrafik. Die statische Fabrik-Funktion getLocalGraphicsEnvironment() liefert ein solches GraphicsEnvironment-Objekt.
Beispiel Im folgenden Codesegment gibt eine Schleife alle Zeichensatznamen aus:
    for ( String fonts : GraphicsEnvironment.getLocalGraphicsEnvironment().
                             getAvailableFontFamilyNames() )
      System.out.println( fonts );
Auf meinem System liefert die Schleife die folgenden Zeilen:
    Arial
    Arial Black
    Arial Narrow
    ...
    Wingdings
    Wingdings 2
    Wingdings 3
    abstract class java.awt.GraphicsEnvironment
static GraphicsEnvironment getLocalGraphicsEnvironment() Liefert das aktuelle GraphicsEnvironment-Objekt. abstract Font[] getAllFonts() Liefert ein Feld mit allen verfügbaren Font-Objekten in einer Größe von einem Punkt. abstract String[] getAvailableFontFamilyNames() Liefert ein Feld mit allen verfügbaren Zeichensatzfamilien. abstract String[] getAvailableFontFamilyNames( Locale l ) Liefert ein Feld mit verfügbaren Zeichensatzfamilien, die zu einer Sprache l gehören. ### 16.3.5 Neue TrueType-Fonts in Java nutzen Die auf allen Systemen vordefinierten Standardzeichensätze sind etwas dürftig, obwohl die Font-Klasse selbst jeden installierten Zeichensatz einlesen kann. Da ein Java-Programm aber nicht von der Existenz eines bestimmten Zeichensatzes ausgehen kann, ist es praktisch, einen Zeichensatz mit der Installation auszuliefern und dann diesen zu laden; das kann die Font-Klasse mit der statischen Funktion createFont() sein. Aus einem Eingabestrom liest die Methode den TrueType-Zeichensatz und erstellt das entsprechende Font-Objekt. Listing 16.5 com/tutego/insel/ui/graphics/TrueTypePanel.java, Ausschnitt
    Font f = Font.createFont( Font.TRUETYPE_FONT,
                              new FileInputStream("NASALIZA.TTF") );
Das erste Argument ist immer Font.TRUETYPE_FONT. Das zweite Argument bestimmt den Eingabestrom zur Binärdatei mit den Zeichensatzinformationen. Die Daten werden ausgelesen und zu einem Font-Objekt verarbeitet. Da die Daten intern über einen gepufferten Datenstrom in eine temporäre Datei geschrieben werden, ist eine eigene Pufferung über einen BufferedInputStream nur zusätzlicher Overhead. Waren die Beschreibungsinformationen in der Datei ungültig, so erzeugt die Font-Klasse eine FontFormatException("Unable to create font – bad font data"). Dateifehler fallen hier nicht darunter und werden extra über eine IOException angezeigt. Der Datenstrom wird anschließend nicht wieder geschlossen. An dieser Stelle verwundert es vielleicht, dass von der Arbeitsweise her die Methode createFont() der des Konstruktors ähnlich sein müsste, aber der Parameterliste die Attribute fehlen. Das liegt daran, dass die Methode automatisch einen Zeichensatz der Größe 1 im Stil Font.PLAIN erzeugt. Um einen größeren Zeichensatz zu erzeugen, müssen wir ein zweites Font-Objekt anlegen, was am einfachsten mit der Methode deriveFont() geschieht.
    class java.awt.Font
    implements Serializable
static Font createFont( int fontFormat, InputStream fontStream ) throws FontFormatException, IOException Liefert ein neues Zeichensatzobjekt in der Größe von einem Punkt und mit keinem besonderen Stil. ### 16.3.6 Font-Metadaten durch FontMetrics Jedes Font-Objekt beinhaltet Informationen zur Schriftsatzfamilie, zum Schriftsatznamen sowie zu Größe und Stil. Was es nicht bietet, ist Zugriff auf Metadaten, etwa auf Abmessungen des Zeichensatzes. Um diese Daten aufzuspüren, ist ein FontMetrics-Objekt nötig. Es verwaltet metrische Informationen, die mit einer Schriftart verbunden sind. Dazu gehören Ober- und Unterlänge, Schrifthöhe und Zeilenabstand. Da die Klasse FontMetrics keinen öffentlichen Konstruktor besitzt, müssen wir es von einer anderen Stelle aus erfragen. Es bieten sich unter anderem an: getFontMetrics() von Graphics getFontMetrics(Font) von Graphics getFontMetrics(Font) von Component getFontMetrics(Font) von Toolkit Ein FontMetrics-Objekt lässt sich merkwürdigerweise nicht direkt vom Font-Objekt erfragen. (Umgekehrt liefert aber getFont() aus FontMetrics das Font-Objekt, das diese Metriken beschreibt.) In der paint()-Methode kann also mittels
    FontMetrics fm = g.getFontMetrics();
auf die Metriken des aktuellen Zeichensatzes zugegriffen werden.
    abstract class java.awt.Graphics
FontMetrics getFontMetrics() Liefert die Font-Metriken zum aktuellen Zeichensatz. abstract FontMetrics getFontMetrics( Font f ) Liefert die Font-Metriken für den Zeichensatz f. Die Klasse FontMetrics bietet die folgenden Methoden an, wobei sich alle Angaben auf das jeweilige Zeichensatzobjekt beziehen. Beziehen sich die Rückgabeparameter auf die Zeichengröße, so erfolgt die Angabe immer in Pixel.
    abstract class java.awt.FontMetrics
    implements Serializable
int charWidth( int ch ), int charWidth( char ch ) Liefert die Breite zu einem Zeichen. int charsWidth( char[] data, int off, int len ) int bytesWidth( byte[] data, int off, int len ) Gibt die Breite aller Zeichen des Felds zurück. Beginnt bei off und liest len Zeichen. int stringWidth( String str ) Gibt die Breite der Zeichenkette zurück, wenn diese gezeichnet würde. Nutzt intern charsWidth(). int getAscent() Gibt den Abstand von der Grundlinie zur oberen Grenze (Oberlänge) zurück. Ist standardmäßig getSize() vom Font-Objekt. int getDescent() Gibt den Abstand von der Grundlinie zur unteren Grenze (Unterlänge) zurück. Standardmäßig 0. int getLeading() Gibt den Durchschuss (engl. leading) zurück. Der Durchschuss ist der Standard-Abstand zwischen zwei Zeilen. int getHeight() Gibt den Standard-Zeilenabstand (Abstand zwischen Grundlinie und Grundlinie) in Pixel zurück. Er berechnet sich aus Durchschuss + Oberlänge + Unterlänge. In Quellcode ausgedrückt: getAscent() + getDescent() + getLeading(). int getMaxAdvance() Liefert die Breite des breitesten Zeichens. –1, wenn unbekannt. int getMaxAscent() Liefert das Maximum aller Oberlängen in Pixel. Einige Zeichen können sich oberhalb der Oberlänge bewegen. Die Standard-Implementierung leitet einfach nur an getAscent() weiter. int getMaxDescent() Liefert das Maximum aller Unterlängen in Pixel. Leitet standardmäßig an getDescent() weiter. int[] getWidths() Liefert in einem Ganzzahlfeld die Breiten – ermittelt durch charWidth() – der ersten 256 Zeichen zurück. Font getFont() Liefert den aktuellen Zeichensatz
Hinweis Die Ergebnisse von FontMetrics sind bescheiden und mitunter ungenau. Bessere Ergebnisse, etwa über die Ausmaße eines zu zeichnenden Strings, und interessante Zusatzfunktionen bieten FontRenderContext, TextLayout und LineMetrics.
    Font font = ...;
    FontRenderContext frc = g.getFontRenderContext();
    TextLayout layout = new TextLayout( "Text", font, frc );
    Rectangle2D bounds = layout.getBounds();
LineMetrics bietet Angaben wie die nötige Dicke einer Linie beim Unterstreichen und Durchstreichen.
    Font font = ...;
    FontRenderContext frc =;
    LineMetrics lm = font.getLineMetrics( str, g.getFontRenderContext() );
Hier klicken, um das Bild zu vergrößern #### Einen String unterstreichen Wir wollen nun stringWidth() und die Metadaten nutzen, um einen unterstrichenen Text darzustellen. Dafür gibt es keine Standardfunktion. Also schreiben wir uns einfach eine Methode, die die Koordinaten sowie den String übergeben bekommt. Die Methode draw-UnderlinedString() schreibt mit drawString() die Zeichenkette. drawLine() zeichnet eine Linie unter der Grundlinie mit einer Verschiebung und Dicke, wie sie LineMetrics angibt, und mit der Länge, die das FontMetrics-Objekt für die Zeichenkette liefert. Listing 16.6 com/tutego/insel/ui/graphics/DrawUnderlinedString.java, drawUnderlinedString()
    public void drawUnderlinedString( Graphics g, int x, int y, String s )
    {
      g.drawString( s, x, y );

      FontMetrics fm = g.getFontMetrics();
      LineMetrics lm = fm.getLineMetrics( s, g );

      g.fillRect( x, y + (int) lm.getUnderlineOffset(),
                  fm.stringWidth(s), (int) lm.getUnderlineThickness() );
    }
Natürlich achtet so eine kleine Funktion nicht auf das Aussparen von Buchstaben, die unter der Grundlinie liegen, und so sind die Buchstaben wie »y« oder »q« unten gnadenlos durchgestrichen. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de