PROGRAM Schule;

{$M 10000,20000,20000}

{Beispiel f�r die Verwaltung einer Klassenstufe

written by Frank Riemenschneider
           Postfach 730309
           3000 Hannover 71}


USES dos,portcrt;


(**************************** Konstanten ***************************)

CONST
  zeit_8   =  8.30;        { Normalzeit Klasse 8 - hier als Beispiel }
  bon_8    =  30;          { Vorgabe der M„. Klasse 8 - ebenso }
  tab      :  array[1..7] of byte = (1, 4, 16, 27, 31, 33, 35);
  maxzeile     = 23;
  anfangszeile = 4;      { ..der Bildschirmausgabe ohne šberschrift }
  fullstern : string[80] = '********************************************************************************';
  randstern : string[1] = '*';
  ASCII = 0;
  Scan = 1;


(**************************** Typ Deklarationen *******************)

TYPE
       Schuelerdaten = RECORD                      { zur Datensicherung }
          Klassenbezeichnung        : string[7];
          Klassennummer             : byte;
          Nummer                    : byte;
          Nachname                  : string[18];
          Vorname                   : string[18];
          genus                     : boolean;
          angemeldet                : boolean;
          teilgenommen              : boolean;
          Laufzeit                  : real;
       END;


(*************************Objekttyp Deklarationen *******************)

TYPE
       Name = OBJECT
          nachname, vorname         : string[18];
          zeile, Xn, Xv             : byte;
          CONSTRUCTOR init(nachn, vorn: string);
          FUNCTION getnachn: string;
          FUNCTION getvorn: string;
          FUNCTION getzeile: byte;
          PROCEDURE putzeile(zl: integer);
          PROCEDURE anlegen(zl: byte); virtual;
          FUNCTION z: byte;         { diese beiden Funktionen ermitteln...}
          FUNCTION seite: byte;     {...auf welcher Bildschirmh„lfte... }
          PROCEDURE Ausgabe;virtual; {...die Ausgabe erfolgen soll }
       END;


      Person = OBJECT(Name)
          genus                     : boolean;         { M„dchen/Junge }
          Xg                        : byte;
          CONSTRUCTOR init(nachn, vorn: string; gen: boolean);
          FUNCTION getgen:boolean;
          PROCEDURE anlegen(zl: byte); virtual;
          PROCEDURE ausgabe; virtual;
       END;

       Teilnehmer = OBJECT(Person)
          angemeldet, teilgenommen  : boolean;
          Laufzeit                  : real;
          Xa, Xt, Xl                : byte;
          CONSTRUCTOR init(nachn, vorn: string; gen: boolean;
                           ang, tlg: boolean; lz: real);
          FUNCTION getang: boolean;
          FUNCTION gettlg: boolean;
          FUNCTION getlz: real;
          PROCEDURE tg;
          PROCEDURE ntg;
          PROCEDURE ummelden;
          PROCEDURE ausgabe; virtual;
          PROCEDURE lieszeit;
       END;

              scPtr    = ^Schueler;
              knPtr    = ^knoten;
       knoten   = RECORD
          next           : knPtr;
          item           : scPtr;
       END;


       Schueler     = OBJECT(Teilnehmer)
          Klassennummer, Xkl        : byte;
          nummer, Xnr               : byte;
          Klassenbezeichnung        : string[7];
          Zkbz, Xkbz                : byte;
          CONSTRUCTOR init(nachn, vorn, klbz: string; bon, ang, tlg: boolean;
                           lz: real; nr, klnr: byte);
          FUNCTION getnr: byte;
          FUNCTION getklnr: byte;
          FUNCTION getklbz: string;
          DESTRUCTOR done; virtual;
          PROCEDURE ausgabe; virtual;
          PROCEDURE ausgabe2; virtual;  {Ausgabe f�r die Jahrg. - Bestenl.}
          PROCEDURE anlegen(zl: byte); virtual;
          PROCEDURE maske;
       END;


       Jahrgangsliste = OBJECT
          CONSTRUCTOR init;
          PROCEDURE load;
          PROCEDURE store;
          PROCEDURE add(VAR K: knPtr; S: scPtr);
          PROCEDURE sortieren(VAR K: knPtr);
          PROCEDURE loeschen(klnr, nr: byte);
          PROCEDURE meldum(klnr, nr: byte);
          PROCEDURE ausgeben;   { wird noch nicht verwendet }
          DESTRUCTOR done; virtual;
       END;

       Jahrgangsbestenliste = OBJECT(Jahrgangsliste)
          start             : knPtr;
          CONSTRUCTOR init;
          PROCEDURE einsammeln(gen: boolean);
          PROCEDURE sortieren(VAR K: knPtr);
          PROCEDURE ausgeben;
          PROCEDURE herstellen;
          DESTRUCTOR done; virtual;
       END;


       Klassenbestenliste = OBJECT(Jahrgangsbestenliste)
          CONSTRUCTOR init;
          PROCEDURE einsammeln(gen: boolean; klnr: byte);
          PROCEDURE herstellen(klnr: byte);
       END;


       Klassenliste   = OBJECT(Jahrgangsliste)
          anfang                    : knPtr;
          CONSTRUCTOR init;
          FUNCTION ausgeben(klnr: byte): knPtr;
          PROCEDURE listeanlegen(klnr: byte);
          PROCEDURE numerieren(klnr: byte);
          PROCEDURE loeschen(klnr: byte);
          PROCEDURE ummelden(klnr: byte);
          PROCEDURE zeiteingeben(klnr: byte);
          FUNCTION durchschnitt(klnr: byte): string;
       END;


