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.6 Bilder Bilder sind neben dem Text das wichtigste visuelle Gestaltungsmittel. In Java können Grafiken an verschiedenen Stellen eingebunden werden. So zum Beispiel als Grafiken in Zeichengebieten (Canvas) oder als Icons in Schaltflächen, die angeklickt werden und ihre Form ändern. Über Java können GIF-, PNG- und JPEG-Bilder geladen werden. [Benannt nach den Erfindern Lempel, Ziv und Welch. ]
Hinweis Das GIF-Format (Graphics Interchange Format) ist ein komprimierendes Verfahren, das 1987 von CompuServe-Betreibern zum Austausch von Bildern entwickelt wurde. GIF-Bilder können bis zu 1600 × 1600 Punkte umfassen. Die Komprimierung nach einem veränderten LZW6 -Packverfahren hat keinen Einfluss auf die Bildqualität (sie ist verlustfrei). Jedes GIF-Bild kann aus maximal 256 Farben bestehen – bei einer Palette aus 16,7 Millionen Farben.
Entsprechend dem Standard von 1989 können mehrere GIF-Bilder in einer Datei gespeichert werden. JPEG-Bilder sind dagegen in der Regel verlustbehaftet, und das Komprimierverfahren speichert die Bilder mit einer 24-Bit-Farbpalette. Der Komprimierungsfaktor kann prozentual eingestellt werden.
Jede Grafik wird als Exemplar der Klasse Image erzeugt, wobei einige Lademethoden auch Exemplare der Unterklasse BufferedImage liefern. Hier klicken, um das Bild zu vergrößern ### 16.6.1 Eine Übersicht über die Bilder-Bibliotheken Die Java-API bietet – historisch gewachsen – mehrere Möglichkeiten zum Laden und für einige Formate auch das Speichern von Bildern an. Zudem gibt es Zusatzbibliotheken für Spezialformate und besondere Anforderungen wie die Verwaltung sehr großer Grafiken: Die Methode getImage() der Klassen Toolkit (bei Applikationen) und Applet (bei Applets) liefert ein Image-Objekt. Der Media-Tracker lädt Bilder und informiert über den Ladevorgang. Die Klasse ImageIcon lädt für Swing Bilder, die sich direkt auf der grafischen Oberfläche auf Komponenten wie Schaltflächen platzieren lassen. Sie nutzt im Hintergrund den Media-Tracker. Sun hat in Java 1.4 das Paket javax.imageio eingeführt, um das Lesen und Schreiben von Grafiken zu vereinheitlichen. Die Klasse ImageIO bietet eine einfache statische Funktion read(). Das Paket com.sun.image.codec.jpeg definiert seit Java 1.2 Funktionen zum Lesen und Schreiben von JPGs. Der Paketname zeigt an, dass es nicht ganz offiziell ist und damit nicht jeder Java-Implementierung bekannt sein muss. Über die externe Java-Bibliothek JAI (Java Advanced Imaging API) kommen Formate wie TIFF und WBMP dazu. Informationen gibt die Seite http://java.sun.com/products/java-media/jai/iio.html. JIMI (Java Image Management Interface) ist eine hundertprozentige Java-Klassenbibliothek, die hauptsächlich Lade- und Speicherroutinen für Bilder zur Verfügung stellt. Die Klasse JimiUtils stellt beispielsweise eine getThumbnail()-Methode bereit, die zu einer Datei ein Vorschaubild als Image-Objekt berechnet. Ebenso stellt JIMI Möglichkeiten zur Anzeige bereit, um etwa sehr große Grafiken speichersparend zu verwalten. Diese Technik nennt sich Smart-Scrolling und kann von der JimiCanvas-Komponente übernommen werden. So wird nur jener Bildteil im Speicher gehalten, der gerade sichtbar ist. Für die Speicherverwaltung stellt JIMI ein eigenes Speicherverwaltungssystem, das VMM (Virtual Memory Management), bereit, ebenso wie eine eigene Image-Klasse, die schnelleren Zugriff auf die Pixelwerte erlaubt. Zusätzlich bietet JIMI eine Reihe von Filtern für Rotation und Helligkeitsanpassung, die auf JIMI- und AWT-Bildern arbeiten. Auch Farbreduktion ist ein Teil von JIMI. JIMI-Bilder lassen sich im Gegensatz zu den bekannten AWT-Bildern serialisieren. Für exotische Formate – etwa das Windows Icon-Format – hilft nur eine Suche im Web. Im Fall der ICO-Dateien hilft die freie Bibliothek AC.lib ICO unter http://www.acproductions.de/commercial/aclibico/. ### 16.6.2 Bilder mit ImageIO lesen ImageIO ist sehr einfach zu nutzen, denn mit einer kleinen statischen Funktion ImageIO.read() ist die Grafik geladen. Unterstützte Dateiformate sind sicher GIF, JPEG und PNG; weitere Formate können von Plattform zu Plattform unterschiedlich sein. (Eine präzisere Liste der angemeldeten Leser liefert ImageIO.getReaderFormatNames() und Image IO.getReaderMIMETypes().)
    final class javax.imageio.ImageIO
static BufferedImage read( File input ) throws IOException static BufferedImage read( InputStream input ) throws IOException static BufferedImage read( URL input ) throws IOException static BufferedImage read( ImageInputStream input ) throws IOException Lädt ein Bild und liefert ein BufferedImage oder null, wenn kein Decoder das Bild lesen konnte.
Beispiel Lesen eines Bildes aus einer Datei, Datenquelle und URL:
    BufferedImage img1 = ImageIO.read( new File( "bild.gif" ) );
    BufferedImage img2 = ImageIO.read( socket.getInputStream() );
    BufferedImage img3 = ImageIO.read( new URL("http://www.tutego.com/images/email.gif") );
