Das Grafiksystem für CP/M Plus und CP/M-86

GSX ohne Geheimnisse

Teil 2: GSX-Funktionen und Turbo-Pascal

Martin Kotulla
Was liegt näher, als den Grafik-Standard GSX und das auf CP/M-Ebene grafikfreie Turbo-Pascal sinnvoll zu verkoppeln. Das geht einfacher, als man glaubt, man muß nur einiges über die GSX-Funktionen wissen - und über die mitgelieferten Treiber, die beim Schneider mit einer unangenehmen Überraschung aufwarten.

Zunächst wird, wie in der letzten c't versprochen, das Rätsel um die Größenwerte für die x-y-Koordinaten gelöst. Diese liegen im Bereich zwischen 0 und 32767. Ein normaler Bildschirm kann jedoch höchstens 640 (Schneider CPC, IBM PC mit Farbgrafik) oder 720 Punkte (Joyce) darstellen.

Da GSX so weit wie möglich geräteunabhängig arbeiten soll, verwendet es nicht die realen Koordinaten (RC: Real Coordinates), sondern ein imaginäres Koordinatensystem, die sogenannten NDCs (Normalized Device Coordinates). GSX überläßt es dann dem jeweiligen Gerätetreiber, die NDC-Koordinaten in die realen x-y-Werte umzuwandeln, die das jeweilige Gerät darzustellen vermag.

So wandelt der Bildschirmtreiber die x-Koordinate 32767 (NDC) in RC-639 oder RC-719 um. Ein Drucker kann hingegen bis zu 1920 Punkte darstellen. Deshalb ist hier der Endpunkt der x-Achse eben 1919. Dieses System hat den Vorteil, daß eine Grafik, die die gesamte Ausgabefläche eines Peripheriegeräts bedeckt, auch bei jedem anderen Gerät die Gesamtfläche einnimmt. Würde GSX mit realen Koordinaten arbeiten, dann nähme eine Bildschirmgrafik auf dem Drucker nur einen Bruchteil des Papiers ein.

Das Koordinatensystem von GSX ist so angelegt, daß die linke untere Bildschirmecke den Punkt (0,0) darstellt, die rechte obere Ecke (32767,32767). Der erste Parameter ist stets der x-, der zweite der y-Wert. So ist man es ja schließlich auch aus dem Mathematik-Unterricht und von den Grafikbefehlen des Schneider-BASIC auf dem CPC gewohnt.

GSX und Turbo

Alles klar? Dann kommen wir jetzt zu einem der wohl interessantesten Gebiete der Grafikdarstellung von GSX. Wie bereits in der letzten Folge angedeutet, ist auch Turbo-Pascal in der Lage, GSX-Grafiken zu erzeugen. Denn für CP/M ist auch TURBO.COM nichts anderes als ein Anwendungsprogramm im COM-Format. So funktioniert GENGRAF demnach mit dem Turbo-Pascal-Compiler und den erzeugten Programmen.

Soll ein Turbo-Pascal-Programm GSX-Routinen aufrufen, muß man zwei Fälle unterscheiden. Wenn ein Programm im Speicher kompiliert und gestartet wird (Options = Memory), genügt es, an die Datei TURBO.COM einen GSX-Lader anzuhängen:

A>GENGRAF TURBO.COM

Die Kompilierung im Speicher ist wohl die übliche Methode, unter CP/M Plus Programme in Turbo-Pascal zu entwickeln. Ist aber ein Programm fertig ausgetestet, wird es meist im COM-Format auf die Diskette geschrieben (Options = COM-File). Dann muß das erzeugte Programm vor dem ersten Start mit GENGRAF behandelt werden. Hier ein Beispiel für ein kompiliertes Programm mit dem Namen TEST.PAS (Quellcode) beziehungsweise TEST.COM (Compilat):

A>GENGRAF TEST.COM

Wird bereits TURBO.COM zusammen mit GSX betrieben, läßt sich so ohne Schwierigkeiten ein Stand-alone-Programm erzeugen. Denn dann weiß der Compiler bereits während der Programmübersetzung, wieviel Platz die GSX-Software im Speicher belegt.

Für den Fall, daß Turbo über keinen GSX-Lader angehängt wurde, müßten Sie ausdrücklich im Options-Menü die Endadresse ($F342 beim 6128) um den Betrag der Länge Ihrer GSX-Version herabsetzen. Als Endadresse dürfte $C000 aber in wohl allen Fällen genügen. Das gilt aber nur, wenn keine weiteren RSXen wie GET.COM oder PUT.COM zur Laufzeit geladen werden. Gegebenenfalls muß deren Größe auch noch berücksichtigt werden.

Als kleines Übungsbeispiel kann man das Assembler-Programm aus der letzten Ausgabe von c't in ein Turbo-Pascal-Programm umsetzen. Zur Erinnerung: Es initialisiert GSX und füllt dann den gesamten Bildschirm mit der Schriftfarbe auf.

Workstations

Dazu benötigt man die GSX-Funktion 1, OPEN WORKSTATION. Sie startet die Darstellung der GSX-Grafik und lädt bei Bedarf den passenden Device-Treiber von der Diskette.

OPEN WORKSTATION verlangt eine Menge verschiedener Daten, die unter anderem die Farben, Schriftarten und Linientypen festlegen.

In contrl(1), dem ersten Eintrag des contrl-Feldes, wird die Funktionsnummer abgelegt. Das gilt im übrigen für alle GDOS-Funktionen. contrl(2) muß den Wert 0 enthalten, contrl(4) wird auf die Länge des intin-Feldes festgelegt. Dieses besteht bei OPEN WORKSTATION stets aus zehn Einträgen. Fassen wir also zusammen:

contrl(1) := 1
contrl(2) := 0
contrl(4) := 10

Das zweite belegte Datenfeld ist intin. Der Eintrag intin(1) ist mit der Nummer des gewünschten Device-Treibers aus der Datei ASSIGN.SYS zu laden. Für die Bildschirmausgabe ist also intin(1) := 1, zur Ausgabe auf dem Drucker hingegen gilt intin(1) := 21.

Die restlichen Elemente von intin sind bei der Funktion OPEN WORKSTATION wie folgt belegt:

intin(2)	Muster der Linien
intin(3)	Farbe der Polygon-Linien
intin(4)	Aussehen des 'Markers'
intin(5)	Farbe der Polymarker
intin(6)	Schriftart (Zeichensatz)
intin(7)	Farbe für die Textausgabe
intin(8)	Schraffierung beim Füllen
intin(9)	Schraffiermuster beim Füllen
intin(10)	Farbe beim Füllen

Treiber

Fürs erste genügt es, alle diese Werte auf die Standardvorgabe zu setzen. Um aber etwaige Hoffnungen gar nicht erst aufkommen zu lassen: Obwohl GSX an sich in der Lage ist, mehrere Schriftarten und Schriftgrößen zu verarbeiten, sind die von Schneider gelieferten GSX-Treiber für den Bildschirm allzu spartanisch ausgefallen und dazu nicht fähig. Dabei sind sogar dem Druckertreiber DDFXLR7 mehr Fähigkeiten mitgegeben worden als den Bildschirmtreibern. Eigentlich sollte das genau andersherum sein. Denn im allgemeinen läßt sich eine Bildschirmgrafik leichter erzeugen als eine identische Ausgabe auf dem Drucker, der mit ESCAPE-Sequenzen gesteuert werden muß ...

Die Leistungsfähigkeit des jeweiligen GSX-Treibers können Programme aus den von der Funktion OPEN WORKSTATION zurückgegebenen Werten ablesen. OPEN WORKSTATION meldet in den Arrays contrl, intout und ptsout eine Vielzahl von Werten. Davon ist allerdings nur ein Bruchteil für die meisten Programme von Interesse. Das abgedruckte Turbo-Pascal-Programm Show_Capabilities (Programm 1) listet die Fähigkeiten verschiedener Treiber auf.

Program ShowCapabilities;

(***********************************************************************)
(*                                                                     *)
(*  ShowCapabilities zeigt die Faehigkeiten von GIOS-Treibern an       *)
(*                                                                     *)
(***********************************************************************)
(*                       *)
(*  A>TYPE ASSIGN.SYS    *)
(*  21 A:DDFXLR7         *)
(*  01 A:DDMODE2         *)
(*  A>                   *)
(*                       *)
(*************************)

Var contrl: Array[1..30] Of Integer;
    intin:  Array[1..200] Of Integer;
    ptsin:  Array[1..200] Of Integer;
    intout: Array[1..200] Of Integer;
    ptsout: Array[1..200] Of Integer;
    pblock: Array[1..5] Of Integer;
    i,j:    Integer;

Procedure GSX_Open_Workstation(DriverID:Integer);