(*********************** Variablen ************************)

VAR
       modus                       : byte;
       wahl                        : string;
       SCR                         : knPtr;
       temp: string;
       root                        : knPtr;
       Einejahrgangsliste          : Jahrgangsliste;
       Einejahrgangsbestenliste    : Jahrgangsbestenliste;
       Eineklassenbestenliste      : Klassenbestenliste;
       Eineklassenliste            : Klassenliste;


{********* Methoden des Typs "Name" *******************}

CONSTRUCTOR Name.init(nachn, vorn: string);
BEGIN
  nachname := nachn;
  vorname  := vorn;
  zeile    := anfangszeile;
  Xn       := tab[2] ;
  Xv       := tab[3] ;
END;


FUNCTION Name.getnachn: string;
BEGIN
  getnachn := nachname;
END;


FUNCTION Name.getvorn: string;
BEGIN
  getvorn := vorname;
END;


FUNCTION Name.getzeile: byte;
BEGIN
  getzeile := zeile;
END;


PROCEDURE Name.putzeile(zl: integer);
BEGIN
  zeile := zl;
END;


FUNCTION Name.seite: byte;
BEGIN
  IF zeile < maxzeile THEN seite := 0
  ELSE seite := 40;
END;


FUNCTION Name.z: byte;
BEGIN
  IF zeile < maxzeile THEN z := zeile
  ELSE z := zeile - maxzeile + anfangszeile;
END;


FUNCTION LesTaste(modus: byte) : byte;
VAR reg : registers;
BEGIN
   IF modus = 0 THEN BEGIN
     reg.ah := 0;
     intr(22,reg);
     LesTaste := reg.al;
   END
   ELSE BEGIN
     LesTaste := reg.ah;
   END;
END;


PROCEDURE Eingabe(var ss: string; x,y,maxlaenge,
                  numerisch : byte; vs: string);
VAR taste : byte;
posi,code,laenge : byte;
i : byte;
flag : boolean;
BEGIN
  GotoXY(x,y);
  FOR i:= 1 TO maxlaenge DO begin
    write(' ');
  end;
  GotoXY(x,y);
  write(vs);
  GotoXY(x,y);
  ss:= vs;
  laenge := length(ss);
  posi := 0;
  flag := true;
  REPEAT
    GotoXY(x+posi,y);
    taste := Ord(LesTaste(ASCII));               {ASCII-Code holen}
    code := Ord(LesTaste(scan));
    IF flag THEN begin
      IF ((code <> $1C) and (code <> $0E)
          and (code <> $52) and (code <> $53)
          and (code <> $4B) and (code <> $4D)
          and (code <> $47) and (code <> $4F)) then begin
        FOR i:= 1 TO maxlaenge DO begin
          write(' ');
        END;
        ss := '';
        laenge := 0;
        GotoXY(x,y);
      END;
    END;
    flag := false;

   IF (((laenge < maxlaenge) or (posi < laenge))
      and ((taste >31) and (taste<156))
      and ((numerisch<>0) or ((taste = 43) or
      (taste = 46) or ((taste >47) and (taste<58)))))
      THEN BEGIN
             IF posi = laenge THEN BEGIN
                 inc(laenge);
                 inc(ss[0]);
             END;
             inc(posi);
             write(chr(taste));
             ss[posi] := chr(taste);
   END;


    {Hier beginnen, wenn Backspace gedr�ckt. (šber Scan-Code)}

    CASE code OF


       $0E : BEGIN
              IF posi > 0 THEN BEGIN
                dec(posi);
                dec(laenge);
                ss := Copy(ss,1,posi)+Copy(ss,posi+2,100);
                GotoXY(x,y);
                write(ss+' ');
               END;
             END;

       $53 : BEGIN
              IF posi < laenge THEN BEGIN
                dec(laenge);
                ss := Copy(ss,1,posi)+Copy(ss,posi+2,100);
                GotoXY(x,y);
                write(ss+' ');
               END;
             END;

       $4B : IF posi > 0 THEN dec(posi);
       $4D : IF posi < laenge THEN inc(posi);

       $52 : BEGIN
              IF ((laenge < maxlaenge) and (posi < laenge)) THEN BEGIN
                ss := Copy(ss,1,posi)+' '+Copy(ss,posi+1,100);
                GotoXY(x,y);
                write(ss);
                inc(laenge);
              END;
             END;

       $47 : posi := 0;
       $4F : posi := laenge;

    END;

  UNTIL code = $1C;         {Abschluá mit RETURN}
END;


PROCEDURE Standardbild;
VAR i : byte;
BEGIN
   ClrScr;
   write(fullstern);
   GotoXY(0,2);
   write('***************************** M & T  SCHšLERSPORT ******************************');
   GotoXY(0,4);
   write('************ (C)opyright 1990 by Markt & Technik Aktiengesellschaft ************');
   GotoXY(0,6);
   write(fullstern);
   GotoXY(0,0);
   FOR i := 0 to 22 DO BEGIN
     write(randstern);
     GotoXY(79,i);
     write(randstern);
   END;
   write(fullstern);
