PACKET edit menue (* Autor: Thomas Berlage *)
(* Stand: 16.10.88 *)
DEFINES
edit,
edit status anzeigen,
zeilenmenue anbieten,
editfile setzen,
edit menue,
element markieren,
text menue,
ausschnitt drucken,
gewaehlte schriftarten einstellen :
(************************* Zeilenmenue *************************************)
LET
menue status =
"MENUE: Wählen: <-,-> Ausführen: LEER,RET Abbruch: ESC h Hilfe: ESC ?";
PROC zeilenmenue anbieten (TEXT CONST menuename,
PROC (INT CONST) kommandos) :
bild vorbereiten;
zeilenmenue anbieten (menuename, TRUE, PROC (INT CONST) kommandos);
bild nachbereiten .
bild vorbereiten :
INT VAR x, y;
get cursor (x, y);
cursor (1, y size); out (""5"");
status anzeigen (menue status);
cursor (x, y);
IF aktueller editor > 0 THEN
get editcursor (x, y);
y := line no (editfile) + y size - y;
abschnitt neu (y - 1, y)
END IF .
bild nachbereiten :
IF aktueller editor > 0 THEN
IF mark (editfile) THEN
bild neu
ELSE
abschnitt neu (y - 1, y)
END IF
END IF;
cursor (1, y size - 1); out (""4"") .
END PROC zeilenmenue anbieten;
PROC eget (TEXT CONST prompt, TEXT VAR inhalt) :
editget (prompt, inhalt, "", "GET/Allgemein")
END PROC eget;
BOOL PROC eja (TEXT CONST frage) :
ja (frage, "JA/Allgemein", TRUE)
END PROC eja;
(* EDIT MENUE *)
TEXT VAR
param,
fensterdatei := "";
FENSTER VAR zweitfenster;
fenster initialisieren (zweitfenster);
PROC edit menue :
zeilenmenue anbieten ("EDIT MENUE:",
PROC (INT CONST) edit menue kommandos)
END PROC edit menue;
PROC edit menue kommandos (INT CONST wahl) :
SELECT wahl OF
CASE 1 : springen auf zeile
CASE 2 : suchen nach text
CASE 3 : suchen und ersetzen
CASE 4, 5 : markieren
CASE 6 : kopieren oder lesen
CASE 7 : fenster editieren
CASE 8 : limit einstellen
CASE 9 : tastenbelegung
END SELECT .
springen auf zeile :
TEXT VAR z := "";
eget ("Zeilennummer:", z);
IF z <> "" THEN
INT CONST auf zeile := int (z);
IF last conversion ok THEN
edit file setzen; T auf zeile
ELSE
errorstop ("Zeilennummer ist keine Zahl")
END IF
END IF .
suchen nach text :
param := "";
eget ("Text:", param);
IF param = "" THEN
ELIF eja ("Vorwärts") THEN
ek ("D" + textdarstellung (param))
ELSE
ek ("U" + textdarstellung (param))
END IF .
suchen und ersetzen :
param := "";
eget ("Suchtext:", param);
IF param <> "" THEN
z := ""; eget ("Ersetzen durch:", z);
IF z <> "" THEN
IF eja ("Nur einmal") THEN
ek (textdarstellung (param) + "C" + textdarstellung (z))
ELSE
editfile setzen;
param CA z
END IF
END IF
END IF .
markieren :
element markieren (wahl = 5) .
kopieren oder lesen :
param := "";
editfile setzen;
IF mark THEN
eget ("Zieldatei (RET = Speicher):", param);
PUT param
ELSE
eget ("Quelldatei (RET = Speicher):", param);
GET param
END IF .
fenster editieren :
INT VAR xa, ya, xl, yl;
get window (xa, ya, xl, yl);
IF groesster editor >= 2 THEN
errorstop ("Nur zwei Fenster")
ELSE
fenstergroesse setzen (zweitfenster,
xa, ya + yl DIV 2, xl, yl - yl DIV 2);
eget ("Name der Datei:", fensterdatei);
IF NOT exists (fensterdatei) CAND
NOT eja ("""" + fensterdatei + """ neu einrichten") THEN
errorstop ("")
END IF;
FILE VAR eff := sequential file (modify, fensterdatei);
edit (eff, zweitfenster, "EDIT/Allgemein")
END IF .
limit einstellen :
z := text (limit);
REP
eget ("Zeilenbreite bis Umbruch (limit) in Zeichen:", z);
INT CONST l := int (z);
UNTIL last conversion ok OR z = "" PER;
IF z <> "" THEN limit (l) END IF .
tastenbelegung :
TEXT VAR taste;
status anzeigen ("");
cursor (1, 24);
put ("Gewünschte Taste drücken (ESC = Abbruch):"5"");
getchar (taste);
IF taste <> ""27"" THEN
put (""13"Sequenz ggf editieren, dann ESC q"5"");
lernsequenz editieren (taste)
END IF .
END PROC edit menue kommandos;
PROC ek (TEXT CONST kom) :
kommando auf taste legen ("f", kom);
std kommando interpreter ("f")
END PROC ek;
PROC editfile setzen :
kommando auf taste legen (""27"", "");
std kommando interpreter (""27"")
END PROC editfile setzen;
DATASPACE VAR ds;
PROC lernsequenz editieren (TEXT CONST taste) :
disable stop;
ds := nilspace;
editieren (taste);
forget (ds)
END PROC lernsequenz editieren;
PROC element markieren (BOOL CONST bis satzende) :
FILE VAR edfile := editfile;
INT VAR spalte := col (edfile);
IF NOT mark (edfile) THEN
zeile lesen;
cursor zuruecksetzen;
mark (edfile, line no (edfile), spalte)
ELSE
zeile lesen
END IF;
IF bis satzende THEN
position auf satzende
ELSE
position auf wortende
END IF .
zeile lesen :
read record (edfile, param) .
cursor zuruecksetzen :
WHILE spalte > 1 CAND (param SUB spalte - 1) <> " " REP
spalte DECR 1
END REP .
position auf satzende :
WHILE pos (param, ".", spalte) = 0 CAND kein absatz REP
down (edfile);
zeile lesen;
spalte := 1
END REP;
spalte := pos (param, ".", spalte);
IF spalte = 0 THEN spalte := length (param) ELSE spalte INCR 1 END IF;
col (edfile, spalte) .
kein absatz :
(spalte = LENGTH param OR (param SUB LENGTH param) <> " ")
AND NOT eof (edfile) .
position auf wortende :
spalte DECR 1;
REP
spalte INCR 1;
spalte := pos (param, ""33"", ""255"", spalte);
IF spalte = 0 THEN
IF eof (edfile) THEN
spalte := length (param)
ELSE
down (edfile);
zeile lesen
END IF
END IF
UNTIL spalte > 0 END REP;
spalte := pos (param, " ", spalte);
IF spalte = 0 THEN spalte := length (param) END IF;
col (edfile, spalte) .
END PROC element markieren;
TEXT VAR sequenz, aenderung;
PROC editieren (TEXT CONST taste) :
enable stop;
FILE VAR f := sequential file (output, ds);
maxlinelength (f, 37);
sequenz := lernsequenz auf taste (taste);
klartext in file (f, sequenz);
alles neu;
abgrenzung zeichnen;
editstatus anzeigen;
edit (f, 42, 2, x size - 42, y size - 3);
klartext aus file (f, aenderung);
IF aenderung <> sequenz CAND wirklich aendern THEN
lernsequenz auf taste legen (taste, aenderung)
END IF .
abgrenzung zeichnen :
cursor (40, 1);
y size - 3 TIMESOUT ""10""15""14""8""8"" .
wirklich aendern :
eja ("Lernsequenz aendern") .
END PROC editieren;
(* TEXT MENUE *)
PROC text menue :
zeilenmenue anbieten ("TEXT MENUE:",
PROC (INT CONST) text menue kommandos)
END PROC text menue;
FENSTER VAR fontfenster, modfenster;
fenster initialisieren (fontfenster);
fenster initialisieren (modfenster);
fenstergroesse setzen (fontfenster, 40, 2, 40, 21);
fenstergroesse setzen (modfenster, 55, 13, 25, 10);
TEXT VAR
ezeile,
format macro := "";
PROC text menue kommandos (INT CONST mwahl) :
SELECT mwahl OF
CASE 1 : schrifttyp einstellen
CASE 2 : schriftart einstellen
CASE 3 : neue seite beginnen
CASE 4 : zwischenraum freilassen
CASE 5 : globaleinstellung
CASE 6 : zeilenweise formatieren
CASE 7 : ausschnitt drucken
END SELECT .
schrifttyp einstellen :
TEXT VAR typname;
schrifttyp auswaehlen (typname);
IF typname <> "" THEN
textanweisung einfuegen ("type", schriftname, FALSE)
END IF .
schriftname :
textdarstellung (typname) .
schriftart einstellen :
schriftart auswaehlen;
gewaehlte schriftarten einstellen (gewaehlte modifikationen) .
schriftart auswaehlen :
alles neu;
auswahl anbieten ("TEXT.Modwahl", modfenster, -10, "AUSWAHL/Allgemein",
PROC (TEXT VAR, INT CONST) modname) .
neue seite beginnen :
param := "";
eget ("Nummer der nächsten Seite (RET = +1):", param);
IF param = "" THEN
textanweisung einfuegen ("page", "", TRUE)
ELSE
INT CONST seitennr := int (param);
IF last conversion ok THEN
textanweisung einfuegen ("page", text (seitennr), TRUE)
ELSE
errorstop ("Seitennummer keine Zahl")
END IF
END IF .
zwischenraum freilassen :
param := "";
eget ("Zwischenraum in cm:", param);
IF param <> "" THEN
change all (param, ",", ".");
REAL CONST wert := real (param);
IF last conversion ok THEN
textanweisung einfuegen ("free", text (wert), TRUE)
ELSE
errorstop ("kein Zahlenwert")
END IF
END IF .
zeilenweise formatieren :
editfile setzen;
lineform; ueberschrift neu .
globaleinstellung :
einstellung erfragen;
einstellung eintragen .
END PROC text menue kommandos;
LET zwischendatei = "&&Druckabschnitt";
PROC ausschnitt drucken :
LET ende der seite = "Ende der Seite ";
FILE VAR ef := editfile;
INT VAR pageform anfang;
auf pageform datei testen;
IF pageform anfang > 0 THEN
editfile setzen;
IF mark (ef) THEN
markierten pageform abschnitt drucken
ELSE
nach seiten fragen und drucken
END IF;
print (zwischendatei);
forget (zwischendatei, quiet)
ELIF mark (ef) THEN
abschnitt formatieren und drucken
ELSE
errorstop ("kein Abschnitt markiert")
END IF;
alte position einnehmen .
auf pageform datei testen :
INT VAR
zeile := line no (ef),
spalte := col (ef);
to line (ef, 1); col (ef, 1);
pageform anfang := 0;
WHILE NOT eof (ef) CAND kommando in zeile REP
IF pos (ef, ende der seite, 8) > 0 THEN
pageform anfang := line no (ef);
END IF;
down (ef)
UNTIL pageform anfang > 0 END REP;
to line (ef, zeile); col (ef, spalte) .
kommando in zeile :
pos (ef, "#", 1) = 1 .
markierten pageform abschnitt drucken :
markierten abschnitt kopieren;
pageform anfang kopieren (ef, pageform anfang) .
nach seiten fragen und drucken :
anfang erfragen;
ende erfragen;
markierten abschnitt kopieren;
pageform anfang kopieren (ef, pageform anfang);
mark (ef, 0, 0) .
anfang erfragen :
TEXT VAR seitennr := "";
eget ("Erste Seite:", seitennr);
IF seitennr = "" THEN
mark (ef, pageform anfang + 1, 1)
ELSE
to line (ef, 1);
down (ef, ende der seite + text (int (seitennr) - 1));
IF eof (ef) THEN
mark (ef, pageform anfang + 1, 1)
ELSE
down (ef);
mark (ef, line no (ef), 1)
END IF
END IF .
ende erfragen :
eget ("Letzte Seite:", seitennr);
IF seitennr <> "" THEN
to line (ef, mark line no (ef));
down (ef, ende der seite + seitennr);
IF NOT eof (ef) THEN down (ef) END IF
ELSE
to eof (ef)
END IF;
col (ef, 1) .
abschnitt formatieren und drucken :
macro einfuegen;
editfile setzen;
ueberschrift neu;
IF eja ("Zeilenweise formatieren") THEN
lineform; page; ueberschrift zeigen; bild zeigen;
markierte schlusszeile
END IF;
markierten abschnitt kopieren;
IF eja ("Seitenweise formatieren") THEN
pageform (zwischendatei);
alles neu;
print (zwischendatei + ".p");
forget (zwischendatei + ".p", quiet)
ELSE
print (zwischendatei)
END IF;
forget (zwischendatei, quiet);
macro entfernen .
markierte schlusszeile :
cursor (1, y size - 1);
out (""15""); x size - 5 TIMESOUT " "; out (""14""4"") .
macro einfuegen :
eget ("Format-Makro:", format macro);
IF format macro <> "" THEN
to line (ef, mark line no (ef));
read record (ef, ezeile);
change (ezeile, mark col (ef), mark col (ef) - 1,
"#" + format macro + "#");
write record (ef, ezeile);
to line (ef, zeile); col (ef, spalte)
END IF .
macro entfernen :
IF format macro <> "" THEN
zeile := line no (ef); spalte := col (ef);
to line (ef, mark line no (ef));
read record (ef, ezeile);
change (ezeile, mark col (ef), mark col (ef) + length (format macro) + 1,
"");
write record (ef, ezeile)
END IF;
alte position einnehmen .
alte position einnehmen :
to line (ef, zeile); col (ef, spalte) .
END PROC ausschnitt drucken;
PROC markierten abschnitt kopieren :
IF exists (zwischendatei) THEN
IF eja ("""" + zwischendatei + """ löschen") THEN
forget (zwischendatei, quiet)
ELSE
errorstop ("")
END IF
END IF;
bitte warten;
PUT zwischendatei
END PROC markierten abschnitt kopieren;
PROC pageform anfang kopieren (FILE VAR ef, INT CONST zeilen) :
FILE VAR zwischen := sequential file (modify, zwischendatei);
INT VAR i;
to line (zwischen, 1);
to line (ef, 1);
FOR i FROM 1 UPTO zeilen REP
read record (ef, ezeile);
insert record (zwischen);
write record (zwischen, ezeile);
down (ef); down (zwischen)
END REP
END PROC pageform anfang kopieren;
PROC schrifttyp auswaehlen (TEXT VAR typname) :
alles neu;
auswahl anbieten ("TEXT.Fontwahl", fontfenster, 1, "AUSWAHL/Allgemein",
PROC (TEXT VAR, INT CONST) aus fonttab);
IF wahl (1) <> 0 THEN
typname := font (wahl (1))
ELSE
typname := ""
END IF
END PROC schrifttyp auswaehlen;
PROC aus fonttab (TEXT VAR name, INT CONST stelle) :
IF stelle > 49 THEN
name := ""
ELSE
name := font (stelle)
END IF
END PROC aus fonttab;
PROC gewaehlte schriftarten einstellen (TEXT CONST mod) :
INT VAR
zeile := line no (editfile),
spalte := col (editfile);
FILE VAR edfile := editfile;
read record (edfile, ezeile);
IF mark (edfile) THEN
modifikationen nachher behandeln;
modifikationen vorher behandeln
ELSE
gewaehlte modifikationen einstellen
END IF .
modifikationen nachher behandeln :
BOOL VAR geloescht;
ueber blanks zuruecksetzen;
ueber zeilenanfang zuruecksetzen;
modifikationen am ende beseitigen;
modifikationen am ende einfuegen .
ueber blanks zuruecksetzen :
WHILE spalte > 1 CAND (ezeile SUB (spalte - 1)) = " " REP
spalte DECR 1
END REP .
ueber zeilenanfang zuruecksetzen :
INT VAR stelle;
IF spalte = 1 CAND zeile > 1 THEN
up (edfile);
read record (edfile, ezeile);
stelle := length (ezeile);
IF (ezeile SUB stelle) = " " THEN stelle DECR 1 END IF
ELSE
stelle := max (spalte - 1, 1)
END IF .
modifikationen am ende beseitigen :
WHILE (ezeile SUB stelle) = "#" REP
ggf anweisung entfernen
END REP .
ggf anweisung entfernen :
INT VAR anw anf := stelle - 1;
WHILE anw anf > 1 CAND (ezeile SUB anw anf) <> "#" REP
anw anf DECR 1
END REP;
anweisung entfernen ("off", anw anf, stelle, geloescht);
IF geloescht THEN
spalte DECR (stelle - anw anf + 1)
END IF;
stelle := anw anf - 1 .
modifikationen am ende einfuegen :
IF pos (mod, "a") = 0 THEN
neue modifikationen nachher
END IF;
write record (edfile, ezeile) .
neue modifikationen nachher :
FOR i FROM length (mod) DOWNTO 1 REP
change (ezeile, spalte, spalte - 1, mod param off);
spalte INCR mod param laenge
END REP .
modifikationen vorher behandeln :
to line (edfile, mark line no (edfile));
col (edfile, mark col (edfile));
read record (edfile, ezeile);
stelle := col (edfile);
WHILE (ezeile SUB stelle) = "#" REP
ggf anfangsanweisung entfernen
END REP;
neue modifikationen am anfang einfuegen;
write record (edfile, ezeile);
to line (edfile, zeile);
col (edfile, spalte);
abschnitt neu (mark line no (edfile), zeile);
mark (edfile, 0, 0) .
ggf anfangsanweisung entfernen :
INT VAR anw ende := pos (ezeile, "#", stelle + 1);
anweisung entfernen ("on", stelle, anw ende, geloescht);
IF geloescht THEN
IF line no (edfile) = zeile THEN
spalte DECR (anw ende - stelle + 1)
END IF
ELSE
stelle := anw ende + 1
END IF .
neue modifikationen am anfang einfuegen :
IF pos (mod, "a") = 0 THEN
neue modifikationen vorher
END IF .
neue modifikationen vorher :
FOR i FROM length (mod) DOWNTO 1 REP
change (ezeile, stelle, stelle - 1, mod param on);
IF line no (edfile) = zeile THEN
spalte INCR mod param laenge
END IF
END REP .
gewaehlte modifikationen einstellen :
INT VAR i;
BOOL VAR mod aus;
mod aus := pos (mod, "a") > 0;
FOR i FROM length (mod) DOWNTO 1 REP
IF (mod SUB i) = "a" THEN
ELIF mod aus THEN
change (ezeile, spalte, spalte - 1, mod param off)
ELSE
change (ezeile, spalte, spalte - 1, mod param on)
END IF
END REP;
write record (edfile, ezeile);
abschnitt neu (zeile, zeile) .
mod param on :
TEXT VAR
mod zeichen := mod SUB i,
mod text;
IF mod zeichen = "h" THEN
mod text := "#u#"
ELIF mod zeichen = "t" THEN
mod text := "#d#"
ELSE
mod text := "#on(""" + mod zeichen + """)#"
END IF;
mod text .
mod param off :
mod zeichen := mod SUB i;
IF mod zeichen = "h" OR mod zeichen = "t" THEN
mod text := "#e#"
ELSE
mod text := "#off(""" + mod zeichen + """)#"
END IF;
mod text .
mod param laenge :
length (mod text) .
END PROC gewaehlte schriftarten einstellen;
PROC modname (TEXT VAR name, INT CONST stelle) :
SELECT stelle OF
CASE 1 : name := "Fett"
CASE 2 : name := "Kursiv"
CASE 3 : name := "Unterstrichen"
CASE 4 : name := "Hoch"
CASE 5 : name := "Tief"
CASE 6 : name := "Aus"
OTHERWISE name := ""
END SELECT
END PROC modname;
TEXT PROC gewaehlte modifikationen :
TEXT VAR ergebnis := "";
INT VAR stelle := 1;
WHILE wahl (stelle) > 0 REP
wahl merken;
stelle INCR 1
END REP;
ergebnis .
wahl merken :
SELECT wahl (stelle) OF
CASE 1 : ergebnis CAT "b"
CASE 2 : ergebnis CAT "i"
CASE 3 : ergebnis CAT "u"
CASE 4 : ergebnis CAT "h"
CASE 5 : ergebnis CAT "t"
CASE 6 : ergebnis CAT "a"
END SELECT .
END PROC gewaehlte modifikationen;
PROC anweisung entfernen (TEXT CONST anw name, INT CONST beginn, ende,
BOOL VAR geloescht) :
geloescht := FALSE;
IF beginn > 0 AND ende > 0
CAND (ezeile SUB beginn) = "#" CAND (ezeile SUB ende) = "#" THEN
INT CONST vorkommen := pos (ezeile, anw name, beginn, ende);
IF vorkommen > 0 AND vorkommen < beginn + 4
OR up down anweisung THEN
change (ezeile, beginn, ende, "");
geloescht := TRUE
END IF
END IF .
up down anweisung :
IF ende = beginn + 2 THEN
TEXT CONST alte anweisung := ezeile SUB beginn + 1;
IF anw name = "on" THEN
alte anweisung = "u" OR alte anweisung = "d"
ELSE
alte anweisung = "e"
END IF
ELSE
FALSE
END IF .
END PROC anweisung entfernen;
PROC textanweisung einfuegen (TEXT CONST anweisung, param,
BOOL CONST ab anfang) :
FILE VAR edfile := editfile;
IF ab anfang THEN col (edfile, 1) END IF;
INT CONST ce := col (edfile);
read record (edfile, ezeile);
IF (ezeile SUB ce) = "#" CAND gleiche anweisung THEN
anweisung ersetzen
ELIF ce = 1 THEN
neue zeile einfuegen
ELSE
an stelle einfuegen
END IF .
gleiche anweisung :
INT CONST apos := pos (ezeile, anweisung, ce);
apos > 0 AND pos (ezeile, "#", ce + 1) > a pos AND
(param = "" OR pos (ezeile, "(", ce) > a pos) .
anweisung ersetzen :
IF param <> "" THEN
INT CONST anf := pos (ezeile, "(", ce),
end := pos (ezeile, ")", anf);
IF anf > 0 AND end > 0 AND anf < end THEN
change (ezeile, anf + 1, end - 1, param);
write record (edfile, ezeile);
abschnitt neu (line no (edfile), line no(edfile))
END IF
END IF .
neue zeile einfuegen :
insert record (edfile);
IF param <> "" THEN
write record (edfile, "#" + anweisung + "(" + param + ")# ")
ELSE
write record (edfile, "#" + anweisung + "# ")
END IF;
abschnitt neu (line no (edfile), 9999) .
an stelle einfuegen :
IF param <> "" THEN
change (ezeile, ce, ce - 1, "#" + anweisung + "(" + param + ")#")
ELSE
change (ezeile, ce, ce - 1, "#" + anweisung + "#")
END IF;
write record (edfile, ezeile);
abschnitt neu (line no (edfile), line no (edfile)) .
END PROC textanweisung einfuegen;
LET
global anfang =
"#- Globale Einstellungen, nicht verschieben -# ",
global ende =
"#- Ende der globalen Einstellungen ----------# ";
TEXT VAR
e type := "",
e limit := "16.0",
e x start := "2.5",
e y start := "2.25",
e pagelength := "25.0",
e linefeed := "1.0";
PROC einstellung erfragen :
REP
schrifttyp auswaehlen (e type);
IF e type = "" CAND
eja ("Typ muß gewaehlt werden, Funktion abbrechen") THEN
errorstop ("")
END IF
UNTIL e type <> "" END REP;
eget ("Breite des Schreibfelds in cm:", e limit);
eget ("Länge des Schreibfelds in cm:", e pagelength);
eget ("Oberer Rand in cm:", e y start);
eget ("Linker Rand in cm:", e x start);
eget ("Zeilenabstand als relativer Faktor:", e linefeed)
END PROC einstellung erfragen;
PROC einstellung eintragen :
FILE VAR edfile := editfile;
INT VAR
zeile := line no (edfile),
spalte := col (edfile);
col (edfile, 1);
to line (edfile, 1);
read record (edfile, ezeile);
IF pos (ezeile, "type") > 0 THEN
down (edfile);
read record (edfile, ezeile);
alte einstellung suchen
END IF;
ab hier einfuegen;
an alte stelle .
alte einstellung suchen :
IF ezeile = global anfang THEN
down (edfile, global ende);
IF eof (edfile) THEN
to line (edfile, 2)
ELSE
down (edfile)
END IF
END IF .
ab hier einfuegen :
IF line no (edfile) > 1 CAND eja ("Alte Einstellung loeschen") THEN
INT CONST zu loeschen := line no (edfile) - 1;
to line (edfile, 1);
INT VAR i;
FOR i FROM 1 UPTO zu loeschen REP
delete record (edfile)
END REP;
zeile DECR zu loeschen
END IF;
typ und limit einfuegen;
global anfang einfuegen;
seitenlaenge einfuegen;
start einfuegen;
linefeed einfuegen;
global ende einfuegen .
typ und limit einfuegen :
insert record (edfile);
write record (edfile,
"#type (""" + etype + """)##limit (" + e limit + ")# ");
down (edfile) .
global anfang einfuegen :
insert record (edfile);
write record (edfile, global anfang);
down (edfile) .
seitenlaenge einfuegen :
insert record (edfile);
write record (edfile, "#pagelength (" + e pagelength + ")# ");
down (edfile) .
start einfuegen :
insert record (edfile);
write record (edfile,
"#start (" + e x start + ", " + e y start + ")# ");
down (edfile) .
linefeed einfuegen :
insert record (edfile);
write record (edfile, "#linefeed (" + e linefeed + ")# ");
down (edfile) .
global ende einfuegen :
insert record (edfile);
write record (edfile, global ende);
zeile INCR 6 .
an alte stelle :
to line (edfile, zeile);
col (edfile, spalte) .
END PROC einstellung eintragen;
(* Editor im EUDAS-Fenster *)
INT VAR return code;
LET
edit status = #1003#
"EDIT: Menü: ESC m, ESC t Abbruch: ESC h Verlassen: ESC q Hilfe: ESC ?";
BOOL VAR status frei;
PROC edit status anzeigen :
status anzeigen (edit status)
END PROC edit status anzeigen;
PROC edit (FILE VAR f, FENSTER CONST fenster, TEXT CONST hilfe) :
INT VAR x, y, x l, y l;
fenstergroesse (fenster, x, y, x l, y l);
fenster veraendert (fenster);
enable stop;
fenster datei := "";
IF groesster editor = 0 THEN status frei := y > 1 END IF;
REP
IF status frei THEN status anzeigen (edit status) END IF;
open editor (groesster editor + 1, f, TRUE, x, y, x l, y l);
edit (groesster editor, "eqvw19dpgn"9"?hFmt", PROC (TEXT CONST) kdo);
return code behandeln
END REP .
return code behandeln :
SELECT return code OF
CASE 0 : LEAVE edit
CASE 1 : hilfe anbieten (hilfe, fenster)
CASE 2 : errorstop ("")
END SELECT .
END PROC edit;
PROC kdo (TEXT CONST zeichen) :
return code := pos ("q?h", zeichen);
IF return code > 0 THEN
return code DECR 1;
quit
ELIF zeichen = "m" THEN
edit menue;
IF status frei THEN status anzeigen (edit status) END IF;
ELIF zeichen = "t" THEN
text menue;
IF status frei THEN status anzeigen (edit status) END IF;
ELSE
std kommando interpreter (zeichen);
IF status frei THEN status anzeigen (edit status) END IF;
END IF
END PROC kdo;
END PACKET edit menue;
(*
FENSTER VAR fe; fenster initialisieren (fe);
fenstergroesse setzen (fe, 1, 2, 79, 23);
FILE VAR f := sequential file (modify, "testdatei");
edit (f, fe, "EDIT/Allgemein")
*)