Begin
  pblock[1]:=Addr(contrl[1]);
  pblock[2]:=Addr(intin[1]);
  pblock[3]:=Addr(ptsin[1]);
  pblock[4]:=Addr(intout[1]);
  pblock[5]:=Addr(ptsout[1]);

  contrl[1]:=1;
  contrl[2]:=0;
  contrl[4]:=10;
  intin[1]:=DriverID;
  intin[2]:=1;
  intin[3]:=1;
  intin[4]:=1;
  intin[5]:=1;
  intin[6]:=1;
  intin[7]:=1;
  intin[8]:=1;
  intin[9]:=1;
  intin[10]:=1;
  Bdos(115,Addr(pblock[1]);

  Write(#27,'c',#32,#27,'b',#30);   (* Bildschirmfarben normalisieren  *)
  Write(#27,'e');                      (* Cursor wieder einschalten *)
  WriteLn('Groesse von intout                    ',contrl[5]);
  WriteLn('Hoechste X-Koordinate                 ',intout[1]);
  WriteLn('Hoechste Y-Koordinate                 ',intout[2]);
  WriteLn('Pixelbreite in Mikrorometer           ',intout[4]);
  WriteLn('Pixelhoehe in Mikrorometer            ',intout[5]);
  WriteLn('Zahl der Zeichengroessen              ',intout[6]);
  WriteLn('Zahl der Linienarten                  ',intout[7]);
  WriteLn('Zahl der Linienbreiten                ',intout[8]);
  WriteLn('Zahl der Markertypen                  ',intout[9]);
  WriteLn('Zahl der Markergroessen               ',intout[10]);
  WriteLn('Zahl der Schriftarten                 ',intout[11]);
  WriteLn('Zahl der Muster                       ',intout[12]);
  WriteLn('Zahl der Schraffurmuster              ',intout[13]);
  WriteLn('Gleichzeitig darstellbare Farben      ',intout[14]);
  WriteLn('Zahl der GDPs                         ',intout[15]);
  WriteLn('0=monochrom, 1=farbfaehig             ',intout[36]);
  WriteLn('1=Textausgabe kann rotieren           ',intout[37]);
  WriteLn('1=Flaechen koennen gefuellt werden    ',intout[38]);
  WriteLn('Zahl der verfuegbaren Farben          ',intout[40]);
  WriteLn('MiniMale Zeichengroesse               ',ptsout[2]);
  WriteLn('Maximale Zeichengroesse               ',ptsout[4]);
  WriteLn('Kleinste Linienbreite                 ',ptsout[5]);
  WriteLn('Groesste Linienbreite                 ',ptsout[7]);
  WriteLn('Minimale Markerhoehe                  ',ptsout[10]);
  WriteLn('maximale Markerhoehe                  ',ptsout[12]);
End;

Begin (* HauptProgramm *)
  ClrScr;
  WriteLn('Der Bildschirmtreiber DDMODE2:');
  WriteLn('------------------------------');
  WriteLn;
  GSX_Open_Workstation(1);
  WriteLn;
  Repeat Until Keypressed;
  ClrScr;
  WriteLn('Der Druckertreiber DDFXLR7');
  WriteLn('--------------------------');
  WriteLn;
  GSX_Open_Workstation(21);
End.

Programm 1. 'Showcapabilities' gibt Ihnen einen Überblick über die Leistungsfähigkeit von Bildschirm und Druckertreiber.

Zuerst kommt der Bildschirmtreiber DDMODE2 dran, dann der Druckertreiber DDFXLR7. Damit alles nach Wunsch klappt, sollte die Datei ASSIGN.SYS folgendes Format besitzen:

21 A:DDFXLR7
01 A:DDMODE2

Während des Ablaufs des Turbo-Programms können Sie übrigens recht anschaulich sehen, wie GSX die Treiber von der Diskette in den Speicher lädt, sofern sich der passende Driver nicht schon dort befindet.

Wenn Sie mit einem Joyce arbeiten, können Sie mit den bei diesem Computer vorhandenen Druckertreibern sowie DDSCREEN experimentieren.

Die untenstehende Tabelle zeigt, was GSX über die Treiber des CPC 6128 so alles offenbart.

Feature                          DDMODE2      DDMODE2      DDFXLR7
                                 (Amstrad)    (CBASIC)
---------------------------------------------------------------------
Groesse von intout                    45           45           45
Hoechste X-Koordinate                639          639          479
Hoechste Y-Koordinate                191          191          671
Pixelbreite in Mikrometer            375          375          423
Pixelhoehe in Mikrometer             800          800          352
Zahl der Zeichengroessen               1            1           12
Zahl der Linienarten                   5            5            6
Zahl der Linienbreiten                 1            1            1
Zahl der Markertypen                   5            5            5
Zahl der Markergroessen                1            1           12
Zahl der Schriftarten                  1            1            1
Zahl der Muster                        0            6            6
Zahl der Schraffurmuster               0            6            6
Gleichzeitig darstellbare Farben       2            2            2
Zahl der GDPs                          1            1            1
0=monochrom, 1=farbfaehig              1            1            0
1=Textausgabe kann rotieren            0            0            1
1=Flaechen koennen gefuellt werden     0            1            1
Zahl der verfuegbaren Farben          27           27            2
Minimale Zeichengroesse             1195         1195          390
Maximale Zeichengroesse             1365         1195         4681
Kleinste Linienbreite                 51           51           68
Groesste Linienbreite                 51           51           68
Minimale Markerhoehe                1195         1195          390
Maximale Markerhoehe                1195         1195         4681

Die Tabelle offenbart die Leistungsfähigkeit der mitgelieferten Treiber. Wie man sieht, ist der Treiber des CPC 6128 ziemlich rudimentär.

Sie werden bemerken, daß zwei unterschiedliche Treiber unter dem Namen DDMODE2 aufgeführt sind. Den ersten und leistungsschwächeren finden Sie auf der dritten Seite Ihrer CP/M-Systemdiskette. Der zweite Treiber gehört zum CBASIC-Compiler, wie er zur Zeit von Markt & Technik vertrieben wird. Er besitzt, obwohl er immer noch nicht vollständig ist, eine Reihe wichtiger zusätzlicher Funktionen. So kann er zum Beispiel Flächen mit verschiedenen Mustern füllen.

Falls Sie beim Programm GSXDEMO.ASM in der letzten Ausgabe von c't statt einer gefüllten Fläche lediglich einen Rahmen gesehen haben, dann haben Sie garantiert den originalen Amstrad-Treiber benutzt.

Wenn Sie vernünftig mit der Grafikerweiterung GSX arbeiten wollen, sollten Sie sich unbedingt (auf legale Weise!) den Treiber besorgen, der zum CBASIC-Paket gehört.

Denn einige der im folgenden besprochenen Programme arbeiten nur mit dem zu CBASIC gehörenden DDMODE2.PRL zufriedenstellend. Sollten Sie keine Möglichkeit haben, an die verbesserten Treiberdateien heranzukommen, dann müßten Sie die abgedruckten Demonstrationsprogramme so abändern, daß sie den Druckertreiber DDFXLR7 nutzen. Denn dieser kann beispielsweise Flächen in verschiedenen Mustern füllen.

Bei den Listen, die das Turbo-Programm anzeigt, gibt es jetzt einiges zu erklären. Was Koordinaten, Linien und Farben sind, kann ja wohl als bekannt vorausgesetzt werden.

Marker

'Marker' hingegen sind eine Spezialität von GSX. Erinnern Sie sich vielleicht noch an die Kurvendiskussion in der Schule und das unbeliebte Zeichnen von Funktionsgraphen? Jeder berechnete Punkt auf dem Graphen wurde da durch ein Kreuz kenntlich gemacht. Das ist nichts anderes als ein Marker in GSX, eine Markierung also. Je nach Treiber können als Marker 'X', Sternchen, 'O' oder andere Zeichen zulässig sein. Die beiden CPC-Treiber DDFXLR7 und DDMODE2 kennen fünf verschiedene Marker-Typen. Allerdings kann nur der Drucker-Driver diese Marker in der Größe variieren. Dasselbe gilt auch für die Zeichengröße.

Unter der Rotation von Zeichen versteht man die Fähigkeit eines Peripheriegeräts, bei Bedarf Texte auch senkrecht oder auf dem Kopf stehend zu schreiben. Das ist ganz nützlich zur Beschriftung von Funktionszeichnungen und Balkendiagrammen. Hier leistet wieder nur der Druckertreiber Entsprechendes.

Die Tatsache, daß der Bildschirmtreiber DDMODE2 nur maximal 192 Punktzeilen darstellen kann, rührt daher, daß die unterste Bildschirmzeile beim CPC 6128 als Statuszeile vorgesehen ist. In dieser reservierten Zeile zeigt der Computer bei Systemen mit nur einem Laufwerk an, welches Diskettenlaufwerk gerade simuliert wird:


Drive is A:

oder


Drive is B:

Wenn Sie mit dem Steuercode ESC 0 die Statuszeile abschalten, können Sie dennoch nicht den Gesamtbildschirm mit 200 Punktzeilen ausnutzen. Denn dann erscheint die Grafik nur um acht Pixel-Zeilen nach unten verschoben.

Ob ein Gerät dazu in der Lage ist, verschiedene Farben darzustellen, zeigt Show_Capabilities ebenfalls an. Die Zahl der verfügbaren Farben ist entsprechend der Hardware des Video-Chips und des Gate-Array bei den CPCs auf 27 festgelegt, beim Drucker hingegen auf zwei: nämlich schwarz und weiß.

Wir sind bereits auf die imaginären Koordinaten (NDCs) eingegangen. Das ist ein recht eleganter Weg, die unterschiedlichen Ausgabeflächen zwischen verschiedenen Peripheriegeräten auszugleichen. Doch es gibt da noch ein Problem: Während die meisten Drucker annähernd quadratische Pixel erzeugen, sind die Punkte auf dem Bildschirm nahezu doppelt so hoch wie breit. Deshalb ist ein Kreis auf dem Bildschirm noch lange kein Kreis auf dem Drucker - und umgekehrt. Allzu schnell wird da aus einem Kreis eine stehende oder liegende Ellipse.

In Fällen, in denen das Verhältnis der x- und der y-Koordinaten von entscheidender Bedeutung ist, kann ein Programm auf die von OPEN WORKSTATION gemeldete Pixel-Breite und Pixel-Höhe zurückgreifen. Diese Werte sind in der Einheit Mikrometer (10^-6 Meter) angegeben, damit sie nicht gar so klein werden. Im allgemeinen wird aber sowieso nur der Quotient aus beiden Werten benötigt, um einen Ausgleichsfaktor zu berechnen.

Die Entwickler von GSX haben den Programmierern, die die Gerätetreiber erstellen, relativ große Freiheiten gelassen, Funktionen wegzulassen oder hinzuzufügen. So können - entsprechenden guten Willen des Programmierers vorausgesetzt - verschiedene GDPs integriert werden. Das sind 'Generalized Drawing Primitives'. Darunter hat man vorgegebene geometrische Körper zu verstehen, auf die Programme zurückgreifen können. Digital Research hat angeregt, beispielsweise Balken, Kreise und Kreisbögen zu integrieren. Bei den Schneider-Treibern findet sich sowohl in der Amstrad- als auch in der CBASIC-Version als einzige GDP der Balken ('bar'). Deshalb der Wert 1 beim Punkt 'Zahl der GDPs'.

Damit sind bereits die wichtigsten Eigenschaften der Funktion OPEN WORKSTATION abgehandelt. Bei den folgenden Funktionen werden die einzelnen Besonderheiten von GSX noch detaillierter besprochen.

Zurück zum Programm...

Die Aufgabe war ja, das Maschinenprogramm aus der letzten c't in Turbo-Pascal umzusetzen. Es fehlen jetzt lediglich noch Informationen über die zweite dort benutzte Funktion, FILLED AREA.

Sie besitzt die Funktionsnummer 9 und hat die Aufgabe, einen geometrischen Körper mit der aktuellen Schriftfarbe auszufüllen. Dieser Körper kann allerdings nicht beliebig geformt sein, sondern muß ein Vieleck (Polygon) mit einer endlichen Anzahl von x/y-Koordinaten sein.

Im Feld ptsin werden die Koordinaten der Reihe nach abgelegt:

ptsin(1)  - Punkt 1,x
ptsin(2)  - Punkt 1,y
ptsin(3)  - Punkt 2,x
ptsin(4)  - Punkt 2,y
ptsin(5)  - Punkt 3,x
usw.

Damit FILLED AREA weiß, wieviel Koordinatenpaare das Feld ptsin enthält, wird die Zahl der Paare im Element contrl(2) übergeben. Und contrl(1) enthält wieder die gewünschte Funktionsnummer, hier eine 9.

Diese Informationen reichen vollkommen aus, um das Turbo-Pascal-Programm zu schreiben. Programm 2 ist ein Vorschlag, wie es beispielsweise aussehen könnte. Der Einfachheit halber wurde auf Records und ähnliche komplizierte Datentypen verzichtet. Statt dessen werden die Datenstrukturen von GSX mit Arrays nachgebildet (Programm 2).

Program GsxFillDemo;

(********************************************************************)
(*                                                                  *)
(*   GsxFillDemo - Beispielprogramm fuer verschiedene Fuellmuster   *)
(*                                                                  *)
(********************************************************************)

Var contrl: Array[1..30] Of Integer;
    intin:  Array[1..200] Of Integer;
    ptsin:  Array[1..200] Of Integer;
    intout: Array[1..200] Of Integer;
    ptsout: Array[1..200] Of Integer;
    pblock: Array[1..5] Of Integer;
    i,j:    Integer;

Procedure GSX_Open_Workstation(DriverID:Integer);

Begin
  pblock[1]:=Addr(contrl[1]);
  pblock[2]:=Addr(intin[1]);
  pblock[3]:=Addr(ptsin[1]);
  pblock[4]:=Addr(intout[1]);
  pblock[5]:=Addr(ptsout[1]);

  contrl[1]:=1;
  contrl[2]:=0;
  contrl[4]:=10;
  intin[1]:=DriverID;
  intin[2]:=1;
  intin[3]:=1;
  intin[4]:=1;
  intin[5]:=1;
  intin[6]:=1;
  intin[7]:=1;
  intin[8]:=1;
  intin[9]:=1;
  intin[10]:=1;
  Bdos(115,Addr(pblock[1]);       (* Das GSX-GDOS aufrufen           *)
  Write(#27,'c',#32,#27,'b',#30); (* Bildschirmfarben normalisieren  *)
End;

Procedure GSX_Fill(x1,y1,x2,y2,x3,y3,x4,y4:Integer);

Begin
  contrl[1]:=9;               (* Funktionsnummer fuer FILLED AREA    *)
  contrl[2]:=5;               (* Zahl der X/Y-Koordinaten in ptsin   *)
  ptsin[1]:=x1;               (* X-Koordinate fuer den ersten Punkt  *)
  ptsin[2]:=y1;               (* Y-Koordinate fuer den ersten Punkt  *)
  ptsin[3]:=x2;               (* X-Koordinate fuer den zweiten Punkt *)
  ptsin[4]:=y2;               (* Y-Koordinate fuer den zweiten Punkt *)
  ptsin[5]:=x3;               (* X-Koordinate fuer den dritten Punkt *)
  ptsin[6]:=y3;               (* Y-Koordinate fuer den dritten Punkt *)
  ptsin[7]:=x4;               (* X-Koordinate fuer den vierten Punkt *)
  ptsin[8]:=y4;               (* Y-Koordinate fuer den vierten Punkt *)
  ptsin[9]:=x1;               (* X-Koordinate fuer den Endpunkt      *)
  ptsin[10]:=y1;              (* Y-Koordinate fuer den Endpunkt      *)
  Bdos(115,Addr(pblock[1]);   (* Das GSX-GDOS wird hier aufgerufen   *)
End;

Procedure GSX_Fill_Style(i:Integer);

Begin
  contrl[1]:=23;
  contrl[2]:=0;
  intin[1]:=i;
  Bdos(115,Addr(pblock[1]);
End;

Procedure GSX_Update_Workstation;

Begin
  contrl[1]:=4;
  contrl[2]:=0;
  Bdos(115,Addr(pblock[1]);
End;

Begin (* Hauptprogramm *)
  GSX_Open_Workstation(1);
  GSX_Fill_Style(2);
  GSX_Fill(0,0,32767,0,32767,32767,0,32767);
  GSX_Fill_Style(3);
  GSX_Fill(15000,1000,31000,1000,31000,25000,15000,25000);
  GSX_Fill_Style(0);
  GSX_Fill(10000,6000,27000,6000,27000,30000,10000,30000);
  GSX_Fill_Style(1);
  GSX_Fill(2000,8000,15000,8000,15000,27000,2000,27000);
  GSX_Update_Workstation;
  Repeat Until KeyPressed;
  Write(#27,'e'); (* Cursor wieder einschalten *)
End.

Programm 2. Ein Demo-Programm zum Füllen von Flächen mit einer Schraffur.

FILL mit Muster

Bis jetzt hat die ausgefüllte Fläche stets komplett die aktuelle Schriftfarbe eingenommen. Doch das ist nicht das einzige Muster, mit dem sich Polygone füllen lassen.

Die Funktion SET FILL INTERIOR STYLE (Funktionsnummer 23) bietet bei dem CBASIC-Treiber DDMODE2 sowie bei dem Original Druckertreiber DDFXLR7 insgesamt vier Muster zur Auswahl an:

0 - Leer: Die Fläche wird nicht gefüllt, sondern nur umrahmt.

1 - Gefüllt: Das ist das, was Sie schon kennen.

2 - Punktmuster: Die Fläche wird mit gegeneinander versetzten Punkten gefüllt und dann umrandet.

3 - Schraffur: Die Fläche wird mit Linien gefüllt und umrandet.

Die Funktion stellt folgende Anforderungen:

contrl(1) = 23 - Funktionsnummer
contrl(2) = 0
intin(1) = ? - gewünschtes Muster

Eine Demonstration dafür, für welche interessanten Effekte SET FILL INTERIOR STYLE herangezogen werden kann, zeigt das Turbo-Programm GsxFillDemo (Programm 3). Es zeichnet verschiedene gefüllte Flächen in den von GSX angebotenen Mustern.

Abwandeln kann man die Schraffuren (Muster 3) dadurch, daß man über die GDOS-Funktion 24 den FILL STYLE INDEX neu festlegt. Die folgenden unterschiedlichen Schraffuren sind zulässig:

- Senkrechte Linien
- Waagerechte Linien
- Steigende Diagonalen
- Fallende Diagonalen
- Gitter aus Senkrechten und Waagerechten
- Gitter aus steigenden und fallenden Diagonalen

Wie diese Funktion genutzt werden kann, zeigt das Turbo-Pascal-Programm GsxHatchDemo (Programm 3).

Program GsxHatchDemo;

(********************************************************************)
(*                                                                  *)
(*   GsxHatchDemo - Beispielprogramm fuer verschiedene Schraffuren  *)
(*                                                                  *)
(********************************************************************)

Var contrl: Array[1..30] Of Integer;
    intin:  Array[1..200] Of Integer;
    ptsin:  Array[1..200] Of Integer;
    intout: Array[1..200] Of Integer;
    ptsout: Array[1..200] Of Integer;
    pblock: Array[1..5] Of Integer;
    i,j:    Integer;

Procedure GSX_Open_Workstation(DriverID:Integer);

Begin
  pblock[1]:=Addr(contrl[1]);
  pblock[2]:=Addr(intin[1]);
  pblock[3]:=Addr(ptsin[1]);
  pblock[4]:=Addr(intout[1]);
  pblock[5]:=Addr(ptsout[1]);

  contrl[1]:=1;
  contrl[2]:=0;
  contrl[4]:=10;
  intin[1]:=DriverID;
  intin[2]:=1;
  intin[3]:=1;
  intin[4]:=1;
  intin[5]:=1;
  intin[6]:=1;
  intin[7]:=1;
  intin[8]:=1;
  intin[9]:=1;
  intin[10]:=1;
  Bdos(115,Addr(pblock[1]);       (* Das GSX-GDOS aufrufen           *)
  Write(#27,'c',#32,#27,'b',#30); (* Bildschirmfarben normalisieren  *)
End;

Procedure GSX_Fill(x1,y1,x2,y2,x3,y3,x4,y4:Integer);

Begin
  contrl[1]:=9;               (* Funktionsnummer fuer FILLED AREA    *)
  contrl[2]:=5;               (* Zahl der X/Y-Koordinaten in ptsin   *)
  ptsin[1]:=x1;               (* X-Koordinate fuer den ersten Punkt  *)
  ptsin[2]:=y1;               (* Y-Koordinate fuer den ersten Punkt  *)
  ptsin[3]:=x2;               (* X-Koordinate fuer den zweiten Punkt *)
  ptsin[4]:=y2;               (* Y-Koordinate fuer den zweiten Punkt *)
  ptsin[5]:=x3;               (* X-Koordinate fuer den dritten Punkt *)
  ptsin[6]:=y3;               (* Y-Koordinate fuer den dritten Punkt *)
  ptsin[7]:=x4;               (* X-Koordinate fuer den vierten Punkt *)
  ptsin[8]:=y4;               (* Y-Koordinate fuer den vierten Punkt *)
  ptsin[9]:=x1;               (* X-Koordinate fuer den Endpunkt      *)
  ptsin[10]:=y1;              (* Y-Koordinate fuer den Endpunkt      *)
  Bdos(115,Addr(pblock[1]);   (* Das GSX-GDOS wird hier aufgerufen   *)
End;

Procedure GSX_Hatch_Style(i:Integer);

Begin
  contrl[1]:=23;
  contrl[2]:=0;
  intin[1]:=3;
  Bdos(115,Addr(pblock[1]);

  contrl[1]:=24;
  contrl[2]:=0;
  intin[1]:=i;
  Bdos(115,Addr(pblock[1]);
End;

Procedure GSX_Update_Workstation;

Begin
  contrl[1]:=4;
  contrl[2]:=0;
  Bdos(115,Addr(pblock[1]);
End;

Begin (* Hauptprogramm *)
  GSX_Open_Workstation(1);
  For i:=0 to 5 Do
      Begin
        GSX_Hatch_Style(i+1);
        GSX_Fill(i*5000,0,i*5000+4000,0,i*5000+4000,32767,i*5000+4000,32767);
      End;
  GSX_Update_Workstation;
  Repeat Until KeyPressed;
  Write(#27,'e'); (* Cursor wieder einschalten *)
End.

Programm 3. Man kann Flächen auch mit unterschiedlichen Mustern füllen.

Noch 'ne Funktion

Eine interessante Abwandlung des Programms GsxTurboDemo (Programm 4) erreichen Sie, indem Sie in der Prozedur GSX_Filled_Area die Zeile

contrl[1]: = 9;

durch

contrl[1]: = 6;

ersetzen.

Program GsxTurboDemo;

(********************************************************************)
(*                                                                  *)
(*   GsxTurboDemo - Umsetzung der Maschinensprache-Demonstration    *)
(*                                                                  *)
(********************************************************************)

Var contrl: Array[1..30] Of Integer;
    intin:  Array[1..200] Of Integer;
    ptsin:  Array[1..200] Of Integer;
    intout: Array[1..200] Of Integer;
    ptsout: Array[1..200] Of Integer;
    pblock: Array[1..5] Of Integer;
    i,j:    Integer;

Procedure GSX_Open_Workstation(DriverID:Integer);

Begin
  pblock[1]:=Addr(contrl[1]);
  pblock[2]:=Addr(intin[1]);
  pblock[3]:=Addr(ptsin[1]);
  pblock[4]:=Addr(intout[1]);
  pblock[5]:=Addr(ptsout[1]);

  contrl[1]:=1;
  contrl[2]:=0;
  contrl[4]:=10;
  intin[1]:=DriverID;
  intin[2]:=1;
  intin[3]:=1;
  intin[4]:=1;
  intin[5]:=1;
  intin[6]:=1;
  intin[7]:=1;
  intin[8]:=1;
  intin[9]:=1;
  intin[10]:=1;
  Bdos(115,Addr(pblock[1]);       (* Das GSX-GDOS aufrufen           *)
  Write(#27,'c',#32,#27,'b',#30); (* Bildschirmfarben normalisieren  *)
End;

Procedure GSX_Filled_Area;

Begin
  contrl[1]:=9;               (* Funktionsnummer 9 fuer FILLED AREA  *)
  contrl[2]:=5;               (* Zahl der X/Y-Koordinaten in ptsin   *)
  ptsin[1]:=0;                (* X-Koordinate fuer den ersten Punkt  *)
  ptsin[2]:=0;                (* Y-Koordinate fuer den ersten Punkt  *)
  ptsin[3]:=32767;            (* X-Koordinate fuer den zweiten Punkt *)
  ptsin[4]:=0;                (* Y-Koordinate fuer den zweiten Punkt *)
  ptsin[5]:=32767;            (* X-Koordinate fuer den dritten Punkt *)
  ptsin[6]:=32767;            (* Y-Koordinate fuer den dritten Punkt *)
  ptsin[7]:=0;                (* X-Koordinate fuer den vierten Punkt *)
  ptsin[8]:=32767;            (* Y-Koordinate fuer den vierten Punkt *)
  ptsin[9]:=0;                (* X-Koordinate fuer den Endpunkt      *)
  ptsin[10]:=0;               (* Y-Koordinate fuer den Endpunkt      *)
  Bdos(115,Addr(pblock[1]);   (* Das GSX-GDOS wird hier aufgerufen   *)
End;

Begin (* Hauptprogramm *)
  GSX_Open_Workstation(1);
  GSX_Filled_Area;
  Repeat Until KeyPressed;
  Write(#27,'e'); (* Cursor wieder einschalten *)
End.

Programm 4. Die Demo aus der vorigen c't nur diesmal in Turbo-Pascal.

In diesem Fall zeichnet GSX ein Rechteck für Sie. Statt FILLED AREA rufen Sie nämlich die Funktion POLYLINE auf. Sie stellt ein Vieleck dar, das nicht mit Farbe ausgefüllt wird. Ansonsten gilt alles, wie es bereits für FILLED AREA gesagt wurde.

POLYLINE läßt sich aber auch dazu heranziehen, Punkte oder einzelne Linien darzustellen. Für Linien geben Sie als x/y-Koordinaten den Start- und den Endpunkt an:

Procedure GSX_Line(x,y,xend,yend:Integer);

Begin
  contrl[1]:=6;   (* Funktion 6 *)
  contrl[2]:=2;   (* 2 K.-Paare *)
  ptsin[1]:=x;    (* X-Start    *)
  ptsin[2]:=y;    (* Y-Start    *)
  ptsin[3]:=xend; (* X-Ende     *)
  ptsin[4]:=yend; (* Y-Ende     *)
  Bdos(115,Addr(pblock[1]);
End;

Der Aufruf kann dann beispielsweise so erfolgen:

GSX_Line(0,0,32000,32000);
GSX_Line(0,32000,32000,0);

Wenn diese beiden Prozeduraufrufe ausgeführt werden, erscheint ein großes 'X' auf dem Ausgabegerät.

Ein Punkt ist eigentlich nichts anderes als eine Linie, bei der die Start- und Endkoordinaten übereinstimmen:

Procedure GSX_SetPix(x,y:Integer);

Begin
  contrl[1]:=6;   (* Funktion 6 *)
  contrl[2]:=2;   (* 2 K.-Paare *)
  ptsin[1]:=x;    (* X-Start=x  *)
  ptsin[2]:=y;    (* Y-Start=y  *)
  ptsin[3]:=x;    (* X-Ende =x  *)
  ptsin[4]:=y;    (* Y-Ende =y  *)
  Bdos(115,Addr(pblock[1]);
End;

Wollen Sie einen 'Sternenhimmel' erzeugen, können Sie dazu die Random-Funktion von Turbo-Pascal heranziehen:

For i:=1 To 1500 Do
GSX_SetPix(Random(32767),Random(32767));

Eine andere Möglichkeit zur Ausgabe von Pixels ist die Nutzung der Marker. Diese haben wir bereits angesprochen. Sie dienen im allgemeinen vorrangig dazu, Punkte auf Funktionsgraphen kenntlich zu machen. Doch es gibt insgesamt fünf verschiedene Marker:

1 -	.	Punkt
2 -	+	Plus-Zeichen
3 -	*	Sternchen
4 -	o	Kreis
5 -	x	x-Kreuz

Der Markertyp 1 ist das kleinste auf dem virtuellen Gerät darstellbare Zeichen, eben ein Pixel oder Dot. Wählt man sich nun diesen Marker an und setzt ihn mit der GSX-Funktion POLYMARKER an eine Stelle auf dem Bildschirm oder dem Papier, erhält man auch auf diese Weise den gewünschten Punkt.

Das Aussehen des Marker kann man mit der Funktion 18 SET POLYMARKER TYPE bestimmen. Es sind die Werte 1 bis 5 erlaubt. Diese entsprechen der obigen Tabelle. SET POLYMARKER TYPE erwartet die Werte:

`contrl(1)`	= 18 Funktionsnummer
`contrl(2)`	= 0 Stets Null
`intin(1)`	= 1 Markertyp, hier Punkt

Durch Aufruf der GSX-Funktion 10, POLYMARKER, können Sie eine beliebige Anzahl von Markern gleichzeitig auf den Bildschirm bringen. Die x- und y-Koordinaten werden - wie bereits bei POLYLINE und FILLED AREA gesehen - der Reihe nach im Feld ptsin abgelegt. In die Variable contrl(2) trägt man die Zahl der darzustellenden Marker ein, in contrl(1) die Funktionsnummer 7. Die Umsetzung in Turbo-Puscal könnte so aussehen:

Procedure GSX_SetPix2(x,y:Integer);
Begin
  (* SET POLYMARKER TYPE *)
  contrl[1]:=18; {Funktionsnummer  }
  contrl[2]:=0;  {Stets Null       }
  intin[1]:=1;   {Typ = Punkt      }
  Bdos(115,Addr(pblock[1]);
  (* POLYMARKER *)
  contrl[1]:=7;  {Funktionsnummer  }
  contrl[2]:=1;  {Zahl der Marker  }
  ptsin[1]:=x;   {X-Koordinate     }
  ptsin[2]:=y;   {Y-Koordinate     }
  Bdos(115,Addr(pblock[1]);
End;

Wenn Sie in intin(1) andere Werte als 1 einsetzen, erhalten Sie beim Ablauf des Programms 'Sternenhimmel' Effekte, die stark der beliebten (?) Blockgrafik ähneln.

Der Drucker schweigt...

Angesichts der Tatsache, daß GSX bekanntlich geräteunabhängig arbeitet, haben Sie vielleicht schon versucht, die Ausgabe vom Bildschirm auf den Drucker umzulegen. Beim Programmlauf wird auch der Druckertreiber korrekt geladen - vorausgesetzt, Ihr File ASSIGN.SYS hat das richtige Format. Doch es will einfach keine Druckerausgabe kommen.

Woran das liegt, kann man recht leicht herausfinden. Während GSX auf dem Bildschirm unidirektional (in alle Richtungen) 'herumfahren' kann, ist das beim Drucker etwas schwieriger. Denn viele Drucker sind nicht in der Lage, das Papier entgegengesetzt zur normalen Richtung zu bewegen. Deshalb reserviert sich GSX im RAM-Speicher des Computers einen bestimmten Bereich und führt alle Berechnungen tatsächlich nur in ihm durch. Erst wenn die Grafik komplett erstellt ist, gibt das GDOS sie auf dem Drucker aus.

Schön und gut. Doch wie merken die Grafikroutinen von GSX, wann eine Grafik eigentlich vollendet ist? Das muß das Anwenderprogramm dem GSX ausdrücklich zu verstehen geben. Dazu gibt es die GSX-Funktion UPDATE WORKSTATION. Sie veranlaßt GSX, alle offenen Puffer zu löschen und die Grafik auf dem vorgewählten Gerät auszugeben.

Damit ein Programm wirklich geräteunabhängig arbeitet, sollte es stets nach Ausgabe der Grafik die Funktion UPDATE WORKSTATION aufrufen - auch wenn das Ausgabegerät nur der Bildschirm ist.

UPDATE WORKSTATION verlangt keine komplizierten Parameter. Es muß nur in contrl(1) die Funktionsnummer 4 und in contrl(2) der Wert 0 enthalten sein. Fügen Sie also in das Pascal-Programm GsxTurboDemo die folgende Prozedur ein:

Procedure GSX_Update_Workstation;
Begin
  contrl[1]:=4;
  contrl[2]:=0;
  Bdos(115,Addr(pblock[1]);
End;

Das Hauptprogramm sollten Sie dann so abändern:

Begin
:ee
 GSX_Open_Workstation(21);
 GSX_Filled_Area;
 GSX_Update_Workstation;
 Repeat Until KeyPressed;
 Write(#27,'e');
:ea
End.

Wenn Sie das Programm in dieser Form starten, erhalten Sie sehr wohl eine Druckerausgabe. Aber das Ergebnis entspricht nicht so recht den Erwartungen. Denn der Druckertreiber DDFXLR7 ist leider nicht intelligent genug, von sich aus der Zeilenabstand des Druckers auf einen vernünftigen Wert einzustellen. Deshalb ist die ganze Grafik mit Leerzeilen durchsetzt. Das einfachste ist, im Hauptprogramm direkt nach 'Begin' die folgende Zeile einzufügen:

Write(Lst,27,51,20);

Nach dieser Änderung können Sie sich an Ihrer ersten GSX-Turbo-Pascal-Druckergrafik erfreuen.

GSX ade!

Irgendwann einmal hat ein Programm genug von der GSX-Grafik. Es will mit der normalen Textausgabe weitermachen oder fordert ein anderes Peripheriegerät zur Ausgabe auf. In beiden Fällen kann man die Funktion CLOSE WORKSTATION anwenden. Sie trennt die Verbindung zwischen dem Programm und dem virtuellen (imaginären) Peripheriegerät.

CLOSE WORKSTATION besitzt die Opcode-Nummer 2 und läßt sich in Pascal so aufrufen:

Procedure GSX_Close_Workstation;
Begin
  contrl[1]:=2; (* Opcode-Nummer *)
  contrl[2]:=0;
  Bdos(115,Addr(pblock[1]);
End;

War das Ausgabegerät der Bildschirm, wird dieser von GSX gelöscht. Ging die Grafikausgabe an den Drucker, ruft GSX die Funktion UPDATE WORKSTATION auf, um die Grafik auf das Papier zu bringen.

CLS + GSX = CLEAR WORKSTATION

Soll der Bildschirm oder der interne Druckerpuffer gelöscht werden, kann dazu die GDOS-Funktion CLEAR WORKSTATION Verwendung finden. Je nach Peripheriegerät löscht CLEAR WORKSTATION den Screen oder wirft mit einem Form-Feed das Blatt aus dem Drucker.

Die Funktionsnummer 3 wird wie gewohnt in das Feldelement contrl(1) eingetragen, contrl(2) setzt man auf Null. In Turbo-Pascal kann man das so formulieren:

Procedure GSX_Clear_Workstation;
Begin
  contrl[1]:=3;
  contrl[2]:=0;
  Bdos(115,Addr(pblock[1]);
End;

Ausblicke

Für die nächste Ausgabe stehen weitere GDOS-Funktionen auf dem Programm, und außerdem bekommen Sie eine komplette Grafikbibliothek in Turbo-Pascal serviert.