END;

PROCEDURE Name.anlegen(zl: byte);
VAR s : string;
BEGIN
  zeile := zl;
  gotoxy(Xn + seite, z);
  Eingabe(s,Xn+seite,z,12,1,'');
  Nachname := s;
  gotoxy(Xv + seite, z);
  Eingabe(s,Xv+seite,z,10,1,'');
  Vorname := s;
END;


PROCEDURE Name.ausgabe;
BEGIN
  gotoxy(Xn + seite, z);
  write(Nachname);
  gotoxy(Xv + seite, z);
  write(Vorname);
END;


{********* Methoden des Objekttyps "Person"********}

CONSTRUCTOR Person.init(nachn, vorn: string; gen: boolean);
BEGIN
  genus := gen;
  Xg    := tab[4];
  Name.init(nachn, vorn);
END;


FUNCTION Person.getgen: boolean;
BEGIN
  getgen := genus;
END;


PROCEDURE Person.anlegen(zl: byte);
VAR ch : char;
s : string;
BEGIN
  zeile := zl;
  Name.anlegen(zeile);
  gotoxy(Xg + seite, z);
    REPEAT                                          { genus einlesen }
      Eingabe(s,Xg+seite,z,1,1,'');
      ch := Upcase(s[1]);
    UNTIL (ch = 'M') or (ch = 'J');
    gotoxy(Xg + seite, z);
    IF ch = 'M' THEN
    BEGIN
      genus := TRUE;
      write('M');
    END
    ELSE
    BEGIN
      genus := FALSE;
      write(' J');
    END;
END;


PROCEDURE Person.ausgabe;
BEGIN
  gotoxy(Xg + seite, z);
     IF genus = TRUE THEN write ('M')
      ELSE write(' J');
  Name.ausgabe;
END;


{********* Methoden von "Teilnehmer" ******************}

CONSTRUCTOR Teilnehmer.init(nachn, vorn: string; gen: boolean;
                       ang, tlg: boolean; lz: real);
BEGIN
  angemeldet   := ang;
  teilgenommen := tlg;
  laufzeit     := lz;
  Xa           := tab[5];
  Xt           := tab[6];
  Xl           := tab[7];
  Person.init(nachn, vorn, gen);
END;


FUNCTION Teilnehmer.getang:boolean;
BEGIN
  getang := angemeldet;
END;


FUNCTION Teilnehmer.gettlg: boolean;
BEGIN
  gettlg := teilgenommen;
END;


FUNCTION Teilnehmer.getlz: real;
BEGIN
  getlz := laufzeit;
END;


PROCEDURE Teilnehmer.tg;
BEGIN
  teilgenommen := TRUE;
END;


PROCEDURE Teilnehmer.ntg;
BEGIN
  teilgenommen := FALSE;
END;


PROCEDURE Teilnehmer.ummelden;
BEGIN
  angemeldet := NOT angemeldet;
  IF angemeldet = FALSE THEN laufzeit := 0.00;
END;


PROCEDURE Teilnehmer.lieszeit;
VAR
 t : real;
 s : string;
 i : integer;
BEGIN
  IF angemeldet = FALSE THEN laufzeit := 0.00   ELSE
  BEGIN
    IF teilgenommen = FALSE THEN laufzeit := zeit_8   ELSE
    BEGIN
      gotoxy(Xl + seite, z);
      readln(s);
      val(s, t, i);
      IF (t >= 3) and (t < 10.00) and (i = 0) and (frac(t) < 0.6) THEN BEGIN
        laufzeit := t
      END
      ELSE BEGIN
        gotoxy(1, 23);
        write('*************************** Falsche Eingabe!!! ***************************');
        lieszeit;
      END;
    END;
  END;
END;


PROCEDURE Teilnehmer.ausgabe;
BEGIN
  Person.ausgabe;
  gotoxy(Xa + seite, z); IF angemeldet = TRUE THEN write('J')
                                                ELSE write('N');
  gotoxy(Xt + seite, z); IF teilgenommen = TRUE THEN write('J')
                                                ELSE write('N');
  gotoxy(Xl + seite, z); write(laufzeit:4:2);
END;


{****************** Methoden von "Schueler" **************************}

CONSTRUCTOR Schueler.init(nachn, vorn, klbz: string; bon, ang, tlg: boolean;
                           lz: real; nr, klnr: byte);

BEGIN
    Klassenbezeichnung   := klbz;
    Xkbz                 := 30;
    Zkbz                 := 1;
    nummer               := nr;
    Klassennummer        := klnr;
    Xnr                  := tab[1];
    Teilnehmer.init(nachn, vorn, bon, ang, tlg, lz);
END;


FUNCTION Schueler.getklbz: string;
BEGIN
  getklbz := Klassenbezeichnung;
END;


FUNCTION Schueler.getnr: byte;
BEGIN
  getnr := nummer;
END;


FUNCTION Schueler.getklnr: byte;
BEGIN
  getklnr := Klassennummer;
END;


