Turbo Toolbox/Turbo_Toolbox.iso/1987/04/gplotsys.pas

Pascal/Delphi Source File | 1987-03-13 | 8.2 KB | 255 lines

(***************************************************************************)
(*                            GPLOTSYS.PAS                                 *)
(*                                                                         *)
(*     MODULE GPlotter : Simulation eines Plotters mittels eines           *)
(*                       Matrixdruckers   (hier: QUEN DATA DMP 1180)       *)
(***************************************************************************)

(* enthaltene Funktionen:
    GPinit, GPexit, GPloescheBlatt, GPinvertiereBlatt, GPdruckeBlatt,
    Point_System u. Point (so benannt wg. 'Vom Punkt...' und den dortigen
    Algorithmen), GPholePunkt.

   Voraussetzungen an Pascal-Implementation:
    Direktzugriffsdateien, bitweises AND, OR, XOR                          *)

(*-------------------------------------------------------------------------*)
(*                  Speichere aktuelle Zeile in Puffer:                    *)

PROCEDURE GPsichereZeile;

BEGIN
  Seek(GPpufferFile, GPgeladeneZeile);
  Write(GPpufferFile, GPpufferZeile);          (* ev. mit 'Put' ersetzen ! *)
END;

(*-------------------------------------------------------------------------*)
(*                   benoetigte Zeile aus Puffer laden:                    *)

PROCEDURE GPladeZeile (zeile: INTEGER);

BEGIN
  Seek(GPpufferFile, zeile);
  Read(GPpufferFile, GPpufferZeile);           (* ev. mit 'Get' ersetzen ! *)
  GPgeladeneZeile := zeile;
  GPuntergrenze   := zeile * 16;
  GPobergrenze    := GPuntergrenze + 15;
END;

(*-------------------------------------------------------------------------*)
(*     Sichere alte Zeile in Puffer und hole neue Zeile aus Puffer:        *)

PROCEDURE GPzeilenwechsel (y: INTEGER);

BEGIN
  IF (y < GPuntergrenze) OR (GPobergrenze < y) THEN
  BEGIN                 (* Wechsel notwendig, wenn y ausserhalb akt. Zeile *)
    GPsichereZeile;
    GPladeZeile(y DIV 16);
  END;
END;

(*-------------------------------------------------------------------------*)
(*  pruefen, ob (x,y) im Zeichenbereich. Wenn ja, Zeilenwechsel durchf.:   *)

FUNCTION GPaufBlatt (x, y: INTEGER): BOOLEAN;

BEGIN
  IF (x >= 0) AND (x <= GPXmax_Sys) AND (y >= 0) AND (y <= GPYmax_Sys) THEN
    BEGIN
      GPzeilenwechsel(y);
      GPaufBlatt := TRUE;
    END
  ELSE
    GPaufBlatt := FALSE;
END;

(*-------------------------------------------------------------------------*)
(*                gesamten Grafikpuffer loeschen:                          *)

PROCEDURE GPloescheBlatt;

VAR  i: INTEGER;

BEGIN
(*$I-*)            (* I/O-Fehlerbehandlung des Laufzeitsystems ausschalten *)
  ReWrite(GPpufferFile);
(*$I+*)                                        (* ...und wieder aktivieren *)
  IF IOResult = 0 THEN          (* kein I/O-Fehler bei ReWrite aufgetreten *)
    BEGIN
      FOR i := 0 TO GPXmax_Sys DO
        GPpufferZeile[i].BS := 0;
      FOR i := 1 TO GPanzPufferZeilen DO
        Write(GPpufferFile, GPpufferZeile);
      Close(GPpufferFile);
      ReSet(GPpufferFile);
      GPladeZeile(GPgeladeneZeile);
    END
  ELSE
    Halt;                                            (* Programm abbrechen *)
END;

(*-------------------------------------------------------------------------*)
(*                gesamten Grafikpuffer invertieren:                       *)

PROCEDURE GPinvertiereBlatt;

VAR  i, j: INTEGER;

BEGIN
  GPsichereZeile;
  FOR i := 0 TO Pred(GPanzPufferZeilen) DO
  BEGIN
    GPladeZeile(i);
    FOR j := 0 TO GPXmax_Sys DO
      GPpufferZeile[j].bs := GPpufferZeile[j].bs XOR $FFFF;
    GPsichereZeile;
  END;
END;

(*-------------------------------------------------------------------------*)
(*                    gesamte Grafik ausdrucken:                           *)
(* 'lst' ist in Turbo-Pascal vordefinerte Datei fuer Druckerausgabe.       *)

PROCEDURE GPdruckeBlatt;

CONST esc = 27;
      doub_dens = 'L';
      form_feed = 12;
      l7_72     = '1';
      l1_6      = '2';

VAR  i, j, k: INTEGER;

