Turbo Toolbox/Turbo_Toolbox.iso/qpdemo/grdemo.pas

Pascal/Delphi Source File | 1994-04-11 | 22.3 KB | 887 lines

PROGRAM grdemo;
{ GRDEMO.PAS demonstriert die QuickPascal Graphikbibliothek.
  Es benutzt zwei zusätzliche Units: Menu und Turtle (für
  Schildkrötengraphik).
  Hinweis: Stellen Sie sicher, daß in Optionen/Umgebung die
  Umgebungsvariable für Units (.QPU) richtig gesetzt ist (z.B.:
  c:\qp\Beispiel), damit der Compiler die Dateien TURTLE.PAS
  und MENU.PAS auch findet und mitkompiliert.
}

USES
    MSGraph, Crt, menu, turtle;

CONST
    haupt_menu : element_array_t =
    ( ( WTast : 1; element :  'Beenden' ),
      ( WTast : 1; element :  'Kreise' ),
      ( WTast : 1; element :  'Rotierende Kugel' ),
      ( WTast : 1; element :  'Tunnel' ),
      ( WTast : 1; element :  'Spirale' ),
      ( WTast : 1; element :  'Invertierte Spirale' ),
      ( WTast : 1; element :  'Wanze' ),
      ( WTast : 1; element :  'Fenster anpassen' ),
      ( WTast : 1; element :  'Modus ändern' ),
      ( WTast : 1; element :  '' ) ,
      ( WTast : 1; element :  '' )
    );

    modus_mldg = 'Graphikmodus kann nicht gesetzt werden.';

    { Konstanten für die Auswahl aus dem Hauptmenü }
    do_beenden = 0;
    do_kreise = 1;
    do_kugel = 2;
    do_tunnel = 3;
    do_spirale = 4;
    do_invert_spirale = 5;
    do_wanze = 6;
    do_anpassen = 7;
    do_modus_aendern = 8;

TYPE
    modus_array_t = ARRAY[0..14] OF Integer;

VAR
    aktuelles_hauptm : Integer;     { Aktuelle Wahl aus dem Hauptmenü }
    aktueller_modus : Integer;      { Aktuelle Wahl aus den Modi }
    modus_array  : modus_array_t;   { Indiziert von aktueller_modus }
    modus_menu   : element_array_t; { Menü der Graphikmodi }
    bool_wert, farbe : Boolean;
    vc : _VideoConfig;
    zeilen_mitt, spalten_mitt : Byte;  { Bildschirmmitte }
    modus : Integer;                { Modus }
    rueck_code : Integer;
    ch : Char;
    ITast : Word;

{ ============================ zufalls_gen =============================
  Zufalls_gen gibt eine Zufallszahl vom Typ Integer zurück. Der Bereich
  ist durch ihre Parameter beschränkt.
}

FUNCTION zufalls_gen( min, max: Integer ) : Integer;

    BEGIN
    zufalls_gen := Random( max - min ) + min;
    END;   { Funktion zufalls_gen }

{ ============================= anpassen  ===============================
  Ändert Seitenverhältnis, Fenstergröße und Ort des Fensters entsprechend
  den Eingaben des Benutzers.
 }

PROCEDURE anpassen;

VAR
    links, rechts, spitze, anfang : Integer;
    i         : Integer;
    fmt, tmp  : CSTRING;
    taste     : Word;
    vc        : _VideoConfig;

CONST
    radius_xy : Real = 400.0;
    fn_inkr = 4;
    u_oben = $0148;   { Pfeil nach oben }
    u_unten = $0150;  { Pfeil nach unten }
    u_links = $014B;  { Pfeil nach links }
    u_rechts = $014d; { Pfeil nach rechts }
    s_oben = $0248;   { UMSCH + Pfeil nach oben }
    s_unten = $0250;  { UMSCH + Pfeil nach unten }
    s_links = $024B;  { UMSCH + Pfeil nach links }
    s_rechts = $024d; { UMSCH + Pfeil nach rechts }
    n_plus = $014E;   { Plustaste auf numerischen Tastenblock }
    n_minus = $014A;  { Minustaste auf numerischen Tastenblock }
    eingabe  = 13;    { Eingabetaste }
    n_eingabe = $1E0; { Eingabetaste auf numerischen Tastenblock }