Die Bilder können auf unterschiedliche Art weiterverarbeitet werden. Sie lassen sich über drawImage() anzeigen und auch als Grafiken in Swing weiterverarbeiten. Zwar fordert Swing sie als ImageIcon an, doch die Klasse ist so gütig, einen Konstruktor anzubieten, der ein Image-Objekt akzeptiert. Hier klicken, um das Bild zu vergrößern #### Bilder in Applets und alten Java-Versionen Ab der Version Java 1.4 steht die Klasse ImageIO zur Verfügung. Für Programme vor Java 1.4 muss die getImage()-Methode vom Toolkit oder im Fall von Applets die Methode get-Image() von Applet verwendet werden.
    class java.applet.Applet
    extends Panel
Image getImage( URL url ) Lädt ein durch die URL angegebes Bild. Müssen wir in einem Applet die Grafik relativ zu einem Bezugspunkt angeben, der jedoch fehlt, so hilft uns die Funktion getCodeBase() weiter, die uns die relative Adresse des Applets übergibt. (Mit getDocumentBase() bekommen wir die URL des HTML-Dokuments, unter der das Applet eingebunden ist.) Genau genommen lädt getImage() das Bild nicht sofort, anders als read() von ImageIO. Ein Image-Objekt wird gültig erzeugt und das Objekt mit der Grafik in Verbindung gebracht, aber es wird erst dann aus der Datei beziehungsweise dem Netz geladen, wenn der erste Zeichenaufruf stattfindet. Somit schützt uns die Bibliothek vor unvorhersehbaren Ladevorgängen für Bilder, die später oder gar nicht genutzt werden. ### 16.6.3 Ein Bild zeichnen Eine Grafik zeichnet die Funktion drawImage() der Graphics-Klasse. Die Methode ist mit unterschiedlichen Varianten überladen, um die Grafik auch in anderen Größen zu zeichnen – was sie skaliert – oder auch nur Teile zu zeichnen. Der einfachste Aufruf, der die Grafik in ihrer Originalgröße ab der Position oben links mit der Position (0,0) setzt, ist:
    g.drawImage( image, 0, 0, this );
Die drawImage()-Funktionen sind mehrheitlich in der Oberklasse Graphics, doch zwei zusätzliche Funktionen definiert Graphics2D. Auf die Modifizierer abstract und die Rückgabe boolean verzichtet die erste Aufzählung der Kürze halber.
    abstract class java.awt.Graphics
drawImage( Image img, int x, int y, ImageObserver observer ) drawImage( Image img, int x, int y, Color bgcolor, ImageObserver observer ) drawImage( Image img, int x, int y, int width, int height, ImageObserver observer ) drawImage( Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer ) drawImage( Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer ) drawImage( Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer )
    abstract class java.awt.Graphics2D
    extends Graphics
boolean drawImage( Image img, AffineTransform xform, ImageObserver obs ) void drawImage( BufferedImage img, BufferedImageOp op, int x, int y )
Hinweis In den Methoden fällt ein besonderer Beobachter, der ImageObserver, auf. Der Grund für seinen Einsatz ist die Tatsache, dass Java bei den über das Toolkit angesprochenen Grafiken das Laden so weit hinauszögert, bis eine Darstellung die Pixel-Daten wirklich erforderlich macht. Damit aber nach (oder während) des Ladens die Darstellung erfolgen kann, informiert der Lader die Interessenten über den Ladezustand. Nutzen wir drawImage() in einer Unterklasse von Component – sie implementiert ImageObserver –, ist das Argument für den ImageObserver oft this, andernfalls null, wenn eine Ladeüberwachung nicht nötig ist.
#### Bildanschauprogramm Das folgende Programmlisting zeigt eine einfache Applikation mit einer Menüleiste, die über einen Dateiauswahldialog eine Grafik lädt und anzeigt. Wir beginnen mit der ersten Klasse, die eine Swing-Komponente darstellt, die das Bild zeichnet. Hier klicken, um das Bild zu vergrößern Abbildung 16.9 Ein einfacher Bildbetrachter mit Dateiauswahldialog Listing 16.16 com/tutego/insel/ui/image/ImageViewer.java, ImageComponent
    class ImageComponent extends JComponent
    {
      private BufferedImage image;

      public void setImage( File file )
      {
        try
        {
          if ( (image = ImageIO.read( file )) != null )
          {
            setPreferredSize( new Dimension(image.getWidth(), image.getHeight()) );
            repaint();
          }
        }
        catch ( IOException e ) { e.printStackTrace(); }
      }

      @Override
      protected void paintComponent( Graphics g )
      {
        if ( image != null )
          g.drawImage( image, 0, 0, this );
      }
    }
Da ein Dateiauswahl-Dialog gewünscht ist, der auf Grund einer Menüauswahl die Datei lädt, folgt eine Implementierung der Schnittstelle ActionListener. Listing 16.17 com/tutego/insel/ui/image/ImageViewer.java, FileOpenAction
    class FileOpenAction implements ActionListener
    {
      private final ImageComponent viewComponent;

      public FileOpenAction( ImageComponent viewComponent )
      {
        this.viewComponent = viewComponent;
      }

      public void actionPerformed( ActionEvent e )
      {
        JFileChooser d = new JFileChooser();
        d.setFileFilter( new FileFilter()
        {
          @Override
          public boolean accept( File f )
          {
            return f.isDirectory() || f.getName().toLowerCase().endsWith( ".jpg" )
                || f.getName().toLowerCase().endsWith( ".gif" );
          }

          @Override
          public String getDescription()
          {
            return "*.jpg;*.gif";
          }
        } );

        d.showOpenDialog( null );
        File file = d.getSelectedFile();
        if ( file != null )
          viewComponent.setImage( file );
      }
    }
