Program PinnOFF;

{ Version für Kickpascal 2.0x
  Workspace: min 180 KB, Stack im KP-Icon auf 20000 }


{ "Interpreter" für NEC - P2200 / P2+ / P6 /P6+  sowie
  Epson LQ (24-Nadler) - Druckerdateien,
  die mit CMD (WorkBench 1.3) abgefangen wurden.

  © by Henrich Deppenmeier
       Turnerstr. 50
       4800 Bielefeld 1

  Rohfassung, geschrieben 16/17, 23/24 Februar 91 in Kickpascal 2.01

  PinnOFF! benötigt und benutzt die req.library, die mit diesem
  Programm weitergegeben werden muß.

  PinnOFF! ist FD-Software. Es ist verboten, dieses Programm
  auf PD-Disketten für mehr als 5,- zu vertreiben.

  Darf mit kommerziellen Programmen nur nach schriftlicher
  Absprache geliefert werden. }




{$incl "req.lib","intuition.lib","libraries/dos.h","exec/libraries.h"}
{$incl "workbench/startup.h","workbench/icon.h" }

Const Stop    = 0;
      Run     = 1;
      Datei   = 2;
      Fenster = 3;
      DataOn  = 4;
      DataOff = 5;
      CharOn  = 6;
      CharOFF = 7;

Type Länderzeichenfeld=Array[0..14,1..12] of byte;

Var NeuWindow  : NewWindow;
    MeinWindow : ^Window;
    Msg        : ^Intuimessage;
    g          : ^Gadget;
    Gad1,
    Gad2,
    gad3,
    gad4       : GadgetBlock;
    ende       : Boolean;
    Charstatus,
    Outputstatus,
    Datastatus,
    Runstatus  : integer;
    i,k,l,
    result     : integer;
    Verzeichnis,
    Dateiname,
    Eindatei,
    Ausdatei   : string;

    Ein        : File of Byte;
    Aus        : Text;

    Knopf,
    erfolg     : long;
    Mess       : string[200];

    b          : byte;
    pos        : long;

    Grafikmodus_K,
    Grafikmodus_L,
    Grafikmodus_Y,
    Grafikmodus_Z : integer;

    Land       :integer;

    Länderzeichen:Länderzeichenfeld;

    test:p_Library;


label xxx;


Procedure Print (x,y:integer;Text:str;win:p_window);

{ Kleiner "Print at"-Ersatz für normale Windows   }

Var Itext:Intuitext;

  begin
    x:=2+x*8; y:=12+y*9;
    Itext:=IntuiText(1,0,1,0,0,NIL,Text,NIL);
    PrintIText(Win^.RPort,^Itext,x,y);
  end;


Procedure Initgadget(num:word; Var Gad:GadgetBlock);

{ intialisiert die Bool-GadgetStructuren (req.library) }

 begin
   Gad.gadget:=gadget(nil,0,0,0,0,0,0,0,nil,nil,nil,0,nil,num,0);
   Gad.border:=Border(0,0,0,0,0,0,nil,nil);
   For i:=0 to numpairs do Gad.pairs[i]:=0;
   Gad.text:=intuitext(0,0,0,0,0,nil,"",nil);
 end;


Procedure changetext(var Gad:Gadgetblock; text:str; win:p_window);

{ ändert den Text eines bestehenden Gadgets }

 begin
   gad.text:=IntuiText(1,0,1,0,0,NIL,Text,NIL);
   Refreshgadgets(win^.Firstgadget,win,nil);
 end;


Function FRequester (Titel,Verzeichnis,Datei,Pfad:STR):long;

{ Filerequester der req.library }

var  FReq : Filerequester;    { Aus req.lib }

  begin
  FReq:=Filerequester(
    0,                { VersionNumber     }
    Titel,            { Title             }
    Verzeichnis,      { Dir               }
    Datei,            { File              }
    Pfad,             { PathName          }
    NIL,              { Window            }
    0,                { MaxExtendedSelect }
    15,               { numlines          }
    35,               { numcolumns        }
    10,               { devcolumns        }
    FRQLoading,       { Flags             }
    3,                { dirnamescolor     }
    1,                { filenamescolor    }
    3,                { devicenamescolor  }
    3,                { fontnamescolor    }
    1,                { fontsizescolor    }
    2,                { detailcolor       }
    1,                { blockcolor        }
    1,                { gadgettextcolor   }
    1,                { textmessagecolor  }
    1,                { stringnamecolor   }
    1,                { stringgadgetcolor }
    1,                { boxbordercolor    }
    1,                { gadgetboxcolor    }
    chr(0),           { RFU_Stuff         }
    datestamp(0,0,0), { DirDateStamp      }
    0,                { WindowLeftEdge    }
    0,                { WindowTopEdge     }
    0,                { FontYSize         }
    0,                { FontStyle         }
    nil,              { ExtendedSelect    }
    "",               { Hide              }
    "",               { Show              }
    0,                { FileBufferPos     }
    0,                { FileDispPos       }
    0,                { DirBufferPos      }
    0,                { DirDispPos        }
    0,                { HideBufferPos     }
    0,                { HideDispPos       }
    0,                { ShowBufferPos     }
    0,                { ShowDispPos       }
    nil,              { Memory            }
    nil,              { Memory2           }
    nil,              { Lock              }
    "",               { PrivateDirBuffer  }
    nil,              { FileInfoBlock     }
    0,                { NumEntries        }
    0,                { NumHiddenEntries  }
    0,                { filestartnumber   }
    0                 { devicestartnumber }
    );

    Openlib(reqbase,"req.library",0);
    Frequester:=FileRequest(^Freq);
    Closelib(reqbase);
end;


Function TRequest(Titel,Frage,pos,mitte,neg:str):long;

{ "Normaler" Requester mit 1-3 Buttons aus req.library }

