Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
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 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort

Download:
- ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom
Programmieren mit der Java Standard Edition Version 6
Buch: Java ist auch eine Insel (8. Auflage)

Java ist auch eine Insel (8. Aufl.)
8., aktual. Auflage, geb., mit DVD
1.475 S., 49,90 Euro
Galileo Computing
ISBN 978-3-8362-1371-4
Pfeil 17 Grafikprogrammierung
Pfeil 17.1 Grundlegendes zum Zeichnen
Pfeil 17.1.1 Die paint()-Methode für das AWT-Frame
Pfeil 17.1.2 Zeichnen von Inhalten mit JFrame
Pfeil 17.1.3 Auffordern zum Neuzeichnen mit repaint()
Pfeil 17.1.4 Grundbegriffe: Koordinaten, Punkte, Pixel
Pfeil 17.1.5 Die ereignisorientierte Programmierung ändert Fensterinhalte
Pfeil 17.1.6 Java 2D-API
Pfeil 17.2 Einfache Zeichenmethoden
Pfeil 17.2.1 Linien
Pfeil 17.2.2 Rechtecke
Pfeil 17.2.3 Ovale und Kreisbögen
Pfeil 17.2.4 Polygone und Polylines
Pfeil 17.3 Zeichenketten schreiben und Fonts
Pfeil 17.3.1 Zeichenfolgen schreiben
Pfeil 17.3.2 Die Font-Klasse
Pfeil 17.3.3 Einen neuen Font aus einem gegebenen Font ableiten
Pfeil 17.3.4 Zeichensätze des Systems ermitteln
Pfeil 17.3.5 Neue TrueType-Fonts in Java nutzen
Pfeil 17.3.6 Font-Metadaten durch FontMetrics
Pfeil 17.4 Geometrische Objekte
Pfeil 17.4.1 Die Schnittstelle Shape
Pfeil 17.4.2 Kreisförmiges
Pfeil 17.4.3 Kurviges
Pfeil 17.4.4 Area und die konstruktive Flächengeometrie
Pfeil 17.4.5 Pfade
Pfeil 17.4.6 Punkt in einer Form, Schnitt von Linien, Abstand Punkt/Linie
Pfeil 17.5 Das Innere und Äußere einer Form
Pfeil 17.5.1 Farben und die Paint-Schnittstelle
Pfeil 17.5.2 Farben mit der Klasse Color
Pfeil 17.5.3 Die Farben des Systems über SystemColor
Pfeil 17.5.4 Composite und Xor
Pfeil 17.5.5 Dicke und Art der Linien von Formen bestimmen über Stroke
Pfeil 17.6 Bilder
Pfeil 17.6.1 Eine Übersicht über die Bilder-Bibliotheken
Pfeil 17.6.2 Bilder mit ImageIO lesen
Pfeil 17.6.3 Ein Bild zeichnen
Pfeil 17.6.4 Programm-Icon/Fenster-Icon setzen
Pfeil 17.6.5 Splash-Screen
Pfeil 17.6.6 Bilder im Speicher erzeugen
Pfeil 17.6.7 Pixel für Pixel auslesen und schreiben
Pfeil 17.6.8 Bilder skalieren
Pfeil 17.6.9 Schreiben mit ImageIO
Pfeil 17.6.10 Asynchrones Laden mit getImage() und dem MediaTracker
Pfeil 17.7 Weitere Eigenschaften von Graphics
Pfeil 17.7.1 Eine Kopie von Graphics erstellen
Pfeil 17.7.2 Koordinatensystem verschieben
Pfeil 17.7.3 Beschnitt (Clipping)
Pfeil 17.7.4 Zeichenhinweise durch RenderingHints
Pfeil 17.7.5 Transformationen mit einem AffineTransform-Objekt
Pfeil 17.8 Drucken
Pfeil 17.8.1 Drucken der Inhalte
Pfeil 17.8.2 Bekannte Drucker
Pfeil 17.9 Zum Weiterlesen


Galileo Computing - Zum Seitenanfang