BEGIN
    _GetVideoConfig( vc );
    WHILE True DO
    BEGIN
    _SetTextPosition( 1, 2 );
    _OutText(' PLUS und MINUS des numerischen Blocks passen'+
         ' das Verhältnis an' );
    _SetTextPosition( 2, 2 );
    _OutText(' Pfeiltasten            Fenstergröße' );
    _SetTextPosition( 3, 2 );
    _OutText(' UMSCH + Pfeiltasten    Fenster verschieben' );
    _SetTextPosition( 4, 2 );
    _OutText(' Eingabe                Ende' );

    Str( TVerhYX:5:2, tmp );
    fmt := ' Verhältnis = ' + tmp + '   xMax = ';
    Str( tmaxx:5:2, tmp );
    fmt := fmt + tmp + '   yMax = ';
    Str( tmaxy:5:2, tmp );
    fmt := fmt + tmp;
    _SetTextPosition( 6, 2 );
    _OutText( fmt );

    { Zeichne Rand und Kreis. }
    Rechteck( 2 * tmaxx,  2 * tmaxy );
    stiftkont( False );
    gehzu( 75.0, 0.0 );
    stiftkont( True );
    kreis( radius_xy );
    FOR i := 1 TO 4 DO
        BEGIN
        stiftkont( True );
        Bewegen( radius_xy );
        drehen( 180 );
        stiftkont( False );
        Bewegen( radius_xy );
        drehen( 90 );
        END;

    { Eingabe lesen und Werte entsprechend anpassen. }
    holfenster( links, spitze, rechts, anfang );
    taste := hol_taste( LEER_WART );
    CASE taste OF
        n_minus:
        TVerhYX := (tmaxx - (fn_inkr * TEinh)) / tmaxy;
        n_plus:
        TVerhYX := (tmaxx + (fn_inkr * TEinh)) / tmaxy;
        u_rechts:
        BEGIN
        IF (links < (vc.NumXPixels DIV 3) ) THEN
            links := links + fn_inkr;
        IF( rechts > (vc.NumXPixels - (vc.NumXPixels DIV 3)) )
            THEN
            rechts := rechts - fn_inkr;
        END;
        u_links:
        BEGIN
        IF( links <> 0 ) THEN
            links := links - fn_inkr;
        IF( rechts < vc.NumXPixels ) THEN
            rechts := rechts + fn_inkr;
        END;
        u_unten:
        BEGIN
        IF (spitze < (vc.NumYPixels DIV 3) ) THEN
            spitze := spitze + fn_inkr;
        IF (anfang > (vc.NumYPixels - (vc.NumYPixels DIV 3)) )
            THEN
            anfang := anfang - fn_inkr;
        END;
        u_oben:
        BEGIN
        IF( spitze <> 0 ) THEN
            spitze := spitze - fn_inkr;
        IF( anfang < vc.NumYPixels ) THEN
            anfang := anfang + fn_inkr;
        END;
        s_links:
        IF( links <> 0 ) THEN
            BEGIN
            links := links - fn_inkr;
            rechts := rechts - fn_inkr;
            END;
        s_rechts:
        IF( rechts < vc.NumXPixels ) THEN
            BEGIN
            links := links + fn_inkr;
            rechts := rechts +  fn_inkr;
            END;
        s_oben:
        IF( spitze <> 0 ) THEN
            BEGIN
            spitze := spitze - fn_inkr;
            anfang := anfang - fn_inkr;
            END;
        s_unten:
        IF( anfang < vc.NumYPixels ) THEN
            BEGIN
            spitze := spitze + fn_inkr;
            anfang := anfang + fn_inkr;
            END;

        eingabe, n_eingabe:
        Exit;

        ELSE
        zurueck;
        END; { CASE }
    _ClearScreen( _GClearScreen );
    SetzFenster( links, spitze, rechts, anfang );
    zurueck;
    END; { WHILE }