DESTRUCTOR Schueler.done;
BEGIN
END;


PROCEDURE Schueler.ausgabe;
BEGIN
  gotoxy(Xnr + seite, z);
  write(nummer);
  Teilnehmer.ausgabe;
END;


PROCEDURE Schueler.ausgabe2;
BEGIN
  gotoxy(Xnr + seite, z);
  write(nummer);
  Name.ausgabe;
  gotoxy(Xg + seite, z);
  write(Klassenbezeichnung);
  gotoxy(Xl + seite, z);
  write(laufzeit:4:2);
END;


PROCEDURE Schueler.anlegen(zl: byte);
VAR

  s    : string;
  nr   : longint;
  code : integer;
BEGIN
  zeile := zl;
  REPEAT
    gotoxy(Xnr + seite, z);
    Eingabe(s,xnr+seite,z,3,0,'');
    val(s, nr, code);
  UNTIL (code = 0) and (nr >= 0) and (nr <= 255);
  nummer := nr;
  Person.anlegen(zeile);
END;


PROCEDURE Schueler.maske;
CONST
  text: array[1..7] of string[20] =
      ('Nr ', 'Nachname    ','Vorname  ','M/J  ','A ', 'T ', 'Zeit  ');

VAR
  i: byte;
BEGIN
  ClrScr;
  gotoxy(1,2);
  FOR i := 1 to 7 DO
  BEGIN
    write(text[i]);
  END;
  FOR i := 1 to 7 DO
  BEGIN
    write(text[i]);
  END;
END;


{****************** Methoden von Jahrgangsliste *******************************}

CONSTRUCTOR Jahrgangsliste.init;
BEGIN
END;


PROCEDURE Jahrgangsliste.add(VAR K: knPtr; S: scPtr);
VAR
  KN : knPtr;

BEGIN
    KN := NEW(knPtr);
    KN^.next := K;
    KN^.Item := S;
    K := KN;
END;


PROCEDURE Jahrgangsliste.sortieren(VAR K: knPtr);
VAR
  KN, L: knPtr;
  temp : scPtr;
BEGIN
  KN := K;
  WHILE KN^.next <> NIL DO
  BEGIN
    L := KN^.next;
    WHILE L <> NIL DO
    BEGIN
      IF KN^.item^.getnachn > L^.item^.getnachn THEN
      BEGIN
        temp := KN^.item;
        KN^.item := L^.item;
        L^.item := temp;
      END;
      L := L^.next;
    END;
  KN := KN^.next;
  END;
END;


PROCEDURE Jahrgangsliste.loeschen(klnr, nr: byte);
VAR
  K : knPtr;
BEGIN
  IF (root^.item^.getklnr = klnr) and (root^.item^.getnr = nr) THEN
  root := root^.next ELSE
  BEGIN
    K := root;
    WHILE K^.next <> NIL DO
    BEGIN
      IF (K^.next^.item^.getklnr = klnr) and (K^.next^.item^.getnr = nr) THEN
      K^.next := K^.next^.next;
      IF K^.next <> NIL THEN K := K^.next;
    END;
  END;
END;


PROCEDURE Jahrgangsliste.meldum(klnr, nr: byte);
VAR
  K : knPtr;
BEGIN
  K := root;
  WHILE K <> NIL DO
  BEGIN
    IF (K^.item^.getklnr = klnr) and (K^.item^.getnr = nr) THEN
      BEGIN
        K^.item^.ummelden;
        exit;
      END
    ELSE
      K := K^.next;
  END;
END;


PROCEDURE Jahrgangsliste.ausgeben;
VAR
  K : knPtr;
  N : Teilnehmer;
  sc: Schueler;
  i : byte;
BEGIN
  K := root;
  i := anfangszeile;
  WHILE K <> NIL DO           { zuerst die richtigen Zeilen setzen }
  BEGIN
    K^.item^.putzeile(i);
    inc(i);
    K := K^.next;
  END;
  sc.maske;
  K := root;
  WHILE K <> NIL DO
  BEGIN
    K^.item^.ausgabe;
    K := K^.next;
    inc(i);
  END;
END;


PROCEDURE Jahrgangsliste.load;

VAR
  s : string;
  scdat : Schuelerdaten;
  f     : file of Schuelerdaten;
BEGIN
  GotoXY(15,22);
  write('Dateiname : <                                                  >');
  Eingabe(s,28,22,50,1,'');
  assign(f,s);
  {$I-}                      { Fehlererkennung aus }
  reset(f);
  { $I+}                     {          ...    ein }
  IF ioResult = 0 THEN
  BEGIN
    WHILE not EOF(f) DO
    BEGIN
      read(f, scdat);
      with scdat DO
      BEGIN
        add(root,NEW(scPtr,init(nachname, vorname, Klassenbezeichnung,
        genus, angemeldet, teilgenommen, laufzeit, nummer, Klassennummer)));
      END;
    END;
    sortieren(root);
    close(f);
  END
  ELSE
  BEGIN
    GotoXY(15,22);
    write('Dateifehler - bitte <RTN> dr�cken!                             ');
    readln;
  END;
Standardbild;
END;


PROCEDURE Jahrgangsliste.store;
VAR
  s : string;
  K     : knPtr;
  scdat : Schuelerdaten;
  f     : file of Schuelerdaten;