Der Dialog zur Dateiauswahl ist so über einen FileFilter eingestellt, dass er nur Verzeichnisse und Dateien anzeigt, die auf ».jpg« oder ».gif« enden. Wählte der Benutzer eine gültige Grafik aus, wird setImage() unserer ImageComponent angewiesen, das Bild zu laden und anzuzeigen. Den letzten Teil bildet das Hauptprogramm. Es erzeugt die Bild-Komponte, das Menü und setzt den Listener und zeigt das Fenster an. Listing 16.18 com/tutego/insel/ui/image/ImageViewer.java, ImageViewer
    public class ImageViewer
    {
      public static void main( String[] args )
      {
        JFrame f = new JFrame( "Bildbetrachter" );

        ImageComponent viewComponent = new ImageComponent();
        f.add( new JScrollPane(viewComponent) );

        JMenuBar mbar = new JMenuBar();
        JMenu menu = new JMenu( "Datei" );
        JMenuItem item = new JMenuItem( "Öffnen" );
        item.setAccelerator(
            KeyStroke.getKeyStroke( KeyEvent.VK_O, InputEvent.CTRL_MASK ) );
        item.addActionListener( new FileOpenAction(viewComponent) );
        menu.add( item );
        mbar.add( menu );
        f.setJMenuBar( mbar );

        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        f.setSize( 600, 400 );
        f.setVisible(  true );
      }
    }