END; { anpassen }

{ =========================== Kreise ==============================
  Zeichnet Kreise in verschiedenen Größen, Farbe und runden Mustern.

  Parameter: Keine
}
PROCEDURE Kreise;
VAR
    x, y, radius_xy  : Double;
    fuell_flag, stift_flag : Boolean;

BEGIN
    { Initialiiere unnd speichere Stift- und Fuellflags. }
    IF (tfarbindizes <= 4) THEN
    fuellein( False )
    ELSE
    fuellein( True );
    fuell_flag := FuellStatus;
    stift_flag := StiftStatus;
    stiftkont( False );

    WHILE True DO
    BEGIN

    { Zeichne Kreise. }
    radius_xy := 10.0;
    WHILE (radius_xy <= 130.0) DO
        BEGIN
        x := (tmaxx - 30) * ArcTan( Sin( radius_xy / Pi ) );
        y := (tmaxy - 30) * ArcTan( Cos( radius_xy / Pi ) );
        gehzu( x, y );
        stiftfarbe( naechstfarbindex( vorgabe ) );
        kreis( radius_xy );
        IF (hol_taste( nicht_warten ) <> 0) THEN
        BEGIN
        stiftkont( stift_flag );
        fuellein( fuell_flag );
        Exit;
        END;
        radius_xy := radius_xy + 1.0;
        END; { WHILE }

    { Bei Palettenmodi (ausser 256 Farben), starte erneut. }
    IF (tfarbwerte = 64) OR (tfarbwerte = 16) THEN
        BEGIN
        _ClearScreen( _GClearScreen );
        fuellein( False );
        gehzu( 0.0, 0.0 );
        stiftfarbe( White );
        Rechteck( 2 * tmaxx, 2 * tmaxy );
        fuellein( fuell_flag );
        naechstfarbwert( vorgabe );
        END;
    END; { WHILE }
END;  { Kreise }


{ =========================== RotKugel ==============================
  Zeichnet und füllt Teile einer rotierenden Kugel. Rotiert Farben
  in EGA + modi mit mehr als 4 Farbindizes.

  Params: Keine
}
PROCEDURE RotKugel;
VAR
    aktx, xgroess, ygroess, xinkr : Double;
    cvi, ci, c, rand_farbe, rueck : Integer;
    fuell_flag : Boolean;

BEGIN
    cvi := 0; ci := 0; c := 0;
    xgroess := tmaxy * 0.9 * 2;
    ygroess := xgroess;
    fuell_flag := FuellStatus;
    fuellein( False );
    rueck := naechstfarbindex( 0 );
    xinkr := xgroess / 14;
    rand_farbe := holstiftfarbe;
    randfarbe( rand_farbe );

    { Zeichne Stücke. }
    aktx := xinkr;
    WHILE (aktx <= xgroess) DO
    BEGIN
    ellipse( aktx, ygroess );
    aktx := aktx + (xinkr * 2);
    END;
    fuellein( True );
    stiftkont( False );
    drehen( 90 );
    xgroess := xgroess / 2;
    gehzu( xgroess - xinkr, 0.0 );

    naechstfarbwert( limit );

    { Fülle Stücke. }
    WHILE TAktX >= (-xgroess + xinkr) DO
    BEGIN
    stiftfarbe( naechstfarbindex( vorgabe ) );
    zeichnen;
    Bewegen( -xinkr );
    END;

    WHILE ( hol_taste( nicht_warten ) = 0) DO
    naechstfarbwert( limit );

    stiftkont( True );
    fuellein( fuell_flag );
END; { RotKugel }