Var Textreq : TRStructure;

  begin
    With Textreq do
      begin
        Text           := Frage;
        Controls       := nil;
        Window         := NIL;
        MiddleText     := mitte;
        PositiveText   := pos;
        NegativeText   := neg;
        Title          := Titel;
        Keymask        := $FFFF;   { mit Tastatur-}
        textcolor      := 1;       { bedienung..  }
        detailcolor    := 2;
        blockcolor     := 1;
        versionnumber  := 0;
        rfu1           := 0;
        rfu2           := 0;
      end;
      Openlib(reqbase,"req.library",0);
      TRequest:=Textrequest(^Textreq); {Aufruf d. Req.}
      closelib(reqbase)
  end;


Procedure window_zu;

{ Exitserver für unvorhergesehene Fehler, auf diese
  Weise hat man hinterher zumindestens keine Fensterleiche }

 begin
   closewindow(Meinwindow);
 end;


function getsize(name:str):LONg;

{ Ermittelt die Größe eines Files }

var FIB:^FileInfoBlock;
    FLock:Bptr;

begin
  Flock:=lock(name,shared_lock);
  if Flock=0 then
    begin
      mess:="Kein Lock auf "+name+" möglich !"+chr(10);
      Knopf:=Trequest("Fehler",mess," O. K. ",nil,nil);
    end
  else
    begin
      new(fib);
      if examine(flock,fib)=0 then
        begin
          mess:="Kein Examine von "+name+" möglich !"+chr(10);
          Knopf:=Trequest("Fehler",mess," O. K. ",nil,nil);
        end
      else
        getSize:=Fib^.fib_size;
      unlock(flock);
      dispose(fib);
    end
end;


function Holmessage:boolean;

{ Gadgetabfrage: nach jeweils ca 80 Zeichen }

begin
  holmessage:=false;
  repeat
    Msg:=p_intuimessage(Get_Msg(Meinwindow^.userport));
    if msg<>NIL then
      begin
        Case MSG^.Class of
          Gadgetup:
             begin
               g:= Msg^.iaddress;     { Zeiger auf betätigtes gadget }
               case g^.Gadgetid of           { Nummer }
                 2: begin
                      case Datastatus of
                        dataon: begin
                                  changetext(gad2," OFF  ",meinwindow);
                                  datastatus:=dataoff;
                                  writeln(aus,"");
                                  writeln(aus,"");
                                  Writeln(aus,">> Datenausgabe ausgeschaltet");
                                  writeln(aus,"");
                                  writeln(aus,"")
                                end
                        dataoff: begin
                                   changetext(gad2," ON   ",meinwindow);
                                   datastatus:=dataon;
                                   writeln(aus,"");
                                   writeln(aus,"");
                                   Writeln(aus,">> Datenausgabe eingeschaltet");
                                   writeln(aus,"");
                                   writeln(aus,"")
                                 end;
                      end;
                    end
                 3: begin
                      case Charstatus of
                       charon: begin
                                 changetext(gad3," [Zahl]  ",meinwindow);
                                 charstatus:=charoff;
                                 writeln(aus,"");
                                 writeln(aus,"");
                                 Writeln(aus,">> Länderspezifische Zeichen als [Zahl] eingeschaltet");
                                 writeln(aus,"");
                                 writeln(aus,"")
                               end
                       charoff: begin
                                  changetext(gad3," Zeichen ",meinwindow);
                                  charstatus:=Charon;
                                  writeln(aus,"");
                                  writeln(aus,"");
                                  Writeln(aus,">> Länderspezifische Zeichen als Zeichen eingeschaltet");
                                  writeln(aus,"");
                                  writeln(aus,"")
                                end;
                      end;
                    end;
                 4: begin
                      case runstatus of
                        stop: begin
                               changetext(gad4," Stop  ",meinwindow);
                               runstatus:=run;
                             end;
                        run: begin
                                changetext(gad4," Start",meinwindow);
                                runstatus:=stop;
                                holmessage:=true;
                              end;
                      end;
                    end;
                  otherwise begin
                            end;
               end;
             end;
          _CloseWindow:
            holmessage:=true;
          otherwise begin
                    end;
        end;
        Reply_Msg(Msg);
      end
  until msg=nil
end;


procedure hol(var x:integer);

{ holt ein neues Byte aus der Eindatei und gibt es
  als Dezimalzahl aus }

begin
 read(ein,x);write(aus,intstr(x)+" ");
 inc (pos)
end;


Procedure Datenoutput(s:long);

{ Gibt s Bytes aus Eindatei als Dezimalzahlen durch Komma
  getrennt aus }

var i:integer;

begin
  for i:=0 to s-1 do
    begin
      read(ein,s);inc (pos);
      if (i mod 15 =0) and (DataStatus=Dataon) then
        begin
          writeln(aus,"");
          write(aus,"   ")
        end;
      if datastatus=Dataon then write(aus,s:3,",");
    end;
  if Datastatus=Dataon then
    writeln(aus,"");
end;


Procedure init_länderzeichen;

{ intialisieren der Tabelle für die länderspezifischen
  zeichen im Druckerzeichensatz, also die Zeichen (dez.)
  35,36,64,91,92,93,94,96,123,124,125,126.
  In die einzelnen Zeilen wird jeweils eingetragen, wie die
  Ascii-Codes der jeweiligen Zeichen für den entsprechenden
  Länderspezifischen Zeichensatz auf dem Amiga sind.
  Auf dem Amiga nicht darstellbare Zeichen bekommen eine
  0 und werden dann in der Form [Zahl] ausgegeben, wobei
  Zahl den ASCII-Code des Zeichens auf dem Drucker darstellt.}