17.7 Weitere Eigenschaften von Graphics Zur nächsten ÜberschriftZur vorigen Überschrift


Galileo Computing - Zum Seitenanfang

17.7.1 Eine Kopie von Graphics erstellen Zur nächsten ÜberschriftZur vorigen Überschrift

Das Zeichensystem übergibt an die paintXXX()-Methoden ein Graphics-Objekt, das wir zum Zeichnen oft verändern, etwa um eine Farbe für nachfolgende Operationen zu setzen. Stehen eigene Zeichenmethoden jedoch nicht am Ende der Zeichenfolge, ist es wichtig, den Grafikkontext so zu restaurieren, wie er am Anfang war, um nachfolgende Zeichenoperationen nicht zu beeinflussen. Wichtig ist dies etwa bei Swing-Komponenten, wo paint() der Reihe nach die Methoden

  • protected void paintComponent( Graphics g )
  • protected void paintBorder( Graphics g )
  • protected void paintChildren( Graphics g )

aufruft. Nun lässt sich leicht ausmalen, was passiert, wenn unsere Methode paintComponent() ein verhunztes Graphics-Objekt hinterlässt.

Die erste Lösung ist, sich die alten Zustände zu merken und zurückzusetzen:

Color oldColor = g.getColor(); 
g.setColor( newColor ); 
... 
g.setColor( oldColor );        // Farbe zurücksetzen

Bei wenigen Eigenschaften funktioniert das gut, doch werden es mehr, ist es sinnvoller, eine Kopie aller Zustände des Grafikkontextes vorzunehmen. Dazu dient die Methode create(). Von großer Wichtigkeit ist hier, diesen temporären Kontext auf jeden Fall mit dispose() wieder freizugeben, um keinen Speicherplatz zu blockieren.

@Override protected void paintComponent( Graphics g ) 
Graphics gcopy = g.create();   // Kopie erfragen 
try { 
  gcopy.draw...                  // Alle Zeichenoperationen über gcopy 
} 
finally { 
  gcopy.dispose();             // Kopie freigeben 
}

Ist definitiv keine Ausnahme zu erwarten, kann der try-Block entfallen.


Beispiel Es gibt noch eine zweite Notwendigkeit, ein Graphics freizugeben, nämlich dann, wenn es mit getGraphics() von einer Komponente erfragt wurde. Die an Komponenten übergebenen Graphics-Objekte gibt das System frei, denn die Regel lautet immer: Wer Ressourcen anlegt, muss sie auch wieder freigeben.



Galileo Computing - Zum Seitenanfang

17.7.2 Koordinatensystem verschieben Zur nächsten ÜberschriftZur vorigen Überschrift

Standardmäßig liegt der Koordinatenursprung bei (0,0), also in der oberen linken Ecke. Zum Verschieben des Ursprungs an eine neue Position dient die Graphics-Methode translate(int x, int y). Alle nachfolgenden Zeichenoperationen werden dann relativ zu x, y sein, was auch den Vorteil hat, dass negative Koordinaten bei Zeichenmethoden möglich sind.

Da Graphics2D vor dem Zeichnen beliebige affine Transformationen anwenden kann, kommen unter Graphics2D noch einige Methoden hinzu:

  • rotate( double theta )
  • rotate( double theta, double x, double y )
  • scale( double sx, double sy )
  • setTransform( AffineTransform Tx )
  • shear( double shx, double shy )
  • transform( AffineTransform Tx )
  • translate( double tx, double ty )

Galileo Computing - Zum Seitenanfang

17.7.3 Beschnitt (Clipping) Zur nächsten ÜberschriftZur vorigen Überschrift

Alle primitiven Zeichenoperationen wirken sich auf den gesamten Bildschirm aus und sind nicht auf bestimmte Bereiche eingeschränkt. Wenn wir Letzteres erreichen wollen, setzen wir einen so genannten Clipping-Bereich, außerhalb dessen nicht mehr gezeichnet wird. Der Beschnittbereich lässt sich mit zwei Methoden des aktuellen Graphic-Objekts modifizieren beziehungsweise einschränken:


abstract class java.awt.Graphics

  • abstract void setClip( int x, int y, int width, int height )
    Setzt den neuen Beschnittbereich, sodass gezeichnete Zeilen außerhalb des Bereichs nicht sichtbar sind.
  • abstract void clipRect( int x, int y, int width, int height )
    Verkleinert den Beschnittbereich, indem der aktuelle Bereich (getClip()) mit dem übergebenen Rechteck geschnitten wird. Wurde vorher kein Beschnittbereich festgelegt – getClip() lieferte null –, ist clipRect() mit setClip() identisch.

Das folgende Programm setzt den ersten Clipping-Bereich mit setClip(100, 100, 100, 200). Das Füllen eines sehr großen Bereichs wird dann lokal nur im Beschnittbereich ausgeführt. Anschließend verkleinert clipRect(0, 200, 150, 50) den Bereich, doch obwohl x bei 0 beginnt, hat schon setClip() ihn bei 100 gesetzt, sodass die Verbindung der beiden Bereiche (100, 100, 100, 200) geschnitten (0, 200, 150, 50) = (100, 200, 50, 50) ergibt.

Listing 17.23 com/tutego/insel/ui/graphics/ClipDemo.java

package com.tutego.insel.ui.graphics; 
 
import java.awt.*; 
import javax.swing.*; 
 
public class ClipDemo extends JPanel 
{ 
  private static final long serialVersionUID = 3020598670163407618L; 
 
  @Override protected void paintComponent( Graphics g ) 
  { 
    super.paintComponent( g ); 
 
    Graphics gcopy = g.create(); 
 
    // Set first clipping region. clipRect() is also possible. 
    g.setClip( 100, 100, 100, 200 );            // setClip()!! 
 
    g.setColor( Color.ORANGE ); 
    g.fillRect( 0, 0, getWidth(), getHeight() ); 
    g.setColor( Color.BLACK ); 
    g.drawOval( 150, 100, 100, 100 ); 
 
    // Second clipping region. 
    g.clipRect( 0, 200, 150, 50 );              // clipRect()! 
 
    g.setColor( Color.BLUE ); 
    g.fillRect( 0, 0, 5000, 5000 ); 
 
    // With gcopy we are working with original settings. 
 
    gcopy.setColor( Color.GREEN ); 
    gcopy.fillRect( 50, 50, 20, 50 ); 
 
    gcopy.dispose(); 
  } 
 
  public static void main( String[] args ) 
  { 
    JFrame f = new JFrame(); 
    f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 
    f.setSize( 400, 400 ); 
    f.add( new ClipDemo() ); 
    f.setVisible( true ); 
  } 
}

Abbildung 17.14 Clipping-Bereiche

Alternative Formen

Durch setClip() können alternativ zu den rechteckigen Formen auch beliebige Shape-Objekte die Clipping-Form vorgeben. Die folgende paintComponent()-Methode benutzt als Beschnitt ein Dreieck:

Listing 17.24 com/tutego/insel/ui/graphics/ClipTri.java, Ausschnitt

@Override protected void paintComponent( Graphics g ) 
{ 
  super.paintComponent( g ); 
 
  Rectangle r = g.getClipBounds(); 
 
  System.out.println( r ); 
 
  Polygon p = new Polygon( 
      new int[] { 200, 100, 300 }, 
      new int[] { 100, 300, 300}, 
      3 ); 
 
  g.setClip( p ); 
 
  g.setColor( Color.ORANGE ); 
  g.fillRect( 0, 0, 500, 500 ); 
}

Verdeckte Bereiche und schnelles Bildschirmerneuern

Clipping-Bereiche sind nicht nur zum Einschränken der Primitiv-Operationen sinnvoll. Bei Bereichsüberdeckungen in Fenstern liefern sie wertvolle Informationen über den neu zu zeichnenden Bereich. Bei einer guten Applikation wird nur der Teil wirklich neu gezeichnet, der auch überdeckt wurde. So lässt sich Rechenzeit sparen.