{ =========================== Polygone ==============================
  Zeichnet Polygone (fängt mit einem Dreieck an), deren Größe wächst,
  indem die Anzahl der Seiten zunimmt, ohne daß deren Länge zunimmt
  Vergewissern Sie sich, daß der Lichtstift Kontakt hat.

  Parameter: Keine

  Rückgabe : 1 bei Benutzerunterbrechung,
         0 bei Erreichen des Bildschirmrandes

}
FUNCTION Polygone : Boolean;
VAR
    seiten, atrib : Integer;
    dxy : Double;

BEGIN
    seiten := 3;
    atrib := 1;
    dxy := TEinh;
    WHILE True DO
    BEGIN
    stiftfarbe( naechstfarbindex( vorgabe ) );
    Inc( seiten );
    dxy := dxy + 1.5;
    poly( seiten, dxy );
    IF NOT turtlestat THEN
        BEGIN
        Polygone := False;
        Exit;
        END;
    IF ( hol_taste( nicht_warten ) <> 0) THEN
        BEGIN
        Polygone := True;
        Exit;
        END;
    END;
END;  { Polygone }


{ =========================== Spirale ==============================
  Zeichnet eine Spirale, indem es die Länge der Seiten einer rotie-
  renden Figur inkrementiert.

  Parameter: wink   - legt die Weite fest
         xyInkr - legt die Seitenlänge fest

  Rückgabe : 1 bei Benutzerunterbrechung,
         0 bei Erreichen des Bildschirmrandes

}
FUNCTION Spirale( wink : Integer; xyInkr : Double ) : Boolean;
VAR
    xy : Double;

BEGIN
    xy := TEinh;

    WHILE True DO
    BEGIN
    stiftfarbe( naechstfarbindex( vorgabe ) );
    xy := xy + xyInkr;
    Bewegen( xy );
    IF NOT turtlestat THEN
        BEGIN
        Spirale := False;
        Exit;
        END;
    drehen( wink );
    IF (hol_taste( nicht_warten ) <> 0) THEN
        BEGIN
        Spirale := True;
        Exit;
        END;
    END;
END; { Spirale }

{ =========================== InSpirale ==============================
  Zeichnet ein invertierte Spirale, indem jeder Winkel der rotierenden
  Figur vergrößert wird, während die Länger der Seiten konstant ge-
  halten wird.

  Parameter: xy - legen Größe fest
         wink - initialisiert den Winkel
         wink_inkr - legt Weite und Form fest

  Rückgabe : 1 bei Benutzerunterbrechung,
         0 bei Erreichen des Bildschirmrandes
}
FUNCTION InSpirale( xy : Double; wink, wink_inkr : Integer ) : Boolean;
BEGIN
    WHILE True DO
    BEGIN
    stiftfarbe( naechstfarbindex( vorgabe ) );
    Bewegen( xy );
    IF NOT turtlestat THEN
        BEGIN
        InSpirale := False;
        Exit;
        END;
    wink := wink + wink_inkr;
    drehen( wink );
    IF (hol_taste( nicht_warten ) <> 0) THEN
        BEGIN
        InSpirale := True;
        Exit;
        END;
    END;
END; { InSpirale }

{ =========================== Wanze ==================================
  Zeichnet ein geflügelte Wanze und bewegt sie nach einem zufzälligen
  Muster.

  Parameter : keine
}

PROCEDURE Wanze;
TYPE
    puffer_t   = ARRAY[1..65520] OF Byte;

CONST
    flgspitze : _FillMask = ( $81, $3c, $c3, $66, $66, $0f, $f0, $18 );
    flgansatz : _FillMask = ( $66, $0f, $f0, $18, $81, $3c, $c3, $66 );
    leer      : _FillMask = ( $ff, $ff, $ff, $ff, $ff, $ff, $ff, $ff );

VAR
    puffer : ^Byte;
    bldgr  : LongInt;
    stat   : Integer;

