14.4 Grundlegendes zum Zeichnen

Nachdem wir ein Fenster öffnen können, wollen wir etwas in den Fensterinhalt schreiben. In den nächsten Abschnitten beschäftigen wir uns intensiver mit den Zeichenmöglichkeiten.

14.4.1 Die paint()-Methode

Als einleitendes Beispiel soll uns genügen, einen Text zu platzieren. Dafür überschreiben wir die Funktion paint() der Klasse Frame und setzen dort alles rein, was gezeichnet werden soll, etwa Linien, Texte oder gefüllte Polygone. Der gewünschte Inhalt wird immer dann gezeichnet, wenn das Fenster neu aufgebaut wird oder wir von außen repaint()aufrufen, denn ganau in dem Fall wird das Grafiksystem paint() aufrufen und das Zeichnen anstoßen.

Listing 14.4 Biene.java

import java.awt.*;
import java.awt.event.*;
public class Biene extends Frame
{
  public Biene() 
  {
    setSize( 500, 100 );
    addWindowListener( new WindowAdapter() {
      public void windowClosing ( WindowEvent e) {
        System.exit(0); }
    });
  }
  public void paint( Graphics g )
  {
    g.drawString( "\"Maja, wo bist du?\" (Mittermeier)", 100, 60 );
  }
  public static void main( String args[] )
  {
    new Biene().show();
  }
}

Hier klicken, um das Bild zu Vergrößern

Abbildung 14.2 Ein Fenster mit gezeichnetem Inhalt

Ein spezieller Wert wird in der paint()-Methode übergeben - der Grafikkontext, ein Objekt vom Typ Graphics. Graphic, besitzt verschiedene Methoden zum Zeichnen, etwa von Linien, Kreisen, Ovalen, Rechtecken, Zeichenfolgen oder Bildern. Das grafische System übergibt unserem Programm über paint() ein gültiges Graphics-Objekt, und wir können auf diese Weise auf der grafischen Oberfläche zeichnen. Dies funktioniert auch dann, wenn die Zeichenfläche nicht direkt sichtbar ist, wie bei Hintergrundgrafiken.

Bei jeder Zeichenoperation muss der Grafikkontext angegeben werden, denn dieses Objekt führt Buch über mehrere Dinge:

Die Komponente, auf der zu zeichnen ist (hier erst einmal das rohe Fenster)

Koordinaten des Bildbereichs und des Clipping-Bereichs. Die Zeichenoperationen außerhalb des Clipping-Bereichs werden nicht angezeigt. Daher wird ein Clipping-Bereich auch Beschnitt-Bereich1 genannt.

Der aktuelle Clip-Bereich und Font, die aktuelle Farbe

Die Pixeloperation (XOR2 oder Paint)

Die Funktion, mit der die Farbe verknüpft wird

Wir können nur in der paint()-Methode auf das Graphics-Objekt zugreifen. Diese wiederum wird immer dann aufgerufen, wenn die Komponente neu gezeichnet werden muss. Dies nutzen wir dafür, um einen Text zu schreiben.

Leicht ist zu entnehmen, dass drawString(String text, int x, int y) einen Text in den Zeichenbereich des Grafikkontexts schreibt. Im Folgenden werden wir noch weitere Funktionen kennen lernen.

14.4.2 Auffordern zum Neuzeichnen mit repaint()

Die Methode repaint() kann von außen aufgerufen werden, um ein Neuzeichnen zu erzwingen.

public void run() {
  while ( true )
    component.repaint( time );
}

14.4.3 Fensterinhalte ändern und die ereignisorientierte Programmierung

Der Einstieg in die Welt der Grafikprogrammierung mag etwas seltsam erscheinen, da in der prozeduralen, nicht ereignisgesteuerten Welt (wie der C-64) die Programmierung anders verlief. Es gab ein paar Funktionen, und mit denen ließ sich direkt sichtbar auf dem Bildschirm operieren. Ein Beispiel³ aus der C-128-Zeit:

10 COLOR 0,1                            :REM SELECT BACKGROUND COLOR
20 COLOR 1,3                            :REM SELECT FOREGROUND COLOR
30 COLOR 4,1                            :REM SELECT BORDER COLOR
40 GRAPHIC 1,1                          :REM SELECT BIT MAP MODE
60 CIRCLE 1,160,100,40,40               :REM DRAW A CIRCLE
70 COLOR 1,6                            :REM CHANGE FOREGROUND COLOR
80 BOX 1,20,60,100,140,0,1              :REM DRAW A BLOCK
90 COLOR 1,9                            :REM CHANGE FOREGROUND COLOR
100 BOX 1,220,62,300,140,0,0            :REM DRAW A BOX
110 COLOR 1,9                           :REM CHANGE FOREGROUND COLOR
120 DRAW 1,20,180 TO 300,180            :REM DRAW A LINE
130 DRAW 1,250,0 TO 30,0 TO 40,40 TO 250,0:REM DRAW A TRIANGLE
140 COLOR 1,15                          :REM CHANGE FOREGROUND COLOR
150 DRAW 1,160,160                      :REM DRAW A POINT
160 PAINT 1,150,97                      :REM PAINT IN CIRCLE
170 COLOR 1,5                           :REM CHANGE FOREGROUND COLOR
180 PAINT 1,50,25                       :REM PAINT IN TRIANGLE
190 COLOR 1,7                           :REM CHANGE FOREGROUND COLOR
200 PAINT 1,225,125                     :REM PAINT IN EMPTY BOX
210 COLOR 1,11                          :REM CHANGE FOREGROUND COLOR
220 CHAR 1,11,24,"GRAPHIC EXAMPLE"      :REM DISPLAY TEXT
230 FOR I=1 TO 5000:NEXT:GRAPHIC 0,1:COLOR 1,2

Diese Herangehensweise funktioniert in Java (und auch vielen modernen Systemen) nicht mehr. Sie hat mit Objektorientierung auch nicht viel zu tun!

In Java führt ein Ereignis zum Aufruf der paint()-Funktion. Dieses Ereignis (repaint-Ereignis) kann ausgelöst werden, wenn der Bildschirm zum ersten Mal gezeichnet wird, aber auch, wenn Teile des Bildschirms verdeckt werden. Falls das repaint-Ereignis kommt, springt das Java-System in die paint()-Methode, in der der Bildschirm aufgebaut werden kann. Nur dort finden die Zeichenoperationen statt. Wenn wir nun selbst etwas zeichnen wollen, dann kann das nur in der paint()-Funktion geschehen, beziehungsweise in Methoden, die von paint() aufgerufen werden. Aber wenn wir selbst etwas zeichnen wollen, wie lässt sich paint() dann parametrisieren?

Um mit diesem Problem umzugehen, müssen wir der paint()-Funktion Information mitgeben. Diese kann paint() nur aus den Objektattributen beziehen. Daher implementieren wir eine Unterklasse einer Komponente, die eine paint()-Funktion besitzt. Anschließend können wir Objektzustände ändern, so dass paint() neue Werte bekommt und somit gewünschte Inhalte zeichnen kann.

Ein Beispiel soll dies deutlich machen. Wir bilden eine Unterklasse von Window und setzen dann Objektzustände. Damit wir selbst das Neuzeichnen anregen können, nutzen wir die Methode repaint(). Sie erzeugt ein Neuzeichnen-Event, welches von der Ereignisverarbeitung abgearbeitet wird und zum Neuzeichnen des Bildschirms führt.

Listing 14.5 DrawingWindow.java

import java.awt.*;
import javax.swing.JOptionPane;
class DrawingWindow extends Window
{
  String title = "";
  
  DrawingWindow( Frame f )
  {
    super( f );
    setSize( Toolkit.getDefaultToolkit().getScreenSize() );
    show();
  }
  