BEGIN
  GotoXY(15,22);
  write('Dateiname : <                                                  >');
  Eingabe(s,28,22,50,1,'');
  assign(f,s);
  {$I-}                     { Fehlerkennung aus }
  rewrite(f);
  {$I+}                     {       ...wieder an}
  IF ioResult = 0 THEN
  BEGIN
    K := root;
    WHILE K <> NIL DO
    BEGIN
        with scdat DO
        BEGIN
          Klassenbezeichnung := K^.item^.getklbz;
          Klassennummer      := K^.item^.getklnr;
          nummer             := K^.item^.getnr;
          nachname           := K^.item^.getnachn;
          vorname            := K^.item^.getvorn;
          genus              := K^.item^.getgen;
          angemeldet         := K^.item^.getang;
          teilgenommen       := K^.item^.gettlg;
          laufzeit           := K^.item^.getlz;
        END;
        write(f, scdat);
        K := K^.next;
     END;
    close(f);
  END
  ELSE
  BEGIN
    GotoXY(15,22);
    write('Dateifehler - bitte <RTN> dr�cken!                             ');
    readln;
  END;
END;


DESTRUCTOR Jahrgangsliste.done;
VAR
  K : knPtr;
BEGIN
  WHILE root <> NIL DO
  BEGIN
    K := root;
    dispose(K^.item, done);
    root := K^.next;
    dispose(K);
  END;
END;


{*********************** Methoden von Jahrgangsbestenliste **************************}

CONSTRUCTOR Jahrgangsbestenliste.init;
BEGIN
  start := NIL;
  Jahrgangsliste.init;
END;


PROCEDURE Jahrgangsbestenliste.einsammeln(gen: boolean);
VAR
  A : knPtr;
  S : scPtr;
BEGIN
  A  := root;
  WHILE (A <> NIL) DO
  BEGIN
    IF (A^.Item^.getgen = gen) and (A^.Item^.getang = TRUE)
       and (A^.Item^.gettlg = TRUE) and (A^.Item^.getlz > 3)
       THEN                        { nur tats„chliche Teilnehmer z„hlen }
       BEGIN                       { neuen Zeiger anlegen }
         S := NEW(scPtr, init(A^.item^.getnachn, A^.item^.getvorn,
                       A^.item^.getklbz, A^.item^.getgen, A^.item^.getang,
                       A^.item^.gettlg, A^.item^.getlz, A^.item^.getnr,
                       A^.item^.getklnr));
         add(start, S);               { die Liste verl„ngern }
       END;
       A := A^.next;
  END;
END;


PROCEDURE Jahrgangsbestenliste.sortieren(VAR K: knPtr);
VAR
  KN, L: knPtr;
  temp : scPtr;
BEGIN
  KN := K;
  WHILE KN^.next <> NIL DO
  BEGIN
    L := KN^.next;
    WHILE L <> NIL DO
    BEGIN
      IF KN^.item^.getlz > L^.item^.getlz THEN
      BEGIN
        temp := KN^.item;
        KN^.item := L^.item;
        L^.item := temp;
      END;
      L := L^.next;
    END;
  KN := KN^.next;
  END;
END;


PROCEDURE Jahrgangsbestenliste.ausgeben;
VAR
  S : knPtr;
  i : integer;
BEGIN                          { zuerst richtige Platzziffern festlegen }
  sortieren(start);
  S := start;
  i := 1;
  WHILE S <> NIL DO
  BEGIN
    S^.item^.nummer := i;
    IF (S^.item^.getlz <> S^.next^.item^.getlz) THEN
      inc(i);                         { gleiche Zeiten - gleiche Ziffern }
    S := S^.next;
  END;

  S := start;
  i := anfangszeile;
  WHILE S <> NIL DO         { zuerst die richtigen Zeilen festlegen }
  BEGIN
    IF S^.item^.getgen = FALSE THEN
      S^.Item^.putzeile(i + maxzeile - anfangszeile)
    ELSE
      S^.Item^.putzeile(i);
    S := S^.next;
    inc(i);
  END;
  gotoxy(15, 2);
  write('M„dchen               Bestenliste              Jungen');
  S := start;
  WHILE S <> NIL DO                { Ausgabe der Liste }
  BEGIN
    S^.item^.ausgabe2;
    S := S^.next;
  END;
END;


DESTRUCTOR Jahrgangsbestenliste.done;
VAR
  K : knPtr;
BEGIN
  WHILE start <> NIL DO
  BEGIN
    K := start;
    dispose(K^.item, done);
    start := K^.next;
    dispose(K);
  END;
END;


PROCEDURE Jahrgangsbestenliste.herstellen;  { eine Art Hauptprogramm }
BEGIN
  einsammeln(TRUE);
  ausgeben;
  done;
  einsammeln(FALSE);
  ausgeben;
  done;
END;


{********************* Methoden von Klassenbestenliste **********************}

CONSTRUCTOR Klassenbestenliste.init;
BEGIN
  Jahrgangsbestenliste.init;
END;


PROCEDURE Klassenbestenliste.einsammeln(gen: boolean; klnr: byte);
VAR
  A : knPtr;
  S : scPtr;