BEGIN
    { Draw Wanze. }
    stiftkont( False );
    fuellein( True );
    Bewegen( 40.0 );               { Zeichne und fülle Vorderflügel. }
    drehen( 90 );
    Bewegen( 80.0 );
    stiftfarbe( 1 );
    _SetFillMask( flgspitze );
    ellipse( 172.0, 70.0 );
    drehen( 180 );
    Bewegen( 160.0 );
    ellipse( 172.0, 70.0 );
    drehen(-90 );
    gehzu( 0.0, 0.0 );
    Bewegen( 25.0 );               { Zeichne und fülle Hinterflügel. }
    drehen( 90 );
    Bewegen( 70.0 );
    stiftfarbe( 2 );
    _SetFillMask( flgansatz );
    ellipse( 150.0, 70.0 );
    drehen( 180 );
    Bewegen( 140.0 );
    ellipse( 150.0, 70.0 );
    drehen( -90 );
    gehzu( 0.0, 0.0 );
    _SetFillMask( leer);      { Zeichne Körper. }
    stiftfarbe( 3 );
    randfarbe( 3 );
    ellipse( 52.0, 220.0 );
    stiftfarbe( 1 );              { Drehe Augen. }
    randfarbe( 1 );
    fuellein( False );
    Bewegen( 90.0 );
    drehen( 90 );
    Bewegen( 22.0 );
    kreis( 20.0 );
    stiftfarbe( 0 );
    zeichnen;
    stiftfarbe( 1 );
    drehen( 180 );
    Bewegen( 44.0 );
    kreis( 20.0 );
    stiftfarbe( 0 );
    zeichnen;

    { Gehe zur Position oben rechts des Bildes. }
    gehzu( 0.0, 0.0 );
    drehenin( 0 );
    Bewegen( 120.0 );
    drehen( -90 );
    Bewegen( 175.0 );
    drehen( 90 );

    { Bestimme Größe und reserviere Speicher dafür. }
    bldgr := bildgross( 350.0, 240.0 );
    GetMem( puffer, Word( bldgr ) );
    HolBild( 350.0, 240.0, puffer^ );
    stat := _GrStatus;

    { Bewege zufällig, passe dabei die Ränder an. }
    WHILE (hol_taste( nicht_warten ) = 0) DO
    BEGIN
    IF TAktX <= (-tmaxx + 15.0) THEN
        drehenin( 90 )
    ELSE IF TAktY <= (-tmaxy + 15.0) THEN
        drehenin( 180 )
    ELSE IF TAktX >= (tmaxx - 365.0) THEN
        drehenin( 270 )
    ELSE IF TAktY >= (tmaxy - 255.0) THEN
        drehenin( 0 )
    ELSE
        drehen( zufalls_gen( -20, 20 ) );
    Bewegen( 3.0 );
    ZeigBild( puffer^, _GPSet );
    END;
    FreeMem( puffer, Word( bldgr ) );
END;  { Wanze }

{ ========================= Lade_Modi =================================
  Lädt ein Array mit Menüelementen die alle Graphikmodi repräsentieren,
  die für diesen Graphikkarte gültig sind. Lädt auch ein Array, das
  die Konstanten für jeden Graphikmodus enthält. Die Indizes der
  Arrays sind äquivalent.

  Parameter:
  adapter - Video adapter
  mm      - Array containing menu elements (output)
  ma      - Array containing graphics mode constants (output)
  m       - Preferred initial mode for this adapter (output)

  Rückgabe:
  True, falls das Programm die vorhandene Graphikkarte unterstützt;
    sonst
  False
}
FUNCTION Lade_Modi(      adapter : Integer;
             VAR mm   : element_array_t;
             VAR ma   : modus_array_t;
             VAR m    : Integer ) : Boolean;