### 16.6.4 Programm-Icon/Fenster-Icon setzen Zumindest unter Windows ist jedem Fenster ein kleines Bildchen zugeordnet, das ganz links in der Titelzeile untergebracht ist. Das Programm-Icon lässt sich in Java durch die setIcon-Image()-Funktion setzen. Der Methode wird ein Image-Objekt übergeben, das die Grafik der Größe 16 × 16 Pixel beinhaltet; andere Größen werden skaliert, was nicht immer so toll aussieht. Listing 16.19 com/tutego/insel/ui/image/FramesIconImage, main()
    JFrame f = new JFrame();
    try
    {
      Image img = ImageIO.read( FramesIconImage.class.getResource( "discovery.gif" ) ;
      f.setIconImage( img );
    }
    catch ( IOException e ) { e.printStackTrace(); }
    f.setVisible( true );
Mit getResource() bezieht read() die Datei aus dem Klassenpfad und kann auch in einem Java-Archiv eingebettet sein.
    class java.awt.Frame
    extends Window
    implements MenuContainer
void setIconImage( Image image ) Ordnet dem Fenster eine kleine Grafik zu. Nicht alle grafischen Oberflächen erlauben diese Zuordnung. ### 16.6.5 Splash-Screen Ein Splash-Screen ist ein Willkommens-Bildschirm mit Grafik, der noch vor dem eigentlichen Programmstart über die JVM erscheint und dem Benutzer Informationen über Version und Autor übermittelt. Java kann in zwei Varianten einen Startschirm mit einer beliebigen Grafik – nennen wir sie beispielsweise splash.png – anzeigen: über den Schalter -splash beim Start der JVM. Etwa java-splash:splash.png Main; mit einem Eintrag Splashscreen-Image: splash.png in der Manifest-Datei. Öffnet unser Java-Programm das erste Fenster, schließt sich der Splash-Screen automatisch. Dennoch gibt es Möglichkeiten, auf den Splash-Screen aus dem Java-Programm zuzugreifen:
    SplashScreen splash = SplashScreen.getSplashScreen();
    Graphics2D g2 = splash.createGraphics();
    // Zeichenoperationen
    splash.update();
Die Methode close() schließt manuell den Splash-Screen und wartet nicht auf das erste eigene Fenster, was den Splash-Screen automatisch schließt. ### 16.6.6 Bilder im Speicher erzeugen Nicht immer kommen die Bilder vom Datensystem oder aus dem Internet. Mit der Java-Bibliothek lassen sich einfach auch eigene (Buffered)Image-Objekte anlegen. Dazu bieten sich – wieder historisch bedingt – verschiedene Varianten an: Jede AWT-Komponente, wie Frame oder Panel, bietet die Methode createImage(). Die Anweisung Image image = panel.createImage(800, 600); erzeugt ein Image-Objekt mit 800 Pixel in der Breite und 600 in der Höhe, das mit getGraphics() Zugriff auf den Grafikkontext bietet. Wenn die AWT-Komponente noch nicht angezeigt wurde, liefert createImage() die Rückgabe null, sodass hier leicht eine NullPointerException entstehen kann. Auch unterstützen die Bilder keine Transparenz. Aus den Einschränkungen heraus führt Java 1.2 die Klasse BufferedImage ein, die eine Erweiterung der Image-Klasse ist. Beim Erzeugen ist immer ein Bildtyp anzugeben, der über die physikalische Speicherung bestimmt. createCompatibleImage() über GraphicsConfiguration erzeugt ein BufferedImage und benötigt keinen Bildtyp. #### BufferedImage erzeugen lassen Ein Bild über createCompatibleImage() zu erzeugen, hat den großen Vorteil, dass das Daten- und Farbmodell optimal gewählt ist. Der einzige Nachteil dieser Methode ist die große Menge an benötigten Hilfsobjekten – was zusätzliche Schreibarbeit bedeutet. Listing 16.20 com/tutego/insel/ui/image/CreateCompatibleImageDemo.java, main()
    GraphicsConfiguration gfxConf = GraphicsEnvironment.getLocalGraphicsEnvironment().
        getDefaultScreenDevice().getDefaultConfiguration();
    int width = 600, height = 400;
    BufferedImage image = gfxConf.createCompatibleImage( width, height );
Von createCompatibleImage() gibt es auch eine Variante, die die Angabe einer Transparenz ermöglicht.
    abstract class java.awt.GraphicsConfiguration
abstract BufferedImage createCompatibleImage( int width, int height ) Erzeugt ein BufferedImage. BufferedImage createCompatibleImage( int width, int height, int transparency ) Erzeugt ein BufferedImage mit optionaler Transparenz. Das Argument für transparency kann sein: Transparency.OPAQUE (keine Transparenz, der Alpha-Wert ist 1,0), Transparency.BITMASK (Bilddaten sind komplett sichtbar, also opak mit Alpha-Wert 1, oder transparent, also Alpha-Wert 0.0), Transparency.TRANSLUCENT (Grafik erlaubt das Durchscheinen mit Alpha-Werten von 0.0 bis 1.0). #### Das Bild bemalen Image-Objekte (BufferedImage ist eine Unterklasse) geben über getGraphics() das Graphics-Objekt zurück, mit dem sich das Bild bemalen lässt. Im Fall eines speziellen BufferedImage-Objekts ist es jedoch üblich, die Methode createGraphics() einzusetzen, da sie ein Graphics2D-Objekt – eine Unterklasse von Graphics – liefert, mit dem weitere Zeichenoperationen möglich sind. (Die Betrachtung von Graphics2D verschieben wir auf ein anderes Unterkapitel.) Außerdem ruft getGraphics() sowieso createGraphics() auf ...
    Graphics2D g = img.createGraphics();
    g.setColor( Color.WHITE );
    g.fillRect( 0, 0, b – 1, h – 1 );
Alternativ kann zum Löschen des Hintergrundes auch g.setBackground(Color.WHITE); g.clearRect(Argumente); verwendet werden. #### BufferedImage von Hand erzeugen Der Konstruktor der Klasse BufferedImage wird mit den Ausmaßen parametrisiert und zusätzlich mit einem Speichermodell für die Bildinformationen. Das ermöglicht die Verwendung von beliebigen Farb- und Speichermodellen.
    int h = 400,
        b = 600;
    BufferedImage img = new BufferedImage( b, h, BufferedImage.TYPE_INT_RGB );
Das notwendige dritte Argument kennzeichnet den Speichertyp; hier sind die Farben durch je 8 Bit Rot, Grün und Blau abgebildet. Um weitere zwei der über 10 Bildtypen zu nennen: TYPE_USHORT_GRAY (Graubilder) oder TYPE_INT_ARGB (RGB mit jeweils 8 Bit sowie Alpha).
    class java.awt.image.BufferedImage
    extends Image
    implements RenderedImage, Transparency, WritableRenderedImage
BufferedImage( int width, int height, int imageType ) Liefert ein neues Hintergrundbild mit den gegebenen Ausmaßen. ### 16.6.7 Pixel für Pixel auslesen und schreiben Die Klasse BufferedImage – aber nicht die Basisklasse Image – ermöglicht mit getRGB() das Auslesen einzelner Farbwerte und mit setRGB() das Setzen.
Beispiel Lies die Farbwerte eines BufferedImage-Objekts image, und zerlege die Rückgabe in die Farbwerte Rot, Grün, Blau und den Alpha-Wert:
    int argb  = image.getRGB( x, y );
    int alpha = (argb >> 24) & 0xff;
    int red   = (argb >> 16) & 0xff;
    int green = (argb >> 8)  & 0xff;
    int blue  = (argb)       & 0xff;
Die Methode getRGB() liefert als Rückgabe einen Wert im Standard-RGB-Modell Buffered-Image.TYPE_INT_ARGB – unabhängig von der tatsächlichen physikalischen Kodierung – und dem Standard-RGB-Farbraum. Die Farbwerte sind daher an ihren wohldefinierten Plätzen. Eine Hilfsfunktion zum Extrahieren bietet die Color-Klasse, doch muss für diese Zwecke zuerst ein Objekt aufgebaut werden, was nicht so optimal ist. Das folgende Listing zeigt ein Beispiel.
Eine zweite überladene Methode getRGB() kopiert aus einem Bild-Ausschnitt alle Pixel in ein Feld.
Beispiel Kopiere alle Farbwerte eines BufferedImage in ein Feld:
    int w = image.getWidth(), h = image.getHeight();
    int[] argbArray = new int[ w * h ];
    image.getRGB( 0 /* startX */, 0 /* startY */,
                  w,  h, argbArray,
                  0 /* offset */, w /* scansize */ );
Der Offset bestimmt die Verschiebung im Feld und scansize die Zeilenbreite. Damit liefert argbArray[offset + (y-startY)*scansize + (x-startX)] das Pixel im Feld.
Wünschen wir lediglich ein Teilbild als BufferedImage, führt uns getSubimage(int x, int y, int w, int h) zum Ziel. Zum Überschreiben der Pixel bietet die Klasse BufferedImage symmetrische setRGB()-Methoden.
Beispiel Gib dem Pixel an der Stelle x, y die Farbe von Color.LIGHT_GRAY.
    int argb = Color.LIGHT_GRAY.getRGB();
    image.setRGB( x, y, argb );
#### Ein Beispiel zum Lesen und Schreiben von Pixeln Das folgende Programm lädt über ImageIO ein Bild und gibt die Farbinformationen – also die Anteile Rot, Grün, Blau – beim Bewegen der Maus über das Bild auf der Konsole aus. Die Ereignisbehandlung übernimmt ein MouseMotionListener. Nach der Ausgabe bitten wir die Color-Klasse um einen dunkleren Farbton, und setRGB() überschreibt den vorherigen Farbwert für das Pixel. Listing 16.21 com/tutego/insel/ui/image/ImageGrabber.java, Ausschnitt
    @Override public void mouseMoved( MouseEvent e )
    {
      int pixel = image.getRGB( e.getX(), e.getY() );

      int red   = (pixel >> 16) & 0xFF,
          green = (pixel >> 8) & 0xFF,
          blue  = (pixel) & 0xFF;

        System.out.println( "R=" + red + " G=" + green + " B=" + blue );

        image.setRGB( e.getX(), e.getY(), new Color(pixel).darker().getRGB() );
        repaint();
      }
    } );
    class java.awt.image.BufferedImage
    extends Image
    implements WritableRenderedImage, Transparency