begin
  Länderzeichen:=
  Länderzeichenfeld((35,36,64,91,92,93,94,96,123,124,125,126), {USA}
                    (35,36,224,176,199,167,94,96,233,217,232,168), {Frankreich}
                    (35,36,167,196,214,220,94,96,228,246,252,223), {Deutschland}
                    (163,36,64,91,92,93,94,96,123,124,125,126), {Großbritannien}
                    (35,36,64,91,92,93,94,96,123,124,125,126), {Dänemark1}
                    (35,164,201,196,214,197,220,233,228,246,229,252), {Schweden}
                    (35,36,64,176,92,233,94,217,224,242,232,236), {Italien}
                    (0,36,64,161,209,191,94,96,168,241,125,126), {Spanien}
                    (35,36,64,91,165,93,94,96,123,124,125,126), {Japan}
                    (35,36,64,91,92,93,94,96,123,124,125,126), {Norwegen}
                    (35,36,64,198,216,197,94,96,230,248,229,126), {Dänemark2}
                    (163,36,64,91,0,93,94,96,123,0,125,126), {Niederlande}
                    (0,0,167,0,214,220,0,0,226,246,220,0), {Türkei}
                    (35,36,225,161,209,191,233,252,205,241,211,218), {Spanien2}
                    (35,36,225,161,209,191,233,252,205,241,211,218)); {Lateinamerika}
end;


procedure escauswertung;

{ wertet ESC-Sequencen aus }

var n,m,n1,n2:integer;
    A1,B1,C1:integer;
    grafikmodus:integer;
    l:long;