BEGIN

    Lade_Modi := True;
    CASE adapter OF
    _OCGA:   { Olivettimodus ein. }
    BEGIN
    ma[0] := _ORescolor;
    mm[0].WTast := 1;
    mm[0].element := 'OREScolor';
    ma[1] := _MRes4Color;
    mm[1].WTast := 5;
    mm[1].element := 'MRES4COLOR';
    ma[2] := _MResNoColor;
    mm[2].element := 'MRESNOCOLOR';
    mm[2].WTast := 5;
    ma[3] := _HResBW;
    mm[3].element := 'HRESBW';
    mm[3].WTast := 5;
    mm[4].element := '';
    m := _MRes4Color;
    END;
    _CGA:    { EGA-Modi aus. }
    BEGIN
    ma[0] := _MRes4Color;
    mm[0].WTast := 5;
    mm[0].element := 'MRES4COLOR';
    ma[1] := _MResNoColor;
    mm[1].element := 'MRESNOCOLOR';
    mm[1].WTast := 5;
    ma[2] := _HResBW;
    mm[2].element := 'HRESBW';
    mm[2].WTast := 5;
    mm[3].element := '';
    m := _MRes4Color;
    END;
    _HGC:
    BEGIN
    ma[0] := _MRes4Color;
    mm[0].WTast := 5;
    mm[0].element := 'MRES4COLOR';
    ma[1] := _MResNoColor;
    mm[1].element := 'MRESNOCOLOR';
    mm[1].WTast := 5;
    ma[2] := _HResBW;
    mm[2].element := 'HRESBW';
    mm[2].WTast := 5;
    ma[3] := _MRes16Color;
    mm[3].element := 'MRES16COLOR';
    mm[3].WTast := 1;
    ma[4] := _HRes16Color;
    mm[4].element := 'HRES16COLOR';
    mm[4].WTast := 1;
    ma[5] := _EResColor;
    mm[5].element := 'ERESCOLOR';
    mm[5].WTast := 1;
    mm[6].element := '';
    m := _HercMono;
    END;
    _OEGA:   { Olivettimodi ein; VGA-Modi aus. }
    BEGIN
    ma[0] := _OResColor;
    mm[0].WTast := 1;
    mm[0].element := 'ORESCOLOR';
    ma[1] := _MRes4Color;
    mm[1].WTast := 5;
    mm[1].element := 'MRES4COLOR';
    ma[2] := _MResNoColor;
    mm[2].element := 'MRESNOCOLOR';
    mm[2].WTast := 5;
    ma[3] := _HResBW;
    mm[3].element := 'HRESBW';
    mm[3].WTast := 5;
    ma[4] := _MRes16Color;
    mm[4].element := 'MRES16COLOR';
    mm[4].WTast := 1;
    ma[5] := _HRes16Color;
    mm[5].element := 'HRES16COLOR';
    mm[5].WTast := 1;
    ma[6] := _EResColor;
    mm[6].element := 'ERESCOLOR';
    mm[6].WTast := 1;
    mm[7].element := '';
    IF vc.Memory > 64 THEN m := _EResColor
    ELSE m := _HRes16Color;
    END;
    _EGA:     { VGA-Modi aus. }
    BEGIN
    ma[0] := _MRes4Color;
    mm[0].WTast := 5;
    mm[0].element := 'MRES4COLOR';
    ma[1] := _MResNoColor;
    mm[1].element := 'MRESNOCOLOR';
    mm[1].WTast := 5;
    ma[2] := _HResBW;
    mm[2].element := 'HRESBW';
    mm[2].WTast := 5;
    ma[3] := _MRes16Color;
    mm[3].element := 'MRES16COLOR';
    mm[3].WTast := 1;
    ma[4] := _HRes16Color;
    mm[4].element := 'HRES16COLOR';
    mm[4].WTast := 1;
    ma[5] := _EResColor;
    mm[5].element := 'ERESCOLOR';
    mm[5].WTast := 1;
    mm[6].element := '';
    IF (vc.Memory > 64) THEN m := _EResColor
    ELSE m := _HRes16Color;
    END;
    _OVGA:    { Olivettimodi ein. }
    BEGIN
    ma[0] := _OResColor;
    mm[0].WTast := 1;
    mm[0].element := 'ORESCOLOR';
    ma[1] := _MRes4Color;
    mm[1].WTast := 5;
    mm[1].element := 'MRES4COLOR';
    ma[2] := _MResNoColor;
    mm[2].element := 'MRESNOCOLOR';
    mm[2].WTast := 5;
    ma[3] := _HResBW;
    mm[3].element := 'HRESBW';
    mm[3].WTast := 5;
    ma[4] := _MRes16Color;
    mm[4].element := 'MRES16COLOR';
    mm[4].WTast := 1;
    ma[5] := _HRes16Color;
    mm[5].element := 'HRES16COLOR';
    mm[5].WTast := 1;
    ma[6] := _EResColor;
    mm[6].element := 'ERESCOLOR';
    mm[6].WTast := 1;
    ma[7] := _VRes2Color;
    mm[7].element := 'VRES2COLOR';
    mm[7].WTast := 5;
    ma[8] := _VRes16Color;
    mm[8].element := 'VRES16COLOR';
    mm[8].WTast := 1;
    ma[9] := _MRes256Color;
    mm[9].element := 'MRES256COLOR';
    mm[9].WTast := 2;
    mm[10].element := '';
    m := _VRes16Color;
    END;
    _VGA:
    BEGIN
    ma[0] := _MRes4Color;
    mm[0].WTast := 5;
    mm[0].element := 'MRES4COLOR';
    ma[1] := _MResNoColor;
    mm[1].element := 'MRESNOCOLOR';
    mm[1].WTast := 5;
    ma[2] := _HResBW;
    mm[2].element := 'HRESBW';
    mm[2].WTast := 5;
    ma[3] := _MRes16Color;
    mm[3].element := 'MRES16COLOR';
    mm[3].WTast := 1;
    ma[4] := _HRes16Color;
    mm[4].element := 'HRES16COLOR';
    mm[4].WTast := 1;
    ma[5] := _EResColor;
    mm[5].element := 'ERESCOLOR';
    mm[5].WTast := 1;
    ma[6] := _VRes2Color;
    mm[6].element := 'VRES2COLOR';
    mm[6].WTast := 5;
    ma[7] := _VRes16Color;
    mm[7].element := 'VRES16COLOR';
    mm[7].WTast := 1;
    ma[8] := _MRes256Color;
    mm[8].element := 'MRES256COLOR';
    mm[8].WTast := 2;
    mm[9].element := '';
    m := _VRes16Color;
    END;

    _MCGA:
    BEGIN
    ma[0] := _MRes4Color;
    mm[0].WTast := 5;
    mm[0].element := 'MRES4COLOR';
    ma[1] := _MResNoColor;
    mm[1].element := 'MRESNOCOLOR';
    mm[1].WTast := 5;
    ma[2] := _HResBW;
    mm[2].element := 'HRESBW';
    mm[2].WTast := 5;
    ma[3] := _VRes2Color;
    mm[3].element := 'VRES2COLOR';
    mm[3].WTast := 5;
    ma[4] := _MRes256Color;
    mm[4].element := 'MRES256COLOR';
    mm[4].WTast := 2;
    mm[5].element := '';
    m := _MRes256Color;
    END;
    ELSE
    Lade_Modi := False;
    END; { case }