Beispiel Informationen über Clipping-Bereiche:

@Override public void paint( Graphics g ) 
{ 
  Rectangle r = g.getClipBounds(); 
  System.out.println( r ); 
}

Das Programm erzeugt etwa:

java.awt.Rectangle[x=4,y=23,  width=392,height=373] 
java.awt.Rectangle[x=104,y=87,width=292,height=309] 
java.awt.Rectangle[x=104,y=87,width=286,height=211] 
java.awt.Rectangle[x=104,y=87,width=243,height=196] 
java.awt.Rectangle[x=104,y=87,width=221,height=219] 
java.awt.Rectangle[x=101,y=89,width=221,height=219] 
...

Aus den Ausgaben lassen sich verschiedene Fensteroperationen ableiten: Ein fremdes Fenster wurde über das Java-Fenster geschoben, und dann wurde das fremde Fenster verkleinert.


Die Rectangle-Informationen geben Aufschluss über die Größe der neu zu zeichnenden Bereiche. Haben wir schon daran gedacht, die Information in einem Image-Objekt abzulegen, lässt sich wunderbar drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer) nutzen. Hier müssen wir die Werte aus dem Rectangle auslesen und in drawImage() übertragen. getClipBounds() liefert ein Rectangle-Objekt, dessen Werte für drawImage() nötig sind. Da jedoch auch beliebige Formen möglich sind, liefert getClip() ein Shape-Objekt. getClipRect() ist die veraltete Methode zu getClipBounds(), sonst aber identisch. Die Methode getClipBounds(Rectangle) – eine der wenigen nicht abstrakten Methoden in Graphics – legt die Informationen im übergebenen Rectangle-Objekt ab, das auch zurückgeliefert wird. Sie ruft nur getClipBounds() auf und überträgt die vier Attribute in das Rechteck.

Im Übrigen: In der paint()-Methode ist es oft klug, mit clipRect() den Bereich einzuschränken, statt ihn mit setClip() zu setzen, denn er könnte schon relativ klein sein; setClip() könnte den Beschnittbereich größer machen und unnötige Zeichenoperationen erzwingen.


Galileo Computing - Zum Seitenanfang

17.7.4 Zeichenhinweise durch RenderingHints Zur nächsten ÜberschriftZur vorigen Überschrift

Bisher haben wir stillschweigend eine Zeile eingefügt, die das Antialiasing (eine Art Weichzeichnen) einschaltet. Dadurch erscheinen die Bildpunkte weicher nebeneinander, sind aber etwas dicker, weil in der Nachbarschaft Pixel eingefügt werden.


Beispiel Es soll alles weich gezeichnet werden.

g2.setRenderingHint( RenderingHints.KEY_ANTIALIASING, 
                     RenderingHints.VALUE_ANTIALIAS_ON );

In der Programmzeile nutzen wir die setRenderingHint()-Methode der Klasse Graphics2D. Die Methode nimmt immer einen Schlüssel (daher beginnen die Konstanten mit KEY_XXX) und einen Wert (VALUE_XXX).


abstract class java.awt.Graphics2D 
extends Graphics

  • abstract void setRenderingHint( RenderingHints.Key hintKey, Object hintValue )
    Setzt eine Eigenschaft des Rendering-Algorithmus.

Im Beispiel setzen wir den Hinweis auf das ANTIALIASING. Da durch das Weichzeichnen mehr Rechenaufwand nötig ist, empfiehlt es sich, für eine schnelle Grafikausgabe auf das Antia-liasing zu verzichten. Um dies zu erreichen, übergeben wir den Schlüssel ANTIALIAS_OFF als zweites Argument. Weitere Hinweise sind etwa:

  • KEY_ALPHA_INTERPOLATION, KEY_COLOR_RENDERING, KEY_DITHERING, KEY_FRACTIONAL METRICS, KEY_INTERPOLATION, KEY_RENDERING, KEY_TEXT_ANTIALIASING