begin
  write(aus,b," ");
  case b of
    14: Write(aus,": Breitmodus Rest der Zeile ein");
    15: Write(aus,": Schmalmodus eine Zeile ein");
    25: Begin
          hol(n);
          Write(aus,": Einzelblatteinzug: ");
          case n of
            0,48:write(aus,"Aus");
            4,52:write(aus,"ein");
            82:write(aus,"Formfeed")
            otherwise write(aus,"??? (",n,")");
          end;
        end;
    32: Begin
          hol(n);
          Write(aus,": Zeichenabstand: ",n," Punkte")
        end;
    33: Begin
          hol(n);
          Writeln(aus,": setzt Druckart: ",n, ": ");
          if (n and 1)=0 then write(aus,"10 CPI, ") else write (aus,"12 CPI, ");
          For i:=1 to 7 do
            begin
              n1:=(n and (1 shl i));
              case n1 of
               2:write(aus,"Proportionalschrift, ");
               4:write(aus,"Schmalschrift, ");
               8:write(aus,"Schattenschrift, ");
               16:write(aus,"Fettschrift, ");
               32:write(aus,"Breitschrift, ");
               64:write(aus,"Kursivschrift, ");
               128:write(aus,"Unterstreichung, ");
               otherwise write (aus,"ungültige Druckart:");
              end;
            end;
        end;
    35: Write(aus,": 7-Bit Übertragung ein");
    36: begin
          hol(n1);
          hol(n2);
          Write(aus,": absolute Druckkopfpos: ");
          Write(aus,(n1+n2*256)/60," Zoll vom linken Rand aus");
        end
    37: begin
          hol(n);
          Write (aus,": Downloadschrift ");
          case n of
            0,48:write(aus,"Aus");
            1,49:write(aus,"Ein");
            otherwise write(aus,"(ungültiges n:",n,")");
          end;
        end;
    38: begin
          hol(n); hol(n1); hol(n2);
          for i:=n1 to n2 do
            begin
              read(ein,A1);Read(ein,b1);read(ein,c1);pos:=pos+3;
              write (aus,": DLzeichen ",i," (",chr(i),")"," Schrift ",n,", ",b1*3+3," bytes");
              if Datastatus=Dataon then
                begin
                  writeln(aus,"");
                  writeln(aus,"");
                  writeln(aus,"  A / B / C : ",A1, " / ",b1," / ",c1);
                  writeln(aus,"");
                  writeln (aus,"  Zeichendaten:");
                end;
              datenoutput(3*b1);
            end;
        end;
    40: begin
          hol(n);hol(n);hol(n); { ESC ( - 3 0 1 n1 n2}
          write(aus,"Epson: Unterstreichungsart : ");
          hol(n1);hol(n2);
          case n1 of
           1,49:write(aus,"Unterstreichen");
           2,50:write(aus,"durchstreichen");
           3,51:write(aus,"Überstreichen");
           otherwise write(aus,"??? n1=",n1," ");
          end;
          case n2 of
           0,48:write(aus,"löschen");
           1,49:write(aus,"einfach durchgezogen");
           2,50:write(aus,"doppelt durchgezogen");
           5,53:write(aus,"einfach unterbrochen");
           6,54:write(aus,"doppelt unterbrochen");
           otherwise write(aus,"??? n2=",n2," ");
          end;
        end;
    42: begin
          hol(grafikmodus); hol(n1); hol(n2);
          writeln(aus,": Einzelpunktgrafik mit wählbarer Dichte: ");
          case grafikmodus of
           0,48:write(aus,"         8-Nadeldruck, 60 DPI, einfache Dichte");
           1,49:write(aus,"         8-Nadeldruck, 120 DPI, doppelte Dichte");
           2,50:write(aus,"         8-Nadeldruck, 120 DPI, doppelte Dichte (Schnelldruck)");
           3,51:write(aus,"         8-Nadeldruck, 240 DPI, vierfache Dichte");
           4,52:write(aus,"         8-Nadeldruck, 80 DPI, CRT 1");
           6:write(aus,"            8-Nadeldruck, 90 DPI, CRT 2");
           32:write(aus,"         24-Nadeldruck, 60 DPI, einfache Dichte");
           33:write(aus,"         24-Nadeldruck, 120 DPI, doppelte Dichte");
           38:write(aus,"         24-Nadeldruck, 90 DPI, CRT 2");
           39:write(aus,"         24-Nadeldruck, 180 DPI, dreifache Dichte");
           40:write(aus,"         24-Nadeldruck, 360 DPI, hohe Dichte");
           otherwise write (aus,"         unbekannter Modus : ",grafikmodus);
          end;
          writeln(aus,"");
          l:=n1+n2*256;
          if grafikmodus >30 then l:=l*3;
          writeln(aus,"");
          writeln(aus,"");
          writeln(aus,"  ",l, " Bytes Grafikdaten ");
          Datenoutput(l)
        end;
    45: begin
          hol(n);
          write(aus,": Unterstreichungsmodus: ");
          case n of
            0,48:write(aus,"Aus");
            1,49:write(aus,"Ein");
            otherwise write(aus,"(ungültiges n : ", n,")");
          end;
        end;
    47: begin
          hol(n);
          write(aus,": Anwahl Tabkanal: ",n);
        end;
    48: write(aus,": Zeilenvorschub auf 8 LPI");
    50: write(aus,": Zeilenvorschub auf 6 LPI");
    51: begin
          hol(n);
          Write(aus,": Zeilenvorschub auf ",n,"/180el Zoll");
        end;
    52: write(aus,": Kursivmodus ein");
    53: write(aus,": Kursivmodus aus");
    54: write(aus,": Code 128 - 159 als IBM-Zeichen setzen");
    55: write(aus,": Code 128 - 159 als Steuerzeichen setzen");
    58: begin
          hol(n);hol(n1);hol(n2);
          writeln(aus,": Kopieren des derzeitig aktiven Zeichensatzes in den Bereich");
          write(aus,"              des benutzerdefinierbaren Zeichensatzes: ");
          Case n1 of
           0,48:write (aus,"(Epson: Schriftfamilie Roman)");
           1,49:write(aus,"(Epson: Schriftfamilie Sans Serif)");
           otherwise write("(unbekanntes n1: ",n1,")");
          end
        end;
    60: write(aus,": Druckkopf an linken Rand (einzeilig, unidirektionaler Druck)");
    61: write(aus,": Setzt 8. Datenbit auf 0");
    62: write(aus,": Setzt 8. Datenbit auf 1");
    63: begin
          hol(n);hol(n1);
          Case n of
            75:begin
                 grafikmodus_k:=n1;
                 Write(aus,": ESC K .. wird durch Grafikmodus ",n1," ersetzt");
               end;
            76:begin
                 grafikmodus_l:=n1;
                 Write(aus,": ESC L .. wird durch Grafikmodus ",n1," ersetzt");
               end;
            89:begin
                 grafikmodus_y:=n1;
                 Write(aus,": ESC M .. wird durch Grafikmodus ",n1," ersetzt");
               end;
            90:begin
                 grafikmodus_z:=n1;
                 Write(aus,": ESC N .. wird durch Grafikmodus ",n1," ersetzt");
               end;
            Otherwise write(aus,": ungültiger Versuch, Grafikmodus ESC ",chr(n)," zu ersetzen !");
          end;
        end
    64: write(aus,": Reset mit Ausnahme des Bedienfeldes, zeichensätze, Grafik-Mod.");
    65: begin
          hol(n);
          write(aus,": Zeilenabstand auf ",n,"/60el Zoll");
        end;
    66: begin
          hol(n1);
          if n1=0 then
            begin
              writeln(aus,": Löschen der Vertikal-Tabulatoren");
            end
          else
            begin
              while n1<>0 do
                begin
                  hol(n1)
                end;
              write(aus,": Setzen von Vertikal-Tabulatoren")
            end;
        end;
    67: begin
          hol(n1);
          if n1<>0 then
            write(aus,": Legt Seitenlänge auf ",n1," Zeilen fest")
          else
            begin
              hol(n2);
              write(aus,": Legt Seitenlänge auf ",n2," Zoll fest");
            end;
        end;
    68: begin
          hol(n1);
          if n1=0 then
            begin
              write(aus,": Löschen aller Horizontaltabulatoren");
            end
          else
            begin
              while n1<>0 do
                begin
                  hol(n1);
                end;
              write(aus,": Setzen von Horizontal-Tabulatoren")
            end;
        end;
    69: write(aus,": Schattenschriftmodus ein");
    70: write(aus,": Schattenschriftmodus aus");
    71: write(aus,": Fettschriftmodus ein");
    72: write(aus,": Fettschriftmodus aus");
    74: begin
          hol(n);
          write(aus,": Papiervorschub um ",n,"/180el Zoll");
        end;
    75: begin
          hol(n1);hol(n2);
          writeln(aus,": Setzt 8-Nadel-Grafik mit 60 DPI (einfache Dichte) ");
          l:=n1+n2*256;
          if grafikmodus_k> 30 then l:=l*3;
          write(aus,"  ",l," Bytes Grafikdaten");
          datenoutput(l);
        end;
    76: begin
          hol(n1);hol(n2);
          Write(aus,": Setzt 8-Nadel-Grafik mit 120 DPI (doppelte Dichte)");
          l:=n1+n2*256;
          if grafikmodus_l>30 then l:=l*3;
          write(aus,"  ",l," Bytes Grafikdaten");
          datenoutput(l);
        end;
    77: begin
          write(aus,": setzt 12 CPI");
        end
    78: begin
          hol(n);
          write(aus,": Setzt Perforationssprung auf ",n," zeilen");
        end;
    79: write(aus,": Perforationssprung aus");
    80: begin
          write(aus,": setzt 10 CPI");
        end;
    81: begin
          hol(n);
          write(aus,": Setzt den rechten Rand auf Spalte: ",n);
        end;
    82: begin
          hol(n);
          Write(aus,": Auswahl des nationalen Zeichensatzes: ");
          case n of
            0,48: write(aus,"USA");
            1,49: write(aus,"Frankreich");
            2,50: write(aus,"Deutschland");
            3,51: write(aus,"Großbritannien");
            4,52: write(aus,"Dänemark 1");
            5,53: write(aus,"Schweden");
            6,54: write(aus,"Italien");
            7,55: write(aus,"Spanien");
            8,56: write(aus,"Japan");
            9,57: write(aus,"Norwegen");
            10: write(aus,"Dänemark 2");
            11: write(aus,"NEC: Niederlande, Epson: Spanien II");
            12: write(aus,"NEC: Türkei, Epson: Latein-Amerika");
            13: write(aus,"NEC: Spanien 2, Epson: Korea");
            14: write(aus,"NEC: Lateinamerika");
            64: write(aus,"Epson: Legal");
            otherwise write(aus,"(ungültiges n: ",n,")");
          end;
          if n<48 then
            Land:=n
          else
            land:=n-48
        end;
    83: begin
          hol(n);
          write(aus,": Kleinschrift ");
          case n of
            0,48:write(aus,"hochstellen");
            1,49:write(aus,"tiefstellen");
            otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    84: write(aus,": Kleinschrift aus");
    85: begin
          hol(n);
          write(aus,": Druckrichtung: ");
          case n of
            0,48:write(aus,"bidirektional");
            1,49:write(aus,"unidirektional");
            otherwise write(aus,"(ungültiges n: ",n,")")
          end;
        end;
    86: begin
          hol(n);
          write(aus,": Druckwiederholung ");
          case n of
            0,48: write(aus,"Aus");
            otherwise write (aus,n," mal");
          end;
        end;
    87: begin
          hol(n);
          write(aus,": Breitschriftmodus ");
          case n of
           0,48: Write(aus,"Aus");
           1,48: Write(aus,"Ein");
           otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    89: begin
          hol(n1);hol(n2);
          Write(aus,": Setzt 8-Bit-Grafik mit 120 DPI (doppelte Dichte)");
          l:=n1+n2*256;
          if grafikmodus_y>30 then l:=l*3;
          write(aus,"  ",l," Bytes Grafikdaten");
          datenoutput(l);
        end;
    90: begin
          hol(n1);hol(n2);
          Write(aus,": Setzt 8-Bit-Grafik mit 240 DPI (vierfache Dichte)");
          l:=n1+n2*256;
          if grafikmodus_z>30 then l:=l*3;
          write(aus,"  ",l," Bytes Grafikdaten");
          datenoutput(l)
        end;
    92: begin
          hol(n1);hol(n2);
          Writeln(aus,": Bewegt den Druckkopf um: ");
          write(aus,"       ",((n1+n2*256)/120):7:3," (Draft) ",((n1+n2*256)/180):7:3," (LQ/PS) Zoll");
        end;
    97: begin
          hol(n);
          write(aus,": Justierung: ");
          case n of
           0,48: write(aus,"linksbündig");
           1,49: write(aus,"zentriert");
           2,50: write(aus,"rechtsbündig");
           3,51: write(aus,"rechts- und linksbündig (Blocksatz)")
           otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    98: begin
          hol(n);
          n1:=1;
          while n1<>0 do
            begin
              hol(n1)
            end;
          write(aus,": Setzen von Vertikal-Tabulatoren in Kanal ",n)
        end;
    101: begin
           hol(n);hol(n1);
           write(aus,": Setzt Tabulatoren in jede ",n1,". ");
           case n of
             0,48:write(aus,"Spalte")
             1,49:write(aus,"Zeile");
             otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end;
    102: begin
           hol(n);hol(n1);
           case n of
            0,48:write(aus,": Bewegt den Druckkopf um ",n1," Spalten nach rechts")
            1,49:write(aus,": Bewegt das Papier um ",n1," Zeilen vorwärts");
            otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end;
    103: write(aus,": 15 CPI");
    106: begin
           hol(n);
           write(aus,": Transportiert das Papier um ",n,"/180el Zoll zurück");
         end;
    107: begin
           hol(n);
           write(aus,": LQ-Schrift: ");
           Case n of
            0,48: write(aus,"NEC: Courier 10, Epson: Roman");
            1,49: write(aus,"Epson: Sans Serif");
            2,50: write(aus,"Epson: Courier");
            3,51: write(aus,"Epson: Prestige");
            4,52: write(aus,"Epson: Script");
            5,53: write(aus,"Epson: OCR B");
            6,54: write(aus,"Epson: OCR A");
            7,55: write(aus,"Epson: Orator");
            8,56: write(aus,"Epson: Orator-S");
            15: write(aus,"NEC: ITC 10");
            16: write(aus,"NEC: Helvette 10 PT");
            18: write(aus,"NEC: Times 10 PT");
            19: write(aus,"NEC: New Prestige Elite 12 WP");
            otherwise
               write(aus,"(ungültiges n: ",n,")");
           end;
         end;
    108: begin
           hol(n);
           write(aus,": Setzt linken Rand auf Spalte ",n);
         end;
    112: begin
           hol(n);
           write(aus,": Proportionalschrift ");
           case n of
            0,48:begin
                write(aus,"Aus");
              end;
            1,48:begin
                write(aus,"Ein");
              end;
            otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end
    113: begin
           hol(n);
           write(aus,"Epson: Schriftstil: ");
           case n of
            0,48:write(aus,"Standard");
            1,49:write(aus,"Umrißdruck");
            2,50:write(aus,"Schattendruck");
            3,52:write(aus,"Umriß- & Schattendruck");
            otherwise write(aus,"ungültiges n: ",n,")");
           end;
         end;
    114: begin
           hol(n);
           write(aus,": Druckfarbe ",n," : ");
           case n of
            0,48:write(aus,"schwarz");
            1,49:write(aus,"rot");
            2,50:write(aus,"blau");
            3,51:write(aus,"violett");
            4,52:write(aus,"gelb");
            5,53:write(aus,"orange");
            6,54:write(aus,"grün");
            7,55:write(aus,"braun");
            otherwise write(aus,"unbekannte Druckfarbe: ",n);
           end
         end;
    115: begin
           hol(n);
           write(aus,": Leisedruck ");
           case n of
            0,48:write(aus,"Aus")
            1,49:write(aus,"Ein");
            otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end;
    116: begin
           hol(n);
           write(aus,": Zeichensatz ");
           case n of
            0,48:write(aus,"Kursiv")
            1,49:write(aus,"IBM");
            2,50:write(aus,"Epson: Neuzuordnung der benutzerdefinierten",
                 "Zeichencodes 0-127 auf die Werte 128-255");
            otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end
    119: begin
           hol(n);
           write(aus,"Epson: doppelte Schrifthöhe ");
           case n of
            0,48:write(aus,"Ein");
            1,49:write(aus,"Aus");
           end;
         end;
    120: begin
           hol(n);
           write(aus,": Druck in ");
           case n of
            0,48:write(aus,"Draft")
            1,49:write(aus,"LQ");
            otherwise write(aus,"(ungültiges n: ",n,")");
           end;
         end;

    otherwise
         write(aus,": unbekannt");
  end;
end;


procedure fsauswertung;

{ wertet FS-Sequencen aus }

var n,n1,n2:integer;
    l:long;

begin
  write(aus,b," ");
  case b of
    51: begin
          hol(n);
          write(aus,": Setzt Zeilenabstand auf ",n,"/360el Zoll");
        end;
    64: write(aus,": Volle Initialisierung des Druckers außer Downloadschr.");
    67: begin
          hol(n);
          write(aus,": Wahl der optionalen Schriftart: ");
          case n of
           0,48: write(aus,"interne Schriftart")
           1,49: write(aus,"Font 1 der Kassette");
           2,50: write(aus,"Font 2 der Kassette");
           otherwise write(aus,"(ungültiges n :",n,")");
          end
        end;
    69: begin
          hol(n);
          write(aus,": Schriftbreite Setzen: ");
          case n of
           0,48: write(aus,"normal")
           1,49: write(aus,"doppelt");
           2,50: write(aus,"dreifach");
           otherwise write (aus,"(ungültiges n: ",n,")");
          end;
        end;
    70: write(aus,": setzt Zeilenvorschub vorwärts");
    73: begin
          hol(n);
          write(aus,": Wählt Zeichensatz:");
          case n of
           0,48:write(aus,"kursiv");
           1,49:write(aus,"IBM");
           otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    82: write(aus,": Setzt Zeilenvorschub rückwärts");
    83: begin
          hol(n);
          write(aus,": setzt Druckart: 1");
          case n of
           0,48:write(aus,"Draft 12");
           1,49:write(aus,"Draft HS 12");
           otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    86: begin
          hol(n);
          write(aus,": Vertikale zeichenvergrößerung: ");
          case n of
           0,48:write(aus,"Aus");
           1,49:write(aus,"doppelt hoch");
           otherwise write(aus,"(ungültiges n: ",n,")");
          end
        end;
    87: begin
          hol(n);
          write(aus,": Anzahl der Benutzerdef. Zeichensätze: ");
          case n of
            0,48:write(aus,"2 * 128 Zeichen");
            1,49:write(aus,"1 * 256 Zeichen");
            otherwise write (aus,"(ungültiges n: ",n,")");
          end;
        end;
    88: begin
          hol(n);
          write(aus,": Auswahl des Benutzerdef. Zeichensatzes: ");
          case n of
           0,48: write (aus,"Zeichensatz 1");
           1,49: write (aus,"Zeichensatz 2");
           otherwise write(aus,"(ungültiges n: ",n,")");
          end;
        end;
    90: begin
          hol(n1); hol(n2);
          write(aus,": 24-Nadel-Grafik mit 360 DPI (sechsfache Dichte)");
          l:=(n1+n2*256)*3;
          write(aus,"  ",l," Bytes Grafikdaten");
          datenoutput(l);
        end;
    otherwise write(aus,": Unbekannt");
  end;
end;


procedure Auswertung ;

{ unterteilt ganz grob in Einzelzeichen / Buchstaben /
  Steuersequencen }

begin
  Case b of
     0      : write(aus,"NUL ");
     3      : write(aus,"ETX ");
     6      : write(aus,"ACK ");
     7      : write(aus,"BEL ");
     8      : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," BS : Druckkopf ein Zeichen nach links");
               writeln(aus,"")
              end;
     9      : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," HT : Druckkopf zum nächsten Horizontal-Tabulator");
               writeln(aus,"")
              end;
     10     : writeln(aus,"LF ");
     11     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," VT : Druckkopf zum nächsten Vertikal-Tabulator");
               writeln(aus,"")
              end;
     12     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," FF : Formfeed");
               writeln(aus,"")
              end;
     13     : writeln(aus,"CR ");
     14     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," SO : Breitschrift eine Zeile ein");
               writeln(aus,"")
              end;
     15     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," SI : Schmalschrift ein");
               writeln(aus,"")
              end;
     17     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," DC1 : versetzt Drucker in aktiven Zustand");
               writeln(aus,"")
              end;
     18     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," DC2 : Schmalschriftbetrieb aus");
               writeln(aus,"")
              end;
     19     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," DC3 : versetzt Drucker in inaktiven Zustand");
               writeln(aus,"")
              end;
     20     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," DC4 : Breitschriftmodus aus");
               writeln(aus,"")
              end;
     24     : begin
               writeln(aus,"");
               write(aus,"{",pos:6,"}");
               write(aus," CAN : Löscht Zeile im Puffer, beendet Breitschriftmodus");
               writeln(aus,"")
              end;
     25     : write(aus,"EM ");
     27     : begin
                writeln(aus,"");
                write(aus,"{",pos:6,"}");
                write(aus," ESC ");
                read (ein,b); inc (pos);
                Escauswertung;
                writeln(aus,"")
              end
     28     : begin
                writeln(aus,"");
                write(aus,"{",pos:6,"}");
                write(aus," FS ");
                read(ein,b);inc(pos);
                fsauswertung;
                writeln(aus,"")
              end
     32..34 : write(aus,chr(b));
     35     : if (Länderzeichen[Land,1]<>0) and (Charstatus=charon) then
                write(aus,chr(länderzeichen[land,1]))
              else
                write(aus,"[",b,"]")
     36     : if (Länderzeichen[Land,2]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,2]))
              else
                write(aus,"[",b,"]")
     37..63 : write(aus,chr(b));
     64     : if (Länderzeichen[Land,3]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,3]))
              else
                write(aus,"[",b,"]")
     65..90 : write(aus,chr(b));
     91     : if (Länderzeichen[Land,4]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,4]))
              else
                write(aus,"[",b,"]")
     92     : if (Länderzeichen[Land,5]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,5]))
              else
                write(aus,"[",b,"]")
     93     : if (Länderzeichen[Land,6]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,6]))
              else
                write(aus,"[",b,"]")
     94     : if (Länderzeichen[Land,7]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,7]))
              else
                write(aus,"[",b,"]")
     95     : write(aus,chr(b));
     96     : if (Länderzeichen[Land,8]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,8]))
              else
                write(aus,"[",b,"]")
     97..122: write(aus,chr(b));
     123    : if (Länderzeichen[Land,9]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,9]))
              else
                write(aus,"[",b,"]")
     124    : if (Länderzeichen[Land,10]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,10]))
              else
                write(aus,"[",b,"]")
     125    : if (Länderzeichen[Land,11]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,11]))
              else
                write(aus,"[",b,"]")
     126    : if (Länderzeichen[Land,12]<>0) and (Charstatus=Charon) then
                write(aus,chr(länderzeichen[land,12]))
              else
                write(aus,"[",b,"]")
     127    : begin
                 writeln(aus,"");
                 Write(aus," DEL");
                 writeln(aus,"");
               end;
     otherwise
           begin
             Write(aus,"[",b,"]");
           end

  end;