END; { Lade_Modi }

{ ====================== Hauptprogramm ============================= }

BEGIN

    { Cursor ausschalten.  Herausfinden der Videokonfiguration, so
      daß der gültige Graphikmodus für das Gerät bestimmt werde kann.
    }
    bool_wert := _DisplayCursor( False );
    _GetVideoConfig( vc );

    zeilen_mitt := vc.NumTextRows DIV 2;
    spalten_mitt := vc.NumTextCols DIV 2;

    { Wähle besten Graphikmodus und starte das Menü mit dem besten
      Modus für dieses Gerät.
    }
    IF NOT(Lade_Modi( vc.Adapter, modus_menu, modus_array, modus )) THEN
    BEGIN
    Writeln( 'Kein Graphikmodus verfügbar.' );
    Halt( 1 );
    END;

    CASE vc.mode OF
    _TextBW80, _TextBW40 :
        farbe := False;
    _TextMono, _HercMono, _EResNoColor :
        BEGIN
        farbe := False;
        IF modus <> _HercMono THEN modus := _EResNoColor;
        haupt_menu[8].element := '';  { Schalte Moduswechsel aus. }
        END;
    ELSE
        farbe := True;
    END; { CASE }

    { Initialisiert Zufallszahlengenerator. }
    Randomize;

    { Initialisiere Hauptmenü und Modusauswahl. }
    aktuelles_hauptm := 0;
    aktueller_modus := 0;
    WHILE (modus <> modus_array[aktueller_modus]) DO
    Inc( aktueller_modus );

    WHILE (True) DO
    BEGIN
    { Setze Textmodus und lösche Bildschirm wahlweise in blau }
    rueck_code := _SetVideoMode( _DefaultMode );
    IF (farbe) THEN  _SetBkColor( LongInt( Blue ) );
    _ClearScreen( _GClearScreen );

    { Wähle vom Menü. }
    zeig_menu( zeilen_mitt, spalten_mitt, haupt_menu,
    aktuelles_hauptm );

    { Setze Graphikmodus, initialisiere die Turtlegraphik und
      zeichne den Rand }
    IF (aktuelles_hauptm <> do_modus_aendern) THEN
        BEGIN
        rueck_code := _SetVideoMode( modus );
        IF (_GrStatus <> _GrOk) THEN
        BEGIN
        GotoXY( spalten_mitt - Length( modus_mldg ) DIV 2, 1 );
        TextColor( Black );
        TextBackground( LightGray );
        Writeln( modus_mldg );
        ITast := hol_taste( warten );
        END;
        bool_wert := _DisplayCursor( False );
        _GetVideoConfig( vc );
        bool_wert := initturtle;
        Rechteck( 2 * tmaxx, 2 * tmaxy );
        END;

    { Springe zur Menüauswahl. }
    CASE aktuelles_hauptm OF
        do_beenden :
        BEGIN
        bool_wert := _DisplayCursor( True );
        rueck_code := _SetVideoMode( _DefaultMode );
        Halt( 0 );
        END;
        do_kreise :
        Kreise;
        do_kugel :
        RotKugel;
        do_tunnel :
        BEGIN
        stiftkont( False );
        gehzu( -tmaxx * 0.2, tmaxy * 0.15 );
        stiftkont( True );
        bool_wert := Polygone;
        WHILE (hol_taste( nicht_warten ) = 0) DO
            naechstfarbwert( vorgabe );  { Rotiere Palette. }
        END;
        do_spirale :
        BEGIN
        IF NOT Spirale( zufalls_gen( 30, 80 ),
                zufalls_gen( 1, 5 ) )
        THEN WHILE (hol_taste( nicht_warten ) = 0) DO
             naechstfarbwert( vorgabe );
        END;
        do_invert_spirale:
        BEGIN
        rueck_code := naechstfarbindex( 0 );
        IF (NOT InSpirale( zufalls_gen( 8, 20 ),
              zufalls_gen( 4, 22 ),
              zufalls_gen( 3, 31 ) )) THEN
            WHILE (hol_taste( nicht_warten ) = 0) DO
            naechstfarbwert( vorgabe );
        END;
        do_wanze :
        Wanze;
        do_anpassen :
        anpassen;
        do_modus_aendern :
        BEGIN
        IF (farbe) THEN _SetBkColor( Blue );
        _ClearScreen( _GClearScreen );
        zeig_menu( zeilen_mitt, spalten_mitt, modus_menu,
               aktueller_modus );
        modus := modus_array[aktueller_modus];
        END;  { Case Wechsel2 }
    END; { case }
    END; { WHILE true }
END.