int getRGB( int x, int y ) Liefert den Farbwert vom Punkt x, y im Format TYPE_INT_ARGB. int[] getRGB( int startX, int startY, int w, int h, int[] rgbArray, int offset, int scansize ) Liefert die Farbinformationen eines Bildausschnitts. void setRGB( int x, int y, int rgb ) Setzt den Farbwert an der Stelle x, y auf rgb. void setRGB( int startX, int startY, int w, int h, int[] rgbArray, int offset, int scansize ) Setzt die Farbwerte mehrerer Pixel. ### 16.6.8 Bilder skalieren Die Methode getScaledInstance() der Klasse Image gibt ein neues Image-Objekt mit größeren oder kleineren Ausmaßen zurück. Das neue Bild wird wieder nur dann berechnet, wenn es auch benötigt wird – das Verhalten ist also ebenso asynchron wie bei der gesamten Bildverwaltung über die Image-Klasse. Beim Vergrößern oder Verkleinern kommt es zu Pixelfehlern, und das Vergrößern der Pixel beeinflusst das Endergebnis und die Geschwindigkeit. Stellen wir uns vor, ein Bild der Größe 100 × 100 Pixel soll um das Doppelte vergrößert werden. Das Resultat ist ein Bild 200 × 200 Pixel, doch muss aus einem Bildpunkt nun die Information für drei weitere Punkte abgeleitet werden. Eine Lösung bestünde darin, die Farbwerte der Punkte einfach zu duplizieren, dann bleibt die Schärfe, aber das Bild wirkt wie aus groben Blöcken zusammengesetzt. Eine andere Möglichkeit wäre, die Farbinformationen für die neuen Punkte aus den Informationen der Nachbarpunkte zu errechnen. Das Bild wirkt glatter, aber auch unschärfer bei hoher Skalierung. Und ebenso wie beim Vergrößern der Bilder sollten auch beim Verkleinern die Bildinformationen nicht einfach wegfallen, sondern, wenn möglich, zu neuen Farbwerten zusammengefasst werden. So erwarten wir von einem Algorithmus, dass dieser bei einer Schrumpfung von drei Farbwerten zu einem Farbwert die drei Informationen zu einem neuen Wert zusammenlegt. Damit diese Anforderungen erfüllt werden können, verlangt getScaledInstance() nicht nur die neue Breite und Höhe, sondern auch eine Konstante für die Art der Skalierung. Der Parameter bestimmt den Algorithmus – mögliche Konstanten sind SCALE_DEFAULT, SCALE_FAST, SCALE_SMOOTH, SCALE_REPLICATE und SCALE_AREA_AVERAGING.
Tabelle 16.3 Argumente für getScaledImage()
Skalierungsparameter | Bedeutung
SCALE_DEFAULT | Verwendet einen Standard-Skalierungsalgorithmus.
SCALE_FAST | Verwendet einen Skalierungsalgorithmus, der mehr Wert auf Geschwindigkeit als auf die Glätte des Bilds legt.
SCALE_SMOOTH | Verwendet einen Algorithmus mit guter Bildqualität und legt weniger Wert auf Geschwindigkeit.
SCALE_REPLICATE | Benutzt für den Skalierungsalgorithmus den ReplicateScaleFilter.
SCALE_AREA_AVERAGING | Verwendet den AreaAveragingScaleFilter.
Mit Hilfe dieser Konstanten lässt sich die Funktion aufrufen:
    abstract class java.awt.Image
Image getScaledInstance( int width, int height, int hints ) Liefert ein skaliertes Bild mit den neuen Ausmaßen width und height. Das neue Bild kann asynchron gefördert werden. hints gibt den Skalierungsalgorithmus als Konstante an. Ist die Höhe oder Breite negativ, so berechnet sich der Wert aus dem anderen, um das Seitenverhältnis beizubehalten.
Beispiel Eine Grafik soll geladen und zwei skalierte neue Image-Exemplare sollen abgeleitet werden. Die erste Skalierung soll das Original um einen Prozentwert verändern, und die zweite Skalierung soll – unabhängig von der korrekten Wiedergabe der Seitenverhältnisse – das Bild auf die Größe des Bildschirms bringen. Wir wollen es mit Image.SCALE_SMOOTH skaliert haben.
    Image image = ImageIO.read( "ottosHaus.jpg" );
    int   percent = 175;
    Image scaled1 = image.getScaledInstance(
      (image.getWidth() * percent) / 100,
      (image.getHeight() * percent) / 100,
      Image.SCALE_SMOOTH );
    Image scaled2 = image.getScaledInstance(
      Toolkit.getDefaultToolkit().getScreenSize().width,
      Toolkit.getDefaultToolkit().getScreenSize().height,
      Image.SCALE_SMOOTH );
#### Hinter den Kulissen Was auf den ersten Blick wie die Wahl zwischen unglaublich vielen Varianten aussieht, entpuppt sich als typische Informatiker-Lösung: entweder schnell und schmutzig oder schön und gemächlich. Aber so ist nun mal das Leben. Der Quelltext macht dies deutlich:
    public Image getScaledInstance(int width, int height, int hints)
    {
      ImageFilter filter;
      if ((hints & (SCALE_SMOOTH | SCALE_AREA_AVERAGING)) != 0)
        filter = new AreaAveragingScaleFilter(width, height);
      else
        filter = new ReplicateScaleFilter(width, height);
      ImageProducer prod;
      prod = new FilteredImageSource(getSource(), filter);
      return Toolkit.getDefaultToolkit().createImage(prod);
    }