end;


Procedure work(Startmess:Boolean);

{ Holt Byteweise Daten aus dem CMD-File und führt sie dem
  "Interpreter" zu, bedient die Prozentanzeige }

var prozent:string;
    delta,lastpos,lastmesspos:long;
    filesize:long;
    break:boolean;


Label workende;


begin
  erfolg:=1;
  if not startmess then
    begin
      Verzeichnis:="RAM:";
      Dateiname:="Cmd_file";
      einDatei:="";
      erfolg:=Frequester("Welches File untersuchen ?",verzeichnis,Dateiname,einDatei);
    end;
  if erfolg<>0 then
    begin
      reset(ein,eindatei);
      result:=IOResult;
      if result<>0 then
        begin
          mess:="Die Datei "+eindatei+chr(10)+
                "läßt sich nicht öffnen !"+chr(10);
          Knopf:=Trequest("Fehler:",mess,"O. K.",NIL,NIL);
          goto workende
      end;
      filesize:=getsize(eindatei);
      buffer(ein,4096);
    end
  else
    goto workende;


  case outputstatus of
    Datei: begin
             Verzeichnis:="";
             Dateiname:="Scanfile";
             ausDatei:="";
             erfolg:=Frequester("Output speichern nach:",verzeichnis,Dateiname,ausdatei);
             if erfolg<>0 then
               begin
                 rewrite(aus,ausdatei);
                 result:=IOResult;
                 if result<>0 then
                   begin
                     mess:="Die Datei "+ausdatei+" läßt sich"+chr(10)+
                           "nicht öffnen !"+chr(10);
                     Knopf:=Trequest("Fehler:",mess,"O. K.",NIL,NIL);
                     goto workende
                   end;
                 buffer(aus,4096)
               end
             else
               begin
                 close (ein);
                 goto workende
               end;
             end
    Fenster: begin
               reset(aus,"Con:0/126/640/130/Output");
               result:=IOResult;
               if result<>0 then
                 begin
                   mess:="Output-Window (CON:) läßt "+chr(10)+
                         "sich nicht öffnen !"+chr(10);
                   Knopf:=Trequest("Fehler:",mess,"O. K.",NIL,NIL);
                   goto workende
                 end;
               buffer(aus,4096);
             end;
  end;

  pos:=0;lastpos:=0;lastmesspos:=0;
  delta:=round(Filesize/100);    { 1% = delta Bytes }
  break:=false;
  land:=0;                       { Länderspez. Zeichens: USA }

  Grafikmodus_K:=0;              { die sequencen ESC K, ESC L, }
  Grafikmodus_L:=1;              { ESC Y und ESC Z lassen sich mittels }
  Grafikmodus_Y:=2;              { ESC ? durch best. Grafikmodi belegen,}
  Grafikmodus_Z:=3;              { daher wird die Nummer des Grafikmodus }
                                 { permanent mitgespeichert. }

  Writeln(aus,">> Scanning File: ",eindatei);
  writeln(aus,">>");
  Writeln(aus,">> Pinn Off! - Status: ");
  writeln(aus,">>");
  write(aus,">> Datenausgabe :");
  if Datastatus=DataON then
    writeln(aus,"ON")
  else
    writeln(aus,"OFF");
  write(aus,">> Länderspezifische Zeichen als: ");
  if Charstatus=CharOn then
    writeln(aus,"Zeichen")
  else
    writeln(aus,"[ZAHL]");
  writeln(aus,">>");
  writeln(aus,">>");


  While (not EOF(ein)) and (not break) do
   begin
     read(ein,b);
     auswertung;
     inc(pos);
     if pos-lastpos>delta then    { mal wieder ne neue Prozentzahl ausgeben }
       begin
         prozent:=intstr(round(pos*100/filesize))+" % ";
         lastpos:=lastpos+delta;
         print(31,8,prozent,meinwindow);
       end;
     if pos-lastmesspos>80 then   { mal wieder auf Message horchen }
       begin
         break:=holmessage;
         lastmesspos:=pos
       end
   end;

  if break then
    begin
      writeln(aus,"");
      writeln(aus,">>");
      writeln(aus,">> Abbruch bei Offset : {",pos,"}");
      writeln(aus,">>");
    end
  else
    begin
      writeln(aus,"");
      writeln(aus,">>");
      writeln(aus,">> Ende (",pos-1," Bytes bearbeitet)");
      writeln(aus,">>");
    end;

  close(ein);
  close(aus);