Mit dem RENDERING-Schlüssel können wir zum Beispiel die Geschwindigkeit bestimmen, die direkt mit der Qualität der Ausgabe korreliert.


Galileo Computing - Zum Seitenanfang

17.7.5 Transformationen mit einem AffineTransform-Objekt topZur vorigen Überschrift

Eine affine Transformation eines Objekts ist entweder eine Translation (Verschiebung), Rotation, Skalierung oder Scherung [Ein Objekt wird geschert, wenn es entlang einer Koordinatenachse verzogen wird. Im Zweidimensionalen gibt es zwei Scherungsarten: entlang der x-Achse und entlang der y-Achse.] . Bei diesen Transformationen bleiben parallele Linien nach der Transformation auch parallel. Um diese Operationen durchzuführen, existiert eine Klasse AffineTransform. Transformationen kommen an unterschiedlichen Stellen in der Grafik-Bibliothek zum Einsatz, unter anderem hier:

  • Einem Graphics2D-Kontext weist setTransform() eine Transformation zu. Jede anschließend mit drawXXX() oder fillXXX() dargestellte Form wird vor dem Zeichnen über die Transformationsangaben angepasst.
  • Zum Zeichnen von Grafiken kann bei drawImage() ein AffineTransform-Objekt übergeben werden; die Transformation gilt dann ausschließlich für das Bild.
  • Bei der Methode deriveFont() bestimmt ein übergebenes AffineTransform-Objekt die Eigenschaften eines neuen Fonts.

Translation, Rotation, Skalierung oder Scherung

Die zweidimensionalen Objekte können durch die Operationen Translation, Rotation, Skalierung oder Scherung verändert werden. Diese Operationen sind durch eine 3×3-Matrix gekennzeichnet. Die Klasse AffineTransform bietet nun Methoden an, damit wir diese Matrix selbst erzeugen können, sowie Hilfsmethoden, die uns die Arbeit abnehmen.

AffineTransform trans = new AffineTransform(); 
trans.rotate( 0.1 ); 
g2.setTransform( trans ); 
g2.fill( new Rectangle2D.Float( 150, 100, 60, 60 ) );

Konstruktoren

Die Klasse AffineTransform besitzt sechs Konstruktoren: zunächst einen Standard-Konstruktor und einen Konstruktor mit einem schon vorhandenen AffineTransform-Objekt, dann jeweils einen Konstruktor für eine Matrix mit dem Datentyp float und mit dem Datentyp double sowie zwei Konstruktoren mit allen sechs Werten der Matrix für float und double. Eine eigene Matrix ist nur dann sinnvoll, wenn wir mehrere Operationen hintereinander ausführen lassen wollen. So nutzen wir in der Regel den Standard-Konstruktor wie oben und ändern die Form durch die Methoden rotate(), scale(), shear() oder translate(). Wird nach dem Erzeugen des AffineTransform-Objekts direkt eine der Methoden aufgerufen, geht dies auch einfacher über die statischen Erzeugungsmethoden getRotateInstance(), getScaledInstance(), getShearInstance() und getTranslateInstance(). Sie füllen dann die Matrix mit den passenden Einträgen. Ein Transformationsobjekt kann mit setToIdentity() wieder initialisiert werden, sodass AffineTransform wieder verwendbar ist.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






<< zurück
  Zum Katalog
Zum Katalog: Java ist auch eine Insel





Java ist auch eine Insel
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Tipp
Zum Katalog: Coding for Fun





 Coding for Fun


 Buchempfehlungen
Zum Katalog: Objektorientierte Programmierung





 Objektorientierte
 Programmierung


Zum Katalog: Einstieg in Eclipse 3.4






 Einstieg in
 Eclipse 3.4


Zum Katalog: Java 6 lernen mit Eclipse






 Java 6 lernen
 mit Eclipse


Zum Katalog: NetBeans Platform 6






 NetBeans
 Platform 6


Zum Katalog: Java und XML






 Java und XML


Zum Katalog: Visual C# 2008






 Visual C# 2008


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
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