BEGIN
  GPsichereZeile ;
  WriteLn(Lst, Chr(esc), l7_72);
                                          (* 7/72 Zeilenabstand einstellen *)
  FOR i := Pred(GPanzPufferZeilen) DOWNTO 0 DO
  BEGIN
    GPladeZeile(i);
    FOR j := 1 DOWNTO 0 DO                           (* eine Zeile drucken *)
    BEGIN
      Write(Lst, Chr(esc), doub_dens, Chr(Succ(GPXmax_Sys) MOD 256),
                                      Chr(Succ(GPXmax_Sys) DIV 256));
      FOR k := 0 TO GPXmax_Sys DO
        Write(Lst,GPpufferZeile[k].cc[j]);
      WriteLn(Lst);
    END;
  END;
  WriteLn(Lst, Chr(esc), l1_6, Chr(form_feed));
                                      (* 1/6 Zeilenabstand und neues Blatt *)
END;

(*-------------------------------------------------------------------------*)
(*                       Zeichenmodus setzen:                              *)

PROCEDURE GPsetzeMode (mode: GPModes);

BEGIN
  GPMode := mode;
END;

(*-------------------------------------------------------------------------*)
(*                Punkt gemaess Zeichenmodus setzen:                       *)

PROCEDURE Point_System (x, y: INTEGER);

BEGIN
  IF GPaufBlatt(x,y) THEN
    CASE GPMode OF
      Setzen      : GPpufferZeile[x].bs := GPpufferZeile[x].bs OR
                                           GPbits[y MOD 16];
      Loeschen    : GPpufferZeile[x].bs := GPpufferZeile[x].bs AND
                                           (GPbits[y MOD 16] XOR $FFFF);
      Invertieren : GPpufferZeile[x].bs := GPpufferZeile[x].bs XOR
                                           GPbits[y MOD 16];
    END;
END;

(*-------------------------------------------------------------------------*)
(*                nur aus oben beschriebenem Grund:                        *)

PROCEDURE Point (x, y: INTEGER);

BEGIN
  Point_System(x, y);
  Pen_Xpos := x;  Pen_Ypos := y;
END;

(*-------------------------------------------------------------------------*)
(*                        Punkt abfragen:                                  *)

FUNCTION GPholePunkt (x, y: INTEGER): BOOLEAN;

BEGIN
  IF GPaufBlatt(x,y) THEN
    GPholePunkt := (GPbits[y MOD 16] AND GPpufferZeile[x].bs) <> 0
  ELSE
    GPholePunkt := FALSE;
END;

(*-------------------------------------------------------------------------*)
(* Point-SWAP aus der Graphikserie. Vertauscht die Koord. zweier Punkte    *)
(* fuer den Integer-DDA des gleichen Artikels. Wurde hier noch'mal auf-    *)
(* genommen, um unnoetiges Nachdenken seitens des Lesers zu verhindern!    *)

PROCEDURE point_swap (VAR x1, y1, x2, y2: INTEGER);

VAR hilf: INTEGER;

BEGIN
  hilf := x1;  x1 := x2;  x2 := hilf;
  hilf := y1;  y1 := y2;  y2 := hilf;
END;

(*-------------------------------------------------------------------------*)
(*                   Initialisierung des Plottersimulators:                *)
(* Die Turbo-Anweisungen 'Assign(filevar, filename)' und 'ReSet(filevar)'
   sind bei anderen Implementationen u.U. mit 'ReSet(filevar, filename)' zu
   ersetzen. Entsprechendes ist bei 'ReWrite(filevar)' zu beachten.        *)

PROCEDURE GPinit (GPpuffername: GPfName; clr: BOOLEAN);

VAR i: INTEGER;

BEGIN
  GPanzPufferZeilen := Succ(GPYmax_Sys) DIV 16;
  IF (Succ(GPYmax_Sys) MOD 16) <> 0 THEN
    GPanzPufferZeilen := Succ(GPanzPufferZeilen);
  GPgeladeneZeile := 0;
  Assign(GPpufferFile, GPpuffername);
(*$I-*)
  ReSet(GPpufferFile);                   (* Puffer-Datei schon vorhanden ? *)
(*$I+*)
  IF (IOResult = 0) THEN                 (* ja...                          *)
    BEGIN
      IF clr THEN
        BEGIN
          GPloescheBlatt;
        END;
    END
  ELSE
    GPloescheBlatt;
  GPbits[0] := 1;                             (* Bit-Masken initialisieren *)
  FOR i := 1 TO 14 DO
    GPbits[i] := 2*GPbits[Pred(i)];
  GPbits[15] := $8000;
  GPladeZeile(0);
  GPsetzeMode(Setzen);
  Pen_Xpos := 0;  Pen_Ypos := 0;
END;

(*-------------------------------------------------------------------------*)
(*                   Beenden des Plottersimulators:                        *)

PROCEDURE GPexit;

BEGIN
  GPsichereZeile;
  Close(GPpufferFile);
END;

(*-------------------------------------------------------------------------*)
(*                        Ende von GPLOTSYS.PAS                            *)