workende:

  changetext(gad4," Start",meinwindow);
  runstatus:=stop;
  repeat     { noch irgendwelche Messages über ? }
    msg:=p_intuimessage(Get_Msg(Meinwindow^.userport));
    if msg<>nil then
      reply_msg(msg);
  until msg=nil;
  print(31,8,"0 %   ",meinwindow);
end;



Procedure Startup;

{ Falls ein Icon mit Tooltype PinnOFF gestartet wurde , wird hier fest-
  gestellt, welche Datei dazu gehört und diese Datei bearbeitet }


var StMess  : p_WBStartup;
    DiskObj : p_DiskObject;
    oldlock : BPTR;

begin
  OpenLib(IconBase,'icon.library',0);
  StMess := StartupMessage;
  IF StMess^.sm_NumArgs > 1 THEN
    WITH StMess^.sm_ArgList^[2] DO
      BEGIN
        Eindatei := wa_Name;                   { Filename }
        Oldlock  := currentdir(wa_lock);       { Verzeichniswechsel }
      END;
  CloseLib(IconBase);
  if eindatei<>"" then                         { File behandeln }
    begin
      changetext(gad4," Stop  ",meinwindow);
      runstatus:=run;
      work(true);
    end;
end;



begin

  { req.library da ?}
  test:=OpenLibrary("req.library",0); { OpenLibrary aus exec/libraries.h }
  if test <>nil then
    CloseLibrary(test)
  else
    begin
      Assign(aus,'Con:0/10/400/80/Fehler');
      Reset(aus);
      writeln(aus,"req.library lässt sich nicht öffnen!");
      delay(50);
      close(aus);
      Halt(10);
    end;


  { Alles auf und Los }


  OpenLib(IntBase,'intuition.library',0);
  NeuWindow:=newwindow(0,0,340,125,0,1,
                       _CloseWindow+Gadgetup+Gadgetdown,
                       WindowClose+WindowDrag+Windowdepth+Activate,
                       nil,nil,
                       "PinnOff! ©91 Henrich Deppenmeier",
                       Nil,nil,
                       50,50,640,256,WBenchScreen);

  OpenLib(reqbase,"req.library",0);
  InitGadget(1,Gad1);
  Linkgadget(^Gad1," Fenster ",^NeuWindow,240,21);
  Outputstatus:=Fenster;
  InitGadget(2,Gad2);
  Linkgadget(^Gad2," OFF     ",^NeuWindow,240,39);
  Datastatus:=DataOFF;
  InitGadget(3,Gad3);
  Linkgadget(^Gad3," Zeichen ",^NeuWindow,240,57);
  Charstatus:=CharOn;
  InitGadget(4,Gad4);
  Linkgadget(^Gad4," Start ",^NeuWindow,140,110);
  Runstatus:=Stop;
  CloseLib(reqBase);

  Meinwindow:=Openwindow(^Neuwindow);
   if MeinWindow=Nil then
     begin
       mess:="Schade, Window geht nicht auf !";
       knopf:=Trequest("Fehler:",mess," Tschuessi! ",nil,nil);
       error("");
     end;
  AddExitserver(Window_zu);

  print(2,1,"Output nach             :",meinwindow);
  print(2,3,"Daten                   :",meinwindow);
  print(2,5,"Länderspez. Zeichen als :",meinwindow);
  print(2,8,"Scanned                 :",meinwindow);
  print(31,8,"0 %",meinwindow);

  init_länderzeichen;

  if FromWb then startup;     { Icon mit PinnOff im Tooltype ? }

  ende:=false;
  repeat
    Msg:=Wait_Port(Meinwindow^.userPort);
    Msg:=p_intuimessage(Get_Msg(Meinwindow^.userport));
    Case MSG^.Class of
      Gadgetup:
        begin
          g:= Msg^.iaddress;     { Zeiger auf betätigtes gadget }
          case g^.Gadgetid of           { Nummer }
            1: begin
                 Case Outputstatus of
                   Fenster : begin
                               changetext(gad1," Datei   ",meinwindow);
                               Outputstatus:=Datei
                             end
                   Datei   : begin
                               changetext(gad1," Fenster ",meinwindow);
                               outputstatus:=Fenster
                             end
                 end;
               end;
            2: begin
                 case Datastatus of
                   dataon  : begin
                               changetext(gad2," OFF  ",meinwindow);
                               datastatus:=dataoff
                             end
                   dataoff : begin
                               changetext(gad2," ON   ",meinwindow);
                               datastatus:=dataon
                             end;
                 end;
               end
            3: begin
                 case Charstatus of
                   charon  : begin
                               changetext(gad3," [Zahl]  ",meinwindow);
                               charstatus:=charoff
                             end
                   charoff : begin
                               changetext(gad3," Zeichen ",meinwindow);
                               charstatus:=Charon
                             end;
                 end;
               end;
            4: begin
                 case runstatus of
                   stop    : begin
                               changetext(gad4," Stop  ",meinwindow);
                               runstatus:=run;
                               reply_msg(msg);
                               work(false);
                               ende:=false;
                               goto xxx  { message ist schon beantwortet }
                             end;
                    run    : begin
                               changetext(gad4," Start",meinwindow);
                               runstatus:=stop
                             end;
                 end;
               end;
             otherwise begin
                       end;
          end;
        end;
      _CloseWindow:
        ende:=true;
    end;
    Reply_Msg(Msg);
    xxx:
  until ende;

  CloseLib(intbase);
end.