Bei der Wahl zwischen sanftem Bild und schnellem Algorithmus greift getScaledInstance() auf die beiden Filterklassen AreaAveragingScaleFilter und ReplicateScaleFilter zurück. Sie berechnen jeweils das neue Bild über einen Bildproduzenten. ReplicateScaleFilter ist der einfachere von beiden. Bei der Vergrößerung werden die Pixel einer Zeile oder Spalte einfach verdoppelt. Wird verkleinert, so werden einfach Reihen oder Spalten weggelassen. Mit einem AreaAveragingScaleFilter bekommen wir die besseren Resultate, da Pixel nicht einfach kopiert werden, sondern weil wir eingefügte Pixel aus einer Mittelwertberechnung erhalten. Der Algorithmus heißt im Englischen auch nearest neighbor algorithm. ### 16.6.9 Schreiben mit ImageIO So wie die statische Funktion read() eine Grafik liest, schreibt write() sie zum Beispiel im PNG- oder JPG-Format. Voraussetzung ist eine Grafik, die als RenderedImage vorliegt. Die Schnittstelle wird zum Beispiel von BufferedImage implementiert, der wichtigsten Klasse für Bildinformationen. Gilt es, die Grafik abzuspeichern, wird die Funktion write() mit einem Verweis auf das RenderedImage sowie dem Datenformat und einem File-Objekt aufgerufen.
Beispiel Speichere als PNG-Datei ein Bild mit den Ausmaßen 100 × 100 und einem gefüllten Kreis. Listing 16.22 com/tutego/insel/ui/image/SaveImage.java, main()
    GraphicsConfiguration gfxConf = GraphicsEnvironment
        .getLocalGraphicsEnvironment().getDefaultScreenDevice()
        .getDefaultConfiguration();
    BufferedImage image = gfxConf.createCompatibleImage( 100, 100 );
    image.createGraphics().fillOval( 0, 0, 100, 100 );
    ImageIO.write( image, "png", new File( "c:/kreis.png" ) );
#### Kann ImageIO ein Format behandeln? ImageIO erlaubt standardmäßig das Speichern in JPG und PNG und GIF [Für ältere Java-Versionen bietet sich die Klasse GIFEncoder von Adam Doppelt an (http://www.gurge.com/amd/old/java/GIFEncoder/index.html) oder GifEncoder von Jef Poskanzer (http://www.acme.com/java/software/Acme.JPM.Encoders.GifEncoder.html). ] seit Java 6. Eine Liste der unterstützten Formate liefert ImageIO.getWriterFormatNames() beziehungsweise Image IO.getWriterMIMETypes().
    String[] types = ImageIO.getWriterMIMETypes();
    System.out.println( Arrays.toString(types) );
Die Ausgabe ist unter Java 6:
    image/png, image/jpeg, image/x-png, image/vnd.wap.wbmp, image/bmp, image/gif
Ob ImageIO ein Bild mit einem bestimmten Grafikformat lesen kann, bestimmt im Grunde getImageReadersByFormatName() – die Funktion liefert eine Liste von ImageReader-Objekten, die das Format übernehmen würden. Da die Liste über einen Iterator gegeben ist, lässt sich die Frage, ob ImageIO ein bestimmtes Format lesen kann, über das Ergebnis von get-ImageReadersByFormatName().hasNext() beantworten. Soll für eine Endung die Möglichkeit des Lesens erfragt werden, liefert canReadExtension() die Antwort – wieder über einen Iterator:
    public static boolean canReadExtension( String ext )
    {
      return ImageIO.getImageReadersBySuffix(ext).iter.hasNext();
    }
getImageReadersByMIMEType() liefert einen Iterator der MIME-Typen für Grafik-Leser. Die Anfragemöglichkeit gibt es natürlich nicht nur für die Leser, sondern äquivalent auch für die Schreiber. Hier erfüllen getImageWritersByFormatName(), getImageWritersBySuffix() und getImageWritersByMIMEType() ihren Zweck. Die Anfragetypen richten sich bisher nach den Dateiendungen oder MIME-Typen. Diese Aussagen erfordern aber Unterstützung vom Dateisystem oder vom Server. Was ist, wenn eine Grafik über das Netzwerk übertragen wird, die Typinformationen aber fehlen? Dann helfen Funktionen wie getImageReadersBySuffix() nicht, sondern eine inhaltliche Analyse muss her. Hilfreich ist die Funktion createImageInputStream(), die drei Datengeber analysieren kann: File-Objekte, lesbare RandomAccessFile-Objekte und InputStream-Objekte. Weil die Entwickler nun aber nicht drei unterschiedliche Funktionen mit unterschiedlichen Parametern für createImageInputStream() vorsehen wollten, nahmen sie die Oberklasse – nämlich Object.
    ImageInputStream iis = ImageIO.createImageInputStream( o );
Die Rückgabe ist ein ImageInputStream, der, obwohl er InputStream im Namen trägt, kein Eingabestrom im klassischen Sinne ist. ImageInputStream erlaubt einen Datenzugriff mit wahlfreier Positionierung, und createImageInputStream() ist die Fabrik-Funktion, die den ImageInputStream für eine Datenquelle liefert. Für Benutzer ist ImageInputStream aber immer noch nicht gedacht; Benutzer arbeiten mit ImageReader-Objekten. Ein passendes ImageReader-Objekt für die Bytes liefert getImageReaders():
    Iterator = ImageIO.getImageReaders( iis );
Der Iterator liefert alle ImageReader, die das Datenformat für den Binärstrom verarbeiten können. Uns reicht der erste:
    if ( iter.hasNext() )
      ImageReader reader = (ImageReader) iter.next();
    else
      // Kein Reader, der das Format versteht.
