14.5 Punkte, Linien und Rechtecke aller Art

Die grafischen Objekte werden in einem Koordinatensystem platziert, welches seine Ursprungskoordinaten - also standardmäßig (0,0) - links oben definiert. Die Angabe ist absolut zum Fensterrahmen. Wählen wir die Koordinate auf der y-Achse klein, so kann es vorkommen, dass wir nichts mehr sehen, denn das Objekt wandert in die Bildschirmleiste. Mit der 2D-API kann dieser Ursprung verschoben werden.

Gelegentlich vermischt sich die Umgangssprache mit der Sprache der Mathematik und Computergrafik, so dass wir noch einmal die wichtigsten Begriffe aufzählen.

Punkte

Ein Punkt ist in Abhängigkeit der Dimensionen durch zwei oder mehrere Koordinaten gekennzeichnet. Da er, so kennen wir ihn aus der Mathematik, keine Ausdehnung hat, dürfen wir ihn eigentlich gar nicht sehen. In Java gibt es keine Funktion, mit der Punkte gezeichnet werden können. Diese können nur durch einen Linienbefehl erzeugt werden.

Pixel

Das Wort Pixel ist eine Abkürzung für »Picture Element«. Ein Pixel beschreibt einen physikalischen Punkt auf dem Bildschirm und ist daher nicht zu verwechseln mit einem Punkt (obwohl umgangssprachlich keine feste Trennung existiert). Pixel besitzen, wie Punkte, Koordinaten. Wird ein grafisches Objekt gezeichnet, so werden die entsprechenden Punkte auf dem Bildschirm gesetzt. Die Anzahl der Pixel auf dem Monitor ist beschränkt, unter einer Auflösung von 1024 * 768 »Punkten« sind dies also 786.432 Pixel, die einzeln zu setzen sind. Einen Pixel zu setzen, heißt aber nichts anderes, als ihm eine andere Farbe zu geben.

14.5.1 Linien

Auch bei Linien müssen wir uns von der Vorstellung trennen, die uns die analytische Geometrie vermittelt. Denn dort ist eine Linie als kürzeste Verbindung zwischen zwei Punkten definiert - so sagt es Euklid. Da sie eindimensional sind, besitzen sie eine Länge aus unendlich vielen Punkten, aber keine Breite. Auf dem Bildschirm besteht eine Linie nur aus endlich vielen Punkten, und wenn eine Linie gezeichnet wird, dann werden Pixel gesetzt, die nahe an der wirklichen Linie sind. Die Punkte müssen passend in ein Raster gesetzt werden, und so passiert es, dass die Linie in Stücke zerbrochen wird. Dieses Problem gibt es bei allen grafischen Operationen, da von Fließkommawerten eine Abbildung auf Ganzzahlen, in unserem Fall, absolute Koordinaten des Bildschirms, gemacht werden muss. Eine bessere Darstellung der Linien und Kurven ist durch Antialiasing zu erreichen. Dies ist eine Art Weichzeichnung mit nicht nur einer Farbe, sondern mit Abstufungen, so dass die Qualität auf dem Bildschirm wesentlich besser ist. Auch bei Zeichensätzen ist dadurch eine gute Verbesserung der Lesbarkeit auf dem Bildschirm zu erzielen. Die Fähigkeit zum Weichzeichnen fehlt jedoch im AWT und ist erst bei der neuen JFC 2D-API implementiert.

abstract class java.awt.Graphics

abstract void drawLine( int x1, int y1, int x2, int y2 ) Zeichnet eine Linie zwischen den Koordinaten (x1,y1) und (x2,y2) in der Vordergrundfarbe.

g.drawLine( x, y, x, y );

14.5.2 Rechtecke

Im Folgenden wollen wir nur die paint()-Methode mit etwas Leben füllen. Zunächst werfen wir einen Blick auf die Funktionen, die uns Rechtecke zeichnen lassen. Die Rückgabewerte sind immer void. Es ist nicht so, dass die Funktionen durch einen Wahrheitswert mitteilen, ob ein tatsächlicher Zeichenbereich gefüllt werden konnte. Liegen die Koordinaten des zu zeichnenden Objekts nicht im Sichtfenster, so geschieht einfach gar nichts. Die Zeichenfunktion ist nicht in der Lage, dies in irgendeiner Form dem Aufrufer mitzuteilen.

abstract class java.awt.Graphics

void drawRect( int x, int y, int width, int height ) Zeichnet ein Rechteck in der Vordergrundfarbe. Das Rechteck ist width + 1 Pixel breit und height + 1 Pixel hoch.

void abstract fillRect( int x, int y, int width, int height ) Zeichnet ein gefülltes Rechteck in der Vordergrundfarbe. Das Rechteck ist width + 1 Pixel breit und height + 1 Pixel hoch.

void abstract drawRoundRect( int x, y, int width, height, int arcWidth, arcHeight ) Zeichnet ein abgerundetes Rechteck in der Vordergrundfarbe. Das Rechteck ist width + 1 Pixel breit und height + 1 Pixel hoch. arcWidth gibt den horizontalen und arcHeight den vertikalen Durchmesser der Kreisbögen der Ränder an.

void abstract fillRoundRect( int x, y, int width, height, int arcWidth, arcHeight ) Wie drawRoundRect(), nur gefüllt

void draw3DRect( int x, int y, int width, int height, boolean raised ) Zeichnet ein dreidimensional angedeutetes Rechteck in der Vordergrundfarbe. Der Parameter raised gibt an, ob das Rechteck erhöht oder vertieft wirken soll. Die Farben für den Effekt werden aus den Vordergrundfarben gewonnen.

void fill3DRect( int x, int y, int width, int height, boolean raised ) Wie draw3Drect(), nur gefüllt

Eine konkrete Methodenimplementierung

Die Implementierung einiger Routinen können wir uns im Paket java.awt.Graphics ansehen. So finden wir dort beispielsweise drawRect():

public void drawRect(int x, int y, int width, int height)
{
  if ((width < 0) || (height < 0)) {
    return;
  }
  if (height == 0 || width == 0) {
    drawLine(x, y, x + width, y + height);
  } else {
    drawLine(x, y, x + width - 1, y);
    drawLine(x + width, y, x + width, y + height - 1);
    drawLine(x + width, y + height, x + 1, y + height);
    drawLine(x, y + height, x, y + 1);
  }
}

Neben den anderen beiden Funktionen draw3DRect() und fill3DRect() sind dies aber die einzigen ausprogrammierten Routinen. Die restlichen Methoden werden von der konkreten Graphics-Klasse der darunter liegenden Plattform implementiert.