BEGIN
  A  := root;
  WHILE (A <> NIL) DO
  BEGIN
    IF (A^.Item^.getgen = gen) and (A^.Item^.getang = TRUE)
       and (A^.Item^.gettlg = TRUE) and (A^.Item^.getlz > 3)
       and (A^.item^.getklnr = klnr)
       THEN                        { nur tats„chliche Teilnehmer z„hlen }
       BEGIN                       { neuen Zeiger anlegen }
         S := NEW(scPtr, init(A^.item^.getnachn, A^.item^.getvorn,
                       A^.item^.getklbz, A^.item^.getgen, A^.item^.getang,
                       A^.item^.gettlg, A^.item^.getlz, A^.item^.getnr,
                       A^.item^.getklnr));
         add(start, S);               { die Liste verl„ngern }
       END;
       A := A^.next;
  END;
END;

PROCEDURE Klassenbestenliste.herstellen(klnr: byte); {eine Art Hauptprogramm}
BEGIN
  einsammeln(TRUE, klnr);
  ausgeben;
  done;
  einsammeln(FALSE, klnr);
  ausgeben;
  done;
END;


{******************** Methoden von Klassenliste *****************************}

CONSTRUCTOR Klassenliste.init;
BEGIN
  Jahrgangsliste.init;
END;


FUNCTION Klassenliste.ausgeben(klnr: byte): knPtr;
VAR
  S, temp : knPtr;
  i : integer;
  sc : Schueler;
BEGIN
  sortieren(root);        { die sortierte Liste bearbeiten }
  S := root;
  i := anfangszeile;
  WHILE S <> NIL DO       { zuerst die richtigen Zeilen festlegen }
  BEGIN
    IF S^.item^.getklnr = klnr THEN
       BEGIN
         S^.Item^.putzeile(i);
         inc(i);
         S := S^.next;
       END
    ELSE S := S^.next;
  END;

  sc.maske;
  S := root;
  temp := root;
  WHILE S <> NIL DO           { Liste ausgeben }
  BEGIN
    IF S^.item^.getklnr = klnr THEN
       BEGIN
         S^.Item^.ausgabe;
         temp := S;
         S := S^.next;
       END
    ELSE S := S^.next;
  END;
  ausgeben := temp;
  IF temp <> root THEN
  BEGIN
    gotoxy(20, 1);
    write('Klassenbezeichnung:   ', temp^.item^.getklbz);
  END;
END;


PROCEDURE Klassenliste.listeanlegen(klnr: byte);
VAR
  K    : knPtr;
  N    : scPtr;
  sc   : Schueler;
  klbz,s : string;
  ch   : char;
  zl   : byte;
  jgl  : Jahrgangsliste;
BEGIN
  sc.maske;
  K := ausgeben(klnr);        { zuerst mal zeigen, was da ist }
  IF K = root THEN
    BEGIN
      zl := anfangszeile;
      gotoxy(20, 1);
      write('Klassenbezeichnung :  <   >');
      Eingabe(klbz,43,1,3,1,'');
    END
  ELSE
    BEGIN
      zl := K^.item^.getzeile + 1; { bei der n„chsten Zeile geht es weiter }
      klbz := K^.item^.getklbz;
    END;
  REPEAT
    N := NEW(scPtr, init('', '',klbz, TRUE, TRUE, FALSE, zeit_8, 1, klnr));
    N^.anlegen(zl);
    gotoxy(1, 23);
    write('****************** Weiter: <W>   Abbruch: <A>   Menue: <M> ******************');
    REPEAT
      ch := Upcase(chr(LesTaste(ASCII)));
    UNTIL (ch = 'W') or (ch = 'A') or (ch = 'M');
    gotoxy(1, 25);
    IF ch = 'A' THEN exit;                 { zur�ck ohne zu speichern }
    jgl.add(root, N);
    IF ch = 'W' THEN inc(zl);                    { weiter eingeben }
    IF ch = 'M' THEN                             { aufh”ren }
       BEGIN
         gotoxy(1, 23);
         write('*********************** Soll neu numeriert werden? (J/N) *********************');
         REPEAT
           ch := upcase(chr(LesTaste(ASCII)));
         UNTIL (ch = 'J') or (ch = 'N');
         IF ch = 'J' THEN numerieren(klnr);
         exit;
       END;
  UNTIL zl = 50;
END;


PROCEDURE Klassenliste.numerieren(klnr: byte);
VAR
  i : byte;
  K : knPtr;
  jl: Jahrgangsliste;
BEGIN
  sortieren(root);
  K := root;
  i := 1;
  WHILE K <> NIL DO
  BEGIN
    IF K^.item^.getklnr = klnr THEN
       BEGIN
         K^.Item^.nummer:= i;
         inc(i);
         K := K^.next;
       END
    ELSE K := K^.next;
  END;
END;


PROCEDURE Klassenliste.loeschen(klnr: byte);
VAR
  K     : knPtr;
  jgl   : Jahrgangsliste;
  i     : byte;
  nr    : longint;
  s     : string;
  code  : integer;
  ch    : char;
BEGIN
  K := ausgeben(klnr);
  IF K = root THEN
  BEGIN
    gotoxy(5, 5);
    write ('Keine Klassenliste vorhanden!!   <RTN>  dr�cken!');
    readln;
    exit;
  END;
  gotoxy(1, 23);
  write('************** Welche Nummer soll gel”scht werden ? : <   > ***************');
  REPEAT
    Eingabe(s,56,23,3,0,'');
    val(s, nr, code);
  UNTIL (code = 0) and (nr > 0) and (nr <= 255);
  jgl.loeschen (klnr, nr);
  K := ausgeben(klnr);
  gotoxy(1, 23);
  write('************************** Weiter: <W>   Menue: <M> **************************');
  REPEAT
    ch := upcase(chr(LesTaste(ASCII)));
  UNTIL (ch = 'W') or (ch = 'M');
  IF ch = 'M' THEN                                { aufh”ren }
  BEGIN
    gotoxy(1, 23);
    write('********************** Soll neu nummeriert werden? (J/N) *********************');
    REPEAT
      ch := upcase(chr(LesTaste(ASCII)));
    UNTIL (ch = 'J') or (ch = 'N');
    IF ch = 'J' THEN numerieren(klnr);
    exit;
  END;
  IF ch =  'W' THEN loeschen(klnr);
END;


PROCEDURE Klassenliste.ummelden(klnr: byte);
VAR
  K     : knPtr;
  i     : byte;
  nr    : longint;
  ch    : char;
  s     : string;
  code  : integer;
BEGIN
  K := ausgeben(klnr);
  IF K = root THEN
  BEGIN
    gotoxy(5, 5);
    write ('Keine Klassenliste vorhanden!!   <RTN>  dr�cken!');
    readln;
    exit;
  END;
  gotoxy(1, 23);
  write('************* Welche Nummer soll umgemeldet werden? : <   > *****************');
    REPEAT
      Eingabe(s,57,23,3,0,'');
      val(s, nr, code);
    UNTIL (code = 0) and (nr > 0) and (nr <= 255);
    meldum(klnr, nr);
    K := ausgeben(klnr);
    gotoxy(1, 23);
    write('************************** Weiter: <W>   Menue: <M> **************************');
    REPEAT
      ch := upcase(chr(LesTaste(ASCII)));
    UNTIL (ch = 'W') or (ch = 'M');
    IF ch = 'M' THEN exit;
    IF ch = 'W' THEN ummelden(klnr);
END;


PROCEDURE Klassenliste.zeiteingeben(klnr: byte);
VAR
  S   : scPtr;
  ch  : char;
  K   : knPtr;
  ss : string;

FUNCTION springen: knPtr;
VAR
  s : string;
  nr : byte;
  K  : knPtr;
  code : word;
BEGIN
  gotoxy(1, 23);
  write('********** Zu welcher Nummer soll gesprungen werden? : <   > **********');
  Eingabe(s,58,23,3,0,'');
  val(s,nr,code);
  K := root;
  WHILE K <> NIL DO
  BEGIN
    IF (K^.item^.getklnr = klnr) and (K^.item^.getnr = nr) THEN
      BEGIN
        springen := K;
        exit;
      END
    ELSE  K := K^.next;
  END;
  springen := K;
END;

BEGIN
  K := ausgeben(klnr);         { zuerst die ganze Liste ausgeben }
  K := root;
  WHILE K <> NIL  DO
  BEGIN
    IF (K^.item^.getklnr = klnr) THEN
    BEGIN
      IF (K^.item^.getang = TRUE) THEN
      BEGIN
        gotoxy(1, 23);
        write('************** Springen: <S>  Weiter: <W>  Teilgenommen: <J/N> *************');
        gotoxy(K^.item^.Xt + K^.item^.seite, K^.item^.z);   {an die r. Pos.}
        REPEAT
          ch := Upcase(chr(LesTaste(ASCII)));
        UNTIL (ch = 'S') or (ch = 'W') or (ch = 'J') or (ch = 'N');
        IF ch = 'S' THEN
        BEGIN
          K := springen;
          IF K = NIL THEN exit;
          gotoxy(1, 23);
          write('****************** Weiter: <W>    Teilgenommen: <J/N>  ******************');
          gotoxy(K^.item^.Xt + K^.item^.seite, K^.item^.z); {an die r. Pos.}
          REPEAT
            ch := Upcase(chr(LesTaste(ASCII)));
          UNTIL (ch = 'W') or (ch = 'J') or (ch = 'N');
          IF ch = 'J' THEN K^.item^.tg;
          IF ch = 'N' THEN K^.item^.ntg;
          K^.item^.ausgabe; K^.item^.lieszeit; K^.item^.ausgabe;
        END
        ELSE
        BEGIN
          IF ch = 'J' THEN K^.item^.tg;
          IF ch = 'N' THEN K^.item^.ntg;
          K^.item^.ausgabe; K^.item^.lieszeit; K^.item^.ausgabe;
        END;
        gotoxy (1, 23);
        write('************************* Weiter: <W>   Men�: <M>  *************************');
        REPEAT
          ch := upcase(chr(LesTaste(ASCII)));
        UNTIL (ch = 'W') or (ch = 'M');
        IF ch = 'M' THEN exit;
      END
      ELSE K^.item^.lieszeit;
    END;
    K := K^.next;
  END;
END;