#### Komprimieren mit ImageIO Die statischen Funktionen ImageIO.write() und ImageIO.read() sind nur Hilfsfunktionen, die im Hintergrund einen passenden ImageWriter und ImageReader suchen und ihm die Arbeit überlassen. Während der Kontakt zum tatsächlichen ImageReader eher selten ist, gibt es einen guten Grund, sich mit dem schreibenden ImageWriter näher zu beschäftigen – ihm können über ein ImageWriteParam-Objekt zusätzliche Parameter übertragen werden, etwa der Kompressionsgrad, der sich zwischen 0 und 1 bewegt. JPEG-Bilder sind im Gegensatz zu GIF-Bildern mit Verlust komprimiert, doch lassen sich diese Verluste klein halten. Über eine diskrete Kosinustransformation werden 8 × 8 große Pixelblöcke vereinfacht. Die Komprimierung nutzt die Unfähigkeit des Auges aus, Farbunterschiede so stark wahrzunehmen wie Helligkeitsunterschiede. So können Punkte mit einer ähnlichen Helligkeit, doch einer anderen Farbe zu einem Wert werden. Bei einer hohen Kompression treten so genannte Artefakte (engl. degradation) auf, die unschön wirken. Bei einer sehr hohen Kompression ist die Bildgröße sehr klein (und hässlich). Der Qualitätsfaktor ist vom Typ float und bewegt sich zwischen 0,0 und 1,0. Der Wert 1 bedeutet im Prinzip keine Kompression und somit höchste Qualität. Ein Wert um 0,75 ist ein hoher Wert für Qualitätsbilder, der Wert 0,5 liefert Bilder mittlerer Qualität, und 0,25 sorgt für stärkere Artefakte und hohe Kompression. Ein Programm, das ein Bild im JPG-Format in eine Datei schreibt, muss zunächst einen Image Writer erfragen und anschließend den ImageOutputStream aufbauen, um die Daten schreiben zu können. Nach dem Aufbau der Parameter über ein gefülltes ImageWriteParam-Objekt lässt sich das Bild speichern. Zwar verfügt ImageWriter über eine Funktion write(RenderedImage), um zum Beispiel ein BufferedImage zu schreiben, doch im Fall der Parameter muss das Bild als IIOImage vorliegen. IIOImage versammelt die Bildinformationen (RenderedImage oder Raster), zusammen mit Vorschaubild und Metadaten. #### Bilder in verschiedenen Kompressionsstufen speichern Wir wollen nun ein Programm entwickeln, das einen Screenshot nimmt und ihn in den Qualitätsstufen 1,0 bis 0,0 in 0,25-Schritten komprimiert und das Ergebnis auf dem Bildschirm ausgibt. Listing 16.23 com/tutego/insel/ui/image/ImageWriterDemo.java
    package com.tutego.insel.ui.image;

    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.util.Locale;
    import javax.imageio.*;
    import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
    import javax.imageio.stream.ImageOutputStream;

    class ImageWriterDemo
    {
      public static void main( String[] args ) throws Exception
      {
        BufferedImage img = new Robot().createScreenCapture(
              new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()) );

        int size = 0;

        for ( float quality = 1f; quality >= 0; quality -= 0.25 )
        {
          ByteArrayOutputStream out = new ByteArrayOutputStream( 0xfff );

          writeImage( img, out, quality );

          System.out.print( "Quality: " + quality +
                            " Size: " + out.size() + "k " +
                            " Ratio: " );

          size = (size == 0 ) ? size = out.size() : size;
          System.out.printf( "%.2f%n", (double) out.size() / size );
        }
      }

      private static void writeImage( BufferedImage img,
                                      ByteArrayOutputStream out,
                                      float quality ) throws IOException
      {
        ImageWriter writer = ImageIO.getImageWritersByFormatName( "jpg" ).next();
        ImageOutputStream ios = ImageIO.createImageOutputStream( out );
        writer.setOutput( ios );
        ImageWriteParam iwparam = new JPEGImageWriteParam( Locale.getDefault() );
        iwparam.setCompressionMode( ImageWriteParam.MODE_EXPLICIT ) ;
        iwparam.setCompressionQuality( quality );
        writer.write( null, new IIOImage(img, null, null), iwparam );
        ios.flush();
        writer.dispose();
        ios.close();
      }
    }
Die Ausgabe des Programms für ein Bild ist in etwa die folgende:
    Quality: 1.0 Size: 468311k  Ratio: 1,00
    Quality: 0.75 Size: 160457k  Ratio: 0,34
    Quality: 0.5 Size: 120041k  Ratio: 0,26
    Quality: 0.25 Size: 84461k  Ratio: 0,18
    Quality: 0.0 Size: 33548k  Ratio: 0,07
Da der Bildschirminhalt immer etwas anders aussieht, werden natürlich auch die Dateigrößen immer anders aussehen. ### 16.6.10 Asynchrones Laden mit getImage() und dem MediaTracker Das Laden von Bildern mittels getImage() der Klasse Toolkit oder Applet wird dann vom System angeregt, wenn das Bild zum ersten Mal benötigt wird. Diese Technik ist zwar recht nett und entzerrt den Netzwerktransfer, eignet sich aber nicht für bestimmte grafische Einsätze. Nehmen wir zum Beispiel eine Animation: wir können nicht erwarten, die Animation erst dann im vollen Ablauf zu sehen, wenn wir nacheinander alle Bilder im Aufbauprozess gesehen haben. Daher ist zu wünschen, dass zunächst alle Bilder geladen werden können, bevor sie angezeigt werden. Die Klasse MediaTracker ist eine Hilfsklasse, mit der wir den Ladeprozess von Media-Objekten – bisher sind es nur Bilder – beobachten können. Um den Überwachungsprozess zu starten, werden die Media-Objekte dem MediaTracker zur Beobachtung übergeben. Neben diesem besitzt die Klasse gegenüber der herkömmlichen Methode noch weitere Vorteile: Bilder lassen sich in Gruppen organisieren. Bilder können synchron oder asynchron geladen werden. Die Bildergruppen können unabhängig geladen werden. #### Bilder dem Cache entnehmen Eine Webcam erzeugt kontinuierlich neue Bilder. Sollen diese in einem Applet präsentiert werden, so ergibt sich das Problem, dass ein erneuter Aufruf von getImage() lediglich das alte Bild liefert. Dies liegt an der Verwaltung der Image-Objekte, da sie in einem Cache gehalten werden. Für sie gibt es keinen GC, der die Entscheidung fällt: »Das Bild ist alt«. Hier hilft die Methode flush() der Image-Klasse weiter. Sie löscht das Bild aus der internen Liste. Eine erneute Aufforderung zum Laden bringt also das gewünschte Ergebnis.
    abstract class java.awt.Image
