UNIT bildschirm; {$project vt }
{ Bildschirmausgaben zum Programm VideoText }

INTERFACE; FROM vt USES global,sys,decode,cct;

PROCEDURE cursoroff;
PROCEDURE cursoron;
PROCEDURE mainline;
PROCEDURE mark_queue(alt: Integer);
PROCEDURE redraw_queue(job: Integer);
PROCEDURE redraw_list;
PROCEDURE mark_list(reallydraw: Boolean);
PROCEDURE fileinfo;
PROCEDURE test(active: Boolean);
PROCEDURE displayhelp;
PROCEDURE scanpages;
PROCEDURE writepage(seite: p_onepage, verdeckt: Boolean);
PROCEDURE redraw_all;

{ ---------------------------------------------------------------------- }

IMPLEMENTATION;
{$opt b-}

VAR listoffset: Integer;

PROCEDURE cursoroff;
begin
  write(#155'0 p');  { Cursor unsichtbar }
end;

PROCEDURE cursoron;
begin
  write(#155' p');  { Cursor wieder sichtbar }
end;

PROCEDURE mainline;
begin
  gotoxy(1,24); write(#155'37m',copy(blank40,1,39));
  gotoxy(1,24);
end;

PROCEDURE mark_queue{(alt: Integer)};
{ Gibt die Position des Job-Markers <thisjob> am Bildschirm aus, ein alter }
{ Marker auf Position <alt> wird zuvor gelöscht. }
const x0=1; y0=2;
begin
  IF alt<0 THEN GotoXY(x0,y0+1+maxactive-alt)
    ELSE GotoXY(x0,y0-1+maxactive-alt);
  Write(' ');
  IF thisjob<0 THEN GotoXY(x0,y0+1+maxactive-thisjob)
    ELSE GotoXY(x0,y0-1+maxactive-thisjob);
  Write(#155'37m>');
end;

PROCEDURE redraw_queue{(job: Integer)};
{ Gibt für job<0 die aktuelle Belegung der Warteschlange und der aktiven Jobs }
{ am Bildschirm aus, sonst wird nur der Job mit der angegebenen Nummer neu }
{ ausgegeben: interessant ist dabei vor allem der Status der eingelesenen }
{ Unterseiten. }
CONST x0=1; y0=1;
VAR i,j,max: Integer;
BEGIN
  GotoXY(x0,y0); Write(#155'37m Seitensuche:');
  FOR j := 0 TO maxactive-1 DO
    IF (job<0) OR (j=job) THEN WITH activejobs[j] DO BEGIN
      GotoXY(x0,maxactive+y0-j); write(copy(blank40,1,anzsubpage+10));
      GotoXY(x0+1,maxactive+y0-j);
      IF pg=0 THEN Write('---')
      ELSE BEGIN
        Write(pg); IF sp>0 THEN Write('/',sp);
        IF ist_UT>3 THEN
          Write(' UT ')
        ELSE IF ist_UT>0 THEN
          Write(' UT? ')
        ELSE
          write('  ');
        IF sp_check[0] THEN Write('*');
        IF sp_max>0 THEN     { echte Unterseiten eingetroffen }
          IF sp>0 THEN       { zu einer Einzelanforderung? }
            Write('*')
          ELSE BEGIN
            max := sp_max; if max>anzsubpage then max := anzsubpage;
            write('(');
            for i := 1 to max do
              if sp_check[i] then write('*') else write('-');
            if sp_max>max then write('...') else write(')');
          END;
      END;
    END;
  GotoXY(x0,y0+2+maxactive); Write(' Jobs:');
  IF job<0 THEN BEGIN
    for j := 1 to qlen do begin
      gotoxy(x0,j+y0+2+maxactive); write('         ');
      if j<=queued then begin
        gotoxy(x0+1,j+y0+2+maxactive);
        write(queue[j].pg);
        if queue[j].sp>0 then write('/',queue[j].sp);
      end;
    end;
  END;
  mark_queue(0);
end;

PROCEDURE redraw_list;
{ Gibt eine Übersicht über die in der verketteten Liste gespeicherten }
{ VT-Seiten aus. Es werden drei Spalten zu <qlen> Zeilen erzeugt. Da die }
{ Liste nicht unbedingt ganz auf den Bildschirm paßt, wird ggf. ein Offset }
{ berücksichtigt. }
const x0=10; y0=3+maxactive;
      h=qlen; b=9; cols=3;
var i,j: integer;
    hilf: p_onepage;
begin
  { <listoffset> Seiten überschlagen: }
  hilf := root;
  for i := 1 to listoffset do
    if hilf<>Nil then hilf := hilf^.next;
  { Ausgabe erzeugen: }
  gotoxy(x0,y0); write(#155,'37m Im Speicher:');
  for i := 0 to cols-1 do
    for j := 1 to h do begin
      gotoxy(x0+b*i,j+y0); write('         ');
      gotoxy(x0+b*i,j+y0);
      if hilf<>Nil then begin
        if hilf=thispage then  write('>')  else  write(' ');
        write(hilf^.pg,'/',hilf^.sp);
        hilf := hilf^.next;
      end;
    end;
end;

PROCEDURE mark_list{(reallydraw: Boolean)};
{ Gibt die Position des Seiten-Markers <thispage> am Bildschirm aus, für }
{ <reallydraw>=FALSE wird die Markierung dagegen aufgehoben. }
CONST x0=10; y0=3+maxactive;
      h=qlen; b=9;
VAR nr: Integer;
    hilf: p_onepage;
BEGIN
  { Herausfinden, die wievielte Seite in der Liste <thispage> ist: }
  hilf := root; nr := 0;
  WHILE (hilf<>Nil) AND (hilf<>thispage) DO BEGIN
    hilf := hilf^.next; Inc(nr);
  END;
  WHILE nr<listoffset DO BEGIN
    listoffset := listoffset-qlen; redraw_list;  END;
  WHILE nr-listoffset>=3*qlen DO BEGIN
    listoffset := listoffset+qlen; redraw_list;  END;
  nr := nr-listoffset;
  GotoXY(x0+b*(nr DIV h),y0+1+nr MOD qlen); Write(#155'37m');
  IF reallydraw THEN  Write('>') ELSE Write(' ');
END;

PROCEDURE fileinfo;
CONST x0=1; y0=26;
BEGIN
  GotoXY(x0,y0);
  Write(#155'37mDatei (');
  IF protokoll THEN
    Write('UT-Protokoll): ')
  ELSE IF AsciiRawIff=3 THEN
    Write('IFF-Bild): ')
  ELSE BEGIN
    IF AsciiRawIff=2 THEN  Write('VT, ')
      ELSE  Write('ASCII, ');
    IF overwrite THEN  Write('}berschr.): ')
      ELSE  Write('anf}gend): ');
  END;
  Write(#155'36m'+outputname); ClrEoL;
END;

PROCEDURE test{(active: Boolean)};
{ Decodertest, sollte aus einer Schleife heraus aufgerufen werden. }
{ für active=false wird ein leeres Testfeld erzeugt. }
const x0=26; y0=1;
var stat: byte;
    zeit: str80;
    ch: char;
    tag,min,tic: Long;
procedure zweistellig(x: integer);  begin  write(x div 10, x mod 10);  end;
begin
  gotoxy(x0,y0);
  write(#155'37mStatus:');
  if not active then begin
    for stat := 1 to 4 do begin
      gotoxy(x0,y0+stat); write('             ');  { 13 Spaces }
    end;
    write(#155,'36m');
  end;
  gotoxy(x0,y0+1); write('Bus:');
  gotoxy(x0+5,y0+1); write('AV:');
  gotoxy(x0+5,y0+2); write('VT:');
  gotoxy(x0,y0+3); write(' VT:');
  gotoxy(x0,y0+4); write('Sys:');
  if active then begin
    write(#155'36m');
    stat := VTstat;
    gotoxy(x0,y0+2);
    if i2c_status=0 then begin
      write('OK ');
      gotoxy(x0+9,y0+1)
      if (stat and $01) <> 0 then
        write('ja  ')  else  write('nein');
      gotoxy(x0+9,y0+2);
      if (stat and $02) <> 0 then
        write('ja  ')  else  write('nein');
    end else
      if i2c_status=1 then
        write('NAK')  else  write('tot');
    { Zeit aus dem VT-Seitenspeicher abfragen: }
    gettime(aktspeicher,zeit);
    gotoxy(x0+5,y0+3); write(zeit);
    { zum Vergleich: Amiga-Zeit }
    telltime(tag,min,tic);
    gotoxy(x0+5,y0+4);
    zweistellig(min DIV 60); write(':');
    zweistellig(min MOD 60); write(':');
    zweistellig(tic DIV 50);
  end;
end;

PROCEDURE displayhelp;
{ äöüß sind für den teletext.font durch {|}~ zu ersetzen! }
var ch: Char;
    l: Long;
begin
  clrscr;
  Write(#155'33m');
  WriteLn('                  VIDEOTEXT-SOFTWARE f}r I2C-Bus am RS232-Port'#155'32m');
  WriteLn('          Programmautor: Wilhelm N|ker, Hertastr. 8, D-44388 Dortmund');
  WriteLn('                 Compiler: KICK-Pascal 2.12 von MAXON Computer');
  WriteLn(#155'36m');
  WriteLn('Seiten k|nnen }ber einfache Seitennumern ('#155'37m572'#155'36m) oder }ber Unterseitennummern');
  WriteLn('('#155'37m642/2'#155'36m) angefordert werden. Die Eingabe l{~t sich mit der <Backspace>-Taste');
  WriteLn('korrigieren und wird mit <Enter> abgeschlossen.');
  WriteLn;
  WriteLn('  Crsr   Seiten durchbl{ttern           +/-   Warteschlange durchgehen');
  WriteLn('  Space  angew{hlte Seite anzeigen      *     Job aus der Schlange l|schen');
  WriteLn('  ?      Geheimschrift aufdecken        u     Untertitelstatus erzwingen');
  WriteLn('  Del    Seite wegwerfen');
  WriteLn('                                        F8    alle Seiten wegwerfen');
  WriteLn('  s      Seite speichern                F9    alle Jobs l|schen');
  WriteLn('  n      Dateinamen {ndern              F10   Seitenvorauswahl einlesen');
  WriteLn('  f      Dateiformat: ASCII/VT/IFF');
  WriteLn('  m      Modus: anh{ngen/}berschr.      t     Test/Uhr ein/aus');
  WriteLn('  p      UT-Protokoll ein/aus           i     Seitenangebot');
  WriteLn('                                        Help  diese Seite');
  WriteLn('  F1/F2/F3  Fersehdarstellung           x     Programmende');
  WriteLn('         voll/transparent/aus');
  WriteLn(#155'33m');
  WriteLn('                                    FREEWARE'#155'32m');
  WriteLn('VideoText darf beliebig kopiert und weitergegeben werden. Meinungen, Kritik und');
  WriteLn('    Anregungen (an obige Adresse) sind stets willkommen. Schreiben Sie mir!');
  repeat
    l := Wait(-1);
    stop := stop OR abbruch_test;
    ch := readkey;
  until (ch<>chr(0)) or stop;
end;

PROCEDURE scanpages;
var i,u,t,h,delta,pg_cnt,sp_cnt: integer;
    max: array[100..899] of integer;
    ch: char;
    dummy: p_onepage;
begin
  New(dummy);
  anfordern(0, 100, 0, '***');
  for i := 100 to 899 do
    max[i] := 0;
  ClrScr;
  gotoxy(18,1); write(#155'37mS E I T E N A N G E B O T'#155'36m');
  write('  -  Abbruch mit ESC');
  for i := 10 to 49 do begin
    gotoxy(17*(i div 10)-10,3+i mod 10);
    write(intstr(10*i)+': ----------');
    gotoxy(17*(i div 10)-10,14+i mod 10);
    write(intstr(400+10*i)+': ----------');
  end;
  pg_cnt := 0;
  sp_cnt := 0;
  repeat
    getpage(0,dummy,false);
    u := dummy^.pg mod 10;
    t := (dummy^.pg div 10) mod 10;
    h := dummy^.pg div 100;
    gotoxy(12+17*((h-1) mod 4)+u, 3+t+11*((h-1) div 4));
    if max[dummy^.pg]=0 then Inc(pg_cnt);
    delta := dummy^.sp-max[dummy^.pg];
    if delta>=0 then
      if dummy^.sp=0 then begin
        max[dummy^.pg] := 1;
        write(chr(127));
        Inc(sp_cnt);
      end else begin
        max[dummy^.pg] := dummy^.sp;
        if dummy^.sp<10 then write(chr(dummy^.sp+ord('0'))) else write('+');
        if dummy^.sp<100 THEN sp_cnt := sp_cnt + delta;
      end;
    gotoxy(25,25);
    write(pg_cnt:3,' Seitennummern, ',sp_cnt:4,' Seiten');
    ch := readkey;
    stop := stop OR abbruch_test;
  until (ch = chr(27)) OR stop;
  with activejobs[0] do
    if pg>0 then  anfordern(0, pg, sp, '!!!')  else  sperren(0);
end;

PROCEDURE writepage{(seite: p_onepage, verdeckt: Boolean)};
{ Seite am Bildschirm ausgeben }
var zeile,i,j,j0: Integer;
    out: bigstring;
    s: str80;
    dblheight,special: Boolean;
begin
  cursoron;
  dblheight := False;
  seite^.chars[0] := 2;  { Seitennummer zunächst grün }
  for i := 0 to 24 do begin
    zeile := i MOD 24;
    IF i=24 THEN BEGIN
      seite^.chars[0] := 7;  { Seitennummer weiß -> Seite komplett }
      dblheight := False;
    END;
    IF dblheight THEN
      dblheight := False
    ELSE BEGIN
      IF seite<>Nil THEN
        decode_line(seite, zeile, verdeckt, out, dblheight)
      ELSE
        out := blank40;
      GotoXY(40,zeile+1); Write(out,#155'0;37;40m');
      IF dblheight THEN BEGIN   { Handhabung doppelthoher Zeilen }
        special := False;
        FOR j := 1 TO Length(out) DO BEGIN   { alles außer den ANSI-Codes }
          { entfernen -> erzeugt Kopie der Hintergrundfarben der Zeile }
          IF out[j] = #155 THEN special := True;
          IF NOT special THEN out[j] := ' ';
          IF out[j] = 'm' THEN special := False;
        END;
        GotoXY(40,zeile+2); write(out,#155'0;37;40m');
        special := False;
        FOR j := 0 TO 39 DO   { doppelthohe Abschnitte suchen }
          CASE seite^.chars[40*zeile+j] OF
            13: BEGIN j0 := j; special := True; END;
            12: IF special THEN BEGIN
                stretch_line(zeile+1,40+j0,40+j); special := False;
              END;
            OTHERWISE;
          END;
        IF special THEN
          stretch_line(zeile+1,40+j0,79);
      END;
    END;
    lastkey := readkey; { Taste: Abbruch und Rückmeldung ans HP }
    stop := stop OR abbruch_test;
    IF (lastkey<>chr(0)) OR stop THEN BEGIN
      cursoroff;
      exit;
    END;
  END;
  cursoroff;
END;

PROCEDURE redraw_all;
{ kompletter Neuaufbau des Bildschirms, inklusive clrscr }
begin
  ClrScr;
  writepage(thispage,true); test(false);
  redraw_queue(-1); redraw_list; fileinfo;
end;

BEGIN { Initialisierungsteil }
  listoffset := 0;
END.