  public void paint( Graphics g )
  {
    g.drawString( title, 100, 400 );
  }
}
public class PaintIndirect
{
  public static void main( String args[] ) throws Exception
  {
    DrawingWindow w = new DrawingWindow( new Frame() );
    
    w.title = "Bei den US-Militäraktionen in Afghanistan sind über 800 " +
      "Zivilisten durch militärischen Fehlgriffe umgekommen.";
    w.repaint();
    
    JOptionPane.showMessageDialog( w, "Die Quelle?" );
    
    w.title = "New York Times und die nichtstaatliche Organisation Global Exchange.";
    w.repaint();
    
    w.title = JOptionPane.showInputDialog( w, "Antwort" );
    w.repaint();
    
    JOptionPane.showMessageDialog( w, "Nun ist aber Schluss!" );
    System.exit( 0 );
  }
}

Bleibt als Letztes die Frage, wie sich so etwas wie C-128-Fealing nachbilden lässt. Die zu zeichnenden Elemente (wie Line, Kreis) können Objekte sein, die in eine Datenstruktur eingereiht werden. Nehmen wir an, es existiert für jede zu zeichnende Primitive eine Klasse. Dann kann eine allgemeine Zeichenklasse Methoden wie line() anbieten, die dann ein Zeichenobjekt erstellten und in die Datenstruktur einreihen. In der paint()-Funktion wird einfach die Datenstruktur abgelaufen. Ohne hier eine vollständige Implementierung anzubieten, könnte ein Klasse folgenden Aufbau haben:

Listing 14.6 PrimitivZeichner.java

import java.awt.Graphics;
import java.util.*;
public class PrimitivZeichner
{
  private Collection elements = new ArrayList();
  
  private interface Primitiv
  {
    void paint( Graphics g );
  }
  
  private class Line implements Primitiv
  {
    private int x1, y1, x2, y2;
    
    public Line( int x1, int y1, int x2, int y2 )
    {
      this.x1 = x1;  this.y1 = y1;
      this.x2 = x2;  this.y2 = y2;
    }
    
    public void paint( Graphics g )
    {
      g.drawLine( x1, y1, x2, y2 );
    }
  }
  
  public void line( int x1, int y1, int x2, int y2 )
  {
    elements.add( new Line(x1, y1, x2, y2) );
  }
  
  public void paint( Graphics g )
  {
    for ( Iterator iter = elements.iterator(); iter.hasNext(); )
      ((Primitiv)iter.next()).paint( g );
  }
}

Von außen lässt sich ein Exemplar von PrimitivZeichner erstellen und nutzen.

PrimitivZeichner z = new PrimitivZeichner();
z.line( 12, 34, 23, 344 );
z.line( 18, 454, 423, 4 );

Die line()-Aufrufe zeichnen zwar noch nicht, bereiten das Zeichnen allerdings vor, da die Operationen in die Liste zu zeichnender Objekte eingereiht werden. Der paint()-Funktion einer Komponente muss nun die Referenz auf den PrimitivZeichner zugänglich gemacht werden, und dann kann sie paint() vom PrimitivZeichner aufrufen. Das PrimitivZeichner-Objekt nutzt dann einen gegebenen Graphics-Kontext.

Einen Schritt weiter gedacht ist PrimitivZeichner selbst eine Komponente wie etwa Window. Dann muss an paint() nichts mehr geändert werden, denn sie wird jetzt vom Fensterbehandler angerufen.

¹ Das Wort erspare ich den Lesern.

² Zur Bewegung des Grafik-Cursors wird gerne eine XOR-Operation eingesetzt. Obwohl dies absolut einfach erscheint, ist die Realisierungsidee patentiert.

³ Commodore 128 System Guide, Commodore Business Machine, Inc. in 1985, online zugänglich unter>http://members.tripod.com/~rvbelzen/c128sg/toc.htm.