abstract void flush() Gibt die für das Image belegten Ressourcen frei. Hier klicken, um das Bild zu vergrößern
Hinweis Image-Objekte werden nicht automatisch freigegeben. flush() entsorgt diese Bilder, macht den Speicher frei und den Rechner wieder schneller.
### 16.6.11 Selbst definierte Cursor Bei einem Cursor sind wir nicht allein auf die vordefinierten Muster angewiesen. Leicht lässt sich aus einer Grafik ein eigener Cursor definieren. Dazu bietet das Toolkit die Methode createCustomCursor() an. Als Argument geben wir ein Image-Objekt, einen Hotspot und einen Namen an. Der Hotspot definiert eine Art Nullpunkt, der die Spitze angibt. Zeigt etwa der Standardcursor mit einem Pfeil nicht wie üblich nach oben, sondern nach unten, so gibt der untere Punkt den Nullpunkt an. Der Name ist nur nötig, wenn Java-Accessibility genutzt wird, also eine Möglichkeit gegeben ist, den Cursor zum Beispiel ohne Maus anzusprechen.
Beispiel Weise einer java.awt.Component den Cursor mit der Grafik cursor.gif und dem Hotspot auf (10,10) zu.
    Cursor c = getToolkit().createCustomCursor(
      new ImageIcon( "cursor.gif" ).getImage(),
      new Point(10,10), "Cursor" );
    component.setCursor( c );
Hinweis Animierte Cursor bietet die Java-Umgebung nicht an. Wir könnten selbstständig in einem Thread immer wieder mit setCursor() unterschiedliche Cursor setzen, um etwa eine drehende Sanduhr oder eine rotierende Festplatte zu bekommen.
Da grafische Oberflächen in der Regel keine Cursor beliebiger Auflösung und Farbanzahl zulassen, lässt sich das Toolkit auch über diese Größen erfragen. Die Methode getBestCursorSize() liefert die mögliche Größe des Cursors zurück. Es ist sinnvoll, diese Methode vorher aufzurufen, um ein passendes Bild auszuwählen. Ähnlich wie bei den Icons in der Titelleiste werden die Grafiken sonst skaliert, was nicht unbedingt schön aussehen muss. Gleiches gilt für die Farben. Nicht alle Systeme erlauben beliebig viele Farben für den Cursor. Die maximale Farbanzahl liefert die Funktion getMaximumCursorColors(). Notfalls wird der Cursor auf die Farbanzahl heruntergerechnet.
Tipp Unterstützt die Plattform Cursor beliebiger Größe, so lässt sich dadurch einfach eine Bubble-Help realisieren, die nicht rechteckig ist. An Stelle des Cursors wird eine Grafik mit dem Cursor zusammen mit einer Hilfe angezeigt. Das Betriebssystem verwaltet den Cursor, und wir müssen den Hintergrund nicht sichern und mit der Hilfe verknüpfen.
    abstract class java.awt.Toolkit
Cursor createCustomCursor( Image cursor, Point hotSpot, String name ) throws IndexOutOfBoundsException Erzeugt ein neues Cursor-Objekt. Liegt der Hotspot außerhalb der Grenzen der Grafik, wird eine IndexOutOfBoundsException ausgelöst. Dimension getBestCursorSize( int preferredWidth, int preferredHeight ) Liefert die unterstützte Cursor-Größe, die den gewünschten Ausmaßen am nächsten liegt. Oft werden die Argumente ignoriert, wenn die Umgebung keine beliebige Cursor-Größe zulässt. Erlaubt das System überhaupt keine selbst definierten Cursor, erhalten wir ein Objekt der Dimension (0,0). int getMaximumCursorColors() Liefert das Maximum an Farben, das das Toolkit für Cursor unterstützt. Der Rückgabewert ist null, wenn selbst definierte Cursor nicht gestattet sind.
    public abstract class java.awt.Component
    implements ImageObserver, MenuContainer, Serializable
void setCursor( Cursor cursor ) Weise einen neuen Cursor zu. ### 16.6.12 VolatileImage Die unter 1.4 neu eingeführte abstrakte Klasse VolatileImage mit ihren Unterklassen bietet eine effiziente Möglichkeit, Bilder direkt im Speicher der Grafikkarte abzulegen, sofern dies vom Betriebssystem unterstützt wird. Als Konsequenz gehen die Informationen natürlich verloren, wenn beispielsweise ein Fenster den Inhalt überdeckt. Doch das Einsatzfeld dieser direkten Manipulation liegt im Bereich schneller Bildschirmdarstellungen, wie sie zum Beispiel bei Spielen oder Video-Übertragungen nötig sind. Die VolatileImage-Objekte erkennen defekte Darstellungen und leiten sie an die Software weiter, die dann eine Bildschirmaktualisierung vornehmen kann. Damit VolatileImage-Objekte erstellt werden können, gibt es die Methode createVolatile Image(w, h) in den Klassen Component und ComponentPeer. Da ein VolatileImage sich genauso wie ein Image-Objekt verhält, ändert sich am Zeichnen mit drawImage() nichts. Mehr über die Einsatzgebiete und eine Beispiel-Implementierung finden Sie unter der Web-adresse http://java.sun.com/j2se/1.4/pdf/VolatileImage.pdf. ### 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