home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / VIDEOTEXT.LZX / VTsrc / bildschirm.p next >
Encoding:
Text File  |  1996-04-19  |  14.7 KB  |  485 lines
  1. UNIT bildschirm; {$project vt }
  2. { Bildschirmausgaben zum Programm VideoText }
  3.  
  4. INTERFACE; FROM vt USES pagelist,decode,cct,sys;
  5.  
  6. CONST colht=15;
  7. VAR jobcursor: Boolean;   { >Markierung in der Job- oder in der Seitenliste? }
  8.     incomplete: Boolean;  { Seitenaufbau unterbrochen? }
  9.     concealed: Boolean;   { verdeckte Zeichen wirklich verdeckt? }
  10.     queue_input: String[10];
  11.  
  12. PROCEDURE cursoroff;
  13. PROCEDURE cursoron;
  14. PROCEDURE mainline;
  15. PROCEDURE mark_queue(really: Boolean);
  16. PROCEDURE queue_me;
  17. PROCEDURE redraw_queue(job: Integer);
  18. FUNCTION pos_from_queue(x,y: Integer): Integer;
  19. PROCEDURE mark_list(really: Boolean);
  20. PROCEDURE redraw_list;
  21. PROCEDURE update_list(start: p_onepage; delta: Integer);
  22. FUNCTION page_from_list(x,y: Integer): p_onepage;
  23. PROCEDURE hilite_crsr;
  24. PROCEDURE fileinfo;
  25. PROCEDURE test(active: Boolean);
  26. PROCEDURE writepage(seite: p_onepage, verdeckt: Boolean);
  27. FUNCTION number_from_page(x,y: Integer): Integer;
  28. PROCEDURE redraw_all;
  29. FUNCTION click_action(x,y: Integer): Char;
  30.  
  31. { ---------------------------------------------------------------------- }
  32.  
  33. IMPLEMENTATION;
  34.  
  35. {$opt q,s+,i+ } { keine Laufzeitprüfungen außer Stack und Feldindizes }
  36.  
  37. CONST head=7; tail=6;  { Aufteilung der Warteschlange }
  38.       sp_maxdisp=15;
  39.  
  40. VAR listoffset: Integer;
  41.     fix1,fix2,fix3,fix4: Integer; { fileinfo-x-Positionen }
  42.     lsizex: Integer;   { x-Position der Listengröße }
  43.  
  44. PROCEDURE cursoroff;
  45. BEGIN
  46.   Write(#155'0 p');  { Cursor unsichtbar }
  47. END;
  48.  
  49. PROCEDURE cursoron;
  50. BEGIN
  51.   Write(#155' p');  { Cursor wieder sichtbar }
  52. END;
  53.  
  54. PROCEDURE mainline;
  55. BEGIN
  56.   GotoXY(1,24); Write(#155'0m',Copy(blank40,1,39));
  57.   GotoXY(1,24);
  58. END;
  59.  
  60. PROCEDURE queue_entry(pg,sp: Integer);
  61. { besorgt v. a. die richtige Dekodierung der Unterseitennummer }
  62. BEGIN
  63.   Write(hexstr(pg,0));
  64.   CASE sp OF
  65.     -3: Write('/!');
  66.     -2: Write('/.');
  67.     -1: Write('/*');
  68.      0: ;
  69.     OTHERWISE IF sp>0 THEN Write('/',hexstr(sp,0))
  70.       ELSE Write(sp+10);
  71.   END;
  72. END;
  73.  
  74. PROCEDURE mark_queue{(really: Boolean)};
  75. { Gibt die Position des Job-Markers <thisjob> als '>' am Bildschirm aus, }
  76. { <thisjob> kann Werte von <maxactive>-1 bis -<queued> annehmen. }
  77. { Für <really>=FALSE wird stattdessen ' ' ausgegeben. }
  78. CONST x0=1; y0=1;
  79. VAR y,j: Integer;
  80.     special: Boolean;
  81. BEGIN
  82.   special := False;
  83.   y := y0 + maxactive - thisjob;
  84.   IF thisjob<0 THEN BEGIN
  85.     y := y + 2;
  86.     IF NOT fifo THEN y := y + 1;
  87.     IF (queued>=colht) AND (-thisjob>head) THEN BEGIN
  88.       { unvollständige Anzeige der Schlange }
  89.       IF -thisjob>queued-tail THEN
  90.         y := y + colht-1 - queued { zeigt auf hinteres Ende }
  91.       ELSE BEGIN
  92.         special := True;
  93.         y := y + thisjob + head + 1; { zeigt auf die '...' }
  94.         j := (firstinq - thisjob - 2) MOD qlen + 1;
  95.       END;
  96.     END;
  97.   END;
  98.   GotoXY(x0,y); 
  99.   IF really THEN BEGIN
  100.     IF NOT jobcursor THEN Write(#155,'2m');
  101.     Write('>'#155'0m');
  102.   END ELSE 
  103.     Write(' '); 
  104.   IF special THEN BEGIN
  105.     Write('('); queue_entry(queue[j].pg,queue[j].sp); Write(')');
  106.   END;
  107. END;
  108.  
  109. PROCEDURE queue_me;
  110. { Die aktuelle Benutzereingabe am Ende (bzw. Anfang) der Warteschlange }
  111. { darstellen. }
  112. CONST x0=1; y0=1;
  113. VAR s: String[10];
  114. BEGIN
  115.   { den für Eingaben reservierten Platz ansteuern: }
  116.   IF NOT fifo THEN
  117.     GotoXY(x0+1,y0+3+maxactive)
  118.   ELSE IF queued<colht THEN
  119.     GotoXY(x0+1,queued+y0+3+maxactive)
  120.   ELSE
  121.     GotoXY(x0+1,colht+y0+2+maxactive);
  122.   Write(#155'0m');
  123.   IF queued<qlen THEN BEGIN 
  124.     Write(queue_input,#155'7m');
  125.     IF Length(queue_input)<8 THEN BEGIN
  126.       s := '         '; s[8-Length(queue_input)] := #0;
  127.       Write(' '#155'0m',s);
  128.     END ELSE
  129.       Write(#8,queue_input[8]);
  130.   END;
  131. END;
  132.  
  133. PROCEDURE redraw_queue{(job: Integer)};
  134. { Gibt für job<0 die aktuelle Belegung der Warteschlange und der aktiven Jobs }
  135. { am Bildschirm aus, sonst wird nur der Job mit der angegebenen Nummer neu }
  136. { ausgegeben: interessant ist dabei vor allem der Status der eingelesenen }
  137. { Unterseiten. }
  138. CONST x0=1; y0=1;
  139. VAR i,j,y,max: Integer;
  140. BEGIN
  141.   GotoXY(x0,y0); Write(#155'0m Seitensuche:');
  142.   FOR j := 0 TO maxactive-1 DO
  143.     IF (job<0) OR (j=job) THEN WITH activejobs[j] DO BEGIN
  144.       GotoXY(x0,maxactive+y0-j);
  145.       Write(Copy(blank40,1,25)); { nicht das Testfeld überschreiben! }
  146.       GotoXY(x0+1,maxactive+y0-j);
  147.       IF pg=0 THEN Write('---')
  148.       ELSE BEGIN
  149.         queue_entry(pg,sp);
  150.         Write('  ');
  151.         IF sp_check[0] THEN Write('+');
  152.         IF sp_max>0 THEN     { echte Unterseiten eingetroffen }
  153.           IF (sp>0) OR (sp IN [-3..-1]) THEN  { zu einer Einzelanforderung? }
  154.             Write('+')
  155.           ELSE BEGIN
  156.             max := get_bcd(sp_max); IF max>sp_maxdisp THEN max := sp_maxdisp-2;
  157.             Write('(');
  158.             FOR i := 1 TO max DO
  159.               IF sp_check[i] THEN Write('+') ELSE Write('-');
  160.             IF get_bcd(sp_max)>max THEN Write('...') ELSE Write(')');
  161.           END;
  162.       END;
  163.     END;
  164.   GotoXY(x0,y0+2+maxactive);
  165.   IF fifo THEN Write(' Jobs:') ELSE Write(' Jobs!');
  166.   IF job<0 THEN BEGIN
  167.     y := y0 + 3 + maxactive;
  168.     IF fifo THEN y := y + colht - 1;
  169.     GotoXY(x0,y); Write('         ');
  170.     FOR j := 1 TO colht-1 DO BEGIN
  171.       y := j+y0+2+maxactive; IF NOT fifo THEN y := y + 1;
  172.       GotoXY(x0,y); Write('         ');
  173.       IF j<=queued THEN BEGIN
  174.         GotoXY(x0+1,y);
  175.         i := (firstinq + j - 2) MOD qlen + 1;
  176.         IF (queued>=colht) AND (j>head) THEN
  177.           i := (firstinq + queued + j - colht - 1) MOD qlen + 1;
  178.         IF (queued>=colht) AND (j=head+1) THEN
  179.           Write('...')
  180.         ELSE
  181.           queue_entry(queue[i].pg,queue[i].sp);
  182.       END;
  183.     END; { Ende FOR-Schleife }
  184.     queue_me;
  185.   END;
  186.   mark_queue(True);
  187. END;
  188.  
  189. FUNCTION pos_from_queue{(x,y: Integer): Integer};
  190. { wurde auf eine Nummer in der Warteschlange geklickt? }
  191. CONST x0=1; y0=1;
  192. BEGIN
  193.   pos_from_queue := maxactive;  { unmöglicher Wert }
  194.   IF (x<x0) OR (x>x0+8) THEN Exit;
  195.   IF (y>y0) AND (y<=y0+maxactive) THEN
  196.     pos_from_queue := maxactive + y0 - y { Position in der Seitensuche }
  197.   ELSE BEGIN
  198.     y := y - y0 - maxactive - 2; IF NOT fifo THEN Dec(y);
  199.     IF (y>0) AND (y<colht) AND(y<=queued) THEN
  200.       IF (queued<colht) OR (y<=head) THEN
  201.         pos_from_queue := -y
  202.       ELSE
  203.         pos_from_queue := -(y-colht+queued+1);
  204.   END;
  205. END;
  206.  
  207. { Der Ärger mit der Seitenliste ... }
  208. CONST cols=3; colw=9;
  209.       x0=10; y0=3+maxactive;
  210.  
  211. FUNCTION adjust_offset: Integer;
  212. { Da die Seitenliste meist nicht ganz auf den Bildschirm paßt, gibt ein }
  213. { Offset an, ab wo sie sichtbar ist, dieser <listoffset> wird hier neu }
  214. { berechnet. Der Rückgabewert sagt, um wieviele Spalten die Liste (falls }
  215. { bereits angezeigt) verschoben werden muß. (>0: rechts kommen Spalten dazu) }
  216. VAR nr,delta: Integer;
  217. BEGIN
  218.   nr := posn_in_list(thispage);   { wo steht der Zeiger? }
  219.   delta := 0;
  220.   WHILE nr<listoffset DO BEGIN
  221.     listoffset := listoffset-colht; Dec(delta);  END;
  222.   WHILE nr-listoffset>=cols*colht DO BEGIN
  223.     listoffset := listoffset+colht; Inc(delta);  END;
  224.   adjust_offset := delta;
  225. END;
  226.  
  227. PROCEDURE listentry(seite: p_onepage; nr: Integer);
  228. { Einen Listeneintrag erzeugen, von dem seine Nummer im sichtbaren Bereich }
  229. { der Liste bekannt ist. }
  230. VAR i,x,y: Integer;
  231.     s: String[20];
  232. BEGIN
  233.   x := x0+colw*(nr DIV colht); y := y0+1+nr MOD colht;
  234.   GotoXY(x,y); Write(#155'0m');
  235.   s := '';
  236.   IF seite<>Nil THEN BEGIN
  237.     s := ' '+hexstr(seite^.pg,0)+'/'+hexstr(seite^.sp,0);
  238.     IF NOT seite^.dejavu THEN Write(#155'1m'); { Fettdruck }
  239.   END;
  240.   i := Length(s);
  241.   WHILE i<colw DO BEGIN Inc(i); s[i] := ' '; END;
  242.   s[i+1] := #0;
  243.   Write(s);
  244. END;
  245.  
  246. PROCEDURE redraw_column(col: Integer);
  247. { gibt eine Spalte der Seitenliste aus }
  248. VAR i: Integer;
  249.     hilf: p_onepage;
  250. BEGIN
  251.   hilf := page_on_posn(listoffset+(col-1)*colht);
  252.   FOR i := 1 TO colht DO BEGIN
  253.     listentry(hilf,(i-1)+(col-1)*colht);
  254.     IF hilf<>Nil THEN hilf := hilf^.next;
  255.   END;
  256. END;
  257.  
  258. PROCEDURE mark_list{(really: Boolean)};
  259. { Gibt die Position des Seiten-Markers <thispage> am Bildschirm aus, für }
  260. { <really>=FALSE wird die Markierung dagegen aufgehoben. }
  261. { Scrollt die Liste auch weiter, falls nötig. }
  262. VAR nr,i,x,y: Integer;
  263.     dx: Integer;
  264. BEGIN
  265.   { scrollen? }
  266.   dx := adjust_offset;
  267.   FOR i := cols DOWNTO 1 DO BEGIN
  268.     IF dx>=i THEN  scroll_text(y0+1,y0+colht,x0,x0+cols*colw-1,0,colw);
  269.     IF dx<=-i THEN  scroll_text(y0+1,y0+colht,x0,x0+cols*colw-1,0,-colw);
  270.   END;
  271.   FOR i := 1 TO cols DO
  272.     IF (i+dx>cols) OR (i+dx<1) THEN
  273.       redraw_column(i);
  274.   nr := posn_in_list(thispage) - listoffset;   { wo steht der Zeiger? }
  275.   thispage^.dejavu := True; listentry(thispage,nr);
  276.   x := x0+colw*(nr DIV colht); y := y0+1+nr MOD colht;
  277.   GotoXY(x,y); 
  278.   IF really THEN BEGIN
  279.     IF jobcursor THEN Write(#155,'2m');
  280.     Write('>'#155'0m');
  281.   END ELSE 
  282.     Write(' '); 
  283. END;
  284.  
  285. PROCEDURE redraw_list;
  286. { aktualisiert die gesamte Seitenliste }
  287. VAR i: Integer;
  288.     hilf: p_onepage;
  289. BEGIN
  290.   IF adjust_offset<>0 THEN; { Wert ist egal }
  291.   GotoXY(x0,y0); Write(#155'0m Im Speicher:');
  292.   lsizex := 39-Length(IntStr(listsize)); GotoXY(39-5,y0); Write(listsize:5);
  293.   hilf := page_on_posn(listoffset);
  294.   FOR i := 0 TO cols*colht-1 DO BEGIN
  295.     listentry(hilf,i);
  296.     IF hilf<>Nil THEN hilf := hilf^.next;
  297.   END;
  298.   mark_list(True);
  299. END;
  300.  
  301. PROCEDURE redraw_rows(rows: Integer);
  302. { gibt die ersten <rows> bzw. die letzten <-rows> Zeilen der Seitenliste }
  303. { aus, nicht ganz trivial }
  304. VAR i,j: Integer;
  305.     hilf: p_onepage;
  306. BEGIN
  307.   hilf := page_on_posn(listoffset);
  308.   FOR i := 1 TO cols DO
  309.     FOR j := 1 TO colht DO BEGIN
  310.     IF (j<=rows) OR (j>colht+rows) THEN
  311.       listentry(hilf,(j-1)+(i-1)*colht);
  312.     IF hilf<>Nil THEN hilf := hilf^.next;
  313.   END;
  314. END;
  315.  
  316. PROCEDURE update_list{(start: p_onepage; delta: Integer)};
  317. { Es wurden Seiten in die Liste eingefügt (delta>0) bzw. entfernt (delta<0). }
  318. { <start> ist die erste Seite, die sich dadurch geändert hat. }
  319. { delta=0 ist auch zulässig, z. B. um für eine aktualisierte Nummer wieder }
  320. { Fettdruck zu erzwingen. }
  321. VAR i,nr: Integer;
  322.     hilf: p_onepage;
  323. BEGIN
  324.   lsizex := 39-Length(IntStr(listsize)); 
  325.   GotoXY(39-5,y0); Write(#155'0m',listsize:5);
  326.   { wo auf dem Bildschirm ist die bezeichnete Seite? }
  327.   nr := posn_in_list(start) - listoffset;
  328.   IF delta=0 THEN BEGIN
  329.     IF nr IN [0..cols*colht-1] THEN listentry(start,nr);
  330.     Exit;
  331.   END;
  332.   { ein paar Spalten komplett scrollen, eine nur zum Teil }
  333.   FOR i := 1 TO cols DO BEGIN
  334.     IF (i-1)*colht>=nr THEN
  335.       scroll_text(y0+1,y0+colht,x0+(i-1)*colw,x0+i*colw-1,-delta,0)
  336.     ELSE IF i*colht>=nr+Abs(delta) THEN
  337.       scroll_text(y0+1+nr MOD colht,y0+colht,x0+(i-1)*colw,x0+i*colw-1,-delta,0)
  338.   END;
  339.   hilf := start;
  340.   FOR i := 0 TO delta DO BEGIN { einer zuviel, ist aber Absicht ... }
  341.     IF nr+i IN [0..cols*colht-1] THEN listentry(hilf,nr+i);
  342.     IF hilf<>Nil THEN hilf := hilf^.next;
  343.   END;
  344.   redraw_rows(delta);
  345.   { '>' neu setzten, hat evtl. sogar den Bildschirm verlassen: }
  346.   mark_list(True);
  347. END;
  348.  
  349. FUNCTION page_from_list{(x,y: Integer): p_onepage};
  350. { zu einer angeklickten Zeichenposition die Seite herausfinden }
  351. VAR nr: Integer;
  352.     hilf: p_onepage;
  353. BEGIN
  354.   page_from_list := Nil;
  355.   IF (y IN [y0+1..y0+colht]) AND (x IN [x0-2..x0+cols*colw+2]) THEN BEGIN
  356.     nr := listoffset + y - (y0+1) + colht*(Round((x-x0)/colw+0.5)-1);
  357.     page_from_list := page_on_posn(nr);
  358.   END;
  359. END;
  360.  
  361. PROCEDURE hilite_crsr;
  362. { momentane Funktion des Cursors anzeigen }
  363. BEGIN
  364.   mark_list(True);
  365.   mark_queue(True);
  366. END;
  367.  
  368. PROCEDURE fileinfo;
  369. CONST x0=1; y0=26;
  370. VAR l,space: Integer;
  371. BEGIN
  372.   GotoXY(x0,y0);
  373.   Write(#155'0mDatei ('); fix1 := x0 + 7;
  374.   fix2 := fix1 + 4;
  375.   IF asciifile THEN BEGIN  Write('ASCII, '); fix2 := fix2 + 3; END
  376.     ELSE Write('VT, ');
  377.   fix3 := fix2 + 11;
  378.   IF overwrite THEN BEGIN  Write('}berschr.): '); fix3 := fix3 + 1; END
  379.     ELSE  Write('anf}gend): ');
  380.   space := 80 - fix3; IF withicon THEN space := space - 10;
  381.   l := Length(outputname); IF numbering THEN l := l + 4;
  382.   IF l>space THEN Write(#155'2m...',Copy(outputname,l-space+4,space-3))
  383.     ELSE Write(#155'2m',outputname);
  384.   IF l>space THEN fix4 := fix3 + space ELSE fix4 := fix3 + l;
  385.   IF numbering THEN Write('.###');
  386.   IF withicon THEN Write(#155'0m, mit Icon');
  387.   ClrEoL;
  388. END;
  389.  
  390. PROCEDURE test{(active: Boolean)};
  391. { Decodertest, sollte aus einer Schleife heraus aufgerufen werden. }
  392. { für active=false wird ein leeres Testfeld erzeugt. }
  393. CONST x0=26; y0=1;
  394. VAR stat: Byte;
  395.     i: Integer;
  396.     zeit: str80;
  397.     ch: char;
  398.     tag,min,tic: Long;
  399. PROCEDURE zweistellig(x: Integer);  BEGIN  Write(x DIV 10, x MOD 10);  END;
  400. BEGIN
  401.   GotoXY(x0,y0);
  402.   Write(#155'0mStatus:');
  403.   IF NOT active THEN BEGIN
  404.     FOR stat := 1 TO 5 DO BEGIN
  405.       GotoXY(x0,y0+stat); Write('             ');  { 13 Spaces }
  406.     END;
  407.     Write(#155,'2m');
  408.   END;
  409.   GotoXY(x0,y0+1); Write('Bus:');
  410.   GotoXY(x0+5,y0+1); Write('AV:');
  411.   GotoXY(x0+5,y0+2); Write('VT:');
  412.   GotoXY(x0,y0+3); Write(' VT:');
  413.   GotoXY(x0,y0+4); Write('Sys:');
  414.   IF active THEN BEGIN
  415.     Write(#155,'2m');
  416.     stat := VTstat;
  417.     GotoXY(x0,y0+2);
  418.     IF i2c_status=0 THEN
  419.       Write('OK  ') ELSE Write('Err',i2c_status);
  420.     FOR i := 1 TO 2 DO BEGIN
  421.       GotoXY(x0+9,y0+i);
  422.       IF i2c_status=0 THEN
  423.         IF (stat AND i)<>0 THEN Write('ja  ')  ELSE  Write('nein')
  424.       ELSE
  425.         Write('    ')
  426.     END;
  427.     { Zeit aus dem VT-Seitenspeicher abfragen: }
  428.     gettime(aktspeicher,zeit);
  429.     GotoXY(x0+5,y0+3); Write(zeit);
  430.     { zum Vergleich: Amiga-Zeit }
  431.     telltime(tag,min,tic);
  432.     GotoXY(x0+5,y0+4);
  433.     zweistellig(min DIV 60); Write(':');
  434.     zweistellig(min MOD 60); Write(':');
  435.     zweistellig(tic DIV 50);
  436.   END;
  437.   Write(#155'0m');
  438. END;
  439.  
  440. CONST pgoffx=40;
  441. { PROCEDURE writepage() und FUNCTION number_from_page() includen: }
  442. CONST unit_bildschirm=1701; {$path "PAS:prg/vt/"; incl "dbluse.p" }
  443.  
  444. PROCEDURE redraw_all;
  445. { kompletter Neuaufbau des Bildschirms, inklusive clrscr }
  446. BEGIN
  447.   ClrScr;
  448.   redraw_queue(-1); test(False);
  449.   redraw_list; fileinfo;
  450.   writepage(thispage,True);
  451. END;
  452.  
  453. FUNCTION click_action{(x,y: Integer): Char};
  454. { Ein paar bestimmte Sachen, die man anklicken kann }
  455. BEGIN
  456.   click_action := ' ';
  457.   IF (y=1) AND (x IN [26..32]) THEN click_action := 'T'; { "Status" }
  458.   IF (y=1) AND (x IN [2..13]) THEN click_action := 'S'; { "Seitensuche" }
  459.   IF (y=7) AND (x IN [2..6]) THEN click_action := 'J'; { "Jobs" }
  460.   IF (y=7) AND (x IN [10..22]) THEN click_action := 'L'; { "Im Speicher" }
  461.   IF (y=7) AND (x IN [lsizex..38]) THEN click_action := 'K'; { Löschen }
  462.   IF (y=26) THEN BEGIN
  463.     IF x IN [1..fix1-3] THEN click_action := 'D'; { Dateiname }
  464.     IF x IN [fix1..fix2-3] THEN click_action := 'F'; { Format }
  465.     IF x IN [fix2..fix3-4] THEN click_action := 'M'; { Modus }
  466.     IF x IN [fix3..fix4-1] THEN click_action := 'N'; { Numerierung }
  467.     IF x IN [fix4..80] THEN click_action := 'I'; { Icon? }
  468.   END;
  469.   IF (x>=40) THEN CASE y OF
  470.       1..8: click_action := '-'; { oberes Seitendrittel }
  471.       9..16: click_action := '0'; { Seitenmitte }
  472.       17..24: click_action := '+'; { unteres Seitendrittel }
  473.       OTHERWISE;
  474.     END;
  475. END;
  476.  
  477. BEGIN { Initialisierungsteil }
  478.   listoffset := 0;
  479.   jobcursor := False;
  480.   incomplete := False;
  481.   concealed := True;
  482.   queue_input := '';
  483. END.
  484.  
  485.