FUNCTION Klassenliste.durchschnitt(klnr: byte): string;
VAR
  K : knPtr;
  i : byte;                          { Z„hlvariable }
  sum : real;                        { Summe }
  text1, text2 : string[2];
FUNCTION sekunde: real;             { wandelt die eingetragene Laufzeit..}
BEGIN                               { .. in Sekunden um }
  sekunde := trunc(K^.item^.getlz) * 60 + frac(K^.item^.getlz) * 100;
END;
BEGIN
  K := root; i := 0; sum := 0;     { Initialisierungen }
  WHILE K <> NIL DO
  BEGIN
    IF (K^.item^.getang = TRUE) and (K^.item^.getklnr = klnr) THEN
      BEGIN                        { nur angemeldete Teilnehmer z„hlen }
      sum := sum + sekunde;
      IF K^.item^.getgen = TRUE THEN        { M„dchen bekommen einen Bonus }
      sum := sum - bon_8;
      inc(i);
    END;
    K := K^.next;
  END;
  IF i = 0 THEN i := 1;               { im Fall des Falles }
  sum := (sum/i)/60;                  { in Minuten umwandeln }
  str(trunc(sum), text1);
  str(frac(sum)*60:2:0, text2);
  durchschnitt:= concat(text1, ' min ', text2, ' sec');  {als Str. ausgeben}
END;

{****************Ende der Methoden *******************************}


FUNCTION probe: byte;
VAR
  s    : string;
  klnr : longint;
  code : integer;
BEGIN
  REPEAT
    gotoxy(15, 22);
    write('Bitte die Klassennummer eingeben : <   >');
    Eingabe(s,51,22,3,0,'');
    val(s, klnr, code);
  UNTIL (code = 0) and (klnr > 0) and (klnr <= 255);
  probe := klnr;
END;


PROCEDURE Menue;
CONST
  sp = 15;
VAR
  klnr : byte;
BEGIN
  gotoxy(sp, 8);
  write('Bitte w„hlen Sie :');
  gotoxy(sp, 10);
  write('<1>  Datei laden');
  gotoxy(sp,11);
  write('<2>  Datei speichern');
  gotoxy(sp,12);
  write('<3>  Klassendaten eingeben   ');
  gotoxy(sp, 13);
  write('<4>  Klassendaten ausgeben  ');
  gotoxy(sp, 14);
  write('<5>  Daten l”schen   ');
  gotoxy(sp, 15);
  write('<6>  Ummeldungen   ');
  gotoxy(sp, 16);
  write('<7>  Zeiteingeben    ');
  gotoxy(sp, 17);
  write('<8>  Jahrgangsbesten ');
  gotoxy(sp, 18);
  write('<9>  Klassenbesten  ');
  gotoxy(sp, 19);
  write('<0>  ENDE   ');
  gotoxy(sp, 20);
  write('Ihre Wahl : < >');
  REPEAT
    Eingabe(wahl,sp+13,20,1,0,'');
  UNTIL wahl[1] in ['1', '2', '3', '4', '5', '6', '7', '8','9','0'];
  case wahl[1] of
  '1': BEGIN
        root := NIL;
        Einejahrgangsliste.init;
        Einejahrgangsliste.load;
       END;
  '2': IF root<>NIL THEN BEGIN
        Einejahrgangsliste.store;
       END;
  '3': BEGIN
         klnr := probe;
         Eineklassenliste.init;
         Eineklassenliste.listeanlegen(klnr);
       END;
  '4': IF root <> NIL THEN BEGIN
         klnr := probe;
         Eineklassenliste.init;
         SCR := Eineklassenliste.ausgeben(klnr);
         gotoxy(1, 23);
         write('******* Klassendurchschnitt: ',Eineklassenliste.durchschnitt(klnr));
         gotoxy(48, 23);
         write('Bitte <RTN> eingeben *******');
         readln;
       END;
   '5': IF root<>NIL THEN BEGIN
         klnr := probe;
         Eineklassenliste.init;
         Eineklassenliste.loeschen(klnr);
        END;
   '6': IF root<>NIL THEN BEGIN
          klnr := probe;
          Eineklassenliste.init;
          Eineklassenliste.ummelden(klnr);
        END;
   '7': IF root<>NIL THEN BEGIN
          klnr := probe;
          Eineklassenliste.init;
          Eineklassenliste.zeiteingeben(klnr);
        END;
   '8': IF root<>NIL THEN BEGIN
          ClrScr;
          Einejahrgangsbestenliste.init;
          Einejahrgangsbestenliste.herstellen;
          gotoxy(1, 23);
          write('*************************** Bitte <RTN> eingeben ****************************');
          readln;
        END;
   '9': IF root<> NIL THEN BEGIN
          klnr := probe;
          ClrScr;
          Eineklassenbestenliste.init;
          Eineklassenbestenliste.herstellen(klnr);
          gotoxy(1, 23);
          write('*************************** Bitte <RTN> eingeben ****************************');
          readln;
        END;
   END;
END;


{********Hauptprogramm*********}

BEGIN
Textmode(dynamisch);
root := NIL;
REPEAT
  ClrScr;
  Standardbild;
  menue;
UNTIL wahl = '0';
ClrScr;
END.