diff options
Diffstat (limited to 'app/eudas/4.4/doc')
52 files changed, 14644 insertions, 0 deletions
diff --git a/app/eudas/4.4/doc/ref-manual/abb.1-1 b/app/eudas/4.4/doc/ref-manual/abb.1-1 new file mode 100644 index 0000000..4f705dc --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.1-1 @@ -0,0 +1,71 @@ +init dgs; +window (0.0, 0.0, 13.5, 7.1); (*viewport (0.0,0.0,13.5,7.1); *) +scale (1.0,1.0,0.0,0.0); +(*clear pixels;*) + +karteikasten (1.0, 3.5, "Kartei A", "Wegner", "Herbert"); +karteikasten (5.0, 0.5, "Kartei B", "Regmann", "Karin"); + +LET myname = "abb.1-1"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (10000); +*) +PROC karteikasten (REAL CONST x, y, TEXT CONST name, t name, t vorname) : + + move (x - 0.1, y); + draw (x + 3.6, y); + draw (x + 3.6, y + 1.0); + draw (x - 0.1, y + 1.0); + draw (x - 0.1, y); + + move (x + 0.1, y + 1.1); + draw (x + 0.5, y + 1.5); + move (x + 0.1, y + 1.1); + draw (x + 3.6, y + 1.1); + move (x - 0.1, y + 1.0); + draw (x + 0.5, y + 1.6); + + move (x + 3.6, y); + draw (x + 5.2, y + 1.6); + draw (x + 5.2, y + 2.6); + draw (x + 3.6, y + 1.0); + move (x + 3.6, y + 1.1); draw (x + 5.0, y + 2.5); + move (x + 5.2, y + 2.6); draw (x + 5.0, y + 2.6); + + move (x + 0.5, y + 1.1); + draw (x + 0.5, y + 2.5); + draw (x + 4.0, y + 2.5); + draw (x + 4.0, y + 1.5); + move (x + 0.5, y + 2.5); + draw (x + 1.5, y + 3.5); + draw (x + 5.0, y + 3.5); + draw (x + 5.0, y + 2.5); + move (x + 5.0, y + 3.5); + draw (x + 4.0, y + 2.5); + REAL VAR x off := 0.1; + WHILE x off < 1.0 REP + move (x + 0.5 + xoff, y + 2.5 + x off); + draw (x + 4.0 + xoff, y + 2.5 + xoff); + draw (x + 4.0 + xoff, y + 1.5 + xoff); + x off INCR 0.1 + END REP; + font size (0.5); + font expansion (1.5); + move (x + 0.5, y + 0.2); draw (name); + font size (0.25); + move (x + 0.7, y + 2.10); draw ("Name"); + move (x + 0.7, y + 1.65); draw ("Vorname"); + move (x + 0.7, y + 1.20); draw ("Strasse"); + move (x + 2.1, y + 2.10); draw (": " + t name); + move (x + 2.1, y + 1.65); draw (": " + t vorname); + move (x + 2.1, y + 1.20); draw (":"); + +END PROC karteikasten; + diff --git a/app/eudas/4.4/doc/ref-manual/abb.4-1 b/app/eudas/4.4/doc/ref-manual/abb.4-1 new file mode 100644 index 0000000..439e052 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.4-1 @@ -0,0 +1,43 @@ +init dgs; +window (0.0, 0.0, 13.5, 3.2); viewport (0.0,0.0,13.5,3.2); +(* scale (2.0,2.0,0.0,0.0); *) +(*clear pixels;*) + +font size (0.25); +font expansion (1.5); + +INT VAR i; +FOR i FROM 0 UPTO 4 REP + move (2.0, real (i) * 0.5); + draw (10.0, real (i) * 0.5); + move (2.1, real (i) * 0.5 + 0.1); + draw ("Feld " + code (code ("E") - i)); +END REP; +move (2.0, 2.5); +draw (10.0, 2.5); +move (2.0, 2.5); +draw (2.0, 0.0); +move (3.5, 3.0); +draw (10.0, 3.0); +FOR i FROM 1 UPTO 4 REP + move (2.0 + real (i) * 1.5, 3.0); + draw (2.0 + real (i) * 1.5, 0.0); + move (2.2 + real (i) * 1.5, 2.6); + draw ("Satz " + text (i)) +END REP; +move (9.5, 3.0); +draw (9.5, 0.0); +(* +pause (1000); +*) + +LET myname = "abb.4-1"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); + + diff --git a/app/eudas/4.4/doc/ref-manual/abb.4-2 b/app/eudas/4.4/doc/ref-manual/abb.4-2 new file mode 100644 index 0000000..a836def --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.4-2 @@ -0,0 +1,46 @@ +init dgs; +window (0.0, 0.0, 13.5, 2.0); viewport (0.0,0.0,13.5,2.0); +(*scale (1.7,1.7,-1.6,0.0);*) +(* +clear pixels; +*) + +kasten (1.0, 0.0, 3.0, 1.5); +kasten (7.0, 0.0, 3.0, 1.5); +font size (0.4); font expansion (1.5); +move (1.8, 0.6); draw ("Menü"); +move (7.9, 0.6); draw ("Hilfe"); +move (4.5, 1.0); draw (6.5, 1.0); + draw (6.25, 1.25); move (6.5, 1.0); draw (6.25, 0.75); +move (6.5, 0.5); draw (4.5, 0.5); + draw (4.75, 0.75); move (4.5, 0.5); draw (4.75, 0.25); +font size (0.25); +move (5.0, 1.1); draw ("ESC '?'"); +move (5.0, 0.6); draw ("ESC 'q'"); +move (10.5, 1.0); draw (11.5, 1.0); draw (11.5, 0.5); draw (10.5, 0.5); + draw (10.75, 0.75); move (10.5, 0.5); draw (10.75, 0.25); +move (11.8, 0.9); draw ("ESC 'w'"); +move (11.8, 0.4); draw ("ESC 'z'"); + + +LET myname = "abb.4-2"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000); +*) +PROC kasten (REAL CONST x anf, y anf, x l, y l) : + + move (x anf, y anf); + draw (x anf, y anf + y l); + draw (x anf + x l, y anf + y l); + draw (x anf + x l, y anf); + draw (x anf, y anf) + +END PROC kasten; + diff --git a/app/eudas/4.4/doc/ref-manual/abb.6-1 b/app/eudas/4.4/doc/ref-manual/abb.6-1 new file mode 100644 index 0000000..fb83242 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.6-1 @@ -0,0 +1,75 @@ +init dgs; +window (0.0, 0.0, 13.5, 4.0); viewport (0.0,0.0,13.5,4.0); +(*scale (1.0,1.0, 0.0,0.0);*) +(* +clear pixels; +*) + +move (2.25, 1.0); draw (4.75, 1.0); +move (2.25, 3.0); draw (4.75, 3.0); + move (2.5, 1.0); draw (2.5, 3.3); + move (3.0, 1.0); draw (3.0, 3.3); + move (3.5, 1.0); draw (3.5, 3.3); + move (4.0, 1.0); draw (4.0, 3.3); + move (4.5, 1.0); draw (4.5, 3.3); +font size (0.30); font expansion (1.5); +move (2.6, 3.1); draw ("4"); +move (2.6, 2.0); draw ("M"); +move (3.1, 3.1); draw ("5"); +move (3.1, 2.0); draw ("N"); +move (3.6, 3.1); draw ("6"); +move (3.6, 2.0); draw ("O"); +move (4.1, 3.1); draw ("7"); +move (4.1, 2.0); draw ("P"); + pfeil (3.75, 0.75); + +move (5.0, 2.0); draw (7.0, 2.0); draw (6.75, 2.25); + move (7.0, 2.0); draw (6.75, 1.75); +move (5.0, 2.1); draw ("Einfügen"); + +move (7.25, 1.0); draw (8.5, 1.0); move (9.0, 1.0); draw (10.25, 1.0); +move (7.25, 3.0); draw (8.5, 3.0); move (9.0, 3.0); draw (10.25, 3.0); + move (7.5, 1.0); draw (7.5, 3.3); + move (8.0, 1.0); draw (8.0, 3.3); + move (8.5, 1.0); draw (8.5, 3.3); + move (9.0, 1.0); draw (9.0, 3.3); + move (9.5, 1.0); draw (9.5, 3.3); + move (10.0, 1.0); draw (10.0, 3.3); +move (7.6, 3.1); draw ("4"); +move (7.6, 2.0); draw ("M"); +move (8.1, 3.1); draw ("5"); +move (8.1, 2.0); draw ("N"); +move (8.6, 3.1); draw ("6"); +move (9.1, 3.1); draw ("7"); +move (9.1, 2.0); draw ("O"); +move (9.6, 3.1); draw ("8"); +move (9.6, 2.0); draw ("P"); + +pfeil (8.75, 0.75); + +PROC pfeil (REAL CONST x spitze, y spitze) : + + move (x spitze, y spitze); + draw (x spitze + 0.25, y spitze - 0.25); + draw (x spitze + 0.1, y spitze - 0.25); + draw (x spitze + 0.1, y spitze - 0.5); + draw (x spitze - 0.1, y spitze - 0.5); + draw (x spitze - 0.1, y spitze - 0.25); + draw (x spitze - 0.25, y spitze - 0.25); + draw (x spitze, y spitze) + +END PROC pfeil; + + +LET myname = "abb.6-1"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000) +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.6-2 b/app/eudas/4.4/doc/ref-manual/abb.6-2 new file mode 100644 index 0000000..7771a29 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.6-2 @@ -0,0 +1,77 @@ +init dgs; +window (0.0, 0.0, 13.5, 5.0); viewport (0.0,0.0,13.5,5.0); +(*scale (1.4,1.4, 0.0,0.0);*) +(*clear pixels;*) + +move (2.5, 4.5); draw (12.4, 4.5); draw (12.4, 4.0); draw (11.0, 4.0); + draw (11.0, 3.5); move (10.5, 3.5); draw (10.5, 4.0); draw (2.5, 4.0); +move (13.5, 4.5); draw (12.5, 4.5); draw (12.5, 3.5); move (13.0, 3.5); + draw (13.0, 4.0); draw (13.5, 4.0); +move (2.5, 3.5); draw (13.5, 3.5); move (13.5, 3.0); draw (10.0, 3.0); + draw (10.0, 2.5); move (9.5, 2.5); draw (9.5, 3.0); draw (2.5, 3.0); +move (10.5, 3.0); draw (10.5, 2.5); move (11.0, 2.5); draw (11.0, 3.0); +move (12.5, 2.5); draw (12.5, 3.0); move (13.0, 3.0); draw (13.0, 2.5); +move (2.5, 2.5); draw (6.4, 2.5); draw (6.4, 2.0); draw (4.0, 2.0); + draw (4.0, 1.5); draw (6.5, 1.5); draw (6.5, 2.5); draw (13.5, 2.5); + move (13.5, 2.0); draw (7.0, 2.0); draw (7.0, 1.5); draw (9.0, 1.5); + draw (9.0, 1.0); draw (3.5, 1.0); draw (3.5, 2.0); draw (2.5, 2.0); +move (9.5, 2.0); draw (9.5, 1.0); draw (10.4, 1.0); draw (10.4, 1.5); + draw (10.0, 1.5); draw (10.0, 2.0); +move (10.5, 2.0); draw (10.5, 1.0); draw (13.0, 1.0); draw (13.0, 2.0); + move (11.0, 2.0); draw (11.0, 1.5); draw (12.5, 1.5); draw (12.5, 2.0); +move (4.5, 1.5); draw (4.75, 1.25); draw (4.5, 1.0); +move (5.5, 1.5); draw (5.75, 1.25); draw (5.5, 1.0); +move (7.5, 1.5); draw (7.75, 1.25); draw (7.5, 1.0); +move (11.5, 1.5); draw (11.75, 1.25); draw (11.5, 1.0); + +font size (0.25); font expansion (1.4); +move (2.5, 4.1); draw ("K0"); +move (2.5, 3.1); draw ("N0"); +move (2.5, 2.1); draw ("A0"); + +move (0.0, 4.1); draw ("'Kalender'"); +move (0.0, 3.1); draw ("'Namen'"); +move (0.0, 2.1); draw ("'Adressen'"); +move (0.0, 1.1); draw ("Arbeitskopie"); + +move (4.9, 1.1); draw ("A1"); +move (5.9, 1.1); draw ("A2"); +move (7.9, 1.1); draw ("A3"); +move (11.9, 1.1); draw ("K1"); + +x alignment (right); +move (13.5, 4.1); draw ("K1"); +move (13.5, 3.1); draw ("N0"); +move (13.5, 2.1); draw ("A2"); + +x alignment (normal); +font size (0.2); +INT VAR i; +FOR i FROM 0 UPTO 10 REP + time (2.5 + real (i) * 1.0, i) +END REP; + +PROC time (REAL CONST x pos, INT CONST nr) : + + move (x pos, 4.9); draw (x pos, 4.6); + move (x pos, 3.9); draw (x pos, 3.6); + move (x pos, 2.9); draw (x pos, 2.6); + move (x pos, 1.9); draw (x pos, 1.6); + move (x pos, 0.9); draw (x pos, 0.6); + move (x pos + 0.1, 0.6); draw (text (nr)) + +END PROC time; + + +LET myname = "abb.6-2"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000); +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.7-1 b/app/eudas/4.4/doc/ref-manual/abb.7-1 new file mode 100644 index 0000000..3536ad9 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.7-1 @@ -0,0 +1,46 @@ +init dgs; +window (0.0, 0.0, 13.5, 6.0); viewport (0.0,0.0,13.5,6.0); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +kasten (5.0, 4.5, 3.0, 1.0); +kasten (5.0, 1.5, 3.0, 1.0); +kasten (1.5, 3.0, 3.0, 1.0); +font size (0.35); font expansion (1.5); +x alignment (center); +move (6.5, 4.8); draw ("Druckmuster"); +move (6.5, 1.8); draw ("Druckdatei"); +move (3.0, 3.3); draw ("EUDAS-Datei"); +move (6.5, 0.0); draw ("Drucker"); + +move (6.5, 4.25); draw (6.5, 2.75); draw (6.25, 3.0); + move (6.5, 2.75); draw (6.75, 3.0); +move (4.75, 3.5); draw (6.25, 3.5); draw (6.0, 3.75); + move (6.25, 3.5); draw (6.0, 3.25); +move (6.5, 1.25); draw (6.5, 0.5); draw (6.75, 0.75); + move (6.5, 0.5); draw (6.25, 0.75); + + +PROC kasten (REAL CONST x anf, y anf, x l, y l) : + + move (x anf, y anf); + draw (x anf, y anf + y l); + draw (x anf + x l, y anf + y l); + draw (x anf + x l, y anf); + draw (x anf, y anf) + +END PROC kasten; + + +LET myname = "abb.7-1"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000); +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-1 b/app/eudas/4.4/doc/ref-manual/abb.9-1 new file mode 100644 index 0000000..774b78b --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.9-1 @@ -0,0 +1,41 @@ +init dgs; +window (0.0, 0.0, 13.5, 4.0); viewport (0.0,0.0,13.5,4.0); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +move (1.5, 1.0); draw (8.75, 1.0); +move (1.5, 3.5); draw (8.75, 3.5); +INT VAR i; +FOR i FROM 0 UPTO 9 REP + move (1.75 + real (i) * 0.75, 3.7); + draw (1.75 + real (i) * 0.75, 1.0); +END REP; + +move (4.7, 3.7); draw (4.7, 1.0); + +font size (0.25); font expansion (1.5); +x alignment (center); +FOR i FROM 0 UPTO 8 REP + move (2.125 + real (i) * 0.75, 3.6); draw (text (i + 110)) +END REP; +FOR i FROM 1 UPTO 5 REP + move (2.125 + real (i + 3) * 0.75, 0.6); draw ("(" + text (i) + ")") +END REP; + +font size (0.35); x alignment (left); +move (2.0, 0.0); draw ("Datei A"); +move (5.0, 0.0); draw ("Datei B"); + + +LET myname = "abb.9-1"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000) +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-2 b/app/eudas/4.4/doc/ref-manual/abb.9-2 new file mode 100644 index 0000000..4e9444d --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.9-2 @@ -0,0 +1,96 @@ +init dgs; +window (0.0, 0.0, 13.5, 6.5); viewport (0.0,0.0,13.5,6.5); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +INT VAR i; +move (4.0, 0.0); draw (4.0, 2.0); +move (5.5, 0.0); draw (5.5, 2.0); +FOR i FROM 0 UPTO 4 REP + move (4.0, real (i) * 0.5); + draw (5.5, real (i) * 0.5) +END REP; + +move (4.0, 3.0); draw (4.0, 6.0); +move (5.5, 3.0); draw (5.5, 6.0); +FOR i FROM 0 UPTO 6 REP + move (4.0, real (i) * 0.5 + 3.0); + draw (5.5, real (i) * 0.5 + 3.0) +END REP; + +move (7.5, 2.0); draw (7.5, 6.0); +move (9.0, 2.0); draw (9.0, 6.0); +FOR i FROM 0 UPTO 8 REP + move (7.5, real (i) * 0.5 + 2.0); + draw (9.0, real (i) * 0.5 + 2.0) +END REP; + +strichel (5.5, 6.0, 7.5, 6.0); +strichel (5.5, 3.0, 7.5, 3.0); +strichel (5.5, 1.0, 7.5, 3.0); +strichel (5.5, 0.0, 7.5, 2.0); + +move (5.5, 4.75); draw (6.0, 4.75); + draw (6.0, 1.75); draw (5.5, 1.75); +move (4.0, 3.75); draw (3.5, 3.75); + draw (3.5, 1.25); draw (4.0, 1.25); + +font size (0.4); font expansion (1.5); +move (0.0, 0.8); draw ("Koppeldatei"); +move (0.0, 4.3); draw ("Hauptdatei"); +move (10.0, 4.3); draw ("virtuelle"); +move (10.0, 3.4); draw ("Datei"); + +font size (0.3); +move (4.5, 0.1); draw ("H2"); +move (4.5, 0.6); draw ("H1"); +move (4.5, 1.1); draw ("B"); +move (4.5, 1.6); draw ("A"); +move (4.5, 3.1); draw ("F4"); +move (4.5, 3.6); draw ("B"); +move (4.5, 4.1); draw ("F3"); +move (4.5, 4.6); draw ("A"); +move (4.5, 5.1); draw ("F2"); +move (4.5, 5.6); draw ("F1"); +move (8.0, 5.6); draw ("F1"); +move (8.0, 5.1); draw ("F2"); +move (8.0, 4.6); draw ("A"); +move (8.0, 4.1); draw ("F3"); +move (8.0, 3.6); draw ("B"); +move (8.0, 3.1); draw ("F4"); +move (8.0, 2.6); draw ("H1"); +move (8.0, 2.1); draw ("H2"); + +PROC strichel (REAL CONST x anf, y anf, x end, y end) : + + REAL VAR laenge := x end - x anf; + INT VAR teile := int (abstand/ 0.4); + REAL VAR verhaeltnis := (y end - y anf) / laenge; + laenge := laenge / (real (2 * teile + 1)); + INT VAR i; + FOR i FROM 0 UPTO teile REP + move (x anf + real (i + i) * laenge, + y anf + verhaeltnis * real (i + i) * laenge); + draw (x anf + real (i + i + 1) * laenge, + y anf + verhaeltnis * real (i + i + 1) * laenge) + END REP . + +abstand : + sqrt ((y end - y anf) + (y end - y anf) + + (x end - x anf) * (x end - x anf)) . + +END PROC strichel; + + +LET myname = "abb.9-2"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000); +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-3 b/app/eudas/4.4/doc/ref-manual/abb.9-3 new file mode 100644 index 0000000..9b190ab --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.9-3 @@ -0,0 +1,113 @@ +init dgs; +window (0.0, 0.0, 13.5, 7.0); viewport (0.0,0.0,13.5,7.0); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +x alignment (center); +font size (0.3); font expansion (1.2); +kasten (1.5, 5.0, 2.0, 1.5); +move (2.5, 5.9); draw ("EUDAS-"); +move (2.5, 5.3); draw ("Datei 1"); +move (3.5, 5.75); draw (4.0, 5.75); +kasten (4.0, 5.0, 2.0, 1.5); +move (5.0, 5.9); draw ("gekettete"); +move (5.0, 5.3); draw ("Datei A"); +move (6.0, 5.75); draw (6.5, 5.75); +kasten (6.5, 5.0, 2.0, 1.5); +move (7.5, 5.9); draw ("gekettete"); +move (7.5, 5.3); draw ("Datei B"); +kasten (1.5, 2.0, 2.0, 1.5); +move (2.5, 2.9); draw ("gekoppelte"); +move (2.5, 2.3); draw ("Datei C"); +kasten (4.0, 0.0, 2.0, 1.5); +move (5.0, 0.9); draw ("gekoppelte"); +move (5.0, 0.3); draw ("Datei D"); + +punkt (9.0, 5.75); +punkt (9.25, 5.75); +punkt (9.5, 5.75); + +strichel (1.0, 4.5, 10.0, 4.5); +strichel (1.0, 7.0, 10.0, 7.0); +strichel (1.0, 4.5, 1.0, 7.0); +x alignment (right); font size (0.4); +move (10.0, 3.9); +draw ("Hauptdatei"); + +punkt (2.5, 3.75); +punkt (2.5, 4.0); +punkt (2.5, 4.25); + +punkt (5.0, 1.75); +punkt (5.0, 2.0); +punkt (5.0, 2.25); +punkt (5.0, 2.5); +punkt (5.0, 2.75); +punkt (5.0, 3.0); +punkt (5.0, 3.25); +punkt (5.0, 3.5); +punkt (5.0, 3.75); +punkt (5.0, 4.0); +punkt (5.0, 4.25); + +PROC punkt (REAL CONST x pos, y pos) : + + LET p size = 0.025; + move (x pos, y pos + p size); + draw (x pos + p size, y pos); + draw (x pos, y pos - p size); + draw (x pos - p size, y pos); + draw (x pos, y pos + p size) + +END PROC punkt; + + +PROC strichel (REAL CONST x anf, y anf, x end, y end) : + + REAL VAR laenge := x end - x anf; + INT VAR teile := int (abstand/ 0.4); + REAL VAR senkrecht, verhaeltnis; + IF laenge <> 0.0 THEN + verhaeltnis := (y end - y anf) / laenge; senkrecht := 1.0 + ELSE + verhaeltnis := 1.0; senkrecht := 0.0 ; + laenge := y end - y anf + END IF; + laenge := laenge / (real (2 * teile + 1)); + INT VAR i; + FOR i FROM 0 UPTO teile REP + move (x anf + real (i + i) * laenge * senkrecht, + y anf + verhaeltnis * real (i + i) * laenge); + draw (x anf + real (i + i + 1) * laenge * senkrecht, + y anf + verhaeltnis * real (i + i + 1) * laenge) + END REP . + +abstand : + sqrt ((y end - y anf) * (y end - y anf) + + (x end - x anf) * (x end - x anf)) . + +END PROC strichel; + +PROC kasten (REAL CONST x anf, y anf, x l, y l) : + + move (x anf, y anf); + draw (x anf, y anf + y l); + draw (x anf + x l, y anf + y l); + draw (x anf + x l, y anf); + draw (x anf, y anf) + +END PROC kasten; + + +LET myname = "abb.9-3"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000) +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-4 b/app/eudas/4.4/doc/ref-manual/abb.9-4 new file mode 100644 index 0000000..e243265 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.9-4 @@ -0,0 +1,98 @@ +init dgs; +window (0.0, 0.0, 13.5, 6.0); viewport (0.0,0.0,13.5,6.0); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +kasten (2.0, 1.0, 1.4, 2.0); +kasten (3.5, 1.0, 1.4, 2.0); +kasten (6.5, 1.0, 1.4, 2.0); +kasten (2.0, 3.4, 1.4, 2.0); +kasten (5.0, 3.4, 1.4, 2.0); +kasten (6.5, 3.4, 1.4, 2.0); + strichel (3.5, 3.4, 3.5, 5.4); + strichel (3.5, 5.4, 4.9, 5.4); + strichel (4.9, 5.4, 4.9, 3.4); + strichel (4.9, 3.4, 3.5, 3.4); +move (1.9, 2.7); draw (1.5, 2.7); +draw (1.5, 4.6); draw (1.9, 4.6); + +x alignment (center); +font size (0.3); font expansion (1.4); + +move (2.7, 5.6); draw ("22-1"); +move (2.7, 4.9); draw ("X"); +move (2.7, 4.4); draw ("K"); +move (2.7, 2.5); draw ("K"); +move (2.7, 2.0); draw ("N1"); +move (2.7, 0.4); draw ("(114)"); + +move (4.2, 5.6); draw ("22-2"); +move (4.2, 4.9); draw ("X"); +move (4.2, 4.4); draw ("K"); +move (4.2, 2.5); draw ("K"); +move (4.2, 2.0); draw ("N2"); +move (4.2, 0.4); draw ("(209)"); + +move (5.7, 5.6); draw ("23-1"); +move (5.7, 4.9); draw ("Y"); +move (5.7, 4.4); draw ("L"); + +move (7.2, 5.6); draw ("24-1"); +move (7.2, 4.9); draw ("Z"); +move (7.2, 4.4); draw ("M"); +move (7.2, 2.5); draw ("M"); +move (7.2, 0.4); draw ("(17)"); + +font size (0.4); x alignment (normal); +move (8.5, 2.0); draw ("Koppeldatei"); +move (8.5, 4.4); draw ("Hauptdatei"); + +PROC strichel (REAL CONST x anf, y anf, x end, y end) : + + REAL VAR laenge := x end - x anf; + INT VAR teile := int (abstand/ 0.4); + REAL VAR senkrecht, verhaeltnis; + IF laenge <> 0.0 THEN + verhaeltnis := (y end - y anf) / laenge; senkrecht := 1.0 + ELSE + verhaeltnis := 1.0; senkrecht := 0.0 ; + laenge := y end - y anf + END IF; + laenge := laenge / (real (2 * teile + 1)); + INT VAR i; + FOR i FROM 0 UPTO teile REP + move (x anf + real (i + i) * laenge * senkrecht, + y anf + verhaeltnis * real (i + i) * laenge); + draw (x anf + real (i + i + 1) * laenge * senkrecht, + y anf + verhaeltnis * real (i + i + 1) * laenge) + END REP . + +abstand : + sqrt ((y end - y anf) * (y end - y anf) + + (x end - x anf) * (x end - x anf)) . + +END PROC strichel; + +PROC kasten (REAL CONST x anf, y anf, x l, y l) : + + move (x anf, y anf); + draw (x anf, y anf + y l); + draw (x anf + x l, y anf + y l); + draw (x anf + x l, y anf); + draw (x anf, y anf) + +END PROC kasten; + + +LET myname = "abb.9-4"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000) +*) + diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-5 b/app/eudas/4.4/doc/ref-manual/abb.9-5 new file mode 100644 index 0000000..c00655c --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/abb.9-5 @@ -0,0 +1,51 @@ +init dgs; +window (0.0, 0.0, 13.5, 7.0); viewport (0.0,0.0,13.5,7.0); +(*scale (1.7,1.7, 0.0,0.0);*) +(*clear pixels;*) + +kasten (1.5, 0.0, 3.5, 2.0); +kasten (7.0, 0.0, 3.5, 2.0); +kasten (4.0, 4.0, 4.0, 3.0); + kasten (5.0, 5.5, 2.0, 1.0); + +move (3.25, 2.25); draw (4.75, 3.75); + draw (4.5, 3.75); move (4.75, 3.75); draw (4.75, 3.5); + move (3.25, 2.25); draw (3.5, 2.25); + move (3.25, 2.25); draw (3.25, 2.5); +move (8.75, 2.25); draw (7.25, 3.75); + draw (7.5, 3.75); move (7.25, 3.75); draw (7.25, 3.5); + move (8.75, 2.25); draw (8.5, 2.25); + move (8.75, 2.25); draw (8.75, 2.5); + +x alignment (center); +font size (0.4); font expansion (1.4); + +move (3.25, 0.2); draw ("Benutzer A"); +move (8.75, 0.2); draw ("Benutzer B"); +move (6.0, 4.3); draw ("Manager"); +font size (0.3); +move (6.0, 5.6); draw ("Kunden"); + +PROC kasten (REAL CONST x anf, y anf, x l, y l) : + + move (x anf, y anf); + draw (x anf, y anf + y l); + draw (x anf + x l, y anf + y l); + draw (x anf + x l, y anf); + draw (x anf, y anf) + +END PROC kasten; + + +LET myname = "abb.9-5"; +save pixels (myname + ".p"); +FILE VAR f := sequential file (modify, myname + ".p"); +to line (f, 1); insert record (f); +write record (f, "#linefeed (0.8)#"); +insert record (f); write record (f, myname); +to eof (f); insert record (f); write record (f, myname); +to line (f, 1); +(* +pause (9000) +*) + diff --git a/app/eudas/4.4/doc/ref-manual/bildergenerator b/app/eudas/4.4/doc/ref-manual/bildergenerator new file mode 100644 index 0000000..8129476 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/bildergenerator @@ -0,0 +1,25 @@ +PROC starten : + + command dialogue (FALSE); + disable stop; + fetch (name, /"DGS NEC"); + run (name); + save (name + ".p", /"DGS NEC"); + end (myself) + +END PROC starten; + +TEXT VAR name; + +PROC gen (TEXT CONST t) : + + name := t; + begin ("p", PROC starten, a); + TASK VAR a; + WHILE exists (a) REP pause (100) END REP + +END PROC gen; + +gen ("abb.4-2"); +gen ("abb.6-1"); + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.1 b/app/eudas/4.4/doc/ref-manual/eudas.ref.1 new file mode 100644 index 0000000..4ca390a --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.1 @@ -0,0 +1,323 @@ +#type ("prop")##limit (14.0)# +#format# +#page (3)# +#kapitel ("1", "Zustände", "und", "Bedienung")# + + + +#abschnitt ("1.1", "ZUSTÄNDE", "Zustände")# + +EUDAS befindet sich zu jeder Zeit in einem von 11 verschiedenen +Zuständen. Für jeden Zustand ist festgelegt, welche Eingabetasten +benutzt werden können und welche Wirkung sie haben. Bestimmte +Tastenfunktionen führen in einen anderen Zustand. Obwohl für +jeden Zustand andere Tastenkombinationen gültig sind, wird für die +gleiche Funktion in jedem Zustand auch die gleiche Taste oder +Tastenkombination verwendet. + Die wichtigsten Tastenfunktionen eines Zustandes werden in +der #on("i")#Statuszeile#off("i")# am oberen Bildschirmrand angezeigt. + Im folgenden sind alle möglichen Zustände als Übersicht be +schrieben. Eine Übersicht der Zustandsübergänge enthält Abb. 1-1. + Zu jedem Zustand wird die entsprechende Statuszeile darge +stellt sowie alle möglichen Tastenfunktionen und ihre Bedeutung. + +#bildschirm# +EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv +#text# +_____________________________________________________ + +OBEN Anwahl der nächsthöheren Funktion +UNTEN Anwahl der nächsttieferen Funktion +RECHTS Anwahl des nächsten Menüs zur Rechten +LINKS Anwahl des nächsten Menüs zur Linken +HOP OBEN Anwahl der ersten Funktion +HOP UNTEN Anwahl der letzten Funktion +'1' .. '6' Anwahl des entsprechenden Menüs +LEER Ausführen der gewählten Funktion +'Buchstabe' Ausführen der Funktion mit 'Buchstabe' davor +ESC '?' Hilfestellung zur gewählten Funktion +ESC ESC Eingabe von ELAN-Kommandos + + +#bildschirm# +HILFE: Beenden: ESC q Seite weiter: ESC w Seite zurueck: ESC z +#text# +_____________________________________________________ + +ESC 'w' Blättern zur nächsten Seite +ESC 'z' Blättern zur vorigen Seite +ESC 'q' Verlassen (Rückkehr in alten Zustand) + + +#bildschirm# +AUSWAHL: Ankreuzen: 'x' Durchstreichen: 'o' Beenden: ESC q Hilfe: ESC ? +#text# +_____________________________________________________ + +'x' Auswahl ankreuzen +'o' Ankreuzen rückgängig machen +LEER Ankreuzen und Auswahl sofort verlassen +OBEN Zur nächsten Auswahl nach oben +UNTEN Zur nächsten Auswahl nach unten +HOP OBEN Zur obersten Auswahl bzw. eine Seite zurück +HOP UNTEN Zur untersten Auswahl bzw. eine Seite weiter +HOP RETURN Aktuelle Auswahl wird erste auf der Seite +ESC '1' zur ersten Auswahl +ESC '9' zur letzten Auswahl +ESC 'q' Auswahl verlassen und weitermachen +ESC '?' Hilfe zur Auswahl +HOP 'x' alle freien Wahlen ankreuzen +HOP 'o' alle Kreuze entfernen +ESC 'h' Auswahl und Funktion abbrechen + + +#bildschirm# +EINGABE: Bestätigen: RETURN Zeigen: ESC z Abbrechen: ESC h Hilfe: ESC ? +#text# +_____________________________________________________ + +RECHTS zum nächsten Zeichen +LINKS zum vorigen Zeichen +HOP RECHTS zum letzten Zeichen +HOP LINKS zum ersten Zeichen +RUBOUT Zeichen löschen +RUBIN Einfügemodus umschalten +HOP RUBOUT Rest der Zeile löschen +'Zeichen' Zeichen überschreiben oder einfügen +RETURN Eingabe abschließen und weitermachen +ESC '?' Hilfe zur Eingabe +ESC 'h' Eingabe und Funktion abbrechen +ESC 'z' Auswahl zeigen (falls in Statuszeile aufgeführt) + + +#bildschirm# +FRAGE: Bejahen: j,J Verneinen: n,N Abbrechen: ESC h Hilfe: ESC ? +#text# +_____________________________________________________ + +'j', 'J' Frage bejahen +'n', 'N' Frage verneinen +ESC '?' Hilfe zur Frage +ESC 'h' Frage und Funktion abbrechen + + +#bildschirm# +!!! FEHLER !!! Quittieren: ESC q Hilfe zur Meldung: ESC ? +#text# +_____________________________________________________ + +ESC '?' Hilfe zum Fehler +ESC 'Taste' Fehler quittieren +'Taste' Fehler quittieren + + +#bildschirm# +SATZ ÄNDERN: Abbruch: ESC h Beenden: ESC q Hilfe: ESC ? +SATZ EINFÜGEN: Abbruch: ESC h Beenden: ESC q Hilfe: ESC ? +SUCHMUSTER EINGEBEN: Abbruch: ESC h Beenden: ESC q Hilfe: ESC ? +#text# +_____________________________________________________ + +ESC OBEN eine Seite zurück blättern +ESC UNTEN eine Seite vor blättern +ESC '?' Hilfe zum Satzeditor +ESC 'p' ganzen Satz merken (nicht bei Suchmuster) +ESC 'g' Satz durch gemerkten ersetzen (nicht bei Such + muster) +ESC 'h' Abbruch der Funktion +ESC 'D' Tagesdatum schreiben +ESC 'F' Prüffehler nach Tragen editieren +ESC 'w' Verlassen und mit nächstem Satz erneut aufrufen + (nicht im Suchmuster) +ESC 'z' Verlassen und mit vorigem Satz erneut aufrufen + (nicht im Suchmuster) +ESC RUBIN Rest der Zeile in neue Zeile umbrechen +ESC RUBOUT Rest der Zeile löschen +HOP RUBIN nicht verwenden! +HOP RUBOUT nicht verwenden! +#f2# +Weitere Tasten siehe EUMEL-Benutzerhandbuch (Editor). + + +#bildschirm# +Bitte warten.. +#text# +_____________________________________________________ + +keine Tasten erlaubt (außer SV) + + +#bildschirm# +ZEIGEN: Blättern: HOP OBEN, HOP UNTEN Ende: ESC q Hilfe: ESC ? +#text# +_____________________________________________________ + +HOP OBEN auf erste Zeile bzw. eine Seite zurück +HOP UNTEN auf letzte Zeile bzw. eine Seite vor +ESC '?' Hilfe zur Übersicht +ESC 'h' Abbruch der Funktion +ESC 'q' Verlassen + + +#bildschirm# +EDITIEREN: Abbruch: ESC h Verlassen: ESC q Hilfe: ESC ? +#text# +_____________________________________________________ + +ESC 'F' Feldnamen anzeigen und auswählen +ESC 'h' Abbruch der Funktion +#f2# +Weitere Tasten siehe EUMEL-Benutzerhandbuch (Editor). + + +#bildschirm# +Gib Kommando: +#text# +_____________________________________________________ + +Tasten siehe EINGABE. + + +#free (18.5)# +#beispiel# +#center#Abb. 1-1 Zustandsübergänge +#text# + + + +#abschnitt ("1.2", "MENÜS", "Menüs")# + +Menüs dienen zur Auswahl von Funktionen. Sie werden am linken +Rand des Bildschirms angezeigt. Welches Menü aktiv ist, wird durch +Markierung des Menünamens in der obersten Bildschirmzeile unter +allen zur Verfügung stehenden Menüs angezeigt. In jedem Menü ist +die zuletzt ausgeführte Funktion ebenfalls markiert. + +#a ("Ausführen von Funktionen")# Zum Ausführen einer bestimmten Funk +tion wird mit Hilfe der Cursortasten ein bestimmtes Menü und die +gewünschte Funktion angewählt. Die Funktion wird dann durch +Drücken der Leertaste ausgeführt. Alternativ kann auch der vor der +Funktion stehende Buchstabe gedrückt werden. + Die einzelnen Menüs können auch durch Nummern (1 bis 6) +angewählt werden (absolute Positionierung). + Soll eine andere Taste als die Leertaste zum Ausführen ver +wendet werden, so kann dies durch die Prozedur 'ausfuehrtaste' +angegeben werden (s. Abschnitt 10.3). + Funktionen, deren Ausführung augenblicklich nicht möglich +oder nicht sinnvoll ist, werden durch ein vorangestelltes Minuszei +chen gekennzeichnet. Sie können zwar angewählt, nicht aber ausge +führt werden. + Durch ESC '?' wird ein erläuternder Hilfstext zur gerade ange +wählten Funktion angezeigt. Näheres dazu s. Abschnitt 1.4. + Durch ESC ESC kann ein beliebiges ELAN-Kommando eingegeben +und ausgeführt werden. Die Eingabe des Kommandos erfolgt in der +Statuszeile. + + +#abschnitt ("1.3", "AUSWAHL", "Auswahl")# + +Die Auswahlfunktion dient dazu, aus vorhandenen Datei- oder +Feldnamen in bestimmter Reihenfolge auszuwählen. Die einzelnen +Namen werden untereinander aufgelistet. + Vor jedem Namen ist ein 'o' zum Ankreuzen angegeben. Mit den +Cursortasten kann der Cursor vor einen bestimmten Namen positio +niert werden. Mit 'x' kann dieser Name dann angekreuzt werden. Das +Ankreuzen kann durch 'o' wieder rückgängig gemacht werden. + Die Reihenfolge des Ankreuzens wird durch vorangestellte +Nummern gekennzeichnet. Die Namen werden von der entsprechenden +Funktion später in genau dieser Reihenfolge verwendet. + Wenn nicht alle Namen auf den Bildschirm passen, kann die +Darstellung gerollt werden. Ein Teil der Überschrift bleibt dabei +stehen; am Anfang und am Ende wird jeweils eine Abschlußzeile zur +Kennzeichnung mitgerollt. + Mit ESC '?' kann eine Hilfestellung abgerufen werden. Mit ESC +'q' wird die Auswahl beendet. Mit ESC 'h' können die Auswahl und +die in Ausführung befindliche Operation abgebrochen werden. + + +#abschnitt ("1.4", "HILFE UND DIALOG", "Hilfe und Dialog")# + +In den meisten Situationen kann durch ESC '?' eine spezifische +Hilfestellung abgerufen werden. Die Anzeige der Hilfsinformation +geschieht im rechten Bildschirmteil. + Die Texte sind seitenweise aufgebaut. Es wird immer eine Seite +angezeigt. Mit ESC 'w' bzw. ESC 'z' kann auf die nächste bzw, vorige +Seite umgeblättert werden. Mit ESC 'q' wird die Hilfestellung wieder +verlassen und die Situation wiederhergestellt, in der die Hilfe auf +gerufen wurde. + +#a ("Fragen")# Die meisten Funktionen wickeln zur Eingabe von zusätz +lichen Parametern oder zum Stellen von Fragen einen Dialog in der +unteren Schirmhälfte ab. Es gibt zwei Möglichkeiten des Dialogs: +eine Frage oder die Eingabe eines Textes. + Bei einer Frage kann man mit 'j' oder 'n' antworten. Sowohl +große als auch kleine Buchstaben werden akzeptiert. Mit ESC '?' +kann eine Hilfsinformation zu der Frage abgerufen werden. ESC 'h' +bricht die fragende Funktion ab. + +#a ("Eingabe")# Bei der Eingabe eines Textes können die üblichen Opera +tionen zum Editieren in einer Zeile verwendet werden. Die Eingabe +wird durch RETURN beendet. Auch hier kann durch ESC '?' eine +Hilfsinformation abgerufen werden. ESC 'h' bricht ebenfalls die fra +gende Funktion ab. In einigen Fällen (ersichtlich aus der Statuszei +le) kann durch ESC 'z' eine Auswahl der verfügbaren Namen abgeru +fen werden. + + +#abschnitt ("1.5", "EDITOR", "Editor")# + +Der EUMEL-Editor wird in EUDAS auf zweierlei Weise aufgerufen. +Zum einen dient er im Satzformular zum Eingeben von Daten und +Suchmustern. Dort wird er als #on("i")#Satzeditor#off("i")# bezeichnet. Da hier die +Feldnamen mit berücksichtigt werden müssen, gibt es einige Unter +schiede zum normalen Editor. + An anderen Stellen wird der Editor ohne Änderungen eingesetzt +zum Eingeben von Feldnamen oder Mustern. In diesem Fall finden +Sie die Bedienungshinweise im EUMEL-Benutzerhandbuch. + +#a ("Satzeditor")# Beim Ändern, Einfügen und Eingeben des Suchmusters +wird im EUDAS-Formular der Editor aufgerufen. Das Editorfenster +beschränkt sich auf den rechten Teil des Formulars, der einen Teil +der Überschrift und die Feldinhalte umfaßt. Im Satzeditor können +dann die entsprechenden Inhalte eingegeben bzw. verändert werden. + Rollen unter Beibehaltung der Korrespondenz ist durch ESC +OBEN und ESC UNTEN möglich. Diese Funktionen wirken wie bei der +Anzeige - das Editorfenster wird ebenfalls entsprechend mitgerollt. +Mit ESC '1' kann wie üblich auf die erste, mit ESC '9' auf die letzte +Zeile gesprungen werden. Auch diese Funktionen passen die Feld +namen entsprechend an. + Falls die für ein Feld vorgesehenen Zeilen nicht für den Inhalt +ausreichen, kann durch ESC RUBIN eine weitere Zeile für dieses Feld +bereitgestellt werden. ESC RUBIN wirkt wie zweimal HOP RUBIN, die +Korrespondenz mit den Feldnamen bleibt jedoch gewahrt. + Zum Löschen steht ESC RUBOUT zur Verfügung. Es löscht eine +ganze Zeile, aber nur, wenn für dieses Feld noch andere Zeilen zur +Verfügung stehen, wird die Zeile tatsächlich vom Bildschirm ent +fernt. Im Normalfall bleibt sonst eine Leerzeile für dieses Feld ste +hen. + Ist die Information für ein Feld auf mehrere Zeilen verteilt, so +werden diese Zeilen zur Verarbeitung aneinandergehängt. Gegebe +nenfalls wird zwischen zwei Zeilen noch ein Leerzeichen eingefügt. + Der Editor kann wie üblich mit ESC 'q' verlassen werden. ESC +'h' bricht die Funktion ab, ohne die erfolgten Änderungen und Ein +gaben zu berücksichtigen. Mit ESC 'w' und ESC 'z' kann das Bearbei +ten von mehreren Sätzen beschleunigt werden. Durch diese Tasten +kombinationen wird der Editor verlassen und die gleiche Operation +(Ändern/Einfügen) beim nächsten bzw. vorigen Satz wiederholt. + +#a ("Hinweis")# Aus technischen Gründen kann das Editorfenster gegen +über den Feldnamen verschoben werden (durch Rollen mit HOP +UNTEN zum Beispiel). Dabei geht die sichtbare Korrespondenz zwi +schen Feldnamen und Feldinhalten verloren. Ein solcher Fall wird +durch einen markierten Balken mit entsprechender Meldung ange +zeigt. Durch ESC '1' wird das Fenster aber wieder zurechtgerückt. + Aus diesem Grund sollte im Satzeditor auf HOP OBEN und HOP +UNTEN sowie auf RETURN am Ende des Fensters verzichtet werden. +Auch HOP RUBIN und HOP RUBOUT sollten nicht verwendet werden, +weil auf diese Weise die Anzahl der Zeilen verändert wird. Eine +solche Störung kann nicht durch ESC '1' beseitigt werden. Von Hand +müssen die entsprechenden Zeilen wieder gelöscht oder eingefügt +werden. + + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.10 b/app/eudas/4.4/doc/ref-manual/eudas.ref.10 new file mode 100644 index 0000000..2478130 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.10 @@ -0,0 +1,394 @@ +#type ("prop")##limit (14.0)# +#format# +#page (97)# +#kapitel ("10", "Programmierung", "der", "Menüs")# + + + +#abschnitt ("10.1", "MENÜFORMAT", "Menüformat")# + +EUDAS verwendet drei verschiedene Strukturen zur Benutzerunter +stützung: Menü, Auswahl und Hilfestellung. Ein Menü dient zur +Auswahl von Funktionen, eine Auswahl bietet Feld- oder Datei +namen an und eine Hilfestellung zeigt einen Informationstext. + Alle diese Strukturen werden aus einer Initialisierungsdatei +eingelesen. Die Initialisierungsdatei ist eine normale Textdatei. Ihr +Format soll in diesem Abschnitt beschrieben werden. + Die Strukturen können in beliebiger Reihenfolge in der Initiali +sierungsdatei stehen. Jede Struktur wird durch eine spezielle +Anweisung eingeleitet. Anweisungen beginnen ähnlich wie im +Druckmuster mit einem Prozentzeichen. Dementsprechend gibt es die +drei Anweisungen + +#beispiel# + % MENUE "Name" + % AUSWAHL "Name" + % HILFE "Gebiet/Name" +#text# + +die jeweils eine Struktur einleiten. Beendet wird eine Definition +immer mit + +#beispiel# + % ENDE +#text# + +#a ("Menü")# Für ein Menü wird noch der Text angegeben, der auf dem +Bildschirm erscheinen soll. Er wird durch die Anweisung + +#beispiel# + % BILD +#text# + +eingeleitet. Danach folgen Zeilen mit dem Bildschirminhalt in der +gewünschten Größe (die tatsächliche Anzeigegröße wird erst beim +Aufruf angegeben). Dabei werden die Auswahlpositionen, auf denen +der Cursor sich bewegen kann, durch ein geschütztes Leerzeichen in +Spalte 2 festgelegt. + Nach der Angabe des Bildes muß für jede mögliche Auswahl +position noch eine weitere Angabe gemacht werden. Die Auswahl +positionen (oder Felder) werden dabei von oben nach unten durch +gezählt. Begonnen wird mit der Nummer 1. + Eine Felddefinition hat das Format + +#beispiel# + % FELD nr "Hilfstext" "Tasten" +#text# + +Die Nummer identifiziert das Feld. Der Hilfstext gibt den Namen der +Hilfestellung an, die gezeigt werden soll, wenn auf diesem Feld ESC +'?' gedrückt wird. Die Tasten sind alle Zeichen, die gedrückt werden +können, um dieses Feld direkt auszuführen. + Anschließend an die Felddefinition kann in weiteren Zeilen +noch ein ELAN-Programm folgen, das bei Auswahl des Feldes aus +geführt wird. + +#a ("Auswahl")# Für eine Auswahl muß zuerst ein Vorspann angegeben +werden, der immer in den ersten Bildschirmzeilen der Auswahl an +gezeigt wird. Dieser wird durch + +#beispiel# + % VORSPANN +#text# + +eingeleitet. Danach folgt das Bild. Das Bild setzt sich aus drei Tei +len zusammen. Die erste Zeile, in der ein geschütztes Leerzeichen +vorkommt, bildet den Wiederholungsteil. Diese Zeile wird nachher so +oft wie nötig mit entsprechenden Inhalten wiederholt, wobei das +geschützte Leerzeichen als Bindestrich dargestellt wird, auf dem +sich der Cursor bewegen kann. Die Teile davor und danach werden +jeweils bei Bedarf mitgerollt. + Die Wiederholungszeile darf mehrere geschützte Leerzeichen +enthalten. Die Inhalte werden dann in mehreren Spalten angezeigt. +Zu beachten ist, daß vor einem Trennstrich noch mindestens fünf +Zeichen Platz für eine laufende Nummer bleiben müssen. + +#a ("Hilfe")# Der Name einer Hilfestellung setzt sich aus zwei Teilen +zusammen, die durch einen Schrägstrich getrennt werden. Der erste +Name gibt die Kategorie der Hilfestellung an, der zweite Name den +Einzeltext. Dies dient dazu, die relativ große Zahl der Hilfstexte +überschaubar zu machen. Als Beispiel + +#beispiel# + % HILFE "JA/Allgemein" +#text# + +Eine Hilfestellung besteht einfach aus mehreren Seiten Text. Jede +Seite wird durch die AnweisungQ + +#beispiel# +Q̈Q̈Q̈Q̈Q̈Q̈Q̈Q +#text# + + + + + + + +#beispiel# + +#text# + + + + +Text folgen. + + + + + + + + +hinzugefügt. + + + + + + + + +#proc# + +#endproc# + + + + + +#proc# + +#endproc# + + deutung: + + + + + + + +#proc# + +#endproc# + + + +#proc# + +#endproc# + + + + +#proc# + +#endproc# + + + + +#proc# + + + +#endproc# + + + + +#beispiel# + + + + + + + + + ELSE + + + + + + + +#text# + + + + + + + + + + + + + + + + + + + + + + + + + + + + +selbst. + +#proc# + + + + +#endproc# + + + + + + + + +#f2# + + + + + +#f2# + + + + + + + + + + + + +#f2# + FEHLER: +#f1# + + + +#proc# + + +#endproc# + + + + +#proc# + +#endproc# + + +#f2# + FEHLER: +#f1# + + + + +#proc# + + + +#endproc# + + + + + +#f2# + FEHLER: +#f1# + + + +#proc# + +#endproc# + + + + +#proc# + +#endproc# + + + +#f2# + FEHLER: +#f1# + + + +#proc# + +#endproc# + + + + + + + + + + + + + + + + + + + + + +#proc# + +#endproc# + + + +#proc# +PROC dialog +#endproc# + + + + +#proc# + +#endproc# + + + +#proc# + +#endproc# + + + + +#proc# + + +#endproc# + + + + + + +#proc# + +#endproc# + + + + + den. + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.11 b/app/eudas/4.4/doc/ref-manual/eudas.ref.11 new file mode 100644 index 0000000..3c555d1 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.11 @@ -0,0 +1,327 @@ +#type ("prop")##limit (14.0)# +#format# +#page (105)# +#kapitel ("11", "Programmierung", "von", "Anwendungen")# + + + +Zur Realisierung eigener EUDAS-Anwendungen mit Hilfe von ELAN- +Programmen gibt es mehrere Möglichkeiten mit zunehmender Lei +stungsfähigkeit, aber auch steigender Komplexität und Fehleranfäl +ligkeit. In den folgenden Abschnitten werden die drei wesentlichen +Methoden vorgestellt. Sie sollten erst dann eine kompliziertere +Methode in Angriff nehmen, wenn Sie die einfachere beherrschen. + + +#abschnitt ("11.1", "MUSTERPROGRAMME", "Musterprogramme")# + +Die bevorzugte Methode zur Erstellung eigener Anwendungen unter +EUDAS ist die Programmierung von Mustern. EUDAS läßt dies bei +Druckmustern, Kopiermustern und Änderungsmustern zu. + In diesem Fall steuert EUDAS den Ablauf des Programms im +groben automatisch. Die jeweils unterschiedlichen Anweisungen, was +im einzelnen zu tun ist, werden in ELAN programmiert. Aus dem +Muster mit diesen zusätzlichen Anweisungen generiert EUDAS dann +das Programm und führt es mit Hilfe des ELAN-Compilers aus. + +#a ("Vorteile")# Diese Methode hat den Vorteil, daß nur die minimal not +wendigen Anweisungen tatsächlich selbst programmiert werden +müssen. Dafür reichen bereits geringe ELAN-Kenntnisse vollkommen +aus. Ein Muster kann relativ schnell erstellt und getestet werden. +Durch den einfachen Aufbau ist auch die Fehlerwahrscheinlichkeit +beim Entwickeln geringer als bei anderen Methoden. + Daneben lassen sich die Musterprogramme jeweils bequem im +Menü durch Angabe des Namens oder durch Ankreuzen ausführen, +also auch durch unbedarfte Benutzer. + +#a ("Nachteile")# Nachteil dieser Methode ist, daß jeweils beim Aufruf das +Programm nochmal neu erzeugt und übersetzt werden muß, da die +Übersetzung auch von der gerade geöffneten Datei abhängt. Dies +stört besonders bei umfangreichen Druckmustern (auf langsamen +Rechnern). + Zum zweiten wird ein umfangreiches Druckmuster auch bald +unübersichtlich, da Strukturierungshilfen für größere Programme +fehlen. Der eigentliche Mustertext ist dann schwer von den zahlrei +chen Abkürzungen zu trennen. + Als Abhilfe für diese beiden Nachteile bietet es sich an, um +fangreichere Abkürzungen bzw. Ausdrücke eingebettet in ein +ELAN-Paket aus dem Muster herauszunehmen und vorher zu in +sertieren. + Dadurch fällt zum einen die ständige Neuübersetzung dieser +Ausdrücke weg, zum anderen ist das eigentliche Muster wieder +überschaubar. Voraussetzung zur Anwendung eines solchen Musters +ist dann jedoch, daß das zugehörige Paket in der jeweiligen Task +bereits vorher übersetzt wurde. + Die nachfolgenden Beispiele zeigen, wie dieses Verfahren in der +Realität aussehen kann. + +#a ("Beispiel 1")# In der Schulverwaltung soll ein Kopier- oder Ände +rungsmuster erstellt werden, das die Versetzung am Schuljahresende +realisiert. Angenommen wird eine Datei, die alle Schüler enthält. +Schüler, die nicht versetzt werden, sind vorher im Feld 'Versetzung' +mit einem beliebigen Text gekennzeichnet worden (zum Beispiel +'Nachprüfung' o.ä.). + Die Versetzung kann auf zweierlei Weise erfolgen: zum einen +durch automatische Änderung, wenn die alte Version noch auf einer +Archivdiskette aufgehoben wird, oder durch Kopieren in eine neue +Datei. + Bei beiden Mustern ist die einzige Änderung die Angabe der +neuen Klasse. Daher bietet es sich an, eine Prozedur 'neue klasse' +zu definieren, die als Ergebnis die neue Klasse eines Schülers lie +fert. Diese Prozedur kann dann im Änderungsmuster wie folgt ver +wendet werden: + +#beispiel# + "Klasse" V neue klasse; +#text# + +Entsprechend läuft die Verwendung im Kopiermuster: + +#beispiel# + "Name" K f ("Name"); + "Vorname" K f ("Vorname"); + "Klasse" K neue klasse; + ... +#text# + +Die Prozedur 'neue klasse' muß dann in einem Paket definiert wer +den, das etwa folgendes Aussehen haben könnte (spezifische Ände +rungen natürlich möglich): + +#beispiel# + PACKET klassenwechsel DEFINES neue klasse: + + TEXT PROC neue klasse : + + IF f ("Versetzung") = "" THEN + klasse um 1 erhoeht + ELSE + alte klasse ohne zusatz + END IF . + + klasse um 1 erhoeht : + INT CONST alte klasse := int (f ("Klasse")); + IF alte klasse < 9 THEN + "0" + text (alte klasse + 1) + zusatz + ELSE + text (alte klasse + 1) + zusatz + END IF . + + zusatz : + f ("Klasse") SUB 3. + + alte klasse ohne zusatz : + subtext (f ("Klasse"), 1, 2) . + + END PROC neue klasse; + + END PACKET klassenwechsel; +#text# + +Schüler, die versetzt werden, erhalten ihre neue Jahrgangsstufe mit +dem alten Klassenzusatz zugeteilt. Dabei ist darauf zu achten, daß +die Klassen 5 bis 9 eine '0' vorangestellt bekommen, damit die +Sortierung funktioniert. + Schüler, die nicht versetzt werden, behalten ihre alte Jahr +gangsstufe, allerdings ohne einen Klassenzusatz, der ihnen an +schließend manuell zugewiesen werden muß. + Zur Benutzung muß das oben angegebene Paket in eine Text +datei geschrieben und mit dem Kommando 'insert' fest insertiert +werden. + +#a ("Beispiel 2")# Aus einer Datei mit bibliographischen Einträgen sollen +bestimmte Literaturhinweise gedruckt werden. Der Literaturhinweis +soll jeweils als Endlostext umbrochen werden. Dafür müssen in einer +Abkürzung alle Daten verkettet werden. Es sei das folgende ein +fache Druckmuster vorgegeben: + +#beispiel# + % WIEDERHOLUNG + % MODUS 3 + [&<krz>] &titel + + % ABKUERZUNGEN + &krz : f ("Kurzbez") . (* z.B. "Lew84" *) + &titel : titel lang . +#text# + +Die Prozedur 'titel lang' wird in folgendem Paket definiert: + +#beispiel# + PACKET bibliographie DEFINES titel lang : + + TEXT VAR puffer; (* verringert Heap-Belastung *) + + TEXT PROC titel lang : + + puffer := f ("Name 1"); + puffer CAT ", "; + puffer CAT f ("Vorname 1"); + ggf weitere namen; + titel kursiv; + enthalten in; + erscheinungsort und jahr; + puffer . + + ggf weitere namen: + IF f ("Name 2") <> "" THEN + puffer CAT "; "; + puffer CAT f ("Name 2") + END IF . + + titel kursiv : + puffer CAT " \#on (""i"")\#"; + puffer CAT f ("Titel"); + puffer CAT "\#off (""i"")\#, " . + + enthalten in : + IF f ("in") <> "" THEN + puffer CAT " in: "; + puffer CAT f ("in"); + puffer CAT ", " + END IF . + + erscheinungsort und jahr : + puffer CAT f ("Ort"); + puffer CAT ", "; + puffer CAT f ("Jahr") . + + END PROC titel lang; + + END PACKET bibliographie; +#text# + +Die Puffervariable wird verwendet, um die bei Verwendung des +Operators '+' entstehende Heapbelastung zu verringern. An diese +Variable werden nacheinander alle notwendigen Daten mit den ent +sprechenden Trennzeichen angehängt. + Im Druckmuster wird dieser lange Text dann im Modus 3 auf +mehrere Zeilen umbrochen, wobei die Einrückung erhalten bleibt. Die +Druckausgabe kann dann bei Bedarf noch mit 'lineform' bearbeitet +werden, um einen noch besseren Umbruch zu erzielen. + + +#abschnitt ("11.2", "DATEIANWENDUNGEN", "Dateianwendungen")# + +Die zweite Möglichkeit der Programmierung unter EUDAS besteht +darin, ELAN-Programme zu schreiben, die EUDAS-Dateien mit Hilfe +des in Kapitel 6 beschriebenen Datentyps EUDAT manipulieren. Die +Programmierung gestaltet sich ähnlich wie mit FILEs. + +#a ("Vorteile")# Durch dieses Verfahren haben Sie volle Freiheit der Pro +grammierung. Da lediglich die Struktur der EUDAS-Dateien als +Datenspeicher verwendet wird, sind sehr viele Anwendungen denk +bar. + Außerdem können so beliebig viele Dateien gleichzeitig bear +beitet werden. Da die Programme nicht auf die virtuelle Datei zu +greifen, ist ein Konflikt mit dem aktuellen Zustand von EUDAS +nahezu ausgeschlossen. + +#a ("Nachteile")# Der Nachteil dieses Verfahrens ist, daß viele Dinge +selbst programmiert werden müssen, so zum Beispiel das Durchgehen +einer Datei. Auch die Hilfsmittel der virtuellen Datei wie Such +muster, Koppeln und alle Anwendungen, die auf die virtuelle Datei +zugreifen, stehen nicht zur Verfügung. + +#a ("Beispiel 1")# Die in Abschnitt 6.6 vorgestellte Anwendung als Asso +ziativspeicher kann als Beispiel für diese Methode dienen. + +#a ("Beispiel 2")# Eine EUDAS-Datei (zum Beispiel eine Schülerdatei) soll +in mehrere Dateien aufgespalten werden (zum Beispiel klassen +weise). Dies kann durch das folgende Beispielprogramm bewirkt +werden: + +#beispiel# + LET + klassenfeld = 3, + quellname = "Schüler", + zielname = "Jahrgang "; + ROW 9 EUDAT VAR ziel; + EUDAT VAR quelle; + SATZ VAR feldnamen; + + quelle oeffnen; + zieldateien einrichten; + auf satz (quelle, 1); + WHILE NOT dateiende (quelle) REP + aktuellen satz kopieren; + weiter (quelle) + END REP . + + quelle oeffnen : + oeffne (quelle, quellname); + feldnamen lesen (quelle, feldnamen) . + + zieldateien einrichten : + INT VAR i; + FOR i FROM 1 UPTO 9 REP + oeffne (ziel (i), zielname + text (i + 4)); + feldnamen aendern (ziel (i), feldnamen) + END REP . + + aktuellen satz kopieren : + SATZ VAR satz; + satz lesen (quelle, satz); + satz einfuegen (ziel (stufe), satz); + weiter (ziel (stufe)) . + + stufe : + TEXT VAR klasse; + feld lesen (satz, klassenfeld, klasse); + int (klasse) - 4 . +#text# + + +#abschnitt ("11.3", "INTEGRIERTE ANWENDUNGEN", "Integrierte Anwendungen")# + +Die schwierigste Möglichkeit, Anwendungen unter EUDAS zu reali +sieren, ist ihre Integration. Ein solches Programm greift selbst auf +die virtuelle Datei zu, nutzt die Funktionen von EUDAS so weit wie +möglich und definiert vielleicht sogar ein eigenes Menü. + +#a ("Vorteile")# Auf diese Weise können natürlich alle Möglichkeiten +ausgeschöpft werden. Sie können Programme erstellen, die als eine +natürliche Erweiterung von EUDAS wirken oder EUDAS ganz erset +zen. + +#a ("Nachteile")# Eine solche Integration ist aber besonders schwierig, +wenn EUDAS und die Erweiterung nebeneinander benutzt werden +sollen. In diesem Fall hat EUDAS keine komplette Kontrolle der +Interaktion, so daß leicht undefinierte Zustände möglich sind. + Weniger Probleme treten auf, wenn sichergestellt ist, daß nur +die Anwendung selbst verwendet wird. Auch in diesem Fall ist zu +beachten, daß EUDAS nicht als Programmierumgebung für Anwen +dungssysteme konzipiert wurde und daher nicht immer leicht zu +benutzen ist. + Am einfachsten ist es noch, nur eigene Menüs für eine andere +Anwendung zu verwenden, da die Menüprozeduren relativ unabhän +gig vom Rest sind. + +#a ("Richtlinien")# Bei Erweiterungen von EUDAS sind folgende Richtlinien +zu beachten: +#f2# +1. Ein Programm, das selber Dateien für die virtuelle Datei öffnen + will, sollte vorher prüfen, ob noch eine Datei geöffnet ist und in + diesem Fall abbrechen. Beim Multi-User-Betrieb ist nämlich + sonst nicht gewährleistet, daß alle Sperren wieder entfernt + werden. +#f2# +2. Ein solches Programm sollte seine eigenen Dateien vor dem + Wechsel zu EUDAS selbst wieder sichern und die Arbeitskopien + löschen, damit der Ausgangszustand zu Beginn des Programms + wiederhergestellt wird. +#f2# +3. Programme, die Menüs benutzen, sollten nicht unter EUDAS auf + gerufen werden, da sonst eine Beeinflussung der EUDAS-Menüs + möglich ist. +#f2# +An dieser Stelle soll noch einmal von der Erstellung integrierter +Anwendungen abgeraten werden, wenn es auch andere Möglichkeiten +gibt, das gegebene Problem mit EUDAS zu lösen. Der hohe Aufwand +dieser Methode rechtfertigt sich nur in wenigen Fällen. + Experimentierfreudige Anwender werden sich durch diese War +nung sowieso nicht abhalten lassen. Ihnen sollte aber bewußt sein, +daß ein solches Vorgehen auf eigene Gefahr stattfindet und kein +Anspruch auf Beratung oder Fehlerbeseitigung in einem solchen Fall +besteht. + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.2 b/app/eudas/4.4/doc/ref-manual/eudas.ref.2 new file mode 100644 index 0000000..bed3bf6 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.2 @@ -0,0 +1,820 @@ +#type ("prop")##limit (14.0)# +#format# +#page (13)# +#kapitel ("2", "Zusammenstellung", "der", "Funktionen")# + + + +Im folgenden finden Sie eine Übersicht über alle Menüfunktionen. Zu +jeder Funktion ist aufgeführt, welche Parameter angegeben werden +müssen. Die Parameter werden als Text erfragt. Bei einigen Funk +tionen können alle möglichen Parameterwerte mit ESC 'z' (Zeigen) +als Auswahl abgerufen werden. Bei manchen können in der Auswahl +mehrere Werte angekreuzt werden, die dann nacheinander abgear +beitet werden. Welcher Fall zutrifft, ist jeweils aufgeführt. + + +#abschnitt ("2.1", "MENÜ 'ÖFFNEN'", "Menü 'Öffnen'")# + + +#linefeed (0.5)# +#on ("b")#O EUDAS-Datei Öffnen#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, eine Wahl +#f2# +Zweck: Stellt eine EUDAS-Datei als aktuelle Arbeitsdatei ein. + Falls eine vorher geöffnete Datei verändert wurde, + wird sie nach Anfrage gesichert. Falls die zu öffnende + Datei noch nicht existiert, kann sie nach Anfrage + eingerichtet werden. Dabei müssen dann die Feld + namen angegeben werden. +#f2# + Es wird gefragt, ob die Datei geändert werden soll. In + diesem Fall wird eine Arbeitskopie hergestellt. Fast + alle EUDAS-Funktionen beziehen sich nachher auf die + so eingestellte Datei. +#f2# + Ist ein Mehrbenutzer-Manager eingestellt, kann auch + eine Datei aus dieser Managertask als Parameter + angegeben werden. Die Datei wird dann automatisch + von dort kopiert und eine Sperre im Manager gesetzt, + falls Änderungen vorgenommen werden sollen. +#f2# +Verweise: Abschnitt 3.2 + Benutzerhandbuch Abschnitt 5.1 und 9.1 + + +#linefeed (0.5)# +#on("b")#E EUDAS-Datei Ketten#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Falls bereits eine EUDAS-Datei geöffnet ist, kann eine + weitere Datei gleicher Struktur logisch angekettet + werden. Bei der Bearbeitung werden dann beide Datei + en wie eine zusammenhängende Datei behandelt. +#f2# + Die gekettete Datei kann ebenfalls verändert werden, + wenn dies beim Öffnen der ersten Datei angegeben + wurde. Die angegebene Datei kann auch aus einem + Manager stammen. +#f2# +Verweise: Abschnitt 3.2 + Benutzerhandbuch Abschnitt 9.2 + + +#linefeed (0.5)# +#on("b")#K EUDAS-Datei Koppeln#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Falls bereits eine Datei geöffnet ist, kann eine andere + EUDAS-Datei dazugekoppelt werden. Dazu muß min + destens das erste Feld der zu koppelnden Datei in der + bereits geöffneten Datei vorkommen. +#f2# + Nach dem Koppeln erscheinen beide Dateien wie eine + Datei. Zu jedem Satz der ersten Datei erscheinen je + weils alle Sätze der Koppeldatei, die in dem Koppelfeld + übereinstimmen. +#f2# + Die gekoppelte Datei kann ebenfalls verändert werden, + wenn dies beim Öffnen der ersten Datei angegeben + wurde. Die angegebene Datei kann auch aus einem + Manager stammen. +#f2# +Verweise: Abschnitt 3.3 + Benutzerhandbuch Abschnitt 9.3 und 9.4 + + +#linefeed (0.5)# +#on("b")#S Arbeitskopie Sichern#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Wurde eine EUDAS-Datei geöffnet und verändert, muß + zum Schluß die veränderte Arbeitskopie wieder ge + sichert werden. Die Arbeitskopie kann entweder ge + löscht werden, die alte Version ersetzen oder unter + einem neuen Namen registriert werden. +#f2# + Für jede veränderte Datei wird zunächst erfragt, ob + die alte Version überschrieben werden soll. Dies ist + der Normalfall. Bei Verneinung dieser Frage muß ein + neuer Name für die Arbeitskopie angegeben werden. +#f2# + Zum Schluß wird erfragt, ob alle Arbeitskopien ge + löscht werden sollen (Normalfall: ja). Anderenfalls + bleiben die Dateien weiter geöffnet. +#f2# +Verweise: Abschnitt 3.5 + Benutzerhandbuch Abschnitt 6.4 + + +#linefeed (0.5)# +#on("b")#N Notizen ansehen/ändern#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Zu jeder EUDAS-Datei kann als Notiz ein beliebiger + Text gespeichert werden. Dieser Text der aktuellen + Datei wird mit dieser Funktion im Editor angezeigt + und kann verändert werden, wenn eine Arbeitskopie + angelegt wurde. Anderenfalls werden etwaige Verän + derungen einfach ignoriert. +#f2# +Verweise: Abschnitt 3.1 + + +#linefeed (0.5)# +#on("b")#F Feldstruktur ändern#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Mit dieser Funktion können neue Felder an die aktu + elle Datei angefügt werden. Außerdem lassen sich + Feldnamen und Feldtypen ändern. Die Feldtypen be + stimmen die Behandlung eines Feldes beim Suchen oder + Sortieren (z.B. von Zahlen). +#f2# + Zunächst wird erfragt, ob neue Feldnamen angefügt + werden sollen. Diese können dann im Editor eingege + ben werden. Danach wird gefragt, ob Feldnamen oder + Feldtypen geändert werden sollen (neu angefügte + Felder erhalten erst einmal den Typ TEXT). Falls die + Frage bejaht wird, können in einer Auswahl die zu + ändernden Felder angekreuzt werden. Für jedes ange + kreuzte Feld werden dann der Name und der Typ zum + Überschreiben angeboten. +#f2# +Verweise: Abschnitt 3.1 + Benutzerhandbuch Abschnitt 11.1 + + +#linefeed (0.5)# +#on("b")#P Prüfbedingungen ansehen/ändern#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Beim Tragen in eine EUDAS-Datei können Bedingungen + für die zu tragenden Sätze überprüft werden. Diese + Bedingungen für die aktuelle Datei können mit dieser + Funktion angezeigt und, falls erlaubt, auch geändert + werden. +#f2# +Verweise: Abschnitt 3.1 und 4.4 + Benutzerhandbuch Abschnitt 11.3 + + +#linefeed (0.5)# +#on("b")#M Mehrbenutzer Manager einstellen#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Managertaskname, kein Zeigen +#f2# +Zweck: EUDAS kann beim Öffnen eine Datei von einer anderen + Task des Systems kopieren. Dadurch können mehrere + Benutzer kontrolliert auf die gleiche Datei zugreifen. + Wenn diese Möglichkeit verwendet werden soll, muß + mit dieser Funktion zunächst die in Frage kommende + Managertask angegeben werden. +#f2# +Verweise: Abschnitt 3.7 + Benutzerhandbuch Abschnitt 9.6 + + +#abschnitt ("2.2", "MENÜ 'EINZELSATZ'", "Menü 'Einzelsatz'")# + + +#linefeed (0.5)# +#on("b")#W Weiter#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Geht einen Satz weiter in der aktuellen Datei - falls + eine Suchbedingung eingestellt ist, weiter zum näch + sten ausgewählten Satz. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 5.2 + + +#linefeed (0.5)# +#on("b")#Z Zurück#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Geht einen Satz zurück in der aktuellen Datei - falls + eine Suchbedingung eingestellt ist, zurück zum vori + gen ausgewählten Satz. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 5.2 + + +#linefeed (0.5)# +#on("b")#N Auf Satz Nr. ..#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Positioniert auf einen bestimmten Satz der aktuellen + Datei, dessen Satznummer eingegeben werden muß, und + zwar unabhängig, ob der Satz durch die Suchbedingung + ausgewählt wird oder nicht. Trifft die eingestellte + Suchbedingung nicht auf den Satz zu, erscheint + 'SUCH-' in der Überschrift. Existiert die eingegebene + Satznummer nicht, positioniert EUDAS hinter den + letzten Satz der Datei. +#f2# +Verweise: Benutzerhandbuch Abschnitt 5.2 + + +#linefeed (0.5)# +#on("b")#S Suchbedingung Setzen#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Es kann eine neue Suchbedingung für die aktuelle + Datei eingegeben werden, bzw. eine vorher eingestellte + Suchbedingung wird zum Ändern angeboten. Die Such + bedingung wird in Form eines Suchmusters in das + Satzformular geschrieben. +#f2# + Die eingestellte Suchbedingung wird beim Positionieren + und bei allen Bearbeitungsfunktionen beachtet. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 5.3, 5.4 und 10.3 + + +#linefeed (0.5)# +#on("b")#L Suchbedingung Löschen#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Die eingestellte Suchbedingung wird wieder gelöscht. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 5.3 + + +#linefeed (0.5)# +#on ("b")#M Markierung umkehren#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Mit dieser Funktion können einzelne Sätze zur späte + ren Bearbeitung markiert werden. Falls der aktuelle + Satz bereits markiert ist, wird die Markierung wieder + entfernt, ansonsten wird er markiert. +#f2# + Wenn mindestens ein Satz markiert ist, beachten die + Bearbeitungsfunktionen nur die markierten Sätze. So + kann eine manuelle Auswahl durchgeführt werden. Die + Markierung bleibt nur bis zum Sichern bestehen. Sie + ist keine permanente Eigenschaft einer EUDAS-Datei. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 10.4 + + +#linefeed (0.5)# +#on ("b")#E Datensatz Einfügen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Mit dieser Funktion wird vor dem aktuellen Satz ein + leerer Satz eingefügt, für den anschließend die Feld + inhalte im Satzformular eingetragen werden können. +#f2# +Verweise: Abschnitt 3.4 + Benutzerhandbuch Abschnitt 6.2 und 10.2 + + +#linefeed (0.5)# +#on ("b")#A Datensatz Ändern#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Die Inhalte des aktuellen Satzes werden im Satzformu + lar zum Ändern angeboten. +#f2# +Verweise: Abschnitt 3.4 + Benutzerhandbuch Abschnitt 6.3 und 10.2 + + +#linefeed (0.5)# +#on ("b")#T Datensatz Tragen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, eine Wahl +#f2# +Zweck: Mit dieser Funktion kann der aktuelle Satz in eine + anderen EUDAS-Datei gleicher Struktur transportiert + werden. In der Zieldatei wird er am Ende angefügt. +#f2# +Verweise: Abschnitt 4.4 + Benutzerhandbuch Abschnitt 6.3 + + +#linefeed (0.5)# +#on ("b")#H Datensatz Holen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, eine Wahl +#f2# +Zweck: Mit dieser Funktion kann der letzte Satz einer ande + ren Datei vor dem aktuellen Satz eingefügt werden, + sofern die Struktur gleich ist. Damit kann ein vorher + gegangenes Tragen rückgängig gemacht werden. +#f2# +Verweise: Abschnitt 4.4 + Benutzerhandbuch Abschnitt 6.3 + + +#linefeed (0.5)# +#on ("b")#F Feldauswahl#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Die Felder der aktuellen Datei werden in einer Aus + wahl angeboten. Am Bildschirm werden danach nur die + ausgewählten Felder in der gewählten Reihenfolge + dargestellt. Die Auswahl hat jedoch nur Auswirkung + auf die Darstellung am Bildschirm, anderen Funktionen + stehen nach wie vor alle Felder zur Verfügung. Die + Auswahl gilt bis zum Sichern, sie wird also nicht mit + der Datei abgespeichert. +#f2# +Verweise: Abschnitt 4.1 + Benutzerhandbuch Abschnitt 10.1 + + +#abschnitt ("2.3", "MENÜ 'GESAMTDATEI'", "Menü 'Gesamtdatei'")# + + +#linefeed (0.5)# +#on ("b")#K Satzauswahl Kopieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, eine Wahl + Name Kopiermuster, ohne Zeigen +#f2# +Zweck: Mit dieser Funktion werden die ausgewählten bzw. + markierten Sätze der aktuellen Datei in eine andere + Datei kopiert. Welche Felder kopiert werden sollen und + in welcher Reihenfolge, wird durch ein Kopiermuster + festgelegt. Dieses Kopiermuster kann benannt werden + oder unbenannt nur für ein Mal erstellt werden. Wird + das Kopiermuster neu erstellt, wird ein Standard- + Kopiermuster zum Ändern angeboten. +#f2# +Verweise: Abschnitt 4.4 + Benutzerhandbuch Abschnitt 11.2 + + +#linefeed (0.5)# +#on ("b")#T Satzauswahl Tragen#off("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: EUDAS-Dateiname, mit Zeigen, eine Wahl +#f2# +Zweck: Transportieren der ausgewählten bzw. markierten + Sätze in eine andere Datei gleicher Struktur. Die Sätze + werden in der Zieldatei am Ende eingefügt. +#f2# +Verweise: Abschnitt 4.4 + Benutzerhandbuch Abschnitt 11.3 + + +#linefeed (0.5)# +#on ("b")#V Satzauswahl Verändern#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Name Änderungsmuster, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Bearbeiten der ausgewählten bzw. markierten Sätze + der aktuellen Datei nach Vorgabe einer Änderungs + vorschrift. +#f2# +Verweise: Abschnitt 4.4 + Benutzerhandbuch Abschnitt 11.4 + + +#linefeed (0.5)# +#on ("b")#U Übersicht Satzauswahl#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Anzeige aller ausgewählten Sätze in einem Über + sichtsformat mit einem Satz pro Bildschirmzeile. Die + Felder, die in der Übersicht angezeigt werden sollen, + können vorher ausgewählt werden. In der Übersicht ist + Blättern und Markieren von Sätzen möglich. +#f2# +Verweise: Abschnitt 4.1 + Benutzerhandbuch Abschnitt 10.5 + + +#linefeed (0.5)# +#on ("b")#S Aktuelle Datei Sortieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Sortieren der aktuellen Datei in beliebiger Reihenfolge + auf- oder absteigend. Zum Sortieren muß eine Ar + beitskopie angelegt sein. Die Feldreihenfolge, in der + sortiert werden soll, wird vorher erfragt. +#f2# +Verweise: Abschnitt 4.3 + Benutzerhandbuch Abschnitt 11.1 + + +#linefeed (0.5)# +#on ("b")#L Alle Markierungen Löschen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Löschen aller Markierungen der aktuellen Datei. +#f2# +Verweise: Abschnitt 4.2 + Benutzerhandbuch Abschnitt 10.4 + + +#abschnitt ("2.4", "MENÜ 'DRUCKEN'", "Menü 'Drucken'")# + + +#linefeed (0.5)# +#on ("b")#D Satzauswahl Drucken#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Name Druckmuster, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Ausdruck des Inhalts der ausgewählten oder markier + ten Sätze in druckbarer Form nach Vorgabe eines + Druckmusters. Die Ausgabe kann automatisch zum + Drucker geschickt werden oder erst in einer Datei + zwischengespeichert werden. +#f2# +Verweise: Kapitel 5 + Benutzerhandbuch Abschnitt 7.1 und 7.2 + + +#linefeed (0.5)# +#on ("b")#R Richtung Druckausgabe#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Mit dieser Funktion kann festgelegt werden, ob die + Druckausgabe automatisch zum Drucker geschickt wird, + in eine bestimmte Datei oder in eine automatisch + eingerichtete Datei geschrieben wird. +#f2# + Die Angabe einer bestimmten Datei gilt nur für den + nächsten Druckvorgang. Sie muß also gegebenenfalls + wieder neu eingestellt werden. +#f2# +Verweise: Abschnitt 5.2 + Benutzerhandbuch Abschnitt 7.2 und 12.1 + + +#linefeed (0.5)# +#on ("b")#E Textdatei Editieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Name Textdatei, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Aufruf des EUMEL-Editors zum Erstellen und Ändern + von Druckmustern und Änderungsmustern sowie zum + Ansehen der Druckausgabe. +#f2# +Verweise: Benutzerhandbuch Abschnitt 7.2 + + +#linefeed (0.5)# +#on ("b")#A Textdatei Ausdrucken#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Name Textdatei, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Mit dieser Funktion kann eine Textdatei oder die + zwischengespeicherte Ausgabe des Druckens einer + EUDAS-Datei zum Drucker geschickt werden. +#f2# +Verweise: Benutzerhandbuch Abschnitt 7.2 + + +#linefeed (0.5)# +#on ("b")#N Textdatei Nachbearbeiten#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Name Textdatei, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Mit dieser Funktion kann die zwischengespeicherte + Ausgabe des Druckens einer EUDAS-Datei mit den + Textkosmetikprogrammen 'lineform' und 'pageform' + bearbeitet werden. +#f2# +Verweise: Benutzerhandbuch Abschnitt 12.1 + + +#abschnitt ("2.5", "MENÜ 'DATEIEN'", "Menü 'Dateien'")# + + +#linefeed (0.5)# +#on ("b")#U Übersicht Dateien System#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Übersicht über die Dateien im System in der aktuellen + Benutzertask. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#linefeed (0.5)# +#on ("b")#L Datei Löschen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Löschen einer beliebigen Datei in der aktuellen Be + nutzertask nach Anfrage. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#linefeed (0.5)# +#on ("b")#N Datei Umbenennen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl + Neuer Name, ohne Zeigen +#f2# +Zweck: Umbenennen einer beliebigen Datei in der aktuellen + Benutzertask. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#linefeed (0.5)# +#on ("b")#K Datei Kopieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl + Zieldateiname, ohne Zeigen +#f2# +Zweck: Anfertigen einer logischen Kopie einer beliebigen + Datei in der aktuellen Benutzertask. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#linefeed (0.5)# +#on ("b")#P Platzbedarf einer Datei#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Zeigt den belegten Speicherplatz einer beliebigen + Datei in der aktuellen Benutzertask. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#linefeed (0.5)# +#on ("b")#A Datei Aufräumen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Reorganisieren einer Textdatei oder einer EUDAS- + Datei, um Platz zu sparen oder den Zugriff zu be + schleunigen. Empfiehlt sich bei stark veränderten + oder umsortierten Dateien. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.1 + + +#abschnitt ("2.6", "MENÜ 'ARCHIV'", "Menü 'Archiv'")# + + +#linefeed (0.5)# +#on ("b")#U Übersicht Dateien Archiv#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Übersicht aller Dateien auf der eingelegten Archivdis + kette. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#D Archivübersicht Drucken#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Die Archivübersicht wird direkt zum Drucker ge + schickt. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#K Datei Kopieren vom Archiv#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Eine Datei auf der Archivdiskette wird in die aktuelle + Benutzertask kopiert. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#S Datei Schreiben auf Archiv#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Archivname + Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Eine Datei aus der aktuellen Benutzertask wird auf + die eingelegte Archivdiskette geschrieben. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#L Datei Löschen auf Archiv#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Archivname + Dateiname, mit Zeigen, mehrfache Wahl +#f2# +Zweck: Löschen einer Datei auf der eingelegten Archivdisket + te. Der Platz kann jedoch nicht immer wiederverwendet + werden. +#f2# +Verweis: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#I Archivdiskette Initialisieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: keine +#f2# +Zweck: Mit dieser Funktion kann eine Archivdiskette komplett + gelöscht werden. Die Diskette kann dabei auch gleich + zeitig formatiert werden, falls der Rechner dies zu + läßt. Das Initialisieren ist notwendig, bevor eine neue + Diskette als Archiv verwendet werden kann. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#Z Zielarchiv einstellen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Managertaskname, ohne Zeigen +#f2# +Zweck: Mit dieser Funktion kann eine Managertask angegeben + werden, die als Ziel der Archivoperationen dient. + Damit können Dateien auch in beliebigen Managertasks + oder über das EUMEL-Netz gesichert werden. +#f2# + Es wird erfragt, ob die angegebene Task ein Archiv + manager oder ein gewöhnlicher Dateimanager ist. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#P Paßwort einstellen#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Paßwort +#f2# +Zweck: Mit dieser Funktion kann ein Paßwort eingestellt + werden, das bei der Kommunikation mit allgemeinen + Managertasks überprüft wird. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + +#linefeed (0.5)# +#on ("b")#R Archivmanager Reservieren#off ("b")# +#linefeed (1.07)# +_____________________________________________________ + +Parameter: Reservierungstext +#f2# +Zweck: Falls als Zielarchiv eine Managertask eingestellt ist, + die zwar kein Archivmanager ist, aber reserviert + werden muß (z.B. 'DOS'), kann die Reservierung mit + dieser Funktion ausgeführt werden. Die Freigabe + erfolgt automatisch beim Verlassen des Menüs. +#f2# +Verweise: Benutzerhandbuch Abschnitt 16.2 + + + +#abschnitt ("2.7", "KURZABFRAGE", "Kurzabfrage")# + +Wird 'eudas' innerhalb des EUMEL-Editors aufgerufen, so wird eine +spezielle Kurzabfrage gestartet. Diese ermöglicht die Übernahme von +Druckdaten direkt in die editierte Datei. + Zunächst wird der Dateiname der zu verwendenden EUDAS- +Datei erfragt. Diese Datei wird dann geöffnet. Vorher geöffnete und +veränderte Dateien werden nach Anfrage gesichert. + Als nächstes kann für die folgende Übersicht eine Feldauswahl +eingestellt werden, damit die relevanten Felder auch auf dem Bild +schirm erscheinen. + Danach beginnt ein wiederholbarer Prozeß mit der Eingabe +eines Suchmusters nach Anfrage. Die ausgewählten Sätze werden +dann in einer Übersicht gezeigt. In der Übersicht können auch Sätze +markiert werden. + Nach Verlassen der Übersicht bestehen drei Möglichkeiten zum +Drucken: Falls mindestens ein Satz markiert wurde, können nach +Anfrage alle markierten Sätze gedruckt werden. Wurde kein Satz +markiert, können nach Anfrage alle ausgewählten (bzw. vorher +angezeigten) Sätze gedruckt werden. Wird diese Frage jeweils ver +neint, kann nach Anfrage auch der aktuelle Satz als einziger ge +druckt werden. + Wurde eine der Fragen bejaht, wird der Name des Druckmusters +erfragt, das bereits existieren muß. Das Ergebnis der Druckausgabe +wird dann an der aktuellen Cursorposition in der editierten Datei +eingefügt. + Der Prozeß kann danach mit einem anderen Suchmuster wieder +holt werden. Dabei werden alle Markierungen wieder gelöscht. + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.3 b/app/eudas/4.4/doc/ref-manual/eudas.ref.3 new file mode 100644 index 0000000..77c3fc6 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.3 @@ -0,0 +1,256 @@ +#type ("prop")##limit (14.0)# +#format# +#page (31)# +#kapitel ("3", "Das", "virtuelle", "Dateimodell")# + + + +#abschnitt ("3.1", "DATEISTRUKTUR", "Dateistruktur")# + +Eine EUDAS-Datei hat folgende Bestandteile: + +- 0 bis 5000 #on("i")#Sätze#off("i")#, von 1 an durchnumeriert. Jeder Satz enthält für + jedes Feld einen variabel langen Text als Inhalt, der standard + mäßig leer ist. + +- 1 bis 256 #on("i")#Felder#off("i")#, die die Sätze aufteilen. Jedes Feld besitzt einen + #on("i")#Feldnamen#off("i")# als Text und einen von vier #on("i")#Feldtypen#off("i")# (TEXT, ZAHL, + DATUM oder DIN). Der Feldname dient zur Identifizierung des + Feldes, der Feldtyp spezifiziert die Art der Behandlung beim Ver + gleichen von Feldern. + +- Drei Zusatztexte. Der erste nimmt die #on("i")#Prüfbedingungen#off("i")# auf, der + zweite speichert das Datum der letzten Veränderung und der + dritte kann allgemeine #on("i")#Notizen#off("i")# aufnehmen. + +- Einen #on("i")#Satzzeiger#off("i")#, der einen bestimmten Satz als aktuellen Satz + auszeichnet. Der Satzzeiger kann durch Positionierungsoperatio + nen verändert werden. + +- Eine #on("i")#Sortierreihenfolge#off("i")#, die angibt, in welcher Feldreihenfolge die + Datei zuletzt sortiert worden ist. Dazu für jeden Satz eine Anga + be, ob er entsprechend dieser Reihenfolge an der richtigen Posi + tion steht. + +- Eine interne Datenstruktur, die beschleunigten Zugriff auf eine + Satz nach dem Inhalt des ersten Feldes ermöglicht. Diese Struktur + steht ganz unter Kontrolle von EUDAS und kann nicht von außen + manipuliert werden. + + +#abschnitt ("3.2", "ÖFFNEN", "Öffnen")# + +#a ("Virtuelle Datei")# Die meisten EUDAS-Funktionen arbeiten nicht +direkt auf einer EUDAS-Datei, sondern auf der sogenannten #on("i")#vir +tuellen Datei#off("i")#, die aus mehreren realen Dateien bestehen kann. Die +virtuelle Datei erscheint nach außen hin wie eine einzelne +EUDAS-Datei. Die Operationen auf der virtuellen Datei werden je +weils auf die einzelnen Bestandteile abgebildet. + Damit eine EUDAS-Datei Bestandteil der virtuellen Datei wird, +muß sie geöffnet werden. Dieses Öffnen kann auf dreierlei Art und +Weise geschehen. + Das Öffnen der ersten Datei stellt eine neue virtuelle Datei +her. Die Feldnamen und Feldeigenschaften der ersten Datei werden +in der virtuellen Datei übernommen. Dies ist der Normalfall, in dem +sich die virtuelle Datei noch nicht von der zugrundeliegenden Datei +unterscheidet. + Bei diesem ersten Öffnen muß angegeben werden, ob die vir +tuelle Datei verändert werden soll oder nicht. Falls die virtuelle +Datei verändert werden soll, wird eine Arbeitskopie aller geöffneten +Dateien angelegt. Die Ursprungsdateien können erst am Ende der +Arbeit mit den geänderten Kopien überschrieben werden. + +#a ("Weitere Dateien")# Weitere Dateien können gekettet oder gekoppelt +werden. Gekettete Dateien werden logisch an die zuerst geöffnete +Datei angehängt. Ihre Dateistruktur wird ignoriert, sollte aber mit +der ersten Datei übereinstimmen. Die Folge aneinander geketteter +EUDAS-Dateien wird als #on("i")#Hauptdatei#off("i")# bezeichnet. + In der Hauptdatei werden die Sätze von 1 an durchnumeriert; +die Aufeinanderfolge der Sätze wird durch die Anordnung der Sätze +in den einzelnen Dateien und die Reihenfolge bestimmt, in der die +Dateien gekettet wurden. + Die gekoppelten Dateien werden der Hauptdatei untergeordnet. +Die in ihnen enthaltenen Informationen werden nur angezeigt, wenn +sie mit einem Satzinhalt der Hauptdatei korrespondieren. Der +Mechanismus dieser Satzkopplung wird im nächsten Abschnitt +beschrieben. + +#beispiel# +#free (8.0)# + +#center#Abb. 3-1 Schematischer Aufbau der virtuellen Datei +#text# + + +#abschnitt ("3.3", "KOPPELN", "Koppeln")# + + Die Sätze der gekoppelten Dateien werden in Relation zu den +Sätzen in der Hauptdatei gesetzt. Zu jedem Satz in der Hauptdatei +kann eine Anzahl von Sätzen aus jeder Koppeldatei gehören. Diese +Sätze müssen in den Inhalten der sogenannten #on("i")#Koppelfelder#off("i")# über +einstimmen. + Welche Felder Koppelfelder sind, richtet sich nach den Feld +namen. Die ersten Felder der Koppeldatei, die auch in der Haupt +datei vorhanden sind, werden als Koppelfelder betrachtet. Die Kop +pelfelder müssen also bei der Koppeldatei am Anfang stehen - in +der Hauptdatei kann jedes beliebige Feld ein Koppelfeld sein. + Wenn eine Datei zur virtuellen Datei gekoppelt wird, werden +alle Felder, die nicht Koppelfelder sind, in die virtuelle Datei auf +genommen. Die Koppelfelder brauchen nicht noch mal wiederholt zu +werden, da ihr Inhalt ja immer identisch ist. + Zu beachten ist, daß bei diesem Verfahren auch Namenskonflik +te entstehen können, wenn nach den Koppelfeldern später wieder +ein Feldname vorkommt, der auch in der Hauptdatei vorhanden ist. +In den Fällen, in denen Felder durch ihren Namen angesprochen +werden, ist dann das zweite Feld gleichen Namens nicht verfügbar. + +#beispiel# +#free (7.0)# + +#center#Abb. 3-2 Schema des Koppelvorgangs +#text# + +#a ("Kombinationen")# Beim Vorwärtsgehen in der virtuellen Datei werden +zu jedem Satz der Hauptdatei nacheinander alle möglichen Kombina +tionen der zugehörigen Koppelsätze angezeigt, denn es können +mehrere passende Koppelsätze vorhanden sein. Die Satznummer +bleibt dabei gleich; die einzelnen Kombinationen werden von 1 an +durchgezählt. Beim Rückwärtsgehen wird aus technischen Gründen +immer nur die erste Kombination angezeigt. + Existiert zu einem Satz kein passender Koppelsatz, so bleiben +die entsprechenden Felder leer. Die Koppelsätze müssen in der +ganzen Koppeldatei gesucht werden, daher ist bei großen Koppel +dateien die Suchzeit zu berücksichtigen. + + +#abschnitt ("3.4", "ÄNDERUNGEN", "Änderungen")# + +In der virtuellen Datei kann auch geändert werden. Dabei ist jedoch +Vorsicht angebracht. Es muß festgelegt sein, wie Änderungen der +einzelnen Felder auf die beteiligten Dateien abgebildet werden. + Falls die virtuelle Datei keine Koppeldateien enthält, werden +Änderungen am aktuellen Satz an der zugehörigen Datei durchge +führt. Das Löschen eines Satzes wird auch direkt in der Datei +durchgeführt. Ein neuer Satz wird immer in der Datei eingefügt, zu +der der aktuelle Satz gehört - am Ende der ersten Datei kann also +kein Satz eingefügt werden, wenn noch weitere Dateien folgen. + Enthält die virtuelle Datei Koppeldateien, werden die Änderun +gen in der Hauptdatei wie oben beschrieben durchgeführt. Änderun +gen, die Felder in den Koppeldateien betreffen, werden nach folgen +der Entscheidungstabelle behandelt: + + 1 2 3 4 5 + --------------- + Koppelfelder verändert N J J N N + Übrige Felder verändert N - - J J + Übrige Felder leer - J N - N + Vorher Koppelsatz vorhanden - - - J N + --------------- + Neuen Satz einfügen x x + Koppelsatz ändern x + Kopplung aktualisieren x + +Fall 1: Es wurden keine Veränderungen an den Feldern des Kop + pelsatzes vorgenommen, daher ist auch keine Aktion not + wendig. + +Fall 2: Eines der Koppelfelder wurde verändert. Die Änderung wird + in der Hauptdatei durchgeführt. Die übrigen Felder des + Koppelsatzes sind jedoch als leer angegeben. In diesem Fall + wird der Koppelsatz nicht verändert, sondern nur eine + neue Korrespondenz gesucht. + +Fall 3: Eines der Koppelfelder wurde verändert, gleichzeitig ent + halten aber auch die anderen Felder Informationen. In + diesem Fall wird ein neuer Satz in der Koppeldatei ange + fügt, der die neuen Inhalte enthält. So wird vermieden, + daß an anderer Stelle plötzlich kein passender Koppelsatz + mehr vorhanden ist. + +Fall 4: Nur Felder der Koppeldatei, die nicht Koppelfelder sind, + wurden verändert, außerdem existierte ein korrespondie + render Satz in der Koppeldatei. In diesem Fall werden die + Informationen im Koppelsatz abgeändert. + +Fall 5: Wie 4, nur war vorher noch kein Koppelsatz vorhanden + (Felder waren leer). In diesem Fall muß ein neuer Satz in + die Koppeldatei eingefügt werden. Einfügungen in die + Koppeldatei geschehen immer am Dateiende. + +#a ("Einfügen/Löschen")# Beim Löschen eines Satzes der virtuellen Datei +durch Tragen bleiben die Koppeldateien unverändert. Nach dem +Einfügen eines neuen Satzes wird nur dann ein Satz in einer Kop +peldatei eingefügt, wenn dieser Satz nicht nur Koppelfelder enthal +ten würde. Falls beim Einfügen nur die Koppelfelder angegeben +werden, wird ein korrespondierender Satz in der Koppeldatei ge +sucht. Vergleichen Sie hierzu die Regeln beim Ändern. + + +#abschnitt ("3.5", "SICHERN", "Sichern")# + +Falls Änderungen der virtuellen Datei erlaubt sind, arbeitet EUDAS +immer auf Sicherheitskopien der beteiligten Dateien. Eine Datei, die +wirklich verändert wurde, muß vor dem Aufbau einer neuen virtuel +len Datei gesichert oder explizit gelöscht werden. + Für jede einzelne Datei kann festgelegt werden, ob sie gesi +chert werden soll oder nicht. Als Hilfe wird dazu für jede Datei +angegeben, ob sie tatsächlich verändert wurde oder nicht. Die +Arbeitskopie kann beim Sichern die alte Version überschreiben oder +unter einem neuen Namen gesichert werden. + Am Ende des Sicherns können die Arbeitskopien gelöscht wer +den. Anderenfalls werden die Dateien so betrachtet, als ob sie di +rekt nach dem Sichern wieder geöffnet worden wären und stehen +weiterhin zur Verfügung. + Falls alle Dateien entweder gesichert oder nicht verändert +sind, werden beim nächsten Öffnen einer neuen virtuellen Datei die +vorherigen Arbeitskopien gelöscht. + + +#abschnitt ("3.6", "UMSCHALTEN AUF KOPPELDATEI", "Umschalten auf Koppeldatei")# + +Falls eine Datei gekoppelt ist, kann man die virtuelle Datei auf +diese Koppeldatei umschalten. Dadurch verhält sich die virtuelle +Datei so, als ob nur diese Koppeldatei geöffnet wäre. Die Einstel +lungen der Hauptdatei wie Markierungen und Suchbedingung bleiben +jedoch erhalten und stehen beim Zurückschalten wieder zur Verfü +gung. + Die Satzposition der Koppeldatei beim letzten Umschalten wird +ebenfalls gespeichert und wird beim nächsten Umschalten wieder +eingenommen, unabhängig von der tatsächlichen Satzposition der +Koppeldatei zu diesem Zeitpunkt. + Für die Koppeldatei können eigene Markierungen vergeben +werden, die auch nach dem Umschalten gespeichert bleiben. Auch +ein Suchmuster kann für die Koppeldatei eingestellt werden, dies +geht jedoch beim Zurückschalten wieder verloren. Die eingestellte +Feldauswahl für die Bildschirmanzeige geht leider bei jedem Um +schalten verloren. + Das Umschalten kann entweder im Menü 'Einzelsatz' oder beim +Einfügen und Ändern durch ESC 'K' bewirkt werden, ebenso das +Zurückschalten nur im Menü 'Einzelsatz'. Beim Umschalten aus Ein +fügen oder Ändern erfolgt beim Zurückschalten eine Rückkehr in +diesen Zustand. Dabei können nach Anfrage die Koppelfelder des +aktuellen Satzes der Koppeldatei in die Hauptdatei übernommen und +damit eine bestimmte Kopplung bewirkt werden. + + +#abschnitt ("3.7", "MEHRBENUTZERBETRIEB", "Mehrbenutzerbetrieb")# + +Durch Einstellen einer Managertask für den Mehrbenutzerbetrieb +können auch Dateien dieser Managertask beim Öffnen direkt ver +wendet werden. Die Datei wird automatisch aus der Managertask +kopiert und geöffnet. + Falls die Datei geändert werden soll, wird eine Sperre in der +Managertask gesetzt, die verhindert, daß auch ein anderer Benutzer +diese Datei zum Ändern öffnet. Beim Sichern erfolgt dann ein Rück +schreiben der Arbeitskopie. Die Sperre wird jedoch erst dann zu +rückgesetzt, wenn alle Arbeitskopien gelöscht werden, da erst dann +keine Möglichkeit des Rückschreibens mehr besteht. + Alle Dateien der Managertask werden bei der Dateiauswahl zum +Öffnen mit angeboten. Falls eine Datei in beiden Tasks existiert, +wird die Datei in der Managertask genommen, die Datei der eigenen +Task jedoch erst nach Anfrage überschrieben. + Damit die Sperre funktionieren kann, muß EUDAS in der Mana +gertask zur Verfügung stehen und die Task muß #on("i")#nach#off("i")# dem Insertie +ren von EUDAS als 'global manager' definiert werden (nicht 'free +global manager' verwenden). + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.4 b/app/eudas/4.4/doc/ref-manual/eudas.ref.4 new file mode 100644 index 0000000..92ec931 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.4 @@ -0,0 +1,421 @@ +#type ("prop")##limit (14.0)# +#format# +#page (39)# +#kapitel ("4", "Ansehen", "und", "Bearbeiten")# + + + +#abschnitt ("4.1", "ANZEIGE", "Anzeige")# + +Die Anzeige und Eingabe von Einzelsätzen sowie die Eingabe von +Suchmustern geschieht in einem Standardformular in einem recht +eckigen Fenster. Dieses Fenster befindet sich in der rechten Bild +schirmhälfte. + Das Formular besteht aus vier Teilen: der Überschrift, den +Feldnamen, den Feldinhalten und der Abschlußzeile (s. Abbildung). + +#bildschirm# + Überschrift +#free (0.3)# + Satz 33 ..SUCH+..MARK-... datei ............... Feld 1 + Feld 1 + Feld 2 + Feld 3 Feldinhalte + + Feld 4 + .............................................................. +#free (0.3)# + Feldnamen Abschlußzeile + +#text# + +#a ("Überschrift")# Die Überschrift zeigt folgende Informationen an: + + #bsp ("Satz n[-m]")# + Die Satznummer des aktuellen Satzes, bei gekoppelten Dateien + auch die Satzkombination. + + #bsp ("SUCH+/-")# + Zeigt an, ob der aktuelle Satz die eingestellte Suchbedingung + erfüllt oder nicht (wird während Eintragungen nicht angezeigt). + Wenn keine Suchbedingung eingestellt ist, erscheint diese An + zeige nicht. + + #bsp ("MARK+/-")# + Zeigt an, ob der aktuelle Satz markiert ist oder nicht (Wird + während Eintragungen nicht angezeigt). Wenn kein Satz mar + kiert ist, erscheint diese Anzeige nicht. + + #bsp ("ENDE")# + Wird hinter dem letzten Satz der Datei als Kennzeichnung des + Endesatzes ausgegeben. + + #bsp ("'Dateiname'")# + Gibt den Namen der ersten geöffneten Datei an. + + #bsp ("<KOPPPEL>")# + Erscheint statt des Dateinamens, wenn auf eine Koppeldatei + umgeschaltet wurde. + + #bsp ("Feld n/Zeile n")# + Zeilennummer des obersten angezeigten Feldes (bei Anzeige) + bzw. der aktuellen Cursorzeile (während Eintragungen). + +#a ("Feldteil")# Die Feldnamen sind zur Unterscheidung von den Feld +inhalten invers dargestellt. Die Breite der Feldnamen richtet sich +nach der Länge des längsten Feldnamens. Ist dieser zu lang, um +noch eine ordentliche Anzeige zu ermöglichen, wird bei einer be +stimmten Länge der Rest des Namens abgeschnitten. + Zwischen dem Feldnamen an der linken Seite und dem dane +benstehenden Feldinhalt besteht immer eine Korrespondenz, d.h. der +Inhalt eines Feldes wird direkt neben dem Namen dargestellt. In der +Regel wird pro Feld eine Bildschirmzeile reserviert. Kann der Feld +inhalt jedoch nicht mehr in einer Zeile untergebracht werden, wer +den weitere Zeilen zur Darstellung dieses Feldes herangezogen. In +diesen Zeilen steht statt des Feldnamens nur ein markierter Leer +raum. + Alle folgenden Zeilen ohne Namen gehören zu dem gleichen +Feld. Der Inhalt wird auf diese Zeilen umbrochen, d.h. wenn ein +Wort nicht mehr auf die Zeile paßt, wird es komplett in die nächste +Zeile geschrieben (wie beim Editor). Wörter werden nur dann zer +schnitten, wenn sie nicht als Ganzes auf eine Zeile passen. Wörter +werden untereinander durch Leerzeichen getrennt. + Aus Effizienzgründen werden in bestimmten Fällen auch mehr +Folgezeilen als nötig angezeigt. Hat nämlich ein neuer Satz einen +kürzeren Inhalt als der vorige, so werden die Feldnamen nur dann +wieder zusammengerückt, wenn das ganze Bild neugeschrieben wer +den muß. Anderenfalls werden nur die Feldinhalte aktualisiert. + Die Bildausgabe wird unterbrochen, wenn 'w' oder 'z' gedrückt +wurde, da dann die Inhalte des aktuellen Satzes nicht mehr inter +essieren. + +#a ("Rollen")# Da nicht alle Felder auf den Bildschirm passen müssen, +kann das Bild gerollt werden. + Mit ESC UNTEN wird um eine Seite nach unten geblättert, mit +ESC OBEN wieder zurück. Hinter dem letzten Feld erscheint ein +markierter Balken als Abschlußzeile. Weiter als bis zum Erscheinen +dieses Balken kann nicht gerollt werden. Mit ESC '1' wird ganz an +den Anfang gerollt, mit ESC '9' ganz ans Ende. + Bei Feldern, die sich über mehrere Zeilen erstrecken, kann es +passieren, daß nach dem Rollen die erste Bildschirmzeile nicht die +erste Zeile eines Feldes ist, also der erste Teil eines Feldes nicht +dargestellt wird. Trotzdem wird in diesem Fall in der ersten Anzei +gezeile der Feldname angezeigt. + +#a ("Feldauswahl")# Man kann auswählen, welche Felder in welcher Rei +henfolge angezeigt werden sollen. Dies dient der besseren Übersicht. +Von der Anzeige werden nur die ausgewählten Felder behandelt, die +anderen Felder bleiben leer, werden nicht verändert oder berück +sichtigt. Die Anzeigeauswahl ändert jedoch nichts an der Datei +struktur. + Die Feldauswahl ist keine permanente Eigenschaft einer +EUDAS-Datei. Sie geht daher bei einem neuen Öffnen oder beim +Umschalten auf eine Koppeldatei verloren. + +#a ("Übersicht")# Im Gegensatz zur normalen Anzeige, bei der ein Satz pro +Bildschirm dargestellt wird, können in der Übersicht mehrere Sätze +gleichzeitig überschaut werden. Dabei wird jeder Satz in einer Zeile +untergebracht. Die Auswahl der Felder, die in der Übersicht er +scheinen sollen, wird vor Beginn der Funktion erfragt. + In jeder Zeile steht die Nummer des jeweiligen Satzes, eine +Anzeige, ob er markiert ist (+) oder nicht (-) und die Feldinhalte +in der gewählten Reihenfolge und Auswahl, jeweils duch Komma und +Leerzeichen getrennt. Inhalte, die nicht mehr auf die Zeile passen, +werden abgeschnitten. + Es werden nur durch das Suchmuster ausgewählte Sätze ange +zeigt. Ist der aktuelle Satz nicht ausgewählt, so erscheint an seiner +Stelle #bsp("'<< >>'")# als Hinweis. In der Überschrift sind die Feldnamen +angegeben - durch Komma getrennt, so viele wie hinpassen. + Die Satznummer des aktuellen Satzes ist jeweils markiert. In +der Übersicht kann geblättert werden. HOP OBEN und HOP UNTEN, +OBEN und UNTEN wirken wie im Editor. + Durch '+' oder '-' kann auch die Markierung des aktuellen +Satzes verändert werden. + + +#abschnitt ("4.2", "SATZAUSWAHL", "Satzauswahl")# + +Die Auswahl der Sätze, die gedruckt oder mit den Funktionen aus +Abschnitt 4.4 bearbeitet werden sollen, kann entweder durch eine +Suchbedingung oder durch Markierung vorgenommen werden. Wenn +mindestens ein Satz markiert ist, werden von den Bearbeitungs +funktionen nur die markierten Sätze behandelt. Anderenfalls wird +die eingestellte Suchbedingung beachtet. + Die Bildschirmanzeige richtet sich immer nur nach der einge +stellten Suchbedingung. + +#a ("Suchmuster")# Ein Suchmuster gibt für jedes Feld bestimmte Bedin +gungen an. Es wird im Standardformular mit Hilfe des Satzeditors +eingegeben. Dabei stehen neben jedem Feld die Bedingungen für +dieses Feld in einer intuitiv verständlichen Form. Folgende Einzel +bedingungen sind möglich: + + #bsp("Muster")# Inhalt ist gleich Muster + #bsp("Muster..")# Inhalt ist größergleich Muster + #bsp("..Muster")# Inhalt ist kleiner Muster + #bsp("Muster1..Muster2")# Inhalt liegt dazwischen + #bsp("*Muster")# Inhalt endet mit Muster + #bsp("Muster*")# Inhalt beginnt mit Muster + #bsp("*Muster*")# Inhalt enthält Muster + #bsp("*")# Inhalt ist nicht leer + #bsp("++")# Satz markiert (unabhängig vom Feldinhalt) + +Die ersten vier Einzelbedingungen beachten auch den Typ eines +Feldes (wie er bei der Feldstruktur eingegeben werden kann und +beim Sortieren beachtet wird). So werden z.B. bei der Gleichheit von +Zahlen alle nicht-numerischen Zeichen ignoriert (s. Sortieren). + Die drei Bedingungen mit Stern können auch miteinander ver +knüpft werden. Die Einzelbedingungen müssen dann alle zutreffen, +damit der Satz ausgewählt wird. So bedeutet zum Beispiel das +Muster #bsp ("'M1*M2*M3*M4'")#, daß das Feld mit 'M1' beginnen und mit 'M4' +enden muß. Außerdem muß es 'M2' und 'M3' enthalten, jedoch nicht +unbedingt in der angegebenen Reihenfolge. + Wird der Mustertext durch '&' und einen gültigen Feldnamen der +aktuellen Datei ersetzt, findet der Vergleich nicht mit einem +Mustertext, sondern mit dem Inhalt des angegebenen Feldes statt. +Als Feldtyp für den Vergleich wird in diesem Fall der Typ des Fel +des genommen, in dem der Vergleich steht. + +#a ("Verknüpfung")# Einzelbedingungen können durch Voranstellen von +'--' verneint werden. Einzelbedingungen für verschiedene Felder +werden mit UND verknüpft. + Es gibt zwei Arten der ODER-Verknüpfung: die lokale und die +globale. Die lokale ODER-Verknüpfung wird durch ein Komma zwi +schen Einzelbedingungen realisiert. Sie hat eine höhere Priorität als +das UND zwischen verschiedenen Feldern. So hat folgendes Such +muster + +#beispiel# + Feld1 Bed1,Bed2 + Feld2 Bed3 +#text# + +die Bedeutung + +#beispiel# + ( Bed1 (Feld1) ODER Bed2 (Feld2) ) UND Bed3 (Feld3) +#text# + +Die globale ODER-Verknüpfung wird durch ein Semikolon repräsen +tiert. Alle Einzelbedingungen nach dem n-ten Semikolon aller Zeilen +werden zu einer Alternative zusammengefaßt. Damit hat das Such +muster + +#beispiel# + Feld1 Bed1;Bed2 + Feld2 Bed3 +#text# + +die Bedeutung + +#beispiel# + ( Bed1 (Feld1) UND Bed3 (Feld2) ) ODER Bed2 (Feld1) +#text# + +Damit ergibt sich für die Priorität der einzelnen Konstruktionen +folgende Reihenfolge: + + höchste Einzelbedingung + Verkettung von Einzelbedingungen (UND) + Verneinung + lokales ODER + UND zwischen Feldern + niedrigste globales ODER + +#a ("Optimierung")# Wenn für das erste Feld einer Datei eine Gleich- +Bedingung angegeben wurde und keine globale Alternative vorhan +den ist, kann der Suchvorgang wegen der Dateistruktur optimiert +werden, indem nur Sätze untersucht werden müssen, die im ersten +Feld den gesuchten Text enthalten. + +#a ("Reservierte Zeichen")# Im Rahmen der Analyse einer Musterzeile +wirken folgende Zeichenfolgen als unbeschränkt reservierte Zeichen: + +#beispiel# + , ; .. * +#text# + +Sie dürfen daher in keinem Mustertext oder Feldnamen vorkommen, +da sie als Separator wirken. Die beiden folgenden Zeichenfolgen +werden nur zu Anfang eines durch die vorstehenden Separatoren +gebildeten Abschnitts erkannt: + +#beispiel# + -- & ++ +#text# + +Sie dürfen daher prinzipiell an weiterer Stelle vorkommen, ohne als +Sonderzeichen erkannt zu werden. Alle anderen Zeichen in der Zeile +werden dem Mustertext bzw. Feldnamen ohne weitere Interpretation +zugeordnet. + + +#abschnitt ("4.3", "SORTIEREN UND REORGANISIEREN", "Sortieren und Reorganisieren")# + +Eine EUDAS-Datei kann in einer beliebigen Feldreihenfolge sortiert +werden. Mit dieser Angabe kann man bestimmen, welche Felder beim +Vergleich zweier Sätze berücksichtigt werden sollen und in welcher +Reihenfolge. + Die Sortierreihenfolge wird in der Datei gespeichert und wird +anschließend immer wieder verwendet, wenn keine anderen Angaben +gemacht wurden. + Der Sortierzustand einer Datei wird ebenfalls gespeichert. Wenn +nur wenige Sätze seit der letzten Sortierung verändert wurden, +müssen auch nur diese Sätze einsortiert werden. + +#a ("Feldtypen")# Um eine korrekte Sortierung auch von Zahlen oder +Daten sicherzustellen, wird jedem Feld einer EUDAS-Datei ein Feld +typ zugeordnet, der beim Sortieren (und auch beim Suchen) berück +sichtigt wird. + Es gibt folgende Feldtypen (als Standard wird der Typ TEXT +verwendet): + + TEXT Vergleich von Texten nach dem EUMEL-Code der einzel + nen Zeichen. Dies ist Standard und sorgt für schnellst + möglichen Vergleich. Die weiteren Typen brauchen erheb + lich mehr Zeit. + + DIN Vergleich nach DIN 5007 (s. EUMEL-Benutzerhandbuch). + Umlaute werden korrekt eingeordnet, Groß- und Klein + buchstaben werden gleichbehandelt, Sonderzeichen werden + ignoriert. + + ZAHL Der Wert einer Zahl wird verglichen. Außer den Ziffern, + dem Dezimalkomma und dem Minuszeichen vor der ersten + Ziffer werden alle anderen Zeichen ignoriert. Das Dezi + malkomma ist standardmäßig auf ',' eingestellt, kann aber + verändert werden (s. Abschnitt 6.5). Die nicht ignorierten + Zeichen werden in eine REAL-Zahl umgewandelt und dann + verglichen. + + DATUM Es werden Daten der Form 'tt.mm.jj' verglichen. In diesem + Fall werden Tag und Jahr vertauscht und dann vergli + chen. Texte mit einer anderen Länge als 8 werden alle + als gleich betrachtet. + +#a ("Reorganisieren")# Wenn viele Änderungen an einer EUDAS-Datei +vorgenommen worden sind, steigt ihr Platzbedarf durch viele Text +leichen an. In diesem Fall empfiehlt es sich, die Datei zu reorgani +sieren. Auch wenn beim Sortieren viele Sätze vertauscht wurden, +sollte die Datei reorganisiert werden, da beim Sortieren die physi +kalische Reihenfolge der Sätze nicht verändert wird. In diesem Fall +ergibt sich nach dem Reorganisieren ein Geschwindigkeitsvorteil. + + +#abschnitt ("4.4", "BEARBEITEN", "Bearbeiten")# + +#a ("Kopieren")# Durch Kopieren kann ein Ausschnitt aus der virtuellen +Datei in eine andere EUDAS-Datei kopiert werden. Es werden alle +ausgewählten Sätze kopiert. Wenn mindestens ein Satz markiert ist, +werden alle markierten Sätze als ausgewählt betrachtet, ansonsten +alle, die durch die Suchbedingung angegeben sind. Die kopierten +Sätze werden am Ende der Zieldatei angefügt. + Welche Felder kopiert werden sollen, wird durch das Kopier +muster angegeben. Hierbei können auch mehrere Felder zu einem +verschmolzen werden. Allgemein ergeben sich die Felder der Ziel +datei aus einem beliebigen ELAN-Ausdruck. + Das Kopiermuster ist ein ELAN-Programm und enthält im we +sentlichen Ausdrücke der Form + +#beispiel# + "Feldname" K Ausdruck ; +#text# + +Durch diese Anweisung wird der Ausdruck in das Feld der Zieldatei +mit dem angegebenen Namen kopiert. Existiert dieses Feld in der +Zieldatei noch nicht, so wird es als letztes angefügt. Falls die +Zieldatei noch nicht existiert, wird sie eingerichtet. In diesem Fall +bestimmt also die Reihenfolge der 'K'-Ausdrücke die Reihenfolge der +Feldnamen in der Zieldatei. + Da die Reihenfolge der 'K'-Ausdrücke wichtig ist, dürfen diese +nicht in einer IF-Anweisung stehen, sondern müssen für jeden Satz +komplett in der gleichen Reihenfolge ausgeführt werden. + +#a ("Standard-Kopiermuster")# Vor dem Kopieren wird ein Standard- +Kopiermuster zum Editieren angeboten, das sich nach der Zieldatei +richtet. Existiert die Zieldatei noch nicht, wird das Muster so kon +struiert, daß alle Felder der virtuellen Datei unverändert kopiert +werden. Wollen Sie einige Felder nicht kopieren, brauchen Sie nur +die entsprechenden Zeilen zu löschen; wollen Sie die Felder in eine +andere Reihenfolge bringen, müssen Sie die Zeilen umordnen. + Existiert die Zieldatei bereits, gibt das Standard-Kopiermuster +an, daß alle Felder der Zieldatei einen Wert erhalten. Ist ein Feld +der Zieldatei in der virtuellen Datei enthalten, so wird dieses ko +piert, ansonsten erhält das Feld einen leeren Inhalt. Sie können in +diesem Fall weitere Felder angeben oder für die leeren Felder Aus +drücke formulieren. + +#a ("Tragen")# Durch Tragen werden alle ausgewählten Sätze der virtuel +len Datei in eine andere Datei transportiert. Sie sind in der vir +tuellen Datei dann nicht mehr vorhanden. Damit bei diesem Vorgang +keine Informationen verlorengehen können, muß die Zieldatei so +viele Felder haben wie die virtuelle Datei. Normalerweise sollte sie +in der Feldstruktur mit der virtuellen Datei übereinstimmen. + Die getragenen Sätze werden jeweils am Ende der Datei ange +fügt. + Beim Tragen können zusätzlich noch Konsistenzbedingungen +überprüft werden. Die Prüfbedingungen sind in der Zieldatei gespei +chert und können beim Ändern der Feldstruktur angegeben werden. + Die Prüfbedingung ist ein ELAN-Programm, das vor dem Tragen +des jeweiligen Satzes ausgeführt wird. Durch spezielle Testprozedu +ren kann das Tragen des Satzes verhindert werden, wenn diese +Prozeduren ein negatives Ergebnis liefern. Gleichzeitig wird eine +Meldung in eine Protokolldatei geschrieben, die dann zur Identifi +zierung der fehlerhaften Sätze dienen kann. + Folgende Prüfprozeduren stehen zur Verfügung (siehe auch +Abschnitt 8.3): + +#beispiel# + pruefe ("Feldname", Bedingung) +#text# + Hiermit kann eine beliebige Bedingung (BOOL-Ausdruck in + ELAN) überprüft werden. + +#beispiel# + wertemenge ("Feldname", "Wert1,Wert2,...,Wertn") +#text# + Das Feld muß einen in der angegebenen Liste enthaltenen + Werte annehmen. + +#beispiel# + feldmaske ("Feldname", "Maske") +#text# + Das Feld wird auf Übereinstimmung mit der Maske geprüft. + Fünf spezielle Zeichen in der Maske können dabei auf + mehrere Zeichen zutreffen: + '9' alle Ziffern + 'a' alle Kleinbuchstaben, Umlaute, 'ß' + 'A' alle Großbuchstaben, Umlaute + 'X' alle Zeichen + '*' Folge von beliebigen Zeichen + Der Stern sollte sparsam angewendet werden, da er verar + beitungsaufwendig ist. + +#beispiel# + eindeutige felder (n) +#text# + Die Zahl 'n' gibt an, die wieviel ersten Felder der Zieldatei + eindeutig sein müssen. Stimmt der zu tragende Satz mit + einem Satz der Zieldatei in diesen Feldern überein, wird + eine Fehlermeldung erzeugt. + +Es können auch einzelne Sätze manuell getragen werden. In diesem +Fall wird die Prüfbedingung nicht getestet. Ebenso kann der Satz +wieder zurückgeholt und in der aktuellen Datei eingefügt werden. + +#a ("Nach Vorschrift ändern")# Die ausgewählten Sätze der virtuellen +Datei können automatisch nach einer Verarbeitungsvorchrift geän +dert werden. Die Verarbeitungsvorschrift ist ein ELAN-Programm, in +dem mit Hilfe des Operators 'V' Änderungen angegeben werden: + +#beispiel# + "Feldname" V TEXT-Ausdruck ; +#text# + +Das angegebene Feld erhält den Inhalt, der durch den Ausdruck +angegeben ist. Änderungen an Koppeldateien werden wie im Dialog +behandelt (s. Abschnitt 3.4). + + + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.5 b/app/eudas/4.4/doc/ref-manual/eudas.ref.5 new file mode 100644 index 0000000..02127a6 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.5 @@ -0,0 +1,415 @@ +#type ("prop")##limit (14.0)# +#format# +#page (49)# +#kapitel ("5", "Drucken", "und", "Druckmuster")# + + + +#abschnitt ("5.1", "DRUCKMUSTERSYNTAX", "Druckmustersyntax")# + +Ein Druckmuster ist eine Beschreibung für die Form, in der die In +halte einer EUDAS-Datei ausgedruckt werden sollen. Der syntakti +sche Aufbau des Druckmusters ist zeilenorientiert und gehorcht +folgender Syntax: + + Druckmuster : + [ Initialisierungsteil ] + [ Vorspann ] + [ Wiederholungsteil ] + [ Nachspann ] + + Initialisierungsteil : + ( Kommandozeile #char (""124"")# Textzeile )#bsp ("*")# + ( GRUPPE-Anweisung #char(""124"")# Textzeile )#bsp ("*")# + + Vorspann : + VORSPANN-Anweisung Abschnitt + + Wiederholungsteil : + WIEDERHOLUNG-Anweisung Abschnitt + + Nachspann : + NACHSPANN-Anweisung Abschnitt + + Abschnitt : + Musterteil + [ ABKUERZUNGEN-Anweisung Abkürzungsteil ] + + Musterteil : + ( Musterzeile #char(""124"")# Kommandozeile #char(""124"")# + MODUS-Anweisung #char (""124"")# MEHR-Anweisung )#bsp ("*")# + +Zur Notation: [] bedeutet optional, ()#bsp("*")# beliebig häufige Wiederho +lung, #char(""124"")# Alternative und keine Angabe einfache Aneinanderreihung. +Die verschiedenen Zeilentypen werden weiter unten beschrieben. + Zusätzlich gilt die Bedingung, daß von Vorspann, Wiederho +lungsteil und Nachspann mindestens einer vorhanden sein muß. + +#a ("Zeilentypen")# Im Druckmuster gibt es 6 verschiedene Zeilentypen: + +#on("i")#Kommandozeilen#off("i")# + Eine Kommandozeile beginnt mit '%%' in der ersten und zweiten + Spalte. Der Inhalt der Zeile ab Spalte 3 wird dem ELAN-Compi + ler übergeben. Die Bedeutung dieser Zeilen ergibt sich aus dem + in 5.4 beschriebenen Übersetzungsmechanismus. + +#on("i")#Anweisungen#off("i")# + Anweisungen beginnen mit '%' in der ersten Spalte und dienen + zur Steuerung des Druckgenerators. Der Name der Anweisung + muß in Großbuchstaben und ohne Leerzeichen geschrieben + werden. Davor dürfen sich noch Leerzeichen befinden. An + schließend können noch Parameter folgen, die nur durch Leer + zeichen getrennt aneinander gereiht werden. Die Syntax einer + Anweisung ähnelt der eines Operators in ELAN. + +#on("i")#Textzeilen#off("i")# + Textzeilen sind die nicht anderweitig markierten Zeilen im + Initialisierungsteil. Sie werden unverändert an den Anfang + jeder Druckdatei gestellt. + +#on("i")#Musterzeilen#off("i")# + Musterzeilen sind nicht besonders gekennzeichnete Zeilen im + Musterteil. Sie enthalten Feldmuster und werden nach dem + Einsetzen von Inhalten in die Ausgabedatei übernommen. Die + Interpretation der Musterzeilen wird in Abschnitt 5.3 beschrie + ben. + +#on("i")#Abkürzungszeilen#off("i")# + Abkürzungszeilen markieren den Beginn einer Abkürzung im + Abkürzungsteil eines Abschnittes. Sie werden durch '&' in der + ersten Spalte gekennzeichnet. Darauf folgt ohne Zwischenraum + der Name einer Abkürzung (ohne Leerzeichen) und danach + durch Leerzeichen getrennt ein Semikolon. Der Name der Ab + kürzung wird bei der Übersetzung durch einen Refinementnamen + ersetzt und die Zeile dem ELAN-Compiler übergeben. Der Rest + der Zeile kann also den Beginn eines werteliefernden Refine + ments enthalten. + +#on("i")#Programmzeilen#off("i")# + Programmzeilen sind die nicht durch '&' markierten Zeilen im + Abkürzungsteil. Sie werden unverändert an den ELAN-Compiler + übergeben. Der erlaubte Inhalt richtet sich nach dem Überset + zungsmechanismus (5.4). + + +#abschnitt ("5.2", "DER DRUCKVORGANG", "Der Druckvorgang")# + +Der Druckvorgang besteht im wesentlichen darin, daß für alle zu +bearbeitenden Sätze der Wiederholungsteil einmal interpretiert wird +und das Ergebnis in eine Ausgabedatei geschrieben wird, die dann +gedruckt werden kann. Wenn mindestens ein Satz markiert ist, wer +den alle markierten Sätze der virtuellen Datei bearbeitet, ansonsten +alle durch die Suchbedingung erfaßten. + +#a ("Gruppen")# Eine #on("i")#Gruppe#off("i")# ist eine Folge von Sätzen, die in einem be +stimmten Merkmal übereinstimmen. Durch eine GRUPPE-Anweisung +der Form + +#beispiel# + % GRUPPE n Ausdruck +#text# + +werden aufeinanderfolgende Sätze mit gleichem Wert des angegebe +nen Ausdrucks gruppiert. Über die Nummer 'n' kann festgestellt +werden, ob sich das angegebene Merkmal verändert hat. Dies ge +schieht mit der Prozedur + +#beispiel# + BOOL PROC gruppenwechsel (INT CONST gruppennr) +#text# + +Immer wenn zwischen zwei Sätzen ein Gruppenwechsel stattfindet, +wird beim vorigen Satz der Nachspann und beim folgenden Satz der +Vorspann einmal interpretiert. Dies führt dazu, daß entsprechende +Vorspann- bzw. Nachspannzeilen gedruckt werden. + Vor dem ersten und nach dem letzten zu bearbeitenden Satz +wechseln alle Gruppen, d.h. dort wird immer ein Vorspann bzw. +Nachspann erzeugt. + Ist ein zu interpretierender Abschnitt nicht vorhanden, so wird +an dieser Stelle keine Ausgabe erzeugt. Die Textzeilen des Initali +sierungsteils werden auf jeden Fall bei Beginn des Druckvorganges +in die Ausgabedatei geschrieben. Falls die Ausgabedatei voll ist, +wird eine neue Datei angefangen und die Zeilen des Initialisie +rungsteils erneut an den Anfang gestellt. + +#beispiel# + Satz- Gruppen- Ausgabe + nummer merkmal +#free (0.1)# + Initialisierungsteil + ------------------------------------------------- + 1 x Vorspann + WDH-Teil + 2 x WDH-Teil + Nachspann + ------------------------------------------------- + 3 y Vorspann + WDH-Teil + 4 y WDH-Teil + 5 y WDH-Teil + Nachspann + ------------------------------------------------- + ENDE + +#center#Abb. 5-1 Ablauf des Druckvorganges mit Gruppen +#text# + +#a ("Spaltendruck")# Normalerweise werden die Ausgaben der einzelnen +Abschnitte hintereinander in der Ausgabedatei plaziert. Durch An +gabe einer Nummer als Parameter in der WIEDERHOLUNG-Anweisung +können auch soviel Spalten wie angegeben nebeneinander gedruckt +werden. Die Spaltenbreite wird dabei durch das Dateilimit (Komman +do 'limit' im Editor) festgelegt. Alternativ kann die Spaltenbreite +auch als zweiter Parameter durch Leerzeichen getrennt angegeben +werden. + Vorspann und Nachspann werden jedoch auf jeden Fall wieder +in eine eigene Zeile geschrieben, der Spaltendruck also unterbro +chen. + + +#abschnitt ("5.3", "INTERPRETATION VON MUSTERZEILEN", "Interpretation von Musterzeilen")# + +Musterzeilen können Feldmuster enthalten, die bei der Interpreta +tion durch entsprechende Inhalte ersetzt werden, ehe die Muster +zeile in die Ausgabedatei übernommen wird. Der Beginn eines Feld +musters wird durch ein Musterzeichen ('&' oder '%') markiert. Wo +und wie der Inhalt eingesetzt wird, kann durch folgende Variationen +angegeben werden: + +#beispiel# + Typ ! Beispiel ! Position ! Länge ! bündig + ----+-----------+------------------------------ + 1 ! &Name ! fest ! variabel ! links + 2 ! %Name ! variabel ! variabel ! links + 3 ! &Name&&& ! fest ! fest ! links + 4 ! %Name%%% ! variabel ! fest ! links + 5 ! &&&Name& ! fest ! fest ! rechts + 6 ! %%%Name% ! variabel ! fest ! rechts +#text# + +Der in dem Feldmuster angegebene Name muß Name einer Abkür +zung in irgendeinem Abkürzungsteil oder eines Feldes sein. Der +Name darf kein Leerzeichen oder Musterzeichen enthalten. Falls dies +doch der Fall ist, muß der Name in spitze Klammern eingeschlossen +werden. + Bei fester Länge wird bei zu kurzem Inhalt mit Leerzeichen +aufgefüllt, bei zu langem Inhalt abgeschnitten. Bei linksbündigem +Einsetzen geschieht dies an der rechten, sonst an der linken Seite. + Feldmuster variabler Länge können je nach Inhalt dazu führen, +daß der folgende Teil der Musterzeile verschoben wird. Für diesen +Einsetzprozeß gelten die folgenden Regeln: + +#a ("Position")# Feldmuster fester Position (mit '&' beginnend) werden +immer in der Position eingesetzt, in der sie stehen. Feldmuster +variabler Position (mit '%' beginnen) können nach rechts verschoben +werden, wenn vorherige Inhalte länger als ihre Muster sind, und +nach links, wenn Modus 1 oder 3 eingestellt ist und vorherige In +halte kürzer sind. + +#a ("Länge")# Feldmuster variabler Länge erhalten auf jeden Fall den +Platz, der durch die Länge des Feldmusters reserviert ist. Sind die +Inhalte kürzer, kann der gewonnene Platz als Reserve für andere +Feldmuster verwendet werden; sind die Inhalte länger, so wird der +Inhalt so weit eingesetzt, wie noch Reserve vorhanden ist und der +Rest abgeschnitten. + Muß in ein Feldmuster variabler Länge ein leerer Inhalt einge +setzt werden, so werden beim Drucken auch die auf das Feldmuster +folgenden Leerzeichen unterdrückt, falls vor dem Feldmuster noch +ein Leerzeichen steht oder das Feldmuster in Spalte 1 beginnt. + Feldmuster fester Länge werden immer in ihrer reservierten +Länge eingesetzt. Sie werden im folgenden behandelt wie Feldmuster +variabler Länge, deren Inhalt so lang ist wie das Feldmuster. + +#a ("Verteilung")# Die Verteilung der verschiebbaren Feldmuster auf der +Zeile geschieht jeweils in dem Abschnitt zwischen zwei Feldmustern +fester Position bzw. Zeilenanfang oder Zeilenende. Für jeden Ab +schnitt wird festgestellt, wieviel Stellen die Inhalte insgesamt mehr +oder weniger als ihre Muster benötigen. + Der Längenausgleich geschieht zwischen dem letzten Feldmuster +und dem Ende des Abschnitts. Dort wird ein Pufferplatz bestimmt, +der bei Überlänge bis auf ein Leerzeichen verkleinert werden kann +und an dem bei Unterlänge zusätzliche Leerzeichen eingefügt wer +den. + Außer am Pufferplatz wird an keinem Mustertext des Abschnitts +etwas geändert. Zwischentexte zwischen den Feldmustern werden +unverändert übertragen und mit den umgebenden Feldmustern ver +schoben. + Als Pufferplatz wird die erste Lücke hinter dem letzten Feld +muster eines Abschnittes verwendet, die mehr als ein Leerzeichen +enthält. Ist keine solche Lücke vorhanden, wird das Ende des Ab +schnitts verwendet, falls dort ein Leerzeichen steht, und sonst das +Ende des letzten Feldmusters. + Die durch den Pufferplatz und kürzere Inhalte gewonnene Re +serve wird von links an die Feldmuster mit Überlänge verteilt, bis +die Reserve verbraucht ist. + +#a ("Zeilende")# Das Zeilenende wird als ein Quasi-Feldmuster mit fester +Position aufgefaßt, das am Limit der Druckmusterdatei steht. Es +sind also keine Einsetzungen möglich, die über das Limit der Datei +hinausgehen. Als Pufferplatz wird hier jedoch die erste Blanklücke +vom Zeilenende her verwendet, damit Mustertexte am Zeilenende +gegebenenfalls stehenbleiben. Ist keine solche Lücke vorhanden, so +wird das Zeilenende als Pufferplatz verwendet. + Obwohl nicht als Pufferplatz ausgewiesen, kann der Raum zwi +schen Zeilenende und Dateilimit als Reserve verwendet werden. + +#a ("Modi")# Der Einsetzmechanismus kann durch die MODUS-Anweisung +mit einem Parameter verändert werden. Folgende Modi stehen zur +Verfügung: + +#beispiel# + Modus ! Effekt + ------+---------------------------------------- + 1 ! Normalmodus. + ! '%'-Feldmuster werden auch + ! nach links geschoben. + ! Keine Zeilenwiederholung. + ------+---------------------------------------- + 2 ! Tabellenmodus. + ! '%'-Feldmuster werden nicht + ! nach links geschoben. + ! Keine Zeilenwiederholung. + ------+---------------------------------------- + 3 ! Normalmodus mit Zeilenwiederholung. + ! '%'-Feldmuster werden auch + ! nach links geschoben. + ! Zeilenwiederholung ohne Zwischentexte. + ------+---------------------------------------- + 4 ! Tabellenmodus mit Zeilenwiederholung. + ! '%'-Feldmuster werden nicht + ! nach links geschoben. + ! Zeilenwiederholung mit Zwischentexten. + ------+---------------------------------------- +#text# + +Bei Zeilenwiederholung werden Inhalte in einer folgenden Zeile +fortgesetzt, falls sie in der ersten Zeile nicht untergebracht werden +konnten. Dazu wird die Musterzeile mit den Restinhalten erneut +interpretiert. Je nach Modus werden auch die Zwischentexte noch +wiederholt. Der Restinhalt umfaßt immer noch das ganze letzte Wort, +das nicht mehr auf die vorige Zeile paßte. Es findet also ein Um +bruch statt. Die Positionen, die in der vorigen Zeile vom Anfang des +Wortes eingenommen würden, werden durch Leerzeichen ersetzt. + Durch die MEHR-Anweisung mit einem Parameter kann die Zahl +der Zeilenwiederholungen für die nächste Musterzeile festgesetzt +werden. Dies hat jedoch nur eine Auswirkung, falls Zeilenwieder +holung zugelassen ist. Stehen zur Interpretation keine Restinhalte +mehr zur Verfügung, wird mit leeren Inhalten weitergearbeitet. Kann +ein Inhalt bei der vorgegebenen Anzahl von Zeilen nicht ganz dar +gestellt werden, wird der Rest nicht ausgegeben. + + +#abschnitt ("5.4", "ANSCHLUSS ZUM ELAN-COMPILER", "Anschluß zum ELAN-Compiler")# + +Falls in einem Druckmuster Abkürzungen, Kommandozeilen oder +Gruppendefinitionen vorkommen, wird das Druckmuster in ein +ELAN-Programm umgewandelt, das dann vom ELAN-Compiler über +setzt wird. + Alle Zeilen eines Abkürzungsteils werden direkt in das Pro +gramm übernommen, wobei der Name einer Abkürzung durch einen +beliebig gewählten Refinementnamen ersetzt wird ('abk' + eine lau +fende Nummer). Alle Abkürzungen und Refinements werden als glo +bale Refinements definiert, also außerhalb von Prozeduren. Dadurch +wird erreicht, daß sie an jeder Stelle verwendet werden können. + Damit eine Abkürzung richtig als Refinement übersetzt wird, +muß sie ein TEXT-Objekt als Wert liefern. Die anderen Refinements +sind beliebig, da sie nur in selbstdefinierten Anweisungen verwen +det werden. Die Refinements der Abkürzungen werden in einer Zu +weisung an eine TEXT-Variable verwendet, damit der Druckgenera +tor auf den entsprechenden Wert zugreifen kann. + Jeder Abschnitt wird dagegen als eine Prozedur übersetzt. Eine +Folge von Musterzeilen wird in eine Anweisung übersetzt, diese +Musterzeilen einzusetzen und zu drucken. Eine '%%'-Anweisung wird +einfach unverändert dazwischengeschrieben. Die Prozedur für den +Wiederholungsteil wird einmal für jeden ausgewählten Satz aufgeru +fen, die Vorspann- und die Nachspann-Prozedur einmal bei jedem +Gruppenwechsel. + Anweisungen im Initialisierungsteil werden an den Anfang des +Programms als globale Definitionen gestellt. + +#a ("Fehler")# Findet sich in dem erzeugten ELAN-Programm ein Fehler, +der durch den Druckgenerator nicht erkannt werden konnte (z.B. +eine Abkürzung liefert keinen Wert), so muß der ELAN-Compiler +diesen Fehler erkennen. Anschließend zeigt er das erzeugte Pro +gramm zusammen mit seinen Fehlermeldungen im Paralleleditor. Sie +müssen nun die Fehlermeldung lokalisieren und anhand der eben +gegebenen Hinweise in das ursprüngliche Druckmuster zurücküber +setzen, damit Sie dort den Fehler korrigieren können. + + +#abschnitt ("5.5", "FEHLERMELDUNGEN", "Fehlermeldungen")# + +Folgende Fehlermeldungen können bei der Übersetzung eines Druck +musters auftreten: + +#on("i")#keine schliessende Klammer in Feldmuster#off("i")# + Wenn der Name in einem Feldmuster in spitze Klammern einge + schlossen werden soll, muß noch in der gleichen Zeile eine + schließende Klammer vorhanden sein. + +#on("i")#kein Kommando in Kommandozeile#off("i")# + Eine Zeile, die mit '%' beginnt, enthält keinen weiteren Text. + +#on("i")#unbekanntes Kommando#off("i")# + Das erste Wort in einer Kommandozeile ist kein bekanntes Kom + mando. + +#on("i")#kein % WIEDERHOLUNG gefunden#off("i")# + Das Druckmuster enthält keine Anweisung, die den Beginn eines + Abschnittes markiert. Es muß aber mindestens ein Abschnitt + vorhanden sein. + +#on("i")#nur GRUPPE-Anweisung erlaubt#off("i")# + Im Initialisierungsteil ist nur die GRUPPE-Anweisung erlaubt. + +#on("i")#keine ELAN-Anweisung im Initialisierungsteil nach Gruppen +definition#off("i")# + Sobald im Initialisierungsteil eine GRUPPE-Anweisung aufgetreten + ist, ist keine Kommandozeile mehr möglich. + +#on("i")#illegale Gruppennummer#off("i")# + In einer GRUPPE-Anweisung wurde eine zu große Nummer angege + ben. Gruppen sollten von 1 an durchnumeriert werden. + +#on("i")#diese Gruppe wurde schon definiert#off("i")# + Eine Gruppennummer wurde mehrfach verwendet. + +#on("i")#diese Abkürzung ist nicht definiert#off("i")# + Ein Name in einem Feldmuster tritt nicht als Feld-oder Abkür + zungsname auf. Eventuell enthält er ein Leerzeichen! + +#on("i")#dieser Abschnitt wurde schon einmal definiert#off("i")# + Kein Abschnitt kann mehrmals angegeben werden. + +#on("i")#falscher Modus#off("i")# + In einer MODUS-Anweisung wurde ein nicht definierter Modus als + Parameter angegeben. + +#on("i")#diese Anweisung darf im Musterteil nicht vorkommen#off("i")# + +#on("i")#im Abkürzungsteil darf keine Anweisung auftreten#off("i")# + +#on("i")#in dieser Zeile stehen zu viele Feldmuster#off("i")# + Es können maximal 24 Feldmuster in einer Zeile stehen. Abhilfe: + mehrere Feldmuster durch eine Abkürzung zusammenfassen. + +#on("i")#das Druckmuster enthält zu viele Feldmuster#off("i")# + Die Gesamtanzahl der Feldmuster ist begrenzt. Abhilfe: mehrere + Feldmuster durch eine Abkürzung zusammenfassen. + +#on("i")#nach dem "&" soll direkt der Name einer Abkürzung folgen#off("i")# + In einer Abkürzungszeile stehen Leerzeichen hinter dem '&'. + +#on("i")#kein Doppelpunkt nach Abkürzung#off("i")# + Nach dem Abkürzungsnamen in einer Abkürzungszeile muß durch + ein Leerzeichen getrennt ein Doppelpunkt folgen. + +#on("i")#Abkürzung mehrfach definiert#off("i")# + Die Abkürzung wurde unter dem gleichen Namen schon einmal, + vielleicht in einem anderen Abschnitt, definiert. + +#on("i")#das Druckmuster enthält zu viele Abkürzungen#off("i")# + Abhilfe: mehrere Abkürzungen zu einem Ausdruck zusammenfas + sen. + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.6 b/app/eudas/4.4/doc/ref-manual/eudas.ref.6 new file mode 100644 index 0000000..92c7610 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.6 @@ -0,0 +1,466 @@ +#type ("prop")##limit (14.0)# +#format# +#page (61)# +#kapitel ("6","Struktur","von","EUDAS-Dateien")# + + + +EUDAS-Dateien können unabhängig von EUDAS über den Daten +typ EUDAT manipuliert werden. Die zur Verfügung stehenden Zu +griffsoperationen sind in diesem Kapitel beschrieben. + Der Datentyp EUDAT ist analog zum Datentyp FILE. Jede +EUDAT-Variable kann an eine EUDAS-Datei angekoppelt werden. +Dadurch lassen sich beliebig viele EUDAS-Dateien gleichzeitig be +arbeiten. Wie der Abschnitt 6.6 zeigt, sind so auch ganz andere +Anwendungen realisierbar. + Die wesentlichen EUDAS-Funktionen (Ansehen, Suchen, Druk +ken) können jedoch nicht direkt auf EUDAT-Variablen angewendet +werden, sondern greifen auf die virtuelle Datei zu, die im nächsten +Kapitel beschreiben wird. + + +#abschnitt ("6.1", "DER DATENTYP SATZ", "Der Datentyp SATZ")# + +Der Datentyp SATZ stellt einen einzelnen EUDAS-Satz dar, der +intern als TEXT realisiert ist. Ein SATZ besteht aus bis zu 256 +Feldern, die jeweils einen TEXT enthalten können. Nach dem Initi +alisieren sind alle Felder mit "" vorbelegt. Die Felder können über +Nummern von 1 bis 256 angesprochen werden. + Damit kann man sich einen SATZ als dynamisches ROW n TEXT +vorstellen, das bis zu 256 Elemente haben kann. Anders als ein +entsprechendes ROW belegt ein leerer SATZ praktisch keinen Spei +cherplatz. + Folgende Zugriffsprozeduren stehen zur Verfügung: + +#proc# +TYPE SATZ + +OP := (SATZ VAR, SATZ CONST) + +PROC satz initialisieren (SATZ VAR) +#endproc# + Jeder SATZ muß vor Benutzung initialisiert werden. + +#proc# +INT PROC felderzahl (SATZ CONST) +#endproc# + Liefert die Nummer des höchsten belegten Feldes. + +#proc# +PROC feld lesen (SATZ CONST, INT CONST feldnr, + TEXT VAR inhalt) +#endproc# + Liest den Inhalt des Feldes 'feldnr' in 'inhalt'. +#f2# + FEHLER: +#f2# + #on("i")#n ist keine Feldnummer#off("i")# + 'n' liegt außerhalb des Bereiches 1..256. + +#proc# +PROC feld bearbeiten (SATZ CONST, INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) +#endproc# + Ruft 'bearbeite' auf, wobei 'bearbeite' ein Text und zwei Posi + tionen in diesem Text übergeben werden. Die Positionen geben + das erste und das letzte Zeichen des durch 'feldnr' ausgewähl + ten Feldes an. Ist der Anfang größer als das Ende, so ist das + Feld leer. +#f2# + FEHLER: +#f2# + #on("i")#n ist keine Feldnummer#off("i")# + 'n' liegt außerhalb des Bereiches 1..256. + +#proc# +PROC feld aendern (SATZ VAR, INT CONST feldnr, + TEXT CONST inhalt) +#endproc# + Schreibt 'inhalt' in das Feld mit der Nummer 'feldnr' +#f2# + FEHLER: +#f2# + #on("i")#n ist keine Feldnummer#off("i")# + 'n' liegt außerhalb des Bereiches 1..256. + +#proc# +INT PROC feldindex (SATZ CONST, TEXT CONST muster) +#endproc# + Falls eines der Felder 'muster' enthält, wird die Nummer dieses + Feldes geliefert, sonst 0. + + +#abschnitt ("6.2","DER DATENTYP EUDAT","Der Datentyp EUDAT")# + +Der Datentyp EUDAT muß ähnlich wie ein FILE an einen benann +ten oder unbenannten Datenraum angekoppelt werden. Der Daten +raum hat anschließend den Typ 3243. Weitere Zugriffe auf eine +EUDAT-Variable sind erst nach erfolgtem Ankoppeln zulässig. An +derenfalls können undefinierte Fehler entstehen. + +#proc# +TYPE EUDAT + +PROC oeffne (EUDAT VAR, TEXT CONST dateiname) +#endproc# + Koppelt die EUDAT-Variable an die EUDAS-Datei mit dem + Namen 'dateiname' an. Die Datei wird eingerichtet, falls sie + noch nicht existiert. +#f2# + FEHLER: +#f2# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Die angegebene Datei hat nicht den Typ 3243. + +#proc# +PROC oeffne (EUDAT VAR, DATASPACE CONST ds) +#endproc# + Koppelt die EUDAT-Variable an den Datenraum 'ds'. +#f2# + FEHLER: +#f2# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Der Datenraum wurde bereits verwendet und hat nicht den Typ + 3243. + +Eine EUDAS-Datei ist in Felder und Sätze unterteilt. Die Felder +werden beim Zugriff über Nummern angesprochen. Jedem Feld ist +jedoch zur Identifikation ein TEXT als Feldname zugeordnet. Die +Feldnamen werden als SATZ gespeichert, wobei jedes Feld seinen +zugeordneten Namen enthält. + +#proc# +INT PROC felderzahl (EUDAT CONST) +#endproc# + Liefert Anzahl der benannten Felder. Ist zu Anfang 0. + +#proc# +PROC feldnamen aendern (EUDAT VAR, + SATZ CONST neue namen) +#endproc# + Setzt die Feldnamen einer Datei. Ist 'felderzahl (neue namen)' + größer als die Felderzahl der Datei, so wird die Felderzahl der + Datei entsprechend heraufgesetzt. + +#proc# +PROC feldnamen lesen (EUDAT CONST, SATZ VAR namen) +#endproc# + Liefert alle Feldnamen in einer SATZ-Variablen. + +Eine EUDAS-Datei enthält drei zusätzliche Notiztexte. Zwei davon +sind bereits reserviert, und zwar: +#free (0.2)# + 1: Prüfbedingungen + 2: Datum der letzten Änderung +#f2# +Der dritte kann für freie Notizen verwendet werden. + +#proc# +PROC notizen lesen (EUDAT CONST, INT CONST notiz nr, + TEXT VAR notizen) +#endproc# + Schreibt die Notizen der EUDAS-Datei in 'notizen' ('notiz nr' = + 1,2,3). + +#proc# +PROC notizen aendern (EUDAT VAR, INT CONST notiz nr, + TEXT CONST notizen) +#endproc# + Ändert die Notizen. Alte Notizen werden dabei überschrieben + ('notiz nr' = 1,2,3). + + +#abschnitt ("6.3", "SATZPOSITION", "Satzposition")# + +Eine EUDAS-Datei läßt sich sequentiell vorwärts und rückwärts +bearbeiten. Dazu gibt es eine aktuelle Satzposition. Ein bestimmter +Satz kann auch direkt angesprungen werden. Die Prozeduren, die +nach dem Inhalt des ersten Feldes suchen, arbeiten besonders +schnell, da die entsprechenden Sätze über eine Hashmethode gefun +den werden. + +#proc# +INT PROC satznr (EUDAT CONST) +#endproc# + Liefert aktuelle Satzposition. + +#proc# +INT PROC saetze (EUDAT CONST) +#endproc# + Liefert Anzahl der Sätze. + +#proc# +BOOL PROC dateiende (EUDAT CONST) +#endproc# + Liefert TRUE, wenn 'satznr' groesser als 'saetze' ist. Die letzte + erreichbare Satzposition liegt um eins hinter dem letzten Satz + (um auch am Ende anfügen zu können). + +#proc# +PROC auf satz (EUDAT VAR, INT CONST satznr) +#endproc# + Positioniert auf den gewünschten Satz. Bei nicht existierenden + Sätzen wird auf den ersten bzw. hinter den letzten Satz ge + sprungen. + +#proc# +PROC weiter (EUDAT VAR) +#endproc# + Geht einen Satz weiter, jedoch nicht über das Dateiende hinaus. + +#proc# +PROC zurueck (EUDAT VAR) +#endproc# + Geht einen Satz zurück, falls der erste Satz noch nicht erreicht + ist. + +#proc# +PROC auf satz (EUDAT VAR, TEXT CONST muster) +#endproc# + Positioniert auf den ersten Satz, der als erstes Feld 'muster' + enthält, anderenfalls hinter den letzten Satz. + +#proc# +PROC weiter (EUDAT VAR, TEXT CONST muster) +#endproc# + Geht weiter, bis das erste Feld 'muster' enthält, bzw. bis hinter + den letzten Satz. + +#proc# +PROC zurueck (EUDAT VAR, TEXT CONST muster) +#endproc# + Geht zurück, bis das erste Feld 'muster' enthält, bzw. auf den + ersten Satz der EUDAS-Datei. + + +#abschnitt ("6.4", "SATZZUGRIFFE", "Satzzugriffe")# + +Der aktuelle Satz ist ein SATZ-Objekt. Auf die Felder des aktuellen +Satzes kann direkt zugegriffen werden. + +#proc# +PROC feld lesen (EUDAT CONST, INT CONST feldnr, + TEXT VAR inhalt) +#endproc# + Wirkt wie 'feld lesen' auf den aktuellen Satz. + +#proc# +PROC feld aendern (EUDAT VAR, INT CONST feldnr, + TEXT CONST inhalt) +#endproc# + Wirkt wie 'feld aendern' auf den aktuellen Satz. + +#proc# +PROC feld bearbeiten (EUDAT CONST, INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) +#endproc# + Wirkt wie 'feld bearbeiten' auf den aktuellen Satz. + +Der aktuelle Satz kann auch als Ganzes bearbeitet werden. + +#proc# +PROC satz lesen (EUDAT CONST, SATZ VAR satz) +#endproc# + Liefert den aktuellen Satz. + +#proc# +PROC satz aendern (EUDAT VAR, SATZ CONST satz) +#endproc# + Ersetzt den aktuellen Satz durch 'satz'. + +#proc# +PROC satz einfuegen (EUDAT VAR, SATZ CONST satz) +#endproc# + Fügt 'satz' vor dem aktuellen Satz ein. +#f2# + FEHLER: +#f2# + #on("i")#EUDAS-Datei voll#off("i")# + Eine EUDAS-Datei faßt mindestens 5000 Sätze. + +#proc# +PROC satz loeschen (EUDAT VAR) +#endproc# + Löscht den aktuellen Satz. + + +#abschnitt ("6.5", "SORTIEREN UND REORGANISIEREN", "Sortieren und Reorganisieren")# + +Zum Sortieren können für die einzelnen Felder Typen angegeben +werden, damit auch Zahlen und Daten richtig sortiert werden kön +nen. Außerdem kann die Feldreihenfolge angegeben werden, nach +der sortiert werden soll. + +#proc# +PROC feldinfo (EUDAT VAR, INT CONST feldnr, info) +#endproc# + Setzt den Feldtyp des Feldes 'feldnr'. Es bedeuten + -1 : normaler Text (Standard) + 0 : Text nach DIN. Ziffern und Sonderzeichen werden igno + riert. Groß-und Kleinbuchstaben gelten gleich. Umlaute + werden beachtet. + 1 : Zahl (beim Vergleich werden alle Zeichen außer Zif + fern ignoriert). + 2 : Datum. Es werden Daten der Form "tt.mm.jj" vergli + chen. + +#proc# +INT PROC feldinfo (EUDAT CONST, INT CONST feldnr) +#endproc# + Der Feldtyp des angegebenen Feldes wird geliefert. Zu Anfang + ist -1 voreingestellt. + +#proc# +INT PROC unsortierte saetze (EUDAT CONST) +#endproc# + Liefert die Anzahl von Sätzen, die seit dem letzten Sortiervor + gang geändert wurden. Bei einer neuen Datei, die noch nie + sortiert wurde, wird immer 0 geliefert. + +#proc# +PROC dezimalkomma (TEXT CONST komma) +#endproc# + Stellt das Dezimalkomma ein, das beim Vergleich von Zahlen + gelten soll. +#f2# + FEHLER: +#f2# + #on("i")#Nicht erlaubtes Dezimalkomma#off("i")# + Nur Texte der Länge 1 sind zugelassen. + +#proc# +TEXT PROC dezimalkomma +#endproc# + Liefert das eingestellte Dezimalkomma ("," ist voreingestellt). + +#proc# +PROC sortiere (EUDAT VAR, TEXT CONST reihenfolge) +#endproc# + Sortiert die Datei in der von 'reihenfolge' angegebenen Reihen + folge. Dabei enthält 'reihenfolge' an der Stelle #bsp ("2*i+1")# den Code + der Feldnummer, die als i-te in der Sortierung berücksichtigt + werden soll. Das Zeichen an der Stelle #bsp ("2*i")# gibt an, ob das Feld + mit der davorstehenden Feldnummer aufsteigend ('+') oder + absteigend ('-') sortiert werden soll. + +#proc# +PROC sortiere (EUDAT VAR) +#endproc# + Sortiert die Datei in der zuletzt eingestellten Reihenfolge. + Wurde noch keine Reihenfolge angegeben, wird die Datei in der + Feldreihenfolge sortiert. + +#proc# +TEXT PROC sortierreihenfolge (EUDAT CONST) +#endproc# + Liefert die zuletzt eingestellte Reihenfolge. Wurde noch nicht + sortiert, so wird "" geliefert. + +Nach umfangreichen Änderungen an einer EUDAS-Datei ist eine +Reorganisation sinnvoll, um "Textleichen" zu beseitigen. + +#proc# +PROC reorganisiere (TEXT CONST dateiname) +#endproc# + Die EUDAS-Datei mit dem Namen 'dateiname' wird reorgani + siert. + + +#abschnitt ("6.6", "EUDAS-DATEIEN ALS ASSOZIATIVSPEICHER", "EUDAS-Dateien als Assoziativspeicher")# + +In diesem Abschnitt soll ein Beispiel erläutert werden, in dem +EUDAS-Dateien unabhängig von EUDAS für einen ganz anderen +Zweck benutzt werden. Das folgende kurze Paket soll ein Abkür +zungsverzeichnis realisieren, das auf einer EUDAS-Datei basiert. + +#beispiel# + PACKET abkuerzungsverzeichnis + DEFINES + verzeichnis laden, + abkuerzung einfuegen, + abkuerzung aendern, + abkuerzung loeschen, + langform : + + EUDAT VAR verz; + SATZ VAR satz; + TEXT VAR inhalt; + + PROC verzeichnis laden (TEXT CONST dateiname) : + + oeffne (verz, dateiname) + + END PROC verzeichnis laden; + + PROC abkuerzung einfuegen (TEXT CONST abk, lang) : + + auf satz (verz, abk); + IF NOT dateiende (verz) THEN + errorstop ("Abkürzung existiert bereits") + ELSE + satz initialisieren (satz); + feld aendern (satz, 1, abk); + feld aendern (satz, 2, lang); + satz einfuegen (satz) + END IF + + END PROC abkuerzung einfuegen; + + PROC abkuerzung aendern (TEXT CONST abk, lang) : + + auf satz (verz, abk); + IF dateiende (verz) THEN + errorstop ("Abkürzung existiert nicht") + ELSE + feld aendern (verz, 2, lang) + END IF + + END PROC abkuerzung aendern; + + PROC abkuerzung loeschen (TEXT CONST abk) : + + auf satz (verz, abk); + IF NOT dateiende (verz) THEN + satz loeschen (verz) + END IF + + END PROC abkuerzung loeschen; + + TEXT PROC langform (TEXT CONST abk) : + + auf satz (verz, abk); + IF dateiende (verz) THEN + inhalt := ""; + errorstop ("Abkürzung nicht vorhanden") + ELSE + feld lesen (verz, 2, inhalt) + END IF; + inhalt + + END PROC langform; + + END PACKET abkuerzungsverzeichnis; +#text# + +Die Prozedur 'verzeichnis laden' koppelt die interne EUDAT-Vari +able 'verz' an eine benannte EUDAS-Datei, die eventuell vorher mit +EUDAS erstellt wurde. In diesem Beispiel sind die Feldnamen egal; +falls die übergebene EUDAS-Datei noch nicht existiert, wird sie mit +0 Feldern eingerichtet, was aber nur für eine spätere Anzeige mit +EUDAS störend wäre. + Grundlage für das Aufsuchen einer bestimmten Abkürzung bil +det immer die Prozedur 'auf satz', die nach dem Inhalt des ersten +Feldes optimiert sucht. Falls die Abkürzung nicht gefunden wurde, +wird auf das Dateiende positioniert, daher wird jeweils 'dateiende' +abgefragt. + Beim Einfügen eines neuen Satzes muß eine komplette Satz +variable angegeben werden, die bereits mit den Inhalten gefüllt ist. +Beim späteren Ändern kann jedoch direkt auf ein Feld zugegriffen +werden, ohne die Satzvariable explizit rauszuholen. + Die Abfrage einer bestimmten Abkürzung bereitet dann keine +Schwierigkeiten mehr. + Für die Verwendung von EUDAS-Dateien in diesem Beispiel +spricht zum einen die einfache Programmierung, zum anderen aber +auch die Möglichkeit, das erstellte Verzeichnis mit den Hilfsmitteln +von EUDAS zu warten und auszudrucken. + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.7 b/app/eudas/4.4/doc/ref-manual/eudas.ref.7 new file mode 100644 index 0000000..47533ac --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.7 @@ -0,0 +1,519 @@ +#type ("prop")##limit (14.0)# +#format# +#page (71)# +#kapitel ("7", "Verwaltung", "der offenen", "Dateien")# + + +Die in diesem Kapitel beschriebene Schnittstelle verbindet mehrere +EUDAS-Dateien zu einem großen Dateimodell. Diese virtuelle Datei +dient als Grundlage für die meisten EUDAS-Funktionen. Zuerst muß +eine Datei als Bestandteil der virtuellen Datei geöffnet werden, ehe +sie bearbeitet werden kann. Es ist so bei den Funktionen keine +Angabe mehr nötig, welche Datei gemeint ist. + Diese Schnittstelle ist in vielen Teilen für die interne +EUDAS-Anwendung ausgelegt. Bei einigen Prozeduren werden aus +Effizienzgründen keinerlei Überprüfungen auf illegale Aufrufe oder +Parameter durchgeführt. Wollen Sie eine solche Prozedur dennoch +verwenden, sollten Sie die Einhaltung der angegebenen Bedingungen +sorgfältig überprüfen. + + +#abschnitt ("7.1", "DATEIVERWALTUNG", "Dateiverwaltung")# + +Mit 'oeffne' wird eine Datei zum Bearbeiten geöffnet. Mit 'kette' und +'kopple' können weitere Dateien dazugekettet bzw. dazugekoppelt +werden. Durch 'sichere' können veränderte Kopien zurückgeschrie +ben werden. Durch 'dateien loeschen' werden die internen Kopien +gelöscht. + Mit 'anzahl dateien' kann die Anzahl der vorhandenen Dateien +erfragt werden. 'anzahl koppeldateien' gibt Auskunft darüber, wie +viel Dateien davon gekoppelt sind. 'aendern erlaubt' gibt den Status +wieder, der beim Öffnen der ersten Datei angegeben wurde. 'inhalt +veraendert' gibt an, ob die angegebene Datei verändert wurde. Mit +'eudas dateiname' können die Namen der geöffneten Dateien erfragt +werden. Bei jedem 'oeffne' wird 'dateiversion' um 1 erhöht. Dies +dient dazu, ein erfolgtes neues Öffnen von anderen Stellen aus zu +entdecken. + Mit 'auf koppeldatei' kann die virtuelle Datei auf eine Koppel +datei umgeschaltet werden, so daß der Eindruck entsteht, nur diese +Datei wäre geöffnet worden. + +#proc# +PROC oeffne (TEXT CONST dateiname, + BOOL CONST aendern erlaubt) +#endproc# + Falls Ändern erlaubt sein soll, wird eine Kopie der angegebenen + Datei zur Bearbeitung für EUDAS angelegt. Vorher geöffnete + Dateien werden gelöscht. Die Änderungserlaubnis wird entspre + chend gesetzt. Es wird die Satzposition der EUDAS-Datei ange + nommen (Ausnahme: steht die EUDAS-Datei hinter dem letzten + Satz, wird auf Satz 1 positioniert). 'dateiversion' sowie 'anzahl + dateien' werden um 1 erhöht. +#f2# + FEHLER: +#f1# + #on("i")#Datei nicht gesichert#off("i")# + Eine vorher geöffnete Datei war verändert, aber nicht gesi + chert. +#f1# + #on("i")#Datei existiert nicht#off("i")# + Die angegebene Datei ist nicht vorhanden. +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Die angegebene Datei hat nicht den für EUDAS-Dateien festge + legten Typ. + +#proc# +PROC kopple (TEXT CONST dateiname) +#endproc# + Die angegebene Datei wird zu den bereits geöffneten Dateien + dazugekoppelt. Falls Ändern erlaubt ist, wird eine Kopie dieser + Datei verwendet. Dabei werden die ersten Felder der Datei, die + bereits in der Hauptdatei vorhanden sind, als Koppelfelder + festgelegt. Alle weiteren Felder werden zusätzlich zu den bis + herigen angelegt. 'dateiversion', 'anzahl dateien' und 'anzahl + koppeldateien' werden um 1 erhöht. +#f2# + FEHLER: +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß vorher eine Datei geöffnet werden. +#f1# + #on("i")#Zuviel Dateien geoeffnet#off("i")# + Die Anzahl der gleichzeitig geöffneten Dateien ist begrenzt. +#f1# + #on("i")#Datei existiert nicht#off("i")# + Die angegebene Datei ist nicht vorhanden. +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Die angegebene Datei hat nicht den für EUDAS-Dateien festge + legten Typ. +#f1# + #on("i")#Zu viele Felder#off("i")# + Die Anzahl der Felder insgesamt ist begrenzt. +#f1# + #on("i")#Zu viele Koppelfelder#off("i")# + Die Anzahl der Koppelfelder ist begrenzt. +#f1# + #on("i")#keine Koppelfelder vorhanden#off("i")# + Das erste Feld der zu koppelnden Datei ist in der Hauptdatei + nicht vorhanden (unterschiedliche Feldnamen). + +#proc# +PROC kette (TEXT CONST dateiname) +#endproc# + Die angegebene Datei wird an die Hauptdatei angekettet, d.h. + die Sätze der neuen Datei werden am bisherigen Dateiende + angefügt. Falls Ändern erlaubt ist, wird eine Kopie dieser Datei + verwendet. Die zu kettende Datei muß in der Feldstruktur nicht + mit der Hauptdatei übereinstimmen. Die aktuelle Satzposition + wird beibehalten. 'dateiversion' und 'anzahl dateien' werden um + 1 erhöht. +#f2# + FEHLER: +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß vorher eine Datei geöffnet werden. +#f1# + #on("i")#Zuviel Dateien geoeffnet#off("i")# + Die Anzahl der gleichzeitig geöffneten Dateien ist begrenzt. +#f1# + #on("i")#Datei existiert nicht#off("i")# + Die angegebene Datei ist nicht vorhanden. +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Die angegebene Datei hat nicht den für EUDAS-Dateien festge + legten Typ. + +#proc# +PROC sichere (INT CONST dateinr, TEXT CONST dateiname) +#endproc# + Die geöffneten Dateien werden in der Reihenfolge ihres Öffnens + durchnumeriert (von 1 an). Die Arbeitskopie mit der angegebe + nen Nummer wird unter dem angegebenen Namen gesichert, aber + selbst nicht verändert. Die vorher unter diesem Namen vorhan + dene Datei wird gelöscht. War die zu sichernde Arbeitskopie + verändert worden, so wird sie anschließend als nicht verändert + angesehen. + Bedingungen: + 1 <= dateinr <= anzahl dateien + +#proc# +PROC dateien loeschen (BOOL CONST auch geaenderte) +#endproc# + Es werden alle geöffneten Arbeitskopien gelöscht. EUDAS wird + wieder in den Anfangszustand versetzt. Wird 'auch geaenderte' + angegeben, wird bei geänderten, aber nicht gesicherten Dateien + die Fehlermeldung unterdrückt. +#f2# + FEHLER: +#f1# + #on("i")#Datei nicht gesichert#off("i")# + Eine vorher geöffnete Datei war verändert, aber nicht gesi + chert. + +#proc# +BOOL PROC auf koppeldatei +#endproc# + Liefert TRUE, wenn auf eine Koppeldatei umgeschaltet wurde. + +#proc# +PROC auf koppeldatei (INT CONST nr) +#endproc# + Umschalten auf Koppeldatei 'nr'. Ist bereits umgeschaltet, wird + wieder zurückgeschaltet. In diesem Fall werden bei 'nr' = 1 die + Koppelfelder übernommen, anderenfalls nicht. Beim Umschalten + bleiben Satzposition, Markierungen und Suchmuster gespeichert. + In der Koppeldatei wird die beim letzten Umschalten eingestell + te Position wieder eingenommen. 'dateiversion' wird um 1 er + höht. + +#proc# +INT PROC anzahl dateien +#endproc# + Gibt die Anzahl der insgesamt geöffneten Dateien an. + +#proc# +INT PROC anzahl koppeldateien +#endproc# + Gibt die Anzahl der gekoppelten Dateien an. + +#proc# +BOOL PROC aendern erlaubt +#endproc# + Reflektiert den Status, der bei 'oeffne' gesetzt wurde. + +#proc# +BOOL PROC inhalt veraendert (INT CONST dateinr) +#endproc# + Gibt an, ob die geöffnete Datei mit der angegebenen Nummer + verändert wurde. Wird ggf. von 'sichere' zurückgesetzt. + Bedingung: + 1 <= dateinr <= anzahl dateien + +#proc# +TEXT PROC eudas dateiname (INT CONST dateinr) +#endproc# + Liefert den Namen, unter dem die entsprechende Datei geöffnet + wurde. + Bedingung: + 1 <= dateinr <= anzahl dateien + +#proc# +INT PROC dateiversion +#endproc# + Wird bei jedem 'oeffne', 'kette' und 'kopple' zyklisch erhöht. + +#proc# +INT PROC folgedatei (INT CONST dateinr) +#endproc# + Eine geöffnete EUDAS-Datei wird in eine von zwei Listen auf + genommen, die der geketteten Dateien und die der gekoppelten. + Diese Prozedur liefert jeweils die Nummer der nächsten Datei in + der Liste, am Ende aber 0. Die Liste der geketteten Dateien + beginnt immer mit 1, mit 'folgedatei (0)' erhält man die erste + gekoppelte Datei. + Bedingung: + 0 <= dateinr <= anzahl dateien + + +#abschnitt ("7.2", "FELDSTRUKTUR", "Feldstruktur")# + +Die einzelnen Sätze der kombinierten EUDAS-Datei sind in Felder +unterteilt. Diese setzen sich zusammen aus den Feldern der Haupt +datei und der einzelnen Koppeldateien, wobei die Koppelfelder je +weils nur einmal auftauchen. + 'anzahl felder' liefert die Anzahl der vorhanden Felder. Mit +'feldnamen lesen' und 'feldnamen bearbeiten' können die Feldnamen +abgefragt werden. 'feldnummer' liefert einen Index für einen vor +gegebenen Feldnamen, da die Felder immer über Nummern angespro +chen werden. + Die Prozeduren 'feld lesen' und 'feld bearbeiten' ermöglichen +den Zugriff auf den Feldinhalt des aktuellen Satzes; durch 'feld +aendern' kann dieser Inhalt abgeändert werden. + +#proc# +INT PROC anzahl felder +#endproc# + Liefert die Anzahl der vorhanden Felder. + +#proc# +PROC feldnamen lesen (INT CONST feldnr, + TEXT VAR feldname) +#endproc# + Liefert in 'feldname' den Namen des Feldes mit der Nummer + 'feldnr'. + Bedingung: + 1 <= feldnr <= anzahl felder + +#proc# +PROC feldnamen bearbeiten (INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) +#endproc# + Die Prozedur 'bearbeite' wird aufgerufen. Als Parameter werden + ein Text und Anfangs- und Endposition des gewünschten Feld + namens in diesem Text übergeben. Verhindert unnötiges Kopie + ren des Feldnamens in eine TEXT-Variable. Der übergebene + Text darf nicht verändert werden! + Bedingung: + 1 <= feldnr <= anzahl felder + +#proc# +INT PROC feldnummer (TEXT CONST feldname) +#endproc# + Liefert den index zu dem angegebenen Feldnamen. Falls ein + solcher Name nicht existiert, wird 0 geliefert. + +#proc# +PROC feld lesen (INT CONST feldnr, TEXT VAR inhalt) +#endproc# + Liefert den Inhalt des angegebenen Feldes. + Bedingung: + 1 <= feldnr <= anzahl felder + +#proc# +PROC feld bearbeiten (INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) +#endproc# + Die Prozedur 'bearbeite' wird aufgerufen. Der Feldinhalt des + angegebenen Feldes steht im übergebenen Text innerhalb der + Grenzen. Ist die Obergrenze kleiner als die Untergrenze, so ist + das Feld leer. + Bedingung: + 1 <= feldnr <= anzahl felder + +#proc# +PROC feld aendern (INT CONST feldnr, TEXT CONST inhalt) +#endproc# + Ändert den Inhalt des angegebenen Feldes. + Bedingung: + NOT ende der datei + 1 <= feldnr <= anzahl felder + +#proc# +INT PROC feldinfo (INT CONST feldnummer) +#endproc# + Liefert den Typ des angegebenen Feldes. + Bedingung: + 1 <= feldnummer <= anzahl felder + +#proc# +PROC notizen lesen (INT CONST nr, TEXT VAR inhalt) +#endproc# + Liest die angegebenen Notizen ('nr' = 1,2,3) aus der ersten + Datei oder der umgeschalteten Koppeldatei. + +#proc# +PROC notizen aendern (INT CONST nr, TEXT CONST inhalt) +#endproc# + Ändert die Notizen ('nr' = 1,2,3) der ersten Datei oder der um + geschalteten Koppeldatei. + + +#abschnitt ("7.3", "POSITIONIERUNG", "Positionierung")# + +Das virtuelle Dateimodell von EUDAS verfügt ebenfalls über eine +Satzposition, die verändert werden kann. + Durch 'satznummer' wird die aktuelle Satznummer geliefert, +beim Koppeln kann über 'satzkombination' die Reihenfolge der Kop +pelkombinationen bestimmt werden. 'dateiende' zeigt an, ob die +Satzposition hinter dem letzten Satz liegt. Mit 'weiter' und 'zurueck' +erfolgt die eigentliche Positionierung. Hier kann außer der Positio +nierung um Einzelsätze auch die Positionierung auf den nächsten +ausgewählten oder markierten Satz angefordert werden. Mit 'auf +satz' schließlich kann ein bestimmter Satz angesprungen werden. + +#proc# +INT PROC satznummer +#endproc# + Liefert die Nummer des aktuellen Satzes. Die Sätze werden von + 1 an durchnumeriert, wobei über die geketteten Dateien wei + tergezählt wird. + Bedingung: + anzahl dateien > 0 + +#proc# +INT PROC satzkombination +#endproc# + Liefert die laufende Nummer der Koppelkombination des aktuel + len Satzes. Wird nur durch 'weiter' im Einzelsatzmodus erhöht. + Normalerweise 1. + Bedingung: + anzahl dateien > 0 + +#proc# +BOOL PROC dateiende +#endproc# + Gibt an, ob die Satzposition hinter dem letzten Satz liegt. + +#proc# +PROC weiter (INT CONST modus) +#endproc# + Erhöht die aktuelle Satzposition. Für 'modus' gibt es 3 Möglich + keiten: + 1: Falls eine weitere Satzkombination besteht, wird diese ein + genommen, sonst zum nächsten Satz. + 2: Zum nächsten durch Suchbedingung ausgewählten Satz. Wird + optimiert. + 3: Zum nächsten markierten Satz. Wird optimiert. + Ist kein Satz mehr vorhanden, wird die Satzposition hinter dem + letzten Satz eingenommen. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC zurueck (INT CONST modus) +#endproc# + Geht um einen Satz zurück. Die Modusangabe ist wie bei 'wei + ter', jedoch wird im Modus 1 keine weitere Satzkombination + ausprobiert. Die Positionierung endet bei Satz 1. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC auf satz (INT CONST satznr) +#endproc# + Geht auf den angegebenen Satz. Ist 'satznr' < 1, wird auf Satz 1 + positioniert, ist der angegebene Satz nicht vorhanden, wird + hinter den letzten Satz positioniert. Es wird jeweils die erste + Satzkombination eingenommen. + Bedingung: + anzahl dateien > 0 + + +#abschnitt ("7.4", "ÄNDERUNGEN", "Änderungen")# + +Sätze des Dateimodells können eingefügt oder gelöscht werden. +Durch das Einfügen entsteht ein leerer Satz vor dem aktuellen Satz; +alle weiteren Sätze rücken eine Stelle weiter. Beim Löschen wird +dieser Vorgang wieder rückgängig gemacht. + Durch 'satz einfuegen' wird ein Leersatz eingefügt; durch +'satz loeschen' wird der aktuelle Satz gelöscht. + Sätze in gekoppelten Dateien werden grundsätzlich nicht ge +löscht; auch beim Einfügen entsteht nicht automatisch ein Leersatz +in den gekoppelten Dateien. Änderungen in den Koppeldateien +(durch 'feld aendern') werden gepuffert. Durch 'aenderungen ein +tragen' werden die Änderungen dann in die Koppeldateien eingetra +gen. Dabei kann auch ein neuer Satz in die Koppeldatei eingefügt +werden. Bei Positionierungen wird diese Prozedur automatisch auf +gerufen. + +#proc# +PROC satz einfuegen +#endproc# + Fügt vor dem aktuellen Satz einen Leersatz ein. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC satz loeschen +#endproc# + Löscht den aktuellen Satz. Hat hinter dem letzten Satz keine + Wirkung. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC aenderungen eintragen +#endproc# + Trägt die gepufferten Änderungen in die Koppeldateien ein. + Dabei können die folgenden Fälle auftreten: + 1. Der Satz in der Koppeldatei wird geändert. + Dies geschieht dann, wenn vorher ein passender Satz in der + Koppeldatei vorhanden war und die Koppelfelder nicht ver + ändert wurden. + 2. In der Koppeldatei wird ein neuer Satz eingefügt. + Wenn die Koppelfelder und noch andere Felder einer Datei + geändert wurden, wird in dieser Datei ein neuer Satz einge + fügt. + 3. Es wird neu gekoppelt. + Wurden nur die Koppelfelder einer Datei geändert, wird ein + neuer, zu diesen Feldern passender Satz gesucht. Nach + 'aenderungen eintragen' erscheinen unter den Feldern der + Datei die neuen Inhalte. + + +#abschnitt ("7.5", "SUCHBEDINGUNGEN", "Suchbedingungen")# + +Über 'suchbedingung' kann eine Suchbedingung eingetragen werden, +die für jeden Satz geprüft werden soll. Mit 'satz ausgewaehlt' wird +erfragt, ob der aktuelle Satz die Suchbedingung erfüllt. Die Such +bedingung kann mit 'suchbedingung loeschen' wieder ausgeschaltet +werden. + Einzelne Sätze können auch markiert werden. Nach einem Öff +nen ist zunächst kein Satz markiert. Durch 'markierung aendern' +kann die Markierung eines Satzes geändert werden. 'satz markiert' +fragt ab, ob der aktuelle Satz markiert ist. 'markierte saetze' liefert +die Anzahl der markierten Sätze. Mit 'markierungen loeschen' wer +den alle Markierungen entfernt. + +#proc# +PROC suchbedingung (INT CONST feldnr, + TEXT CONST bedingung) +#endproc# + Stellt für das angegebene Feld die im Text als Muster angege + bene Suchbedingung ein. Weitere Aufrufe verknüpfen die Be + dingungen mit UND (auch wenn das gleiche Feld erneut angege + ben wird). + Bedingung: + anzahl dateien > 0 + 1 <= feldnr <= anzahl felder +#f2# + FEHLER: +#f1# + #on("i")#Suchmuster zu umfangreich#off("i")# + Es wurden zu viele Vergleiche gefordert. + +#proc# +BOOL PROC satz ausgewaehlt +#endproc# + Gibt an, ob die Suchbedingung auf den aktuellen Satz zutrifft. + Hinter dem letzten Satz wird immer FALSE geliefert. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC suchbedingung lesen (INT CONST feldnr, TEXT VAR bedingung) +#endproc# + Liefert die zuletzt für das angegebene Feld eingestellte Bedin + gung, falls die Suchbedingung nicht gelöscht und keine Datei + neu geöffnet wurde. + Bedingung: + 1 <= feldnr <= anzahl felder + +#proc# +PROC suchbedingung loeschen +#endproc# + Löscht die eingestellte Suchbedingung wieder. Anschließend + sind alle Sätze ausgewählt. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC markierung aendern +#endproc# + Ändert die Markierung des aktuellen Satzes ins Gegenteil. + Bedingung: + anzahl dateien > 0 + +#proc# +BOOL PROC satz markiert +#endproc# + Gibt an, ob der aktuelle Satz markiert ist. + Bedingung: + anzahl dateien > 0 + +#proc# +INT PROC markierte saetze +#endproc# + Gibt an, wieviel Sätze insgesamt markiert sind. + Bedingung: + anzahl dateien > 0 + +#proc# +PROC markierungen loeschen +#endproc# + Löscht alle Markierungen. + Bedingung: + anzahl dateien > 0 + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.8 b/app/eudas/4.4/doc/ref-manual/eudas.ref.8 new file mode 100644 index 0000000..5e8d220 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.8 @@ -0,0 +1,444 @@ +#type ("prop")##limit (14.0)# +#format# +#page (83)# +#kapitel ("8", "Funktionen", "zur", "Bearbeitung")# + + + +Die Verarbeitungsfunktionen arbeiten jeweils auf der aktuell geöff +neten Datei. Falls mindestens ein Satz markiert ist, werden nur +markierte Sätze bearbeitet, anderenfalls die durch die Suchbedin +gung ausgewählten Sätze. + + +#abschnitt ("8.1", "DRUCKEN", "Drucken")# + +Zum Drucken wird ein Druckmuster als Textdatei benötigt. Dessen +Name muß beim Aufruf der Prozedur 'drucke' angegeben werden. +Werden beim Übersetzen des Druckmusters Fehler entdeckt, so wird +der Paralleleditor aufgerufen und kein Druckvorgang durchgeführt. + Normalerweise sendet der Druckgenerator die Ausgabe direkt +zum Drucker. Alternativ kann die Ausgabe auch in eine Datei ge +schrieben werden. Dieses Verfahren kann mit 'direkt drucken' umge +stellt werden. Der Aufruf + +#beispiel# + direkt drucken (TRUE) +#text# + +sendet alle Dateien direkt zum Drucker, mit + +#beispiel# + direkt drucken (FALSE) +#text# + +wird die Ausgabe in Dateien abgelegt. Diese Dateien erhalten Namen +der Form + +#beispiel# + "Druckmustername.a$n" +#text# + +wobei 'n' eine laufende Nummer zur Unterscheidung ist. + Soll die Druckausgabe in eine ganz bestimmte Datei geleitet +werden, so kann vor dem Aufruf von 'drucke' die Prozedur 'druck +datei' aufgerufen werden, die als Parameter den Namen der Ausga +bedatei erhält. Existiert die Datei noch nicht, wird sie eingerichtet, +ansonsten wird die Ausgabe am Ende angehängt. + Die Einstellung der Ausgabedatei gilt nur für einen Druckvor +gang und überschreibt für diesen Druckvorgang 'direkt drucken'. +Beim nächsten Druckvorgang wird wieder die durch 'direkt drucken' +festgelegte Einstellung verwendet. + Wenn beim Drucken ein großes Ausgabevolumen anfällt, kann es +sinnvoll sein, die Ausgabe in mehrere kleine Dateien aufzuteilen. +Dies gilt auch, wenn direkt gedruckt werden soll, da auch in diesem +Fall eine Zwischendatei erzeugt werden muß. Die maximale Anzahl +von Zeilen pro Datei wird durch 'max druckzeilen' angegeben. + Der dort angegeben Wert gilt nur ungefähr - ein Wechsel der +Ausgabedatei findet dann statt, wenn die Ausgabedatei nach Bear +beitung eines Satzes die Maximalanzahl überschritten hat. In die +neue Datei wird anschließend zuerst der Initialisierungsteil des +Druckmusters kopiert, ehe mit der Ausgabe des nächsten Satzes +fortgefahren wird. + +Die Prozeduren im einzelnen: + +#proc# +PROC drucke (TEXT CONST druckmuster) +#endproc# + Die aktuell geöffnete Datei wird nach dem angegebenen Druck + muster gedruckt. +#f2# + FEHLER: +#f1# + #on("i")#Datei "druckmuster" existiert nicht#off("i")# + Das angegebene Druckmuster ist nicht vorhanden. +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Zum Drucken muß eine Datei geöffnet sein. +#f1# + #on("i")#direkt Drucken nicht möglich#off("i")# + Es ist kein Druckprogramm installiert oder der Spooler läßt sich + mit 'print' nicht ansprechen. Der Druck wird abgebrochen, die + Ausgabedatei ist noch vorhanden. + +#proc# +PROC direkt drucken (BOOL CONST ja) +#endproc# + Gibt an, ob die Druckausgaben direkt gedruckt oder in einer + Datei gesammelt werden sollen. + +#proc# +PROC druckdatei (TEXT CONST ausgabedatei) +#endproc# + Leitet die Druckausgabe des nächsten Druckvorgangs in die + Datei 'ausgabedatei'. Die Einstellung von 'direkt drucken' wird + für diesen Druckvorgang überschrieben. Die Ausgabe wird am + Ende der Datei angehängt, falls nötig, wird die Ausgabedatei + vorher eingerichtet. + +#proc# +PROC maxdruckzeilen (INT CONST zeilen) +#endproc# + Stellt die maximale Anzahl von Zeilen für die Ausgabedatei ein. + Beim Überschreiten dieses Wertes wird eine neue Datei ange + fangen. Standardwert ist 4000. + +#proc# +TEXT PROC lfd nr +#endproc# + Liefert während des Druckens die laufende Nummer des gerade + gedruckten Satzes als Text. + +#proc# +BOOL PROC gruppenwechsel (INT CONST gruppennr) +#endproc# + Kann innerhalb eines Vor- oder Nachspanns beim Drucken ab + gefragt werden, um festzustellen, ob die angegebene Gruppe + gewechselt und damit den Vor- bzw. Nachspann mitverursacht + hat (es können zu einem Zeitpunkt mehrere Gruppen wechseln). + Die Gruppennummer 0 gibt die Standardgruppe an, die nur vor + dem ersten und nach dem letzten Satz wechselt. + + +#abschnitt ("8.2", "KOPIEREN", "Kopieren")# + +Zum selektiven Kopieren von EUDAS-Dateien wird ein Kopiermuster +benötigt. Dieses gibt die Zuordnung zwischen Feldern der Ziel- und +der Quelldatei an. Die Quelldatei ist immer die aktuell geöffnete +Datei. + Die Kopierfunktion wird durch 'kopiere' aufgerufen. Parameter +sind der Name der Zieldatei und das Kopiermuster als FILE. Alter +nativ kann statt des Kopiermusters eine Prozedur übergeben wer +den, die die Kopieranweisungen erhält. + Der eigentliche Kopiervorgang wird durch den Operator 'K' +bewirkt. Dieser erhält den Zielfeldnamen und einen TEXT-Aus +druck als Parameter. Der Wert des TEXT-Ausdrucks wird in das +jeweilige Feld der Zieldatei geschrieben. + Existiert die Zieldatei noch nicht, so wird sie mit den Feldern +eingerichtet, die in den einzelnen 'K'-Ausdrücken angegeben sind +und zwar in der angeführten Reihenfolge. Existiert die Zieldatei, so +werden gegebenenfalls noch nicht vorhandene Felder am Ende ange +fügt. + Die Prozedur 'std kopiermuster' liefert zu einer gegebenen +Zieldatei ein Standard-Muster, das als Auswahlgrundlage dienen +kann. Existiert die Zieldatei nicht, werden alle Felder der Quell +datei 1 : 1 kopiert, anderenfalls wird zu jedem Feld der Zieldatei +ein passendes Feld der Quelldatei gesucht - die Feldreihenfolge +richtet sich in diesem Fall nach der Zieldatei. + +#proc# +PROC kopiere (TEXT CONST dateiname, + FILE VAR kopiermuster) +#endproc# + Die aktuell geöffnete Datei wird nach den Angaben in 'kopier + muster' in die Datei 'dateiname' kopiert. Das Kopiermuster wird + dem ELAN-Compiler übergeben. Tritt bei der Übersetzung ein + Fehler auf, wird der Paralleleditor aufgerufen. +#f2# + FEHLER: +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Zieldatei existiert, ist aber keine EUDAS-Datei. +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß eine virtuelle Datei vorhanden sein. + +#proc# +PROC kopiere (TEXT CONST dateiname, PROC kopierfunktion) +#endproc# + Wie oben, nur ist die Kopierfunktion gleich als Prozedur vor + handen. +#f2# + FEHLER: +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Zieldatei existiert, ist aber keine EUDAS-Datei. +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß eine virtuelle Datei vorhanden sein. + +#proc# +OP K (TEXT CONST feldname, ausdruck) +#endproc# + Kopiert den Ausdruck in das Feld 'feldname' der Zieldatei. + Dieses Feld wird eingerichtet, falls es noch nicht existiert. + Dieser Operator ist nur während eines Kopiervorganges de + finiert (also in einem Kopiermuster oder einer Kopierfunktion). + Er darf nicht in einer IF-Klausel stehen, sondern muß bei + jedem Satz mit gleichem Feldnamen an der gleichen Stelle auf + gerufen werden. + +#proc# +PROC std kopiermuster (TEXT CONST dateiname, + FILE VAR kopiermuster) +#endproc# + Liefert ein Standard-Kopiermuster, abhängig von der Zieldatei + 'dateiname'. Existiert diese nicht, wird die Quelldatei unverän + dert kopiert, ansonsten richtet sich das Kopiermuster nach der + Zieldatei. + + +#abschnitt ("8.3", "TRAGEN", "Tragen")# + +Durch Tragen können Sätze komplett in eine Zieldatei transportiert +werden. In der Quelldatei sind sie anschließend nicht mehr vorhan +den. Eine ganze Auswahl von Sätzen kann mit 'trage' transportiert +werden. 'trage satz' transportiert nur den aktuellen Satz. Mit +'hole satz' kann der letzte Satz der Zieldatei wieder zurückgeholt +werden, so daß eine EUDAS-Datei auch als Zwischenspeicher für +Einzelsätze verwendet werden kann. + Existiert die Zieldatei bereits, muß sie mindestens so viele +Felder wie die Quelldatei besitzen, damit keine Informationen ver +lorengehen können. Die Feldnamen müssen nicht übereinstimmen. +Existiert die Zieldatei noch nicht, wird sie mit den Feldern der +Quelldatei eingerichtet. + Die Tragefunktion kann um eine gleichzeitige Prüfung erweitert +werden. Dabei werden Bedingungen überprüft, die bei der Zieldatei +gespeichert sind. Sätze, die diese Bedingungen verletzen, werden +nicht getragen. Eine entsprechende Meldung wird in eine Protokoll +datei geschrieben, die als Parameter übergeben werden muß. + Die Prüfbedingungen stehen als ausführbares Programm in den +Notizen der Zieldatei. Prüfbedingungen können mit mehreren Proze +duren formuliert werden. 'pruefe' nimmt eine beliebige Bedingung als +Parameter und gibt bei Mißerfolg eine Meldung aus. 'wertemenge' +prüft auf Übereinstimmung mit einem der angegebenen Werte. 'feld +maske' legt eine Maske für ein Feld fest, die auf den Inhalt zutref +fen muß. + Mit Hilfe der Prozedur 'eindeutige felder' können Satzduplikate +erkannt werden. Auch diese werden nicht getragen. + Die bei den Prüfbedingungen angegebenen Feldnamen müssen in +der Quelldatei vorhanden sein. Falls eine Prüfprozedur außerhalb +von 'trage' aufgerufen wird, führt eine Verletzung der Prüfbedin +gung zu einem 'errorstop'. + +#proc# +PROC trage (TEXT CONST dateiname, + FILE VAR protokoll, BOOL CONST test) +#endproc# + Alle ausgewählten Sätze werden in die Datei 'dateiname' getra + gen. Diese wird gegebenenfalls eingerichtet. Falls 'test' ange + geben ist, werden die in den Notizen der Zieldatei enthaltenen + Bedingungen geprüft. Nur in diesem Fall muß 'protokoll' initial + isiert sein. +#f2# + FEHLER: +#f1# + #on("i")#kein Satz zum Tragen vorhanden#off("i")# + Die Quelldatei ist leer oder es ist keine Datei geöffnet. +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Zieldatei existiert, ist aber keine EUDAS-Datei. +#f1# + #on("i")#Zieldatei hat falsche Felderzahl#off("i")# + Zu wenig Felder in der Zieldatei. + +#proc# +PROC trage satz (TEXT CONST dateiname) +#endproc# + Der aktuelle Satz wird in die Datei 'dateiname' getragen. +#f2# + FEHLER: +#f1# + #on("i")#kein Satz zum Tragen vorhanden#off("i")# + Keine Datei geöffnet oder Datei ist am Ende. +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Zieldatei existiert, ist aber keine EUDAS-Datei. +#f1# + #on("i")#Zieldatei hat falsche Felderzahl#off("i")# + Zu wenig Felder in der Zieldatei. + +#proc# +PROC pruefe (TEXT CONST feldname, BOOL CONST bedingung) +#endproc# + Wenn die angegebene Bedingung FALSE liefert, wird eine Mel + dung in die Protokolldatei geschrieben und der jeweilige Satz + nicht getragen. + +#proc# +PROC wertemenge (TEXT CONST feldname. menge) +#endproc# + Es wird geprüft, ob das angegebene Feld in der Wertemenge + enthalten ist. Die einzelnen Werte in der Wertemenge werden + dabei durch Komma getrennt. Leerzeichen sind signifikant. + +#proc# +PROC feldmaske (TEXT CONST feldname, maske) +#endproc# + Es wird geprüft, ob das angegebene Feld zu der Maske paßt. Die + Zeichen in der Maske haben dabei folgende Bedeutung: + '9' trifft auf jede Ziffer zu + 'X' trifft auf jedes Zeichen zu + 'A' trifft auf jeden Großbuchstaben zu (einschließlich + Umlaute) + 'a' trifft auf jeden Kleinbuchstaben zu (einschließlich + Umlaute und 'ß') + '*' trifft auf eine Folge beliebiger Zeichen zu (auch die + leere Folge). Eine sparsame Verwendung wird empfoh + len, da die Bearbeitung sehr aufwendig ist. + Alle anderen Zeichen treffen nur auf ein gleiches Zeichen zu. + +#proc# +PROC eindeutige felder (INT CONST anzahl) +#endproc# + Gibt an, die wieviel ersten Felder einen Satz eindeutig identifi + zieren sollen. Ein Satz, der mit einem Satz der Datei in diesen + Feldern übereinstimmt, wird nicht getragen. Ohne diese Angabe + wird keine derartige Prüfung vorgenommen. + +#proc# +PROC hole satz (TEXT CONST dateiname) +#endproc# + Holt den letzten Satz der angegebenen Datei und fügt ihn vor + dem aktuellen Satz ein. +#f2# + FEHLER: +#f1# + #on("i")#"dateiname" existiert nicht#off("i")# +#f1# + #on("i")#Datei ist keine EUDAS-Datei#off("i")# + Zieldatei existiert, ist aber keine EUDAS-Datei. +#f1# + #on("i")#Zieldatei hat falsche Felderzahl#off("i")# + Zu viele Felder in der angegebenen Datei. +#f1# + #on("i")#Kein Satz zum Tragen vorhanden#off("i")# + Die angegebene Datei ist leer. +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß eine virtuelle Datei vorhanden sein. + + +#abschnitt ("8.4", "VERARBEITUNG", "Verarbeitung")# + +Die ausgewählten Sätze der aktuellen Datei können nach einer +Verarbeitungsvorschrift verändert oder geprüft werden. Dies ge +schieht durch die Prozedur 'verarbeite'. Als Parameter kann ent +weder ein Verarbeitungsmuster als FILE oder die Verarbeitungs +funktion direkt als Prozedur übergeben werden. + Die Vorschrift wird durch den Operator 'V' realisiert. + +#proc# +PROC verarbeite (FILE VAR verarbeitungsmuster) +#endproc# + Die aktuelle Datei wird nach dem angegebenen Muster bearbei + tet. Enthält die Vorschrift, die dem ELAN-Compiler übergeben + wird, einen Fehler, wird der Paralleleditor aufgerufen. +#f2# + FEHLER: +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß eine virtuelle Datei vorhanden sein. + +#proc# +PROC verarbeite (PROC verarbeitungsfunktion) +#endproc# + Wie oben, nur wird die Vorschrift direkt als Prozedur überge + ben. +#f2# + FEHLER: +#f1# + #on("i")#keine Datei geoeffnet#off("i")# + Es muß eine virtuelle Datei vorhanden sein. + +#proc# +OP V (TEXT CONST feldname, ausdruck) +#endproc# + Das angegebene Feld des aktuellen Satzes wird durch den Aus + druck ersetzt. +#f2# + FEHLER: +#f1# + #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# + Das angegebene Feld ist nicht vorhanden. + + +#abschnitt ("8.5", "FUNKTIONEN IN AUSDRÜCKEN", "Funktionen in Ausdrücken")# + +Für Ausdrücke bei den in diesem Kapitel beschriebenen Prozeduren +sind einfache Funktionen zur Abfrage von Feldinhalten vorhanden. +Mit 'f' kann der Inhalt eines benannten Feldes erfragt werden, bei +'wert' wird der Inhalt erst in eine REAL-Zahl umgewandelt, wobei +nichtnumerische Zeichen ignoriert werden. + Die Prozedur 'textdarstellung' kann dazu verwendet werden, +den Wert einer TEXT-Variablen als TEXT-Denoter in ELAN-Syntax +darzustellen. + Die Prozedur 'zahltext' kann dazu verwendet werden, aus einer +REAL-Zahl einen mit der richtigen Zahl von Nachkommastellen ver +sehenen, variabel langen Text zu machen. + +#proc# +TEXT PROC f (TEXT CONST feldname) +#endproc# + Liefert den Inhalt des angegebenen Feldes. +#f2# + FEHLER: +#f1# + #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# + +#proc# +REAL PROC wert (TEXT CONST feldname) +#endproc# + Liefert den Inhalt des angegebenen Feldes als REAL. Dabei + werden nichtnumerische Zeichen ignoriert, ausgenommen das + Minuszeichen und das eingestellte Dezimalkomma (s. 'dezimal + komma'). Tritt kein numerisches Zeichen auf, wird der Wert 0.0 + geliefert. +#f2# + FEHLER: +#f1# + #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# + +#proc# +REAL PROC wert (TEXT CONST feldname, INT CONST kommastellen) +#endproc# + Wie 'wert' mit einem Parameter, nur daß das Ergebnis auf die + angegebene Anzahl von Nachkommastellen gerundet wird. +#f2# + FEHLER: +#f1# + #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# + +#proc# +TEXT PROC textdarstellung (TEXT CONST anzeigetext) +#endproc# + Liefert 'anzeigetext' als TEXT-Denoter, also in Anführungs + strichen. Anführungsstriche im Text werden dabei verdoppelt. + Steuerzeichen von 0 bis 31 werden in lesbare Form gebracht. + +#proc# +TEXT PROC zahltext (REAL CONST wert, INT CONST kommastellen) +#endproc# + Liefert den Text des angegebenen Werts mit dem eingestellten + Dezimalkomma und mit der angegebenen Zahl von Nachkomma + stellen. Sind die Kommastellen 0, wird auch das Komma unter + drückt. Der Text erhält soviel Stellen, wie zur Darstellung + benötigt werden. + +#proc# +TEXT PROC zahltext (TEXT CONST feldname, + INT CONST kommastellen) +#endproc# + Wirkt wie 'zahltext (wert (feldname), kommastellen)'. + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.9 b/app/eudas/4.4/doc/ref-manual/eudas.ref.9 new file mode 100644 index 0000000..85dd337 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.9 @@ -0,0 +1,184 @@ +#type ("prop")##limit (14.0)# +#format# +#page (93)# +#kapitel ("9", "Anzeige", " ", " ")# + + + +#abschnitt ("9.1", "FENSTERVERWALTER", "Fensterverwalter")# + +Funktionen, die einen Teil des Bildschirms in einem rechteckigen +Fenster beschreiben, werden über den Fensterverwalter untereinan +der koordiniert. Jede Funktion fordert für ihren Fensterbereich eine +Variable vom Typ FENSTER an. Vor jedem Bildschirmzugriff kann die +Funktion erfahren, ob andere Programme den Bildschirm im Fenster +bereich überschrieben haben. Gleichzeitig meldet sie damit Verän +derungen an anderen Fenstern an, die sich mit dem eigenen über +schneiden. + +#proc# +PROC fenster initialisieren (FENSTER VAR neu) +#endproc# + Jede Fenstervariable muß vor Benutzung initialisiert werden. + +#proc# +PROC fenstergroesse setzen (FENSTER VAR fenster, + INT CONST x anf, y anf, + x laenge, y laenge) +#endproc# + Die Fenstergröße des Fensters wird gesetzt. 'x anf' und 'y anf' + werden von 1..n gezählt. Die Größe eines 24x80-Bildschirms + entspricht den Angaben (1, 1, 79, 24). Da das letzte Zeichen + einer Zeile wegen Rollgefahr nicht benutzt werden kann, werden + nur 79 Spalten angegeben. +#f2# + FEHLER: +#f1# + #on("i")#zu viele Fenster#off("i")# + Es sind nur 16 verschiedene Fenstergrößen möglich. + +#proc# +PROC fenstergroesse (FENSTER CONST fenster, + INT VAR x anf, y anf, + x laenge, y laenge) +#endproc# + Meldet die eingestellte Größe des Fensters. + +#proc# +PROC fensterzugriff (FENSTER CONST mein fenster, + BOOL VAR veraendert) +#endproc# + Ein Zugriff auf 'mein fenster' wird angemeldet. 'veraendert' gibt + an, ob das Fenster seit dem letzten Zugriff durch einen über + schneidenden Zugriff verändert wurde. Beim ersten Zugriff ist + 'veraendert' immer TRUE. + +#proc# +PROC fenster veraendert (FENSTER CONST fenster) +#endproc# + Falls ein Unterprogramm eine FENSTER-Variable des Hauptpro + grammes benutzt, kennzeichnet das Unterprogramm das Fenster + mit dieser Prozedur als benutzt, damit das Hauptprogramm das + Bild neu ausgibt. + +#proc# +PROC bildschirm neu +#endproc# + Gibt an, daß der Bildschirm von einer Funktion benutzt wurde, + die ihre Zugriffe nicht über den Fensterverwalter anmeldet. + Alle Fenster werden als verändert gekennzeichnet. + + +#abschnitt ("9.2", "ANZEIGEGRUNDFUNKTIONEN", "Anzeigegrundfunktionen")# + +Sämtliche Anzeigefunktionen werden in einem Fenster abgewickelt, +dessen Größe durch 'anzeigefenster' bestimmt wird. + Die Funktion 'bildausgeben' übernimmt die eigentliche Ausgabe. +Dabei kann durch Parameter mitgeteilt werden, ob sich an der Datei +außer der Markierung etwas geändert hat. Hat sich nichts geändert, +wird zur Optimierung unter Umständen nur die Markierung neu +ausgegeben. Das Bild wird jedoch auf jeden Fall ganz ausgegeben, +wenn das Fenster von anderer Seite verändert wurde. Auch das +Öffnen einer neuen Datei wird automatisch erkannt und richtig +behandelt. + Welche Felder dargestellt werden sollen, kann durch 'feldaus +wahl' angegeben werden. Dabei ist für jeden Anzeigemodus eine +eigene Feldauswahl möglich. Die Darstellung kann durch 'rollen' in +vertikaler Richtung verschoben werden. + Mit 'uebersicht' kann die Übersicht ausgegeben werden. Ihre +Größe wird durch 'uebersichtsfenster' angegeben. + +#proc# +PROC anzeigefenster (INT CONST x anf, y anf, + x laenge, y laenge) +#endproc# + Das Anzeigefenster wird in der entsprechenden Größe reser + viert. +#f2# + FEHLER: +#f1# + #on("i")#Anzeigefenster zu klein#off("i")# + Das Fenster ist zu schmal (< 40 Zeichen), um eine sinnvolle + Anzeige zuzulassen. + +#proc# +PROC bild ausgeben (BOOL CONST datei veraendert) +#endproc# + Im Anzeigefenster wird das Bild je nach eingestelltem Modus + ausgegeben, wenn das Fenster verändert wurde oder 'satz ver + aendert' TRUE ist. 'satz veraendert' muß immer dann angegeben + werden, wenn am Inhalt der virtuellen Datei etwas verändert + wurde. + +#proc# +PROC feldauswahl (TEXT CONST feldcode) +#endproc# + Die im aktuellen Modus anzuzeigenden Felder und ihre Reihen + folge werden ausgewählt. Dabei enthält 'feldcodes' an der i-ten + Stelle den Code der Feldnummer des Feldes, das an i-ter Posi + tion erscheinen soll. + +#proc# +PROC rollen (INT CONST anzahl) +#endproc# + Die Darstellung wird um die angegebene Anzahl von Zeilen + gerollt. Bei einer positiven Angabe wird zu höheren Feld- bzw. + Satznummern gerollt (Bild bewegt sich umgekehrt). Beim ersten + bzw. letzten Feld bzw. Satz hört das Rollen automatisch auf. + +#proc# +PROC uebersichtsfenster (INT CONST x anf, y anf, + x laenge, y laenge) +#endproc# + Legt die Größe des Übersichtsfensters fest. + +#proc# +PROC uebersicht (TEXT CONST feldauswahl) +#endproc# + Ruft eine Übersicht der aktuellen Datei auf, in der geblättert + und markiert werden kann. In 'feldauswahl' steht an der Stelle + i der Code der Feldnummer, die als i-tes in der Aufzählung + erscheinen soll. + + +#abschnitt ("9.3", "EDITORFUNKTIONEN", "Editorfunktionen")# + +Es stehen drei Funktionen zur Verfügung, die den Editor im Anzei +gemodus benutzen. Sie dienen zum Einfügen und Ändern sowie zum +Eingeben eines Suchmusters. + Der Editor wird durch ESC 'q' verlassen. Weitere ESC-Funk +tionen, die zum Verlassen führen sollen, können durch 'exit zeichen' +angegegeben und nach Funktionsausführung mit 'exit durch' abge +fragt werden. + +#proc# +PROC aendern (PROC hilfe) +#endproc# + Bietet den aktuellen Satz zum Ändern an. Steht die virtuelle + Datei am Ende, wird automatisch 'einfuegen' durchgeführt. Bei + ESC '?' wird 'hilfe' aufgerufen. + +#proc# +PROC einfuegen (PROC hilfe) +#endproc# + Fügt vor dem aktuellen Satz einen Satz ein, dessen Inhalt im + Editor angegeben wird. Bei ESC '?' wird 'hilfe' aufgerufen. + +#proc# +PROC suchen (PROC hilfe) +#endproc# + Im Editor wird eine neue Suchbedingung eingegeben. Bei ESC '?' + wird 'hilfe' aufgerufen. + +#proc# +PROC exit durch (TEXT CONST zeichenkette) +#endproc# + Gibt die Zeichen an, die beim Drücken nach ESC zum Verlassen + des Editors führen sollen. Die eingegebenen Daten werden je + doch vorher auf jeden Fall noch verarbeitet. + +#proc# +TEXT PROC exit durch +#endproc# + Gibt an, durch welches Zeichen der Editor verlassen wurde. + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler b/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler new file mode 100644 index 0000000..6ce4287 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler @@ -0,0 +1,129 @@ +#type ("prop")##limit (14.0)# +#format# +#page (115)# +#kapitel (" ", "Fehlermeldungen", " ", " ")# + + + +In diesem Kapitel sind alle Fehlermeldungen aufgeführt, die von +EUDAS erzeugt werden und zum Abbruch einer Funktion führen +können. + +#on("i")#'n' ist keine Feldnummer#off("i")# + Es wurde eine Nummer als Feldnummer angegeben, die nicht er + laubt ist. + +#on("i")#Datei ist keine EUDAS-Datei#off("i")# + Es wurde versucht, eine andere Datei als EUDAS-Datei zu bear + beiten. + +#on("i")#inkonsistente EUDAS-Datei#off("i")# + Die interne Struktur der Datei ist zerstört. Kann durch Hardware + probleme (Archiv-Lesefehler) oder EUDAS-interne Fehler ent + standen sein. + +#on("i")#EUDAS-Datei voll#off("i")# + Eine EUDAS-Datei kann nur eine bestimmte Anzahl von Sätzen + aufnehmen (mindestens 5000). + +#on("i")#Nicht erlaubtes Dezimalkomma#off("i")# + Als Dezimalkomma kann nur ein einzelnes Zeichen angegeben + werden. + +#on("i")#Zuviel Dateien geoeffnet#off("i")# + Es können nicht mehr als 10 Dateien gleichzeitig geöffnet, geket + tet und gekoppelt sein. + +#on("i")#Zu viele Felder#off("i")# + Alle geöffneten Dateien zusammen dürfen nicht mehr als 256 + Felder der virtuellen Datei ergeben. + +#on("i")#Zu viele Koppelfelder#off("i")# + Es dürfen insgesamt nicht mehr als 32 Koppelfelder entstehen. + +#on("i")#keine Koppelfelder vorhanden#off("i")# + Eine Datei kann nicht gekoppelt werden, wenn Sie kein Koppelfeld + besitzt. + +#on("i")#keine Datei geoeffnet#off("i")# + Es kann nicht gekettet oder gekoppelt werden, wenn noch keine + Datei geöffnet wurde. Ebenfalls sind keine Verarbeitungsproze + duren möglich. + +#on("i")#Nicht möglich, wenn auf Koppeldatei geschaltet#off("i")# + Wenn auf eine Koppeldatei umgeschaltet wurde, ist Öffnen, Ketten + und Koppeln nicht möglich. + +#on("i")#kein direkter Dateizugriff bei geketteten oder gekoppelten Dateien#off("i")# + Wenn Dateien gekettet oder gekoppelt sind, ist Sortieren und + Ändern der Feldstruktur nicht möglich. + +#on("i")#Datei nicht gesichert#off("i")# + Eine vorher geöffnete Datei ist verändert und nicht gesichert. + +#on("i")#Datei wird von anderer Task geändert#off("i")# + Das Öffnen der Datei zum Ändern ist im Moment nicht möglich, da + ein anderer Benutzer sie bereits ändert. + +#on("i")#Suchmuster zu umfangreich#off("i")# + Ein Suchmuster darf nicht mehr als 100 Vergleiche erfordern. + +#on("i")#direkt Drucken nicht moeglich#off("i")# + Entweder ist kein Druckprogramm installiert oder die Spooltask + reagiert nicht. + +#on("i")#Das Feld "Feldname" ist nicht definiert#off("i")# + Sie haben einen falschen Namen angegeben. + +#on("i")#Kein Satz zum Tragen vorhanden#off("i")# + Es wurde versucht, aus einer leeren Datei oder am Dateiende zu + tragen. + +#on("i")#Zieldatei hat falsche Felderzahl#off("i")# + Eine Zieldatei beim Tragen hat weniger Felder als die aktuelle + Datei. Daher würden beim Tragen Informationen verlorengehen. + +#on("i")#Zieldatei darf nicht geöffnet sein#off("i")# + Eine geöffnete Datei ist als Zieldatei nicht zulässig. + +#on("i")#Das Feld "Feldname" verletzt die Pruefbedingung#off("i")# + Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und + die Bedingung war nicht erfüllt. + +#on("i")#Das Feld "Feldname" ist nicht in der Wertemenge#off("i")# + Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und + die Bedingung war nicht erfüllt. + +#on("i")#Das Feld "Feldname" stimmt nicht mit der Maske ueberein#off("i")# + Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und + die Bedingung war nicht erfüllt. + +#on("i")#Zu viele Fenster#off("i")# + Es sind nicht mehr als 16 verschiedene Größen von Fenstern + möglich. + +#on("i")#Fenster zu klein#off("i")# + Ein Menü wurde in einem zu kleinen Fenster aufgerufen. + +#on("i")#Hilfe existiert nicht#off("i")# + Es wurde versucht, eine nicht vorhandene Hilfestellung aufzu + rufen. + +#on("i")#Hilfe ist leer#off("i")# + Die angewählte Hilfestellung enthält keinen Text. + +#on("i")#Anzeigefenster zu klein#off("i")# + Das Anzeigefenster muß mindestens 40 Zeichen breit sein. + +#on("i")#Ungueltige Satznummer#off("i")# + Der angegebene Text stellt keine Satznummer dar. + +#on("i")#kein rekursiver Aufruf#off("i")# + Innerhalb von EUDAS darf 'eudas' nicht erneut aufgerufen wer + den. + +#on("i")#Task existiert nicht#off("i")# + Es wurde versucht, eine nicht existente Task als Manager einzu + stellen. + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt b/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt new file mode 100644 index 0000000..a9ac27f --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt @@ -0,0 +1,137 @@ +#type ("prop")##limit (14.0)# +#format# +#page(3)# +#kapitel (" ", " Inhalt", "", " ")# + + + +#type ("12")# + Vorwort . . . . . . . . . . . . . . . . . . . i + Inhalt . . . . . . . . . . . . . . . . . . . . iii + + +#type ("prop")# +#abschnitt ("I.", "FUNKTIONEN ZUM NACHSCHLAGEN", "Funktionen zum Nachschlagen")# + +#type ("prop")# +#on("b")#1 Zustände und Bedienung#off("b")# +#free (0.2)# +#type ("12")# +1.1 Zustände . . . . . . . . . . . . . . . . . . . 3 +1.2 Menüs . . . . . . . . . . . . . . . . . . . . 8 +1.3 Auswahl . . . . . . . . . . . . . . . . . . . 8 +1.4 Hilfe und Dialog . . . . . . . . . . . . . . . 9 +1.5 Editor . . . . . . . . . . . . . . . . . . . . 9 + +#type ("prop")# +#on("b")#2 Zusammenstellung der Funktionen#off("b")# +#free (0.2)# +#type ("12")# +2.1 Menü 'Öffnen' . . . . . . . . . . . . . . . . 13 +2.2 Menü 'Einzelsatz' . . . . . . . . . . . . . . 17 +2.3 Menü 'Gesamtdatei' . . . . . . . . . . . . . . 21 +2.4 Menü 'Drucken' . . . . . . . . . . . . . . . . 23 +2.5 Menü 'Dateien' . . . . . . . . . . . . . . . . 25 +2.6 Menü 'Archiv' . . . . . . . . . . . . . . . . 27 +2.7 Kurzabfrage . . . . . . . . . . . . . . . . . 29 + +#type ("prop")# +#on("b")#3 Das virtuelle Dateimodell#off("b")# +#free (0.2)# +#type ("12")# +3.1 Dateistruktur . . . . . . . . . . . . . . . . 31 +3.2 Öffnen . . . . . . . . . . . . . . . . . . . . 32 +3.3 Koppeln . . . . . . . . . . . . . . . . . . . 33 +3.4 Änderungen . . . . . . . . . . . . . . . . . . 34 +3.5 Sichern . . . . . . . . . . . . . . . . . . . 36 +3.6 Umschalten auf Koppeldatei . . . . . . . . . . 36 +3.7 Mehrbenutzerbetrieb . . . . . . . . . . . . . 37 + +#type ("prop")# +#on("b")#4 Ansehen und Bearbeiten#off("b")# +#free (0.2)# +#type ("12")# +4.1 Anzeige . . . . . . . . . . . . . . . . . . . 39 +4.2 Satzauswahl . . . . . . . . . . . . . . . . . 42 +4.3 Sortieren und Reorganisieren . . . . . . . . . 44 +4.4 Bearbeiten . . . . . . . . . . . . . . . . . . 46 + +#type ("prop")# +#on("b")#5 Drucken und Druckmuster#off("b")# +#free (0.2)# +#type ("12")# +5.1 Druckmustersyntax . . . . . . . . . . . . . . 49 +5.2 Der Druckvorgang . . . . . . . . . . . . . . . 51 +5.3 Interpretation von Musterzeilen . . . . . . . 52 +5.4 Anschluß zum ELAN-Compiler . . . . . . . . . . 56 +5.5 Fehlermeldungen . . . . . . . . . . . . . . . 57 + + +#type ("prop")# +#abschnitt ("II.", "EUDAS FÜR PROGRAMMIERER", "EUDAS für Programmierer")# + +#type ("prop")# +#on("b")#6 Struktur von EUDAS-Dateien#off("b")# +#free (0.2)# +#type ("12")# +6.1 Der Datentyp SATZ . . . . . . . . . . . . . . 61 +6.2 Der Datentyp EUDAT . . . . . . . . . . . . . . 63 +6.3 Satzposition . . . . . . . . . . . . . . . . . 64 +6.4 Satzzugriffe . . . . . . . . . . . . . . . . . 65 +6.5 Sortieren und Reorganisieren . . . . . . . . . 66 +6.6 EUDAS-Dateien als Assoziativspeicher . . . . . 68 + +#type ("prop")# +#on("b")#7 Verwaltung der offenen Dateien#off("b")# +#free (0.2)# +#type ("12")# +7.1 Dateiverwaltung . . . . . . . . . . . . . . . 71 +7.2 Feldstruktur . . . . . . . . . . . . . . . . . 75 +7.3 Positionierung . . . . . . . . . . . . . . . . 77 +7.4 Änderungen . . . . . . . . . . . . . . . . . . 78 +7.5 Suchbedingungen . . . . . . . . . . . . . . . 79 + +#type ("prop")# +#on("b")#8 Funktionen zur Bearbeitung#off("b")# +#free (0.2)# +#type ("12")# +8.1 Drucken . . . . . . . . . . . . . . . . . . . 83 +8.2 Kopieren . . . . . . . . . . . . . . . . . . . 85 +8.3 Tragen . . . . . . . . . . . . . . . . . . . . 87 +8.4 Verarbeitung . . . . . . . . . . . . . . . . . 89 +8.5 Funktionen in Ausdrücken . . . . . . . . . . . 90 + +#type ("prop")# +#on("b")#9 Anzeige#off("b")# +#free (0.2)# +#type ("12")# +9.1 Fensterverwalter . . . . . . . . . . . . . . . 93 +9.2 Anzeigegrundfunktionen . . . . . . . . . . . . 94 +9.3 Editorfunktionen . . . . . . . . . . . . . . . 95 + +#type ("prop")# +#on("b")#10 Programmierung der Menüs#off("b")# +#free (0.2)# +#type ("12")# +10.1 Menüformat . . . . . . . . . . . . . . . . . . 97 +10.2 Verwaltung der Menüs . . . . . . . . . . . . . 99 +10.3 Aufruf . . . . . . . . . . . . . . . . . . . . 101 +10.4 Dialog . . . . . . . . . . . . . . . . . . . . 103 + +#type ("prop")# +#on("b")#11 Programmierung von Anwendungen#off("b")# +#free (0.2)# +#type ("12")# +11.1 Musterprogramme . . . . . . . . . . . . . . . 105 +11.2 Dateianwendungen . . . . . . . . . . . . . . . 109 +11.3 Integrierte Anwendungen . . . . . . . . . . . 111 + + +#type ("prop")# +#abschnitt ("III.", "ANHANG", "Anhang")# + +#type ("12")# + Fehlermeldungen . . . . . . . . . . . . . . . 115 + Prozeduren mit Parametern . . . . . . . . . . 119 + Register . . . . . . . . . . . . . . . . . . . 125 + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.macros b/app/eudas/4.4/doc/ref-manual/eudas.ref.macros new file mode 100644 index 0000000..e86794e --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.macros @@ -0,0 +1,70 @@ +#*format# +#limit (13.5)##start (3.5,2.5)##pagelength (21.0)##block# +#:firsthead (false)# +#linefeed (1.07)# +#*macro end# +#*text# +#type ("prop10")# +#linefeed (1.07)# +#*macro end# +#*beispiel# +#type ("12")# +#linefeed (0.97)# +#*macro end# +#*bildschirm# +#type ("15")# +#linefeed(0.83)# +#*macro end# +#*proc# +#type ("12")# +#*macro end# +#*endproc# +#free (0.1)# +#type ("prop10")# +#linefeed (1.07)# +#*macro end# +#*abschnitt ($1,$2,$3)# +#headodd# +#on("b")#$1#right#$3 %#off("b")# +#free (1.0)# +#end# +#on("b")##ib(9)#$1#ie(9," $3")# $2#off("b")# +#*macro end# +#*char($1)# +$1 +#*macro end# +#*kapitel ($1,$2,$3,$4)# +#free (1.3)# +#"nlq"# +#type("roman.24")# +#on("b")##center#$1#off("b")# +#free (0.2)# +#type ("roman.18")# +#on("b")##center#$2 #off("b")# +#on("b")##center# $3#off("b")# +#on("b")##center#$4#off("b")# +#type ("prop10")# +#free (0.6)# +#headeven# +#on("b")#% $2 $3 $4#off("b")# +#free (1.0)# +#end# +#headodd# +#right##on("b")#%#off("b")# +#free (1.0)# +#end# +#*macro end# +#*f2# +#free (0.2)# +#*macro end# +#*a ($1)# +#on("b")#$1.#off("b")# +#*macro end# +#*bsp ($1)# +#type("12")#$1#type("prop")# +#*macro end# +#*f1# +#free (0.1)# +#*macro end# + + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.proz b/app/eudas/4.4/doc/ref-manual/eudas.ref.proz new file mode 100644 index 0000000..7ec9b50 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.proz @@ -0,0 +1,195 @@ +#type ("prop")##limit (14.0)# +#format# +#page (119)# +#kapitel (" ", "Prozeduren", "mit", "Parametern")# + + + +#beispiel# +:= (SATZ VAR, SATZ CONST) 6.1 + +aendern (PROC hilfe) 9.3 +aendern erlaubt : BOOL 7.1 +aenderungen eintragen 7.4 +anzahl dateien : INT 7.1 +anzahl felder : INT 7.2 +anzahl koppeldateien : INT 7.1 +anzeigefenster (INT CONST x anf, y anf, + x laenge, y laenge) 9.2 +auf satz (EUDAT VAR, INT CONST satznr) 6.3 +auf satz (EUDAT VAR, TEXT CONST muster) 6.3 +auf satz (INT CONST satznr) 7.3 +ausfuehrtaste (TEXT CONST taste) 10.3 +auswahl anbieten (TEXT CONST name, FENSTER CONST f, + TEXT CONST hilfe, + PROC (TEXT VAR, INT CONST) inhalt) 10.3 + +bild ausgeben (BOOL CONST datei veraendert) 9.2 +bildschirm neu 9.1 + +dateiende (EUDAT CONST) : BOOL 6.3 +dateiende : BOOL 7.3 +dateien loeschen (BOOL CONST auch geaenderte) 7.1 +dateiversion : INT 7.1 +dezimalkomma (TEXT CONST komma) 6.5 +dezimalkomma : TEXT 6.5 +dialog 10.4 +dialogfenster (INT CONST x anf, y anf, + x laenge, y laenge) 10.4 +direkt drucken (BOOL CONST ja) 8.1 +druckdatei (TEXT CONST dateiname) 8.1 +drucke (TEXT CONST mustername) 8.1 + +editget (TEXT CONST prompt, TEXT VAR eingabe, + TEXT CONST res, hilfe) 10.4 +eindeutige felder (INT CONST anzahl) 8.3 +einfuegen (PROC hilfe) 9.3 +eudas dateiname (INT CONST dateinr) : TEXT 7.1 +EUDAT 6.2 +exit durch (TEXT CONST exit zeichen) 9.3 +exit durch : TEXT 9.3 + +f (TEXT CONST feldname) : TEXT 8.5 +fehler ausgeben 10.4 +feld aendern (SATZ VAR, INT CONST feldnr, + TEXT CONST inhalt) 6.1 +feld aendern (EUDAT VAR, INT CONST feldnr, + TEXT CONST inhalt) 6.4 +feld aendern (INT CONST feldnr, TEXT CONST inhalt) 7.2 +feldauswahl (TEXT CONST feldcodes) 9.2 +feld bearbeiten (SATZ CONST, INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 6.1 +feld bearbeiten (EUDAT CONST, INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 6.4 +feld bearbeiten (INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 7.2 +felderzahl (SATZ CONST) : INT 6.1 +felderzahl (EUDAT CONST) : INT 6.2 +feldindex (SATZ CONST, TEXT CONST muster) : INT 6.1 +feldinfo (EUDAT VAR, INT CONST feldnr, info) 6.5 +feldinfo (EUDAT CONST, INT CONST feldnr) : INT 6.5 +feld lesen (SATZ CONST, INT CONST feldnr, + TEXT VAR inhalt) 6.1 +feld lesen (EUDAT CONST, INT CONST feldnr, + TEXT VAR inhalt) 6.4 +feld lesen (INT CONST feldnr, TEXT VAR inhalt) 7.2 +feldmaske (TEXT CONST feldname, maske) 8.3 +feldnamen aendern (EUDAT VAR, SATZ CONST namen) 6.2 +feldnamen bearbeiten (INT CONST feldnr, + PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 7.2 +feldnamen lesen (EUDAT CONST, SATZ VAR namen) 6.2 +feldnamen lesen (INT CONST feldnr, TEXT VAR name) 7.2 +feldnummer (TEXT CONST feldname) : INT 7.2 +FENSTER 9.1 +fenstergroesse (FENSTER CONST f, + INT VAR x anf, y anf, + x laenge, y laenge) 9.1 +fenstergroesse setzen (FENSTER VAR fenster, + INT CONST x anf, y anf, + x laenge, y laenge) 9.1 +fenster initialisieren (FENSTER VAR fenster) 9.1 +fenster veraendert (FENSTER CONST fenster) 9.1 +fensterzugriff (FENSTER CONST fenster, + BOOL VAR veraendert) 9.1 + +global manager 10.2 +gruppenwechsel (INT CONST gruppennr) : BOOL 8.1 + +hilfe anbieten (TEXT CONST name, FENSTER CONST f) 10.3 +hole satz (TEXT CONST dateiname) 8.3 + +inhalt veraendert (INT CONST dateinr) : BOOL 7.1 +ja (TEXT CONST frage, hilfe) : BOOL 10.4 + +K (TEXT CONST feldname, ausdruck) 8.2 +kette (TEXT CONST dateiname) 7.1 +kopiere (TEXT CONST dateiname, FILE VAR muster) 8.2 +kopiere (TEXT CONST dateiname, PROC kopierfunktion) 8.2 +kopple (TEXT CONST dateiname) 7.1 + +lfd nr : TEXT 8.1 + +markierte saetze : INT 7.5 +markierung aendern 7.5 +markierungen loeschen 7.5 +maxdruckzeilen (INT CONST anzahl zeilen) 8.1 +menue anbieten (ROW 6 TEXT CONST menuenamen, + FENSTER VAR f, + BOOL CONST esc erlaubt, + PROC (INT CONST, INT CONST) interpreter) 10.3 +menuedaten einlesen (TEXT CONST dateiname) 10.2 +menue loeschen (TEXT CONST name, INT CONST index) 10.2 +menue loeschen (BOOL CONST hilfen reduzieren) 10.2 +menue manager (DATASPACE VAR ds, + INT CONST order, phase, + TASK CONST order task) 10.2 +menuenamen (INT CONST index) : THESAURUS 10.2 + +neuer dialog 10.4 +notizen aendern (EUDAT VAR, INT CONST notiz nr, + TEXT CONST notizen) 6.2 +notizen lesen (EUDAT CONST, INT CONST notiz nr, + TEXT VAR notizen) 6.2 + +oeffne (EUDAT VAR, TEXT CONST dateiname) 6.2 +oeffne (TEXT CONST dateiname, + BOOL CONST aendern erlaubt) 7.1 + +pruefe (TEXT CONST feldname, BOOL CONST bedingung) 8.3 + +reorganisiere (TEXT CONST dateiname) 6.5 +rollen (INT CONST anzahl) 9.2 + +saetze (EUDAT CONST) : INT 6.3 +SATZ 6.1 +satz aendern (EUDAT VAR, SATZ CONST neuer satz) 6.4 +satz ausgewaehlt : BOOL 7.5 +satz einfuegen (EUDAT VAR, SATZ CONST satz) 6.4 +satz einfuegen 7.4 +satz initialisieren (SATZ VAR satz) 6.1 +satzkombination : INT 7.3 +satz lesen (EUDAT CONST, SATZ VAR satz) 6.4 +satz loeschen (EUDAT VAR) 6.4 +satz loeschen 7.4 +satz markiert : BOOL 7.5 +satznr (EUDAT CONST) : INT 6.3 +satznummer : INT 7.3 +sichere (INT CONST dateinr, TEXT CONST dateiname) 7.1 +sortiere (EUDAT VAR, TEXT CONST reihenfolge) 6.5 +sortiere (EUDAT VAR) 6.5 +sortierreihenfolge (EUDAT CONST) : TEXT 6.5 +status anzeigen (TEXT CONST zeile) 10.3 +std kopiermuster (TEXT CONST dateiname, FILE VAR f) 8.2 +suchbedingung (INT CONST feldnr, + TEXT CONST bedingung) 7.5 +suchbedingung loeschen 7.5 +suchen (PROC hilfe) 9.3 + +textdarstellung (TEXT CONST text) : TEXT 8.5 +trage (TEXT CONST dateiname, FILE VAR protokoll, + BOOL CONST test) 8.3 +trage satz (TEXT CONST dateiname) 8.3 + +unsortierte saetze (EUDAT CONST) : INT 6.5 + +V (TEXT CONST feldname, ausdruck) 8.4 +verarbeite (FILE VAR verarbeitungsmuster) 8.4 +verarbeite (PROC verarbeitungsfunktion) 8.4 + +waehlbar (INT CONST menuenr, funktionsnr, + BOOL CONST moeglich) 10.3 +wahl (INT CONST stelle) : INT 10.3 +weiter (EUDAT VAR) 6.3 +weiter (EUDAT VAR, TEXT CONST muster) 6.3 +weiter (INT CONST modus) 7.3 +wert (TEXT CONST feldname) : REAL 8.5 +wert (TEXT CONST feldname, INT CONST kommastellen) : REAL 8.5 +wertemenge (TEXT CONST feldname, menge) 8.3 + +zahltext (REAL CONST wert, INT CONST kommastellen) : TEXT 8.5 +zahltext (TEXT CONST feldname, + INT CONST kommastellen) : TEXT 8.5 +zurueck (EUDAT VAR) 6.3 +zurueck (EUDAT VAR, TEXT CONST muster) 6.3 +zurueck (INT CONST modus) 7.3 + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.reg b/app/eudas/4.4/doc/ref-manual/eudas.ref.reg new file mode 100644 index 0000000..61ebef9 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.reg @@ -0,0 +1,426 @@ +#type ("prop")##limit (6.5)# +#format# +#page (125)# +#kapitel (" ", "Register ", "", " ")# + + + +#columns (2, 0.5)# +#limit (6.5)# +ABKUERZUNGEN-Anweisung 49 +Abkürzungsteil 49 +Abkürzungsverzeichnis 68 +Abkürzungszeile 50 +Abschlußzeile 39 +aendern 96 +Ändern 10, 19 + -, nach Vorschrift 48 +aendern erlaubt 74 +Änderungen 34 +aenderungen eintragen 79 +Änderungsmuster 21 +Alternative 43 +Ankreuzen 8 +anzahl dateien 74 +anzahl felder 75 +anzahl koppeldateien 74 +Anzeige 39, 93 +anzeigefenster 95 +Arbeitskopie 13, 32 + -, löschen 15, 36 + -, sichern 15, 36 +Archivmanager 28 + -, reservieren 29 +Archiv (Menü) 27 +Archivübersicht drucken 27 +Assoziativspeicher 68 +auf koppeldatei 74 +Aufräumen 26 +auf satz 65, 78 +Auf Satz Nr. 17 +Ausdrucken 24 +Ausführen 8 +ausfuehrtaste 8, 102 +AUSWAHL 97 +AUSWAHL: 4 +Auswahl 8 + -, Format 98 +auswahl anbieten 103 + +Bearbeiten 46 +BILD 97 +bild ausgeben 95 +bildschirm neu 94 + +Datei, aufräumen 26 + -, kopieren (logisch) 25 + -, kopieren vom Archiv 27 + -, löschen 25 + -, löschen auf Archiv 28 + -, Platzbedarf 26 + -, reorganisieren 26 + -, schreiben auf Archiv 27 + -, umbenennen 25 + -, virtuelle 32, 71 +Dateianwendungen 109 +Dateien Archiv, Übersicht 27 +dateiende 64, 78 +dateien loeschen 74 +Dateien (Menü) 25 +Dateien System, Übersicht 25 +Dateilimit 52 +Dateimanager 28 +Dateiname 40 +dateiversion 75 +DATUM 45 +Dezimalkomma 45 +dezimalkomma 67 +dialog 104 +Dialog 9, 103 +dialogfenster 104 +DIN 45 +direkt drucken 83f. +Druckausgabe, Richtung 23 +druckdatei 85 +drucke 84 +Drucken 23, 49, 83 + -, Archivübersicht 27 +Drucken (Menü) 23 +Druckmuster 23, 49, 83 + -, Fehler 56 +Druckvorgang 51 + +editget 104 +EDITIEREN: 6 +Editieren 23 + -, Zeile 9 +Editor 9, 29 +eindeutige felder 47, 89 +einfuegen 96 +Einfügen 10, 19 + -, Satz 36 + -, Zeile 10 +EINGABE: 4 +Eingabe 9 +Einzelsatz (Menü) 17 +ELAN-Compiler 56 +ELAN-Kommandos 8 +ENDE 97 +Endekennzeichnung 40 +ESC '?' 6 +ESC '9' 4 +ESC '1' 4 +ESC '?' 4 +ESC '?' 3 +ESC 'D' 5 +ESC ESC 3 +ESC 'F' 5f. +ESC 'g' 5 +ESC 'h' 4ff. +ESC 'K' 36 +ESC OBEN 5 +ESC 'p' 5 +ESC 'q' 4, 6 +ESC RUBIN 5 +ESC RUBOUT 5 +ESC UNTEN 5 +ESC 'w' 4f. +ESC 'z' 4f. +eudas 29 +EUDAS: 3 +EUDAS-Datei, aufspalten 110 + -, drucken 23, 49, 83 + -, einrichten 13 + -, ketten 14, 32 + -, kopieren 21, 46, 85 + -, koppeln 14, 32 + -, nach Vorschrift ändern 48 + -, öffnen 13, 32 + -, reorganisieren 67 + -, sortieren 22 + -, Struktur 31, 61 + -, tragen 46, 87 + -, Übersicht 22 + -, verändern 21 +eudas dateiname 75 +EUDAT 61, 63, 109 +EUMEL-Netz 28 +exit durch 96 + +f 91 +FEHLER 5 +fehler ausgeben 104 +Feld 31 +FELD 98 +feld aendern 62, 65, 76 +Feldauswahl 20, 41, 95 +feld bearbeiten 62, 65, 76 +felderzahl 62, 63 +feldindex 62 +feldinfo 66, 77 +Feldinhalt 31, 39 +feld lesen 65, 76 +feldmaske 47, 89 +Feldmuster 53 +Feldname 31, 39 + -, ändern 16 + -, anfügen 16 +feldnamen aendern 63 +feldnamen bearbeiten 76 +feldnamen lesen 64, 76 +feldnummer 76 +Feldstruktur 15 +Feldtyp 31, 42 +Feldtypen 45, 66 + -, ändern 16 +Feldvergleich 43 +Fenster 93 +fenstergroesse 94 +fenstergroesse setzen 93 +fenster initialisieren 93 +fenster veraendert 94 +fensterzugriff 94 +folgedatei 75 +Folgezeilen 41 +Formular 39 +FRAGE: 5 +Fragen 9 +Funktion, ausführen 8 + -, gesperrte 8 + +Gesamtdatei (Menü) 21 +Gib Kommando: 6 +global manager 36, 100 +Gruppe 51 +GRUPPE-Anweisung 49 +gruppenwechsel 51, 85 + +Hauptdatei 32 +HILFE: 4 +HILFE 97, 99 +Hilfe 9 + -, Format 98 +hilfe anbieten 103 +Holen 19 +hole satz 89 +HOP LINKS 4 +HOP 'o' 4 +HOP OBEN 3ff. +HOP RECHTS 4 +HOP RETURN 4 +HOP RUBOUT 4 +HOP UNTEN 3ff. +HOP 'x' 4 + +inhalt veraendert 74 +Initialisieren 28 +Initialisierungsteil 49 + +ja 104 + +K 46, 86 +kette 73 +Ketten 14, 32 +Klassenwechsel 106 +Kombinationen 34 +Kommandos 8 +Kommandozeile 50 +kopiere 86 +Kopieren 21, 46, 85 +Kopieren (logisch) 25 +Kopieren vom Archiv 27 +Kopiermuster 21, 46 +KOPPEL 40 +Koppeldatei, umschalten auf 36 +Koppelfelder 33 +Koppeln 14, 32f. +kopple 72 +Kurzabfrage 29 + +LEER 3f. +Leertaste 8 +lfd nr 85 +lineform 24 +LINKS 3f. +Literaturangaben 108 +Löschen 25 + -, Satz 36 + -, Zeile 10 +Löschen auf Archiv 28 + +Manager 13 +Manager (Mehrbenutzer) 16, 36 +markierte saetze 81 +Markierung 18, 40, 42 +markierung aendern 81 +Markierungen löschen 22 +markierungen loeschen 81 +maxdruckzeilen 85 +MEHR-Anweisung 50 +MENUE 97 +Menü 8 + -, Aufruf 101 + -, Verwaltung 99 +menue anbieten 101 +menuedaten einlesen 99 +Menüformat 97 +menue loeschen 100 +menue manager 100 +menuenamen 100 +Modi 55 +MODUS-Anweisung 50 +Musterprogramme 105 +Musterteil 50 +Musterzeichen 53 +Musterzeile 50 + -, Interpretation 52 + +Nachbearbeiten 24 +Nachspann 49 +NACHSPANN-Anweisung 49 +Namenskonflikte 33 +neuer dialog 104 +Normalmodus 55 +Notizen 15, 31, 64 +notizen aendern 64, 77 +notizen lesen 64, 77 + +'o' 4 +OBEN 3f. +ODER-Verknüpfung 43 +oeffne 63, 72 +Öffnen 32 +Öffnen (Menü) 13 + +pageform 24 +Paralleleditor 56, 83 +Paßwort 29 +Platzbedarf 26 +Positionieren 17, 31, 64, 77 +Priorität 44 +Programmzeile 51 +Protokolldatei 47 +Prüfbedingungen 16, 31, 47, 64, + 87 +pruefe 47, 88 +Pufferplatz 54 + +RECHTS 3f. +Refinement 56 +reorganisiere 67 +Reorganisieren 26, 45, 67 +Reservieren 29 +RETURN 4 +Richtung Druckausgabe 23 +rollen 95 +Rollen 41 +RUBIN 4 +RUBOUT 4 + +saetze 64 +SATZ 61 +Satz 31 +satz aendern 66 +satz ausgewaehlt 80 +Satzauswahl 42 +Satzeditor 9 +satz einfuegen 66, 79 +Satzformular 39 +satz initialisieren 62 +satzkombination 77 +satz lesen 66 +satz loeschen 66, 79 +satz markiert 81 +satznr 64 +satznummer 77 +Satznummer 39 +Satzposition 64 +Satzzeiger 31 +Satzzugriffe 65 +Schreiben auf Archiv 27 +SEITE 99 +sichere 73 +Sichern 15, 36 +sortiere 67 +Sortieren 22, 31, 44, 66 +Sortierreihenfolge 31, 44 +sortierreihenfolge 67 +Sortierzustand 45 +Spaltendruck 52 +Sperre 36 +Standard-Kopiermuster 21, 46 +status anzeigen 103 +Statuszeile 3 +std kopiermuster 87 +Suchbedingung 17, 39, 42 + -, löschen 18 + -, setzen 18 +suchbedingung 80 +suchbedingung lesen 80 +suchbedingung loeschen 80 +suchen 96 +Suchen, Optimierung 44 +Suchmuster 42 + -, eingeben 10 + +Tabellenmodus 55 +Tasten 3 +Tastenfunktionen 3 +TEXT 45 +textdarstellung 91 +Textdatei, ausdrucken 24 + -, editieren 23 + -, nachbearbeiten 24 +Textzeile 49f. +trage 88 +Tragen 16, 19, 21, 46, 87 +trage satz 88 + +uebersicht 95 +uebersichtsfenster 95 +Umbenennen 25 +Umbruch 40, 55 +Umschalten auf Koppeldatei 36 +UND-Verknüpfung 43 +unsortierte saetze 67 +UNTEN 3f. +Überschrift 39 +Übersicht 22, 41 +Übersicht Dateien Archiv 27 +Übersicht Dateien System 25 + +V 48, 90 +Verändern 21 +verarbeite 90 +Verarbeitung 89 +Verknüpfung von Bedingungen +43 +virtuelle Datei 32, 71 +VORSPANN 98 +Vorspann 49 +VORSPANN-Anweisung 49 + +waehlbar 102 +wahl 103 +Warten 6 +weiter 65, 78 +Weiter 17 +wert 91 +wertemenge 47, 88 +WIEDERHOLUNG-Anweisung 49 +Wiederholungsteil 49 + +'x' 4 + +ZAHL 45 +zahltext 91 +Zeichen, reservierte 44 +ZEIGEN: 6 +Zeilenende 54 +Zeilenwiederholung 55 +Zielarchiv 28 +Zurück 17 +zurueck 65, 78 +Zustand 3 +Zustandsübergänge 7 + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.titel b/app/eudas/4.4/doc/ref-manual/eudas.ref.titel new file mode 100644 index 0000000..289de34 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.titel @@ -0,0 +1,68 @@ +#type ("prop")##limit (14.0)# +#format# +#free (6.0)# +#type ("roman.18")# +#on("b")#EUDAS#off("b")# +#free (1.0)# +#type ("roman.14")# +#on("b")#Anwender-#off("b")# +#on("b")#Datenverwaltungssystem#off("b")# +#free (2.0)# +#type ("10")# +#on ("b")#VERSION 4#off("b")# +#free(1.0)# +#on("u")# #off("u")# +#free (0.5)# +#on("b")#REFERENZHANDBUCH#off("b")# +#type ("prop")##block# +#page# +#free (9.5)# +Hergestellt mit Hilfe der EUMEL-Textverarbeitung und des Pro +gramms FontMaster der Martin Schönbeck GmbH. +#free (1.7)# +Ausgabe September 1987 + +Dieses Handbuch und das zugehörige Programm sind urheberrechtlich +geschützt. Die dadurch begründeten Rechte, insbesondere der Ver +vielfältigung in irgendeiner Form, bleiben dem Autor vorbehalten. + +Es kann keine Garantie dafür übernommen werden, daß das Pro +gramm für eine bestimmte Anwendung geeignet ist. Die Verantwor +tung dafür liegt beim Kunden. + +Das Handbuch wurde mit größter Sorgfalt erstellt. Für die Korrekt +heit und Vollständigkeit der Angaben wird aber keine Gewähr über +nommen. Das Handbuch kann jederzeit ohne Ankündigung geändert +werden. + +(c) Copyright 1987 Thomas Berlage + Software-Systeme + Im alten Keller 3 +#free (0.1)# + D-5205 Sankt Augustin 1 +#page# +#type ("roman.24")# +#free (7.0)# +#center##on("b")#I.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#FUNKTIONEN#off("b")# +#center##on("b")#ZUM#off ("b")# +#center##on("b")#NACHSCHLAGEN#off("b")# +#page# +#type ("roman.24")# +#free (7.0)# +#center##on("b")#II.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#EUDAS#off("b")# +#center##on("b")#FÜR#off ("b")# +#center##on("b")#PROGRAMMIERER#off("b")# +#page# +#free (7.0)# +#type ("roman.24")# +#center##on("b")#III.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#ANHANG#off("b")# + diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort b/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort new file mode 100644 index 0000000..f3880f4 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort @@ -0,0 +1,29 @@ +#type ("prop")##limit (14.0)# +#format# +#page (1)# +#kapitel (" ", "Vorwort", " ", " ")# + + + +Lieber EUDAS-Benutzer! + +Dies ist das zweite Handbuch, das Sie zu EUDAS bekommen. Wenn +Sie sich mit EUDAS noch nicht auskennen, sollten Sie zunächst das +#on("i")#Benutzerhandbuch#off("i")# zu Rate ziehen, ehe Sie in dieses Handbuch +schauen. + + Das #on("i")#Referenzhandbuch#off("i")# ist in zwei Teile geteilt. Im ersten Teil +finden Sie eine Übersicht über alle EUDAS-Funktionen (im Kapitel +2) sowie zusammengefaßte Informationen über die Bedienung (Kapi +tel 1) und die genaue Wirkung der einzelnen Funktionen (Kapitel 3 +bis 5). Dieser Teil soll Ihnen zum Nachschlagen dienen, wenn Sie +eine bestimmte Information suchen. + Im zweiten Teil sind alle Informationen zusammengefaßt, die +ein Programmierer zur Benutzung der EUDAS-Funktionen braucht. Es +sei an dieser Stelle jedoch davon abgeraten, sofort eigene Program +me zu schreiben, da sich in vielen Fällen die gleiche Wirkung auch +durch Programmierung innerhalb von EUDAS-Funktionen erreichen +läßt (zum Beispiel in Druck- und Änderungsmustern). + Im Zweifelsfall orientieren Sie sich anhand von Kapitel 11, wie +Sie Ihr Problem am besten lösen können. + diff --git a/app/eudas/4.4/doc/ref-manual/ref.abb.1-1 b/app/eudas/4.4/doc/ref-manual/ref.abb.1-1 new file mode 100644 index 0000000..bc70722 --- /dev/null +++ b/app/eudas/4.4/doc/ref-manual/ref.abb.1-1 @@ -0,0 +1,58 @@ +#type ("prop")##limit (13.5)# +#start (3.5, 5.0)# +#lpos (0.5)##c pos (3.5)##c pos (4.7)##cpos (7.0)##c pos (10.5)# +#table# + eudas ESC q + + ESC ESC ESC h +#free (0.2)# +#type ("roman.12")# +GIB KDO: EUDAS +#type ("prop")# +#free (0.2)# + ESC h + RET LEER 'Buchst.' + + ESC q + +#type ("roman.12")# + FEHLER + + + WARTEN +#type ("prop")# + n, j +#type ("roman.12")# + FRAGE +#type ("prop")# + + RET +#type ("roman.12")# + EINGABE +#type ("prop")# +#linefeed (0.5)# + + + ESC z + ESC q +#linefeed (1.0)# +#type ("roman.12")# + AUSWAHL +#type ("prop")# + + ESC q +#type ("roman.12")# + EDITIEREN +#type ("prop")# + + ESC q +#type ("roman.12")# + SATZEDITOR +#type ("prop")# +ESC ? ESC q + ESC q +#type ("roman.12")# +HILFE ZEIGEN +#type ("prop")# + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.1 b/app/eudas/4.4/doc/user-manual/eudas.hdb.1 new file mode 100644 index 0000000..0c6871b --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.1 @@ -0,0 +1,254 @@ +#type ("prop10")##limit (14.0)# +#page (3)# +#format# +#kapitel ("1", "Was", "kann", "EUDAS ?")# + + + +In diesem Kapitel wollen wir Ihnen erklären, was EUDAS Ihnen ei +gentlich bringen soll. Sie arbeiten sicher nicht nur aus Spaß am +Computer, sondern wollen ihn für bestimmte Aufgaben einsetzen. Ein +Computer kann bestimmte Aufgaben nur dann bearbeiten, wenn er +dafür programmiert worden ist. + EUDAS ist nun ein Programm, das allgemein Aufgaben der Da +tenverwaltung lösen kann. Zunächst wollen wir Ihnen erläutern, +wodurch dieses Anwendungsgebiet genau charakterisiert wird. + + +#abschnitt ("1.1", "TEXTVERARBEITUNG UND DATENVERWALTUNG", "Textverarbeitung und Datenverwaltung")# + +Es gibt zwei Einsatzbereiche des Computers, die von fast jedem An +wender benötigt werden, egal auf welchem Spezialgebiet er tätig ist: +nämlich die #on("i")#Textverarbeitung#off("i")# und die #on("i")#Datenverwaltung#off("i")#. Durch die +Unterscheidung dieser beiden Bereiche werden die charakteristi +schen Merkmale der Datenverwaltung abgegrenzt. + +#a ("Textverarbeitung")# Die Textverarbeitung befaßt sich damit, einen +beliebigen Text auf einem Rechner zu erfassen und anschließend +über einen Drucker wieder auszugeben. Der Sinn dieser Arbeit liegt +darin, daß man einen einmal eingegebenen Text sehr einfach ändern +kann. Außerdem kann der Computer einige unangenehme Aufgaben +übernehmen, die beim Schreiben von Texten auftreten: die Auftei +lung auf Zeilen und Seiten, die Seitennumerierung und vieles mehr. + Charakteristisch für die Textverarbeitung ist, daß der Einfluß +des Computers sich auf kosmetische Details beschränkt. Die Spei +cherung und eventuelle Aufbereitung zum Drucken haben praktisch +nichts mit dem Inhalt des Textes zu tun. Dies wäre für den Rechner +auch sehr schwierig, da die im Text enthaltenen Informationen in +menschlicher Sprache vorliegen, die für einen Rechner nicht ver +ständlich ist. + +#a ("Datenverwaltung")# Bei der Datenverwaltung werden ebenfalls textu +elle Informationen gespeichert, diese liegen aber in einer aufberei +teten Form vor, die einen Teil des Inhalts für den Computer ver +ständlich macht. Bei der Datenverwaltung werden Objekte betrach +tet, die verschiedene Eigenschaften haben können. Ein solches +Objekt kann z.B. eine Person sein. Als Eigenschaften werden mit +dieser Person zusammenhängende Informationen betrachetet, die für +die jeweilige Anwendung wichtig sind. + Ein Beispiel für eine solche Betrachtungsweise ist der Arbeit +nehmer im Betrieb. Einige der typischerweise erfaßten Daten sind +Name, Adresse, Telefon, Geburtsdatum und Geschlecht. Alle diese +Daten sind Eigenschaften oder #on("i")#Attribute#off("i")#, die einem bestimmten +Menschen mehr oder weniger fest zugeordnet sind. + Die Betonung inhaltlicher Beziehungen erleichtert es dem Com +puter, die gespeicherten Daten in verschiedenen Variationen aus +zuwerten. + +#a ("Beispiel")# Um die Unterscheidung zwischen Textverarbeitung und +Datenverwaltung deutlicher zu machen, werden im folgenden Bei +spiel die Informationen über eine Person in zwei unterschiedlichen +Formen dargeboten, die für den Menschen die gleiche Aussagekraft +haben: + + 1. Frau Magdalene Kant, geb. Hagedorn, wurde am 12. Januar + 1946 geboren. Sie wohnt in Bonn in der Meckenheimer Allee + 112. Seit 1977 arbeitet sie in unserer Firma. Sie ist tele + fonisch erreichbar unter der Nummer 0228/356782. + + 2. Name: Magdalene + Vorname: Kant + Geburtsname: Hagedorn + Geburtsdatum: 12.01.46 + Geschlecht: weiblich + Strasse: Meckenheimer Allee 112 + PLZ: 5200 + Wohnort: Bonn 1 + Vorwahl: 0228 + Telefon: 356782 + beschäftigt seit: 1977 + +Die Form der Darstellung wie in der ersten Alternative eignet sich +nur für den Menschen, da die gleiche Information auf viele ver +schiedene Weisen ausgedrückt werden könnte (z.B. unterschiedlicher +Satzbau). Die zweite Alternative beschränkt sich auf die für die +bestimmte Anwendung wesentlichen Zusammenhänge; der Computer +kann die Aufteilung der Information in einzelne Attribute ausnut +zen. + In dieser zweiten Form können Sie Daten mit EUDAS erfassen +und auch auswerten. Die Attribute können Sie jeweils passend zu +den erfaßten Daten selbst bestimmen. + Für Daten in der ersten Form steht Ihnen die EUMEL-Textver +arbeitung zur Verfügung. EUDAS wurde so entwickelt, daß Sie auch +Daten an die Textverarbeitung übergeben können. + Es ist nämlich möglich, einen freien Text aus der Attributdar +stellung automatisch zu erzeugen, indem Sie dem Computer den +Satzbau mit entsprechenden Platzhaltern vorgeben. Der Rechner +setzt die einzelnen Attribute dann an die angegebenen Stellen. +Diese Funktion ist ein Kernstück von EUDAS und wird in Abschnitt +1.3 näher erläutert. + + +#abschnitt ("1.2", "EUDAS ALS KARTEIKASTEN", "EUDAS als Karteikasten")# + +Wie Sie vielleicht schon bemerkt haben, ähnelt die zweite Form der +Darstellung einer Karteikarte, auf der Platz für bestimmte Einträge +freigehalten wird. Anhand dieses Modells können Sie sich in vielen +Fällen die Arbeitsweise von EUDAS veranschaulichen. Sie sollten die +Analogie allerdings nicht zu weit treiben: EUDAS schaufelt ja nicht +wirklich mit Karteikarten herum. Manche Funktionen sind eben +computerspezifisch und ließen sich mit Karteikarten gar nicht +durchführen. + Mit EUDAS können Sie die möglichen Einträge auf den Karteikar +ten (also die Attribute) völlig frei bestimmen; die einzige Beschrän +kung besteht darin, daß Sie in einem Karteikasten nur Karten mit +völlig gleichem Aufbau verwenden können. Wenn Sie eine neue Kar +teikarte entwerfen wollen, brauchen Sie nur Namen für die einzel +nen Einträge anzugeben. EUDAS zeigt Ihnen dann quasi eine Karte +am Bildschirm, in der diese Einträge aufgeführt sind. + Sie können nun am Bildschirm Daten auf diese Karteikarten +schreiben. Dabei dürfen die Einträge fast beliebig lang sein; wenn +der Platz auf dem Bildschirm nicht reicht, können Sie sich Ihre +überdimensionale Karteikarte in Ausschnitten ansehen. + Die einmal eingegebenen Daten bleiben nun so lange gespei +chert, wie Sie wollen (bzw. bis Ihr Rechner zusammenfällt). Haben +Sie beim Eintragen Fehler gemacht, können Sie diese jederzeit kor +rigieren oder später noch weitere Informationen ergänzen. + +#beispiel# +#free (7.5)# + +#center#Abb. 1-1 EUDAS als Karteikasten +#text# + +#a ("Anwendungen")# Mit den gespeicherten Daten können Sie nun ver +schiedene Dinge anstellen (bzw. vom Rechner anstellen lassen). Das +Einfachste ist natürlich das, was Sie mit einer Kartei auch machen +würden, sich nämlich einzelne Karteikarten anzuschauen. + Um eine bestimmte Karteikarte herauszufinden, geben Sie +EUDAS einfach den Inhalt vor, nach dem gesucht werden soll. Hier +zeigt sich bereits der erste Vorteil eines Computers: Die Suche in +der EUDAS-Kartei ist viel schneller, als Sie es von Hand könnten. +Außerdem kann der Rechner keine Karte zufällig übersehen. + EUDAS zeigt sich auch dann überlegen, wenn Sie einen ganz +bestimmten Teil der Kartei durchforsten müssen. Eine Bücherei muß +z.B. regelmäßig alle Bücher heraussuchen, deren Leihfrist über +schritten ist. Der Computer durchsucht in solchen Fällen ermü +dungsfrei auch große Datenmengen. + Wenn Sie die Karteikarten in einer bestimmten Reihenfolge +haben wollen, kann EUDAS auch das Sortieren übernehmen. Weitere +automatische Vorgänge betreffen z.B. das Rauswerfen überflüssiger +oder veralteter Karten. Die Einträge können auch nach einer be +stimmten Vorschrift alle geändert werden. Solche Aufgaben treten +z.B. in der Schule auf, wo die Schüler jedes Jahr versetzt werden +müssen (natürlich bis auf Ausnahmen). + Auch Beziehungen zwischen verschiedenen Karteien kann +EUDAS herstellen. Dies kann man noch einmal an dem Beispiel der +Bücherei illustrieren. Wenn ein Buch gefunden wurde, dessen Leih +frist überschritten ist, muß der zugehörige Ausleiher gefunden und +angeschrieben werden. Das Heraussuchen beider Karten kann EUDAS +in einem Arbeitsgang durchführen. + + +#abschnitt ("1.3", "DRUCKEN", "Drucken")# + +Eine besondere Stärke von EUDAS ist die Möglichkeit, die gespei +cherten Daten in schriftlicher Form auszuwerten. Dadurch, daß die +Daten in einer Form gespeichert sind, die den Inhalt widerspiegelt, +können die gleichen Daten in vielen verschiedenen Formen auf +Papier ausgegeben werden. + +#beispiel# + + + Karl Eudas + An Poltersdorf + XXXXXXXXXXX + XXXXXXXXXXX + + XXXX XXXXXXXXXXXX + + Lieber XXXXXXX ! + + Dies ist ein Beispiel für ein + Druckmuster. + + Viele Grüße + + + +#center#Abb. 1-2 Muster für die Druckausgabe +#text# + +Zu diesem Zweck geben Sie EUDAS ein Muster des gewünschten Aus +drucks vor. Der Rechner setzt dann an entsprechend markierten +Leerstellen die gespeicherten Informationen ein und druckt das +Ergebnis aus. Auf diese Weise ersparen Sie sich die umfangreiche +Schreibarbeit, die anfällt, wenn die Informationen auf den Kartei +karten in anderer Form benötigt werden. + Natürlich müssen Sie zum Entwerfen des Formulars kein ge +wiefter Programmierer sein. Wenn Sie einen Rundbrief verschicken +wollen, schreiben Sie den Brief, als wollten Sie Ihn nur einmal +schicken. Lediglich im Adressfeld müssen Sie Platzhalter an den +Stellen vorsehen, an denen später die wirklichen Adressen stehen +sollen. + +#a ("Verwendungsmöglichkeiten")# Die Möglichkeiten für solche Formulare +sind unbegrenzt. Beispiele sind Briefe, Adreßaufkleber, Überwei +sungsaufträge und sortierte Listen. Mit den Inhalten einer Kartei +können Sie beliebig viele verschiedene Ausgaben erzeugen. Bei dem +obigen Beispiel der Leihbücherei könnten Sie EUDAS dazu einsetzen, +nicht nur die säumigen Ausleiher herauszufinden, sondern die Mah +nung gleich fertig für einen Fensterbriefumschlag herzustellen. Für +den Bediener bliebe die einzige Tätigkeit, diesen Vorgang anzuwer +fen. + Wie weiter oben schon erwähnt, können Sie diese Ausgaben von +EUDAS auch zur Textverarbeitung übernehmen. So können Sie zum +Beispiel die Literaturliste für ein Buch mit EUDAS führen und Aus +züge später jeweils an die passenden Stellen einfügen. + +#a ("Berechnungen")# Die Druckfunktion von EUDAS kann jedoch nicht nur +zum Ausfüllen von Formularen verwendet werden. Wenn Sie Berech +nungen anstellen oder Auswertungen vornehmen wollen, können Sie +im Druckmuster auch Anweisungen der Sprache ELAN verwenden. +Damit haben Sie eine komplette Programmiersprache für Ihre Muster +zur Verfügung. + Ehe Sie einen Schreck bekommen: Selbst für komplizierte Muster +brauchen Sie nur einen ganz kleinen Teil von ELAN zu beherrschen, +da die meiste Arbeit immer von EUDAS übernommen wird (Sie müssen +also nicht etwa selber ein ganzes Programm schreiben). + Anwendungen für diese Möglichkeit gibt es genug. Angefangen +von einfachen Zählungen bis hin zu statistischen Auswertungen, +von einfachen Summen bis zum kompletten Rechnungsschreiben. +Immer nimmt Ihnen EUDAS alles das ab, was automatisch ablaufen +kann. Sie versorgen EUDAS nur noch mit den passenden Formeln für +Ihre Anwendung. + + +#abschnitt ("1.4", "GRENZEN", "Grenzen")# + +Natürlich können Sie nicht alle Probleme mit EUDAS gleichermaßen +gut lösen. EUDAS verwendet ein einfaches Modell (Karteikasten) und +versucht, mit möglichst wenig Informationen von Ihrer Seite auszu +kommen. Kompliziertere Sachverhalte verlangen auch kompliziertere +Strukturen, die Sie dann selbst entwerfen müssen. Eine einfache +Lösung mit EUDAS kann in solchen Fällen zu langsam oder zu um +ständlich sein. + Wenn Sie jedoch die wenigen Strukturprinzipien von EUDAS +verstanden haben, werden Sie sehr schnell viele Probleme mit +EUDAS lösen können. Zuerst erfassen Sie einfach alle Daten, die Sie +brauchen und überlegen sich erst dann, in welcher Form Sie diese +Daten haben wollen. Auch nachträglich können Sie jederzeit noch +neue Daten und Formulare hinzufügen, so daß Sie mit der Zeit +EUDAS gewinnbringend für viele Routineaufgaben benutzen werden. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.10 b/app/eudas/4.4/doc/user-manual/eudas.hdb.10 new file mode 100644 index 0000000..9d48385 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.10 @@ -0,0 +1,485 @@ +#type ("prop")##limit (14.0)# +#format# +#page (97)# +#kapitel("10", "Datenabfrage", "am", "Bildschirm")# + + + +#abschnitt ("10.1", "FELDAUSWAHL", "Feldauswahl")# + +Da die Anzahl der möglichen Felder bei EUDAS-Dateien viel größer +ist als die Anzahl der zur Verfügung stehenden Zeilen auf dem +Bildschirm (255 gegenüber 22), muß es eine Möglichkeit geben, auch +die übrigen Felder anzusehen. + +#a ("Rollen")# Dazu kann man den Bildschirmausschnitt in vertikaler +Richtung #on("i")#rollen#off("i")#. Sie müssen sich die Bildschirmanzeige als einen +Ausschnitt des wirklichen Satzes vorstellen. Um weitere Inhalte des +Satzes zu sehen, verschieben Sie den Ausschnitt einfach. + Dazu dienen die beiden Tastenkombinationen ESC OBEN und ESC +UNTEN. Diese Kombinationen wirken nur im Menü "Einzelsatz". An +der Bildschirmanzeige ändert sich natürlich nur dann etwas, wenn +es noch weitere Felder zum Anzeigen gibt. + Ob dies der Fall ist, können Sie an zwei Indikatoren ablesen. +Zum einen wird hinter dem letzten Feld eine markierte Abschluß +zeile ausgegeben. Ist diese nicht sichtbar, gibt es noch Felder, die +Sie mit ESC UNTEN hochholen können. Zum anderen steht die Num +mer der ersten Zeile in der Überschrift. Ist diese Nummer größer als +1, können Sie mit ESC OBEN noch Felder sichtbar machen. + Das Rollen ist oft auch dann notwendig, wenn sich ein Feld +über mehrere Zeilen erstreckt. In diesem Fall kann es passieren, +daß die erste Zeile des Feldes nicht mehr sichtbar ist, da sie ober +halb des Anzeigebereichs liegen würde. + +#a ("Feldauswahl")# Eine weitere Möglichkeit bei zu vielen Feldern be +steht darin, nur die interessanten Felder zur Anzeige auszuwählen. +Dies geschieht mit der Funktion +#free (0.2)# +#beispiel# + F Feldauswahl +#text# +#free (0.2)# +Ihnen werden alle Felder zur Auswahl angeboten. Kreuzen Sie die +Felder an, die Sie sehen wollen und denken Sie daran, daß die Rei +henfolge des Ankreuzens beachtet wird. Anschließend werden Ihnen +nur die ausgewählten Felder angezeigt. Falls Sie kein Feld ankreu +zen, bleibt die alte Feldauswahl bestehen. + Wollen Sie wieder alle Felder sehen, müssen Sie diese nicht alle +einzeln ankreuzen. Mit HOP 'x' in der Auswahl werden alle Felder +angekreuzt (die noch nicht angekreuzt waren). Diese Tastenkombi +nation können Sie allgemein bei einer Auswahl verwenden. Sie +können die Kreuzchen mit 'o' auch wieder löschen, um zum Beispiel +"alle außer einem" auszuwählen. + Beachten Sie, daß die Auswahl der anzuzeigenden Felder nichts +mit der eigentlichen Dateistruktur zu tun hat, sondern nur für die +Anzeige gilt. Den Verarbeitungsfunktionen (zum Beispiel Drucken) +stehen natürlich nach wie vor alle Felder zur Verfügung. + Unvermutete Effekte können dann entstehen, wenn Sie bei +einer eingestellten Feldauswahl ändern oder einfügen. Die nicht +ausgewählten Felder werden beim Ändern natürlich nicht geändert +und beim Einfügen einfach leer gelassen. + + +#abschnitt ("10.2", "SATZEDITOR", "Satzeditor")# + +An dieser Stelle sollen noch einige weitere Funktionen des Satz +editors vorgestellt werden, die Sie noch nicht kennengelernt haben. + +#a ("Rollen im Satzeditor")# Sie können auch rollen, wenn Sie sich im +Satzeditor befinden (also beim Suchen, Einfügen und Ändern). Den +ken Sie daran, daß Sie die Einzelsatzanzeige immer mit ESC OBEN +und ESC UNTEN rollen, während sonst (Editor, Auswahl von Datei +namen) immer mit HOP OBEN und HOP UNTEN gerollt wird. + Diese Diskrepanz hat technische Gründe und läßt sich leider +nicht vermeiden. Wie Sie sich vielleicht erinnern, führt das Blättern +mit HOP OBEN und HOP UNTEN im Satzeditor dazu, daß die Korre +spondenz zwischen Feldnamen und Feldinhalt verlorengeht. Daher +muß an dieser Stelle mit ESC statt HOP gearbeitet werden. + +#a ("Ähnliche Sätze")# Wenn Sie mehrere ähnliche Sätze eintragen müssen, +bietet Ihnen EUDAS eine Erleichterung an. Sie können nämlich beim +Einfügen die Daten eines anderen Satzes übernehmen. + Dazu müssen Sie beim Ändern oder Einfügen des anderen Satzes +ESC 'p' drücken. Der Inhalt des Satzes wird dann in einen Zwischen +speicher gebracht. Beachten Sie, daß im Gegensatz zum EUMEL- +Editor kein Text markiert sein muß, sondern immer der ganze Satz +transportiert wird. + Beim Einfügen eines neuen Satzes können Sie diesen Satz dann +mit ESC 'g' in den Satzeditor übernehmen. Alle vorherigen Inhalte +werden überschrieben. Anschließend können Sie die Daten nach +Wunsch abändern. + Der Inhalt des Zwischenspeichers kann beliebig oft auf diese +Weise kopiert werden. Der Inhalt des Zwischenspeichers wird bei +Ändern der Feldauswahl oder beim Öffnen einer neuen Datei ge +löscht. + +#a ("Tagesdatum")# Im Satzeditor können Sie mit ESC 'D' das aktuelle +Tagesdatum abfragen. Es wird an der aktuellen Cursorposition ein +getragen, als ob Sie es selbst getippt hätten. + Auf diese Weise können Sie Sätze einfach mit Datum versehen +oder nach Sätzen suchen, die mit dem Tagesdatum in Beziehung +stehen (zum Beispiel 'Fälligkeit = Heute'). + + +#abschnitt ("10.3", "SUCHMUSTER", "Suchmuster")# + +Die bisher genannten Möglichkeiten des Suchmusters sind noch +etwas beschränkt. Eine Bedingung in unserer Adressendatei, die wir +im Suchmuster noch nicht ausdrücken können, wäre zum Beispiel: +Suche alle Adressen der Personen, die Wegner oder Simmern heißen. + Diese Alternative, Wegner ODER Simmern, kann nun in EUDAS +durch ein Komma ausgedrückt werden: + +#beispiel# + Name Wegner,Simmern + Vorname +#text# + +Beachten Sie, daß hinter dem Komma kein Leerzeichen folgen darf, +wie Sie es vielleicht gewohnt sind, in einem Text zu schreiben. +EUDAS kann nämlich nicht unterscheiden, ob Sie das Leerzeichen +nur aus optischen Gründen geschrieben haben, oder ob Sie danach +suchen wollen. + +#a ("Lokale Alternative")# Die eben beschriebene Konstruktionsmethode +heißt #on("i")#lokale Alternative#off("i")#. Lokal deshalb, weil Sie nur innerhalb +eines Feldes gilt. Was das bedeuten soll, sehen Sie, wenn Sie die +Bedingung mit einer weiteren Bedingung für ein anderes Feld kom +binieren: + +#beispiel# + Name Wegner,Simmern + Vorname + Strasse + PLZ 5* + Ort +#text# + +Dieses Muster hat die Bedeutung: Wähle alle Personen namens Weg +ner oder Simmern aus, die im PLZ-Bereich 5 wohnen. Die beiden +Bedingungen für den Namen sind mit der Bedingung für die PLZ mit +UND verknüpft - das heißt, eine der beiden ersten Bedingungen muß +zutreffen #on("i")#und#off("i")# die untere Bedingung. Dieses UND ist global, da es +Bedingungen für verschiedene Felder miteinander verbindet. + Natürlich können Sie für mehrere Felder gleichzeitig lokale +Alternativen angeben. Eine anderes Suchmuster könnte zum Beispiel +so aussehen: + +#beispiel# + Name Wegner,Simmern + Vorname + Strasse + PLZ 5,5000 + Ort +#text# + +In diesem Fall muß eine ausgewählte Person Wegner oder Simmern +heißen und in Köln wohnen. + +#a ("Globale Alternative")# Es wird nun aber für bestimmte Situationen +noch eine andere Art von Alternativen benötigt. Als Beispiel soll +ein Suchmuster dienen, das folgende Bedingung ausdrückt. Gesucht +ist eine weibliche Person mit Namen Simmern oder eine männliche +Person mit Namen Wegner. + Dieser Fall läßt sich mit unseren bisherigen Mitteln nicht lö +sen. Es wird nämlich eine Alternative zwischen zwei zusammen +gesetzten Bedingungen gefordert. Als Ausweg bietet sich an, prak +tisch mehrere Suchmuster anzugeben, die dann mit ODER verknüpft +werden. + Um diese verschiedenen Suchmuster optisch am Bildschirm zu +kennzeichnen, wird ein Semikolon als sogenannte #on("i")#globale Alternati +ve#off("i")# verwendet. Das Semikolon trennt das Suchmuster quasi in ver +schiedene Spalten auf, die jeweils eine eigene Bedingung enthalten +können. Unser gewünschtes Suchmuster würde also so aussehen: + +#beispiel# + Name Wegner;Simmern + Vorname + Strasse + PLZ + Ort + m/w m;w +#text# + +Ebenso wie bei lokalen Alternativen darf hinter dem Semikolon kein +Leerzeichen folgen. Daher kann das zweite Semikolon auch nicht +direkt unter dem ersten stehen. Die Spalten werden also einfach nur +durchgezählt: nach dem ersten Semikolon beginnt die zweite Spal +te, nach dem zweiten Semikolon die dritte usw. + In Zeilen, in denen keine Bedingungen stehen, kann auch das +Semikolon weggelassen werden. Es kann ebenfalls weggelassen wer +den, wenn die weiteren Spalten leer sind. Steht ein Semikolon direkt +am Anfang der Zeile, so ist die erste Spalte leer. + Um dies zu illustrieren, sei hier noch ein weiteres Beispiel +angegeben: + +#beispiel# + Name Wegner + Vorname ;Anna-Maria + Strasse +#text# + +In diesem Fall muß eine ausgewählte Person mit Nachnamen Wegner +oder mit Vornamen Anna-Maria heißen. + +#a ("Stern")# Bis jetzt haben Sie hauptsächlich Bedingungen betrachtet, +die exakt zutreffen mußten. Sie wissen aber bereits, daß man auch +Bedingungen angeben kann, bei denen nur ein Teil des zu suchen +den Feldes bekannt ist, nämlich indem der unbekannte Teil mit +einem Stern markiert wird. + In Kapitel 5 haben Sie gelernt, daß der Stern nur am Anfang +und Ende des Musters stehen kann. Dies trifft nicht ganz zu, denn +Sie können den Stern auch inmitten eines Textes anwenden. So +trifft die Bedingung #bsp("'Si*n'")# auf alle Namen zu, die mit 'Si' beginnen +und mit 'n' enden. + Beachten Sie hier das "und" in der Formulierung der Bedingung. +Das Muster ist eigentlich eine Schreibweise für zwei Bedingungen +für ein Feld, die mit UND verknüpft sind. + Sie können auch noch weitere Sterne in das Muster aufnehmen. +Dabei gibt es jedoch eine Kleinigkeit zu beachten. Das Muster +#bsp("'*x*y*'")# bedeutet: das Feld muß ein 'x' und ein 'y' enthalten. Über +die Reihenfolge der beiden Zeichen ist jedoch in dieser Bedingung +nichts gesagt, obwohl es vielleicht vom Aussehen suggeriert wird. + Denken Sie daran, keine zwei Sterne nebeneinander zu schrei +ben - eine solche Bedingung hätte keinen Sinn. + Es gibt eine weitere spezielle Bedingung, die mit Hilfe des +Sterns formuliert wird. Ein einzelner Stern bedeutet nämlich: Das +Feld ist nicht leer. Beachten Sie den kleinen Unterschied: ein Stern +in einem Muster kann für einen beliebigen Text stehen, der auch +leer sein kann. Ein einzelner Stern jedoch steht für einen beliebigen +Text, der nicht leer ist. + Damit Sie ein Gefühl für die Verwendung des Sterns bekommen, +hier noch ein paar Beispiele: + +#beispiel# +Mei*r* +#text# + Der Name beginnt mit 'Mei' und enthält ein 'r'. Trifft zu auf + 'Meier', 'Meiring', aber nicht auf 'Meiling' oder 'Merzei'. + +#beispiel# +Donau*dampf*schiff*schaft +#text# + Feld beginnt mit 'Donau', endet mit 'schaft' und enthält + 'dampf' und 'schiff'. Trifft zu auf 'Donaudampfschiffahrtsge + sellschaft', aber auch auf 'Donaugesellschiffdampffahrtschaft'. + +#beispiel# +Roller*erfahren +#text# + Dieses Muster muß man ganz genau interpretieren. Es bedeutet: + der Inhalt beginnt mit 'Roller' und endet mit 'erfahren'. Das + Muster trifft nicht nur auf 'Roller erfahren' sondern auch auf + 'Rollerfahren' zu. Der Stern verliert also in diesem Fall seine + symbolische Bedeutung als Platzhalter für einen bestimmten + Text. + +#a ("Vergleiche")# Es gibt in EUDAS noch weitere Muster, die einen gan +zen Bereich von Werten auswählen. Diese betreffen Bedingungen der +Art "größer als" und "kleiner als". Solche Vergleichsbeziehungen +werden durch zwei Punkte dargestellt. + So wählt das Muster #bsp("'K..'")# alle Felder aus, die in der alphabe +tischen Reihenfolge hinter 'K' liegen, wobei das 'K' selbst mit ein +geschlossen ist. Umgekehrt trifft #bsp("'..K'")# auf alle Felder zu, die davor +liegen. + Sie können beide Bedingungen auch kombinieren. So trifft die +Bedingung #bsp("'A..K'")# auf alle Felder zu, die im Lexikon unter 'A' bis +'J' erscheinen (die Felder mit 'K' sind hier ausgeschlossen). Beach +ten Sie, daß die direkte Kombination wieder die Verknüpfung zweier +einzelner Bedingungen mit UND darstellt. + +#a ("Negation")# Um den Bereich möglicher Suchmuster noch zu erweitern, +können Sie einzelne Bedingungen auch noch verneinen. Dies ge +schieht durch Voranstellen zweier Minuszeichen. So bedeutet das +Muster #bsp("'--Meier'")#, daß alle Personen ausgewählt werden, die nicht +Meier heißen. + Die Verneinung bezieht sich immer auf das unmittelbar folgende +Muster (bis zum nächsten Komma, Semikolon oder dem Zeilenende) +und nicht etwa auf eine ganze Zeile. Sie umfaßt jedoch die UND- +Verknüpfung der kombinierten Bedingungen. So sind zum Beispiel die +Muster #bsp("'--E..M'")#, #bsp("'--E..,--..M'")# und #bsp("'..E,M..'")# völlig gleichbedeu +tend. + +#a ("Feldvergleich")# Als letztes haben Sie im Suchmuster auch noch die +Möglichkeit, ein Feld mit anderen Feldern des gleichen Satzes zu +vergleichen. Bisher hatten Sie ein Feld ja immer nur mit konstanten +Texten verglichen. + Um dies zu erreichen, geben Sie statt eines Vergleichstextes +den Feldnamen des Feldes an, mit dem Sie vergleichen wollen. Zur +Kennzeichnung müssen Sie dem Namen noch ein '&' voranstellen. +Diese Konstruktion funktioniert mit allen bisher besprochenen Ver +gleichen. Beispielsweise trifft + +#beispiel# + Feld1 ..&Feld2 +#text# + +auf alle Sätze zu, in denen der Inhalt von Feld1 kleiner ist als der +Inhalt von Feld2. + Im Gegensatz zum Druckmuster dürfen in den Feldnamen zwar +Leerzeichen enthalten sein, nicht jedoch +#free (0.2)# +#beispiel# + .. * , ; +#text# +#free (0.2)# +da diese Zeichen als reservierte Zeichen gelten und jeweils als +Begrenzer wirken. Die gleiche Beschränkung gilt dementsprechend +auch für konstante Vergleichstexte. + Beachten Sie, daß hinter dem '&' bis zum nächsten Begrenzer +zeichen ein gültiger (vorhandener) Feldname stehen muß. Anderen +falls wird der Text als konstantes Muster betrachtet. + Wie schon oben gesagt, kann der Feldvergleich mit allen Ver +gleichen verwendet werden. Auch gemischte Konstruktionen sind +zulässig, beispielsweise + +#beispiel# + Feld1 A..&Feld3,*&Feld9* +#text# + +Diese Bedingung trifft zu, wenn Feld1 größer oder gleich 'A', aber +kleiner als der Inhalt von Feld3 ist, oder wenn der Inhalt von Feld9 +darin vorkommt. + +#a ("Optimierung")# Hier noch eine Bemerkung zur Geschwindigkeit des +Suchens. Je mehr Bedingungen Sie angeben, desto mehr Vergleiche +müssen beim Suchen angestellt werden und desto länger dauert es. + Das erste Feld einer Datei erfährt jedoch eine Sonderbehand +lung. Wenn Sie für dieses Feld ein Muster für Übereinstimmung +angeben, kann der Suchvorgang enorm beschleunigt werden, da das +erste Feld einer Datei intern speziell verwaltet wird. Damit das +Verfahren funktioniert, dürfen keine globalen Alternativen oder +lokale Alternativen für das erste Feld verwendet werden. + Diese Suchoptimierung sollten Sie bereits beim Einrichten einer +Datei berücksichtigen. Geben Sie als erstes Feld das an, nach dem +am ehesten direkt gesucht wird. Typisches Beispiel hierfür ist der +Nachname, aber auch Artikelnummern sind sinnvoll. Wichtig ist, daß +das erste Feld nicht zu oft identisch ist und auch mehr als zwei +Buchstaben enthält, damit die Optimierung ihre volle Wirksamkeit +entfaltet. + Denken Sie daran, daß durch die Feldauswahl ein beliebiges +Feld als erstes auf dem Bildschirm stehen kann. Für die Optimierung +wird jedoch immer das Feld betrachtet, das beim Einrichten der +Datei als erstes angegeben wurde. + + +#abschnitt ("10.4", "MARKIEREN", "Markieren")# + +Manchmal entsteht die Situation, daß Sie eine Reihe von Sätzen +bearbeiten wollen, aber keine Suchbedingung formulieren können, +die auf alle diese Sätze zutrifft. In diesem Fall bietet EUDAS Ihnen +die Möglichkeit, solche Sätze von Hand zu markieren. + Ein Beispiel: Sie haben eine ganze Reihe von Sätzen geändert +und wollen diese Änderungen als Protokoll ausdrucken. Es läßt sich +aber nicht mit Hilfe eines Suchmusters feststellen, welche Sätze +geändert wurden. + Als Abhilfe wählen Sie bei jedem geänderten Satz die Funktion +#free (0.2)# +#beispiel# + M Markierung +#text# +#free (0.2)# +Dadurch wird der bisher unmarkierte Satz markiert. Dies wird +kenntlich an der Anzeige #bsp("'MARK+'")# in der Überschrift. Sobald Sie den +ersten Satz markiert haben, erscheint bei jedem Satz, ob er markiert +ist oder nicht. + Haben Sie einen Satz irrtümlich markiert, können Sie die Mar +kierung mit der gleichen Funktion auch wieder entfernen. + Alle Funktionen, die bisher die durch das Suchmuster ausge +wählten Sätze bearbeitet haben, arbeiten nun nur noch auf den +markierten Sätzen. Somit können Sie anschließend mit der Druck +funktion die gewünschten Sätze drucken. Die Markierung hat also +Priorität über die eingestellte Suchbedingung. Lediglich die Bewe +gung am Bildschirm beachtet immer nur die Suchbedingung. + Sie können alle Markierungen der Datei mit der Funktion +#free (0.2)# +#beispiel# + Alle Markier. + L Löschen +#text# +#free (0.2)# +im Menü 'Gesamtdatei' wieder entfernen. Anschließend wird beim +Drucken wieder das Suchmuster beachtet. Die Markierungen ver +schwinden auch, wenn eine neue Datei geöffnet wird. Die Markie +rungen sind also nicht permanent in einer Datei gespeichert, son +dern existieren nur, während die Datei geöffnet ist. + Bei Koppeldateien können Sie aus technischen Gründen immer +nur alle Kombinationen auf einmal markieren. Die Markierung einer +Kombination markiert auch alle anderen Kombinationen des gleichen +Satzes. + + +#abschnitt ("10.5", "ÜBERSICHT", "Übersicht")# + +Wie Sie bisher gesehen haben, zeigte EUDAS immer einen einzigen +Satz in dem Standardformular auf dem Bildschirm. Es gibt jedoch +auch eine Möglichkeit, mehrere Sätze gleichzeitig zu betrachten. +Dazu dient die Funktion +#free (0.2)# +#beispiel# + U Übersicht +#text# +#free (0.2)# +im Menü 'Gesamtdatei'. + In der Übersicht nimmt jeder Satz nur eine Bildschirmzeile in +Anspruch. Die Feldinhalte werden, durch Komma getrennt, in der +Zeile nacheinander aufgezählt, bis kein Platz mehr vorhanden ist. +Am Anfang jeder Zeile steht die Satznummer und ob der jeweilige +Satz markiert ist (entweder '+' für markiert oder '-'). In der Über +schrift stehen in gleicher Weise die Feldnamen angegeben. + Der aktuelle Satz wird innerhalb der Übersichtsanzeige immer +durch eine inverse Satznummer dargestellt. Es werden nur die durch +das eingestellte Suchmuster ausgewählten Sätze gezeigt. Trifft die +Selektionsbedingung nicht auf den aktuellen Satz zu, wird an seiner +Stelle zur Information ein leerer Platzhalter angezeigt. Hinter dem +letzten Satz wird auch das Dateiende als besonders gekennzeichne +ter Satz angegeben. + +#bildschirm# +___________________________________________________________________________________________ + + ÜBERSICHT: Blättern: HOP OBEN, HOP UNTEN Ende: ESC q Hilfe: ESC ? + Satznr. Name, Vorname, PLZ, Ort, Strasse, m/w, + 1 - Wegner, Herbert, Krämergasse 12, 5000, Köln, m, + 2 - Sandmann, Helga, Willicher Weg 109, 5300, Bonn 1, w, + 3 - Katani, Albert, Lindenstr. 3, 5210, Troisdorf, m, + 4 - Ulmen, Peter, Mozartstraße 17, 5, Köln 60, m, + 5 - Regmann, Karin, Grengelweg 44, 5000, Köln 90, w, + 6 - Arken, Hubert, Talweg 12, 5200, Siegburg, m, + 7 - Simmern, Anna-Maria, Platanenweg 67, 5, Köln 3, w, + 8 - Kaufmann-Drescher, Angelika, Hauptstr. 123, 53, Bonn 2, w, + 9 - Fuhrmann, Harald, Glockengasse 44, 5000, Köln 1, m, + 10 - Seefeld, Friedrich, Kabelgasse, 5000, Köln-Ehrenfeld, m, + 11 - << DATEIENDE >> + +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 10-1 Übersicht +#text# + +#a ("Feldauswahl")# Wenn Sie die Funktion aufrufen, haben Sie zuerst +noch die Möglichkeit, nur einen Teil der vorhandenen Felder zur +Anzeige auszuwählen. Dazu bejahen Sie die Frage und können dann +die Felder in der gewünschten Reihenfolge ankreuzen. Analog zur +Funktion 'Feldauswahl' wird auch hier die zuletzt für die Übersicht +verwendete Feldauswahl beibehalten, wenn Sie die Frage verneinen +oder kein Feld ankreuzen. Die Feldauswahl für die Übersicht ist +unabhängig von der Feldauswahl für die normale Satzanzeige. + Von der Möglichkeit zur Feldauswahl sollten Sie Gebrauch ma +chen, denn durch die komprimierte Darstellung der Übersicht kann +meistens nur ein kleiner Teil eines Satzes dargestellt werden. + +#a ("Rollen")# Nachdem die Sätze auf dem Bildschirm erschienen sind, +haben Sie wieder die Möglichkeit, die Darstellung zu rollen. Dazu +können Sie die Pfeiltasten OBEN und UNTEN sowie die Tastenkombi +nationen HOP OBEN und HOP UNTEN verwenden. Diese Funktionen +verschieben den invers dargestellten aktuellen Satz und funktio +nieren wie im Editor. Beachten Sie auch hier wieder den Unterschied +zum Rollen in der Einzelsatzanzeige. + Das Rollen wirkt wie ein Positionieren mit 'Weiter' oder 'Zu +rück'. Nach der Rückkehr aus der Übersicht können Sie sich also an +einer ganz anderen Stelle in der Datei befinden. + Es stehen Ihnen zum Rollen auch noch die folgenden Tasten +kombinationen zur Verfügung (wie im Editor): HOP RETURN macht +den aktuellen Satz zum ersten auf der Seite. ESC '1' zeigt den er +sten Satz der Datei, ESC '9' analog dazu den letzten. + Wenn Sie eine komplizierte Suchbedingung eingestellt haben +und EUDAS viele Sätze erfolglos überprüfen muß, dauert der Bild +aufbau natürlich entsprechend lange. EUDAS gibt zu Ihrer Informa +tion aber immer die Nummer des Satzes aus, der gerade überprüft +wird. Außerdem werden Tastenbefehle nach jeder Zeile angenommen, +so daß Sie schon weiterblättern können, wenn Sie den ersten Satz +gesehen haben. + +#a ("Markieren")# In der Übersicht können Sie auch Sätze markieren. Mit +'+' markieren Sie den aktuellen Satz; mit '-' entfernen Sie die Mar +kierung wieder. So können Sie einfach die Sätze ankreuzen, die Sie +später bearbeiten wollen. + +#a ("Verlassen")# Mit ESC 'q' können Sie die Übersicht wieder verlassen, +auch mitten beim Aufbau des Bildes. Haben Sie erkannt, daß EUDAS +sinnlos mit einer falschen Suchbedingung sucht, können Sie die +Funktion auch mit ESC 'h' (Halt) abbrechen und gegebenenfalls ein +neues Suchmuster einstellen. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.11 b/app/eudas/4.4/doc/user-manual/eudas.hdb.11 new file mode 100644 index 0000000..957a413 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.11 @@ -0,0 +1,645 @@ +#type ("prop")##limit (14.0)# +#format# +#page (109)# +#kapitel ("11", "Funktionen", "zur", "Bearbeitung")# + + + +#abschnitt ("11.1", "SORTIEREN", "Sortieren")# + +Wenn Sie die Sätze in Ihrer EUDAS-Datei in einer bestimmten Rei +henfolge haben wollen (dies wird in vielen Fällen zum Drucken +verlangt), müssen Sie die Datei sortieren. Sie können EUDAS ange +ben, in welcher Reihenfolge die Sortierung erfolgen soll. Um die +aktuelle Datei zu sortieren, rufen Sie die Funktion +#free (0.2)# +#beispiel# + Akt. Datei + S Sortieren +#text# +#free (0.2)# +auf. Falls die Datei noch nie sortiert wurde, wird Ihnen auf jeden +Fall die Sortierreihenfolge zum Auswählen angeboten. Anderenfalls +werden Sie gefragt, ob Sie die vorherige Sortierreihenfolge ändern +wollen. + Das Sortieren wird als Veränderung betrachtet und nur auf der +Arbeitskopie durchgeführt! + +#a ("Sortierreihenfolge")# Die Sortierreihenfolge gibt an, welche Felder in +welcher Reihenfolge beim Vergleichen zweier Sätze benutzt werden +sollen. Zuerst wird das an erster Stelle angegebene Feld verglichen. +Sind die Inhalte hier unterschiedlich, wird die Einordnung der Sätze +nach diesem Feld bestimmt. + Sind die Inhalte in diesem Feld aber gleich, so wird nach dem +nächsten Feld verglichen. Ist kein weiteres Feld in der Sortierrei +henfolge angegeben, wird der Vergleich an dieser Stelle mit einem +zufälligen Ergebnis abgebrochen, das heißt, es kann nicht vorher +gesagt werden, welcher der beiden Sätze zuerst kommt. + Die Sortierreihenfolge können Sie in einer Menüauswahl einge +ben. Kreuzen Sie die Felder an, die Sie vergleichen wollen und ach +ten Sie auf die richtige Reihenfolge. Die eingegebene Reihenfolge +wird in der Datei gespeichert, um beim nächsten Sortiervorgang +wiederverwendet zu werden. + Nachdem Sie alle bei der Sortierung zu berücksichtigenden +angekreuzt haben, werden Sie für jedes dieser Felder gefragt, ob +nach dem Feld aufsteigend oder absteigend sortiert werden soll. + +#a ("Ablauf")# Der Ablauf des Sortierens wird durch Ausgabe von Satz +nummern dargestellt. Bis zur ausgegebenen Satznummer sind alle +Sätze richtig sortiert. Bei Bedarf kann der Vorgang durch SV und +dann 'halt' abgebrochen werden. Die Datei bleibt dabei auf jeden +Fall intakt. + +#a ("Optimierung")# Die gespeicherte Sortierreihenfolge wird auch noch zu +einer weiteren Optimierung benutzt. Wenn eine Datei sortiert war +und nur wenige Änderungen stattgefunden haben, brauchen beim +nächsten Sortiervorgang nur die wenigen veränderten Sätze einzeln +einsortiert zu werden. Das funktioniert natürlich nur unter der +Voraussetzung, daß die gleiche Sortierreihenfolge gewählt wird. Das +Sortieren braucht in diesem Fall erheblich weniger Zeit. + +#a ("Probleme")# Normalerweise werden die einzelnen Felder nach dem +EUMEL-Zeichencode verglichen. Das bedeutet, daß sich die Reihen +folge der Zeichen nach dem EUMEL-Zeichencode richtet. Ein Zeichen +mit einem höheren Code wird also vor einem Zeichen mit einem +niedrigeren Code einsortiert. + In manchen Fällen ergeben sich mit diesem Vergleichsverfahren +aber auch Schwierigkeiten. Wenn in einem Feld Zahlen oder DM- +Beträge stehen, führt die Methode zu falschen Ergebnissen. Die '10' +wird zum Beispiel vor der '2' einsortiert. Warum? Texte werden +immer linksbündig geschrieben und verglichen. Bei Zahlen richtet +sich die Wertigkeit jedoch nach dem Abstand vom Komma. + Da bei Texten zuerst das erste Zeichen verglichen wird, ent +steht hier durch Vergleich von '1' und '2' der Eindruck, die '10' +käme vor der '2'. Korrigieren könnte man dies, indem man ein Leer +zeichen vor die '2' schreibt. Wenn also die (nicht geschriebenen) +Dezimalkommata direkt untereinanderstehen, werden Zahlen richtig +verglichen. + +#a ("Typ ZAHL")# EUDAS hat jedoch eine bequemere Art, dieses Problem zu +behandeln. Ein Feld, das Zahlen enthalten soll, bekommt einen spe +ziellen Typ ZAHL zugewiesen, der zu einer richtigen Sortierung +führt. + Bei Feldern vom Typ ZAHL ignoriert EUDAS bei Vergleichen alle +nichtnumerischen Zeichen und vergleicht den Wert der Zahl. So +können Sie zum Beispiel in einem Satz '2,50 DM' und im anderen +Satz '10 DM' eintragen - EUDAS kann jetzt die richtige Reihenfolge +feststellen. + Übrigens: falls Sie numerische Werte lieber mit einem Dezi +malpunkt statt einem Dezimalkomma schreiben, können Sie EUDAS +das mit dem ELAN-Kommando + +#beispiel# + dezimalkomma (".") +#text# + +mitteilen. Wenn Sie ein solches Kommando eingeben wollen, können +Sie im EUDAS-Menü ESC ESC drücken. In der Statuszeile erscheint +dann die Aufforderung: + +#beispiel# + Gib Kommando: +#text# + +Hier können Sie wie im Editor oder im EUMEL-Monitor ein beliebiges +Kommando eingeben und ausführen. + Die Normaleinstellung für das Dezimalkomma erreichen Sie +wieder durch das Kommando + +#beispiel# + dezimalkomma (",") +#text# + + +#a ("Typ ändern")# Die Feldtypen sind eine permanente Eigenschaft einer +EUDAS-Datei. Beim Einrichten einer neuen Datei wird zunächst der +Standardtyp für alle Felder genommen. Sie erhalten jedoch Gelegen +heit, abweichende Feldtypen zu vergeben, wenn Sie die Frage +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Feldnamen oder Feldtypen ändern (j/n) ? +___________________________________________________________________________________________ +#text# + +bejahen. + Auch nachträglich können Sie die Feldtypen noch ändern. Dies +geschieht mit der Funktion +#free (0.2)# +#beispiel# + F Feldstrukt. +#text# +#free (0.2)# +im Menü 'Öffnen'. Zunächst werden Sie gefragt, ob Sie noch weitere +Feldnamen anfügen wollen. So könnten Sie die Datei um weitere +Felder ergänzen, die bei allen Sätzen zunächst leer sind. Die neuen +Felder müssen Sie wie beim Einrichten der Datei untereinander im +Editor schreiben. + Als zweites erscheint dann die gleiche Frage wie oben. Wenn +Sie diese bejahen, wird Ihnen eine Auswahl der zu ändernden Fel +der mit Feldnamen und den zugehörigen Feldtypen angeboten. Kreu +zen Sie hier die Felder an, deren Feldtypen Sie ändern möchten. + Da Sie mit dieser Funktion sowohl Feldnamen als auch Feld +typen verändern können, wird Ihnen für jedes Feld zunächst der +Name zum Ändern angeboten. Sie können den Namen korrigieren oder +überschreiben. Die Namensänderung hat jedoch keine Auswirkung +auf den Feldinhalt! + Wenn Sie den Namen nicht ändern wollen, drücken Sie einfach +RETURN. Anschließend können Sie für das Feld den neuen Feldtyp +angeben. Tippen Sie einen der vier Feldtypen als Text ein und +drücken Sie RETURN. Anschließend hat das Feld einen neuen Typ. +Die verschiedenen möglichen Typen werden jetzt genau erklärt. + +#a ("Feldtypen")# TEXT ist der Standardtyp, der die Feldinhalte nach +EUMEL-Zeichencode vergleicht. Den Typ ZAHL hatten wir schon +weiter oben kennengelernt. Daneben gibt es noch den Typ DATUM. + Dieser Typ vergleicht Daten der Form 'tt.mm.jj'. Soll ein sol +ches Datum richtig einsortiert werden, müßte es anderenfalls in der +Reihenfolge umgedreht werden (also 'jj.mm.tt'). Dies ist aber nicht +nötig, wenn das Feld den Typ DATUM bekommt. Beachten Sie, daß +alle Inhalte, die nicht die beschriebene Form haben, als gleich be +trachtet werden. + Der letzte Typ ist DIN. Dabei werden Texte nach DIN 5007 ver +glichen. Das bedeutet, daß Groß- und Kleinbuchstaben als gleich +angesehen werden, daß alle nichtalphabetischen Zeichen ignoriert +werden und die Umlaute ihren richtigen Platz bekommen (Umlaute +werden in normalen Texten hinter allen anderen Zeichen einsor +tiert). Da hierfür ein relativ großer Zeitaufwand notwendig ist, +sollte dieser Typ nur dann gewählt werden, wenn er erforderlich ist. +Den schnellsten Vergleich ermöglicht der Typ TEXT. + +#a ("Hinweis")# Beachten Sie, daß mit der Vergabe von Feldtypen keine +Überprüfung der Eingabe verbunden ist. Insbesondere beim Datum +wird nicht geprüft, ob die Form 'tt.mm.jj' eingehalten wurde. Wollen +Sie solche Überprüfungen vornehmen, lesen Sie bitte Abschnitt 11.3. + + +#abschnitt ("11.2", "KOPIEREN", "Kopieren")# + +In diesem Abschnitt sollen Sie erfahren, wie Sie eine EUDAS-Datei +#on("i")#kopieren#off("i")# können. Diese Funktion kann nicht nur ein inhaltsgleiches +Duplikat einer EUDAS-Datei herstellen (dies könnten Sie einfacher +durch eine logische Kopie bewerkstelligen, s. 16.1), sondern auch +komplizierte Umstrukturierungen vornehmen. + +#a ("Kopiermuster")# Der Schlüssel zu dieser Leistungsfähigkeit ist das +#on("i")#Kopiermuster#off("i")#. Wie beim Druckmuster legen Sie dadurch die genauen +Auswirkungen der Funktion fest. + Für jedes Feld in der Zieldatei, in die kopiert werden soll, +enthält das Kopiermuster die Angabe, woraus der Inhalt dieses +Feldes entstehen soll. Durch Auswahl und Reihenfolge dieser Anga +ben bestimmen Sie die Struktur der Zieldatei. + Im einfachsten Fall sieht die Kopieranweisung für ein Feld wie +folgt aus: + +#beispiel# + "Feldname" K f ("Feldname"); +#text# + +Das 'K' dient zur Festlegung der Kopierfunktion. Auf der linken +Seite steht in Anführungsstrichen der Name des Zielfeldes. Der +Ausdruck auf der rechten Seite gibt den zukünftigen Inhalt des +Feldes an. Der Ausdruck im obigen Beispiel steht einfach für den +Inhalt des Feldes 'Feldname' in der aktuellen Datei. Das Semikolon +am Ende dient zur Abgrenzung, da der ganze Ausdruck auch mehrere +Zeilen lang sein darf. + In der oben genannten Form würde das Feld 'Feldname' iden +tisch in die Zieldatei kopiert. Weitere Möglichkeiten besprechen wir +später. + +#a ("Feldreihenfolge")# Zunächst wollen wir uns damit befassen, wie Sie +die Feldreihenfolge in der Zieldatei beeinflussen können. Dies ge +schieht einfach dadurch, daß Sie die Kopieranweisungen in der ge +wünschten Reihenfolge aufschreiben. Damit können wir bereits ein +erstes komplettes Beispiel betrachten: + +#beispiel# + "Name" K f ("Name"); + "Vorname" K f ("Vorname"); + "PLZ" K f ("PLZ"); + "Ort" K f ("Ort"); + "Strasse" K f ("Strasse"); + "m/w" K f ("m/w"); +#text# + +Dieses Kopiermuster würde die bereits beschriebene Adressendatei +identisch kopieren, da alle Felder in der gleichen Reihenfolge vor +kommen. + Wenn Sie jedoch die Feldreihenfolge ändern wollen (um zum +Beispiel ein anderes Feld als erstes zu optimieren), brauchen Sie +bloß die Reihenfolge im Kopiermuster zu verändern: + +#beispiel# + "Ort" K f ("Ort"); + "Name" K f ("Name"); + "Vorname" K f ("Vorname"); + "PLZ" K f ("PLZ"); + "Strasse" K f ("Strasse"); + "m/w" K f ("m/w"); +#text# + +Im Gegensatz zur Auswahl der Feldreihenfolge für die Anzeige än +dern Sie so die Feldreihenfolge für die Zieldatei permanent. + +#a ("Felder anfügen")# Die beiden angegebenen Kopiermuster haben jedoch +nur dann die beschriebene Wirkung, wenn die Zieldatei noch nicht +existert. Bei einer existierenden Datei kann die Feldreihenfolge +nicht mehr geändert werden; daher hat die Reihenfolge der Kopier +anweisungen dann keine Wirkung. + Sie können jedoch zu einer existierenden Zieldatei noch Felder +hinzufügen. EUDAS verwendet nämlich folgende einfache Vorschrift: + +#limit (12.0)# + Wenn als Zielfeld in einer Kopieranweisung ein Feld + genannt wird, das in der Zieldatei noch nicht vorkommt, + wird es als weiteres Feld der Zieldatei hinzugefügt. +#limit (13.5)# + +Diese Strategie hat im Fall der nicht existierenden Datei zur Folge, +daß alle Felder neu sind und in der Reihenfolge ihres Auftretens +eingerichtet werden. Existiert die Datei schon, werden zusätzliche +Felder am Ende angefügt. + Beachten Sie, daß zusätzliche Felder für eine existierende +Datei nur in den neu hinzukopierten Sätzen gefüllt sind. In den +alten Sätzen bleiben alle neuen Felder einfach leer. + +#a ("Satzauswahl")# An dieser Stelle sollte erwähnt werden, daß wie bei +allen Funktionen, die die gesamte Datei betreffen, nur die durch die +Suchbedingung ausgewählten Sätze kopiert werden. Ist mindestens +ein Satz markiert, werden nur die markierten Sätze kopiert und die +Suchbedingung ignoriert. + +#a ("Teildatei")# Jetzt können Sie auch die zweite wichtige Aufgabe des +Kopierens verstehen. Sie können aus einer Datei einen Teil der +Sätze und einen Teil der Felder #on("i")#herausziehen#off("i")#. Danach haben Sie +unter Umständen eine wesentlich kleinere Datei, die sich auch +schneller bearbeiten läßt. Gerade wenn Sie nicht den allerneuesten +64-Bit-Supercomputer haben, können Sie so viel Zeit sparen, wenn +Sie wiederholt nur mit einem Teil der Datei arbeiten müssen. + Die Auswahl der Sätze für einen solchen Zweck erfolgt über ein +Suchmuster; im Kopiermuster geben Sie dann nur die gewünschten +Felder an. + +#a ("Aufruf")# An dieser Stelle wollen wir jetzt endlich behandeln, wie Sie +die Kopierfunktion aufrufen. Dazu gibt es die Auswahl +#free (0.2)# +#beispiel# + Satzauswahl + K Kopieren +#text# +#free (0.2)# +im Menü "Gesamtdatei". Als erstes werden Sie nach dem Namen der +Zieldatei gefragt. Existiert die Zieldatei schon und war sie vorher +sortiert, werden Sie gefragt, ob Sie die Datei zum Schluß wieder +sortieren wollen. Wie immer beim Sortieren werden auch hier gege +benenfalls nur die neu hinzugekommenen Sätze einsortiert. + Als nächstes müssen Sie den Namen des Kopiermusters angeben. +Da das Kopiermuster eine normale Textdatei ist, können Sie sich +einen beliebigen Namen ausdenken, unter dem das Muster dann +gespeichert wird. + Wollen Sie das Kopiermuster nicht aufbewahren, sondern nur +einmal verwenden, brauchen Sie keinen Namen anzugeben. Drücken +Sie einfach RETURN und für die Dauer des Kopierens wird das +Kopiermuster als unbenannte Datei eingerichtet. + Nachdem Sie den Namen des Kopiermusters eingegeben haben, +gelangen Sie in den Editor, wo Sie das Muster ändern können. Damit +Sie beim ersten Mal nicht so viel tippen müssen, bietet EUDAS Ihnen +bei einer neuen Musterdatei ein #on("i")#Standard-Kopiermuster#off("i")# zum Ändern +an. Das Aussehen des Standard-Kopiermusters richtet sich danach, +ob die Zieldatei schon existiert oder nicht. + Existiert die Zieldatei noch nicht, so werden im Standard- +Kopiermuster alle Felder der Ausgangsdatei in ihrer originalen Rei +henfolge angegeben. Wenn Sie dieses Muster nicht noch ändern, wird +die aktuelle Datei identisch kopiert. + Sie können jedoch die Feldreihenfolge verändern oder Felder +weglassen, indem Sie einfach die entsprechenden Zeilen vertauschen +oder löschen. Für Umbenennungen überschreiben Sie einfach den +Namen auf der linken Seite der Kopieranweisung. So können Sie das +Kopiermuster mit geringstem Aufwand erstellen. + Existiert die Zieldatei jedoch schon, werden Ihnen im Kopier +muster alle Felder der Zieldatei angeboten. Bei Feldern, die in der +aktuellen Datei nicht vorkommen, erscheint folgende Anweisung: + +#beispiel# + "Anrede" K ""; +#text# + +Obwohl die Anweisung in diesem Fall keine Wirkung hat (wenn man +sie wegließe, würde das Feld ebenfalls leer bleiben), ist sie dennoch +aufgeführt, damit Sie auf der rechten Seite einen entsprechenden +Ausdruck einsetzen können. + Bei den angebotenen Anweisungen hat eine Änderung der Rei +henfolge oder eines Feldnamens keinen Sinn, da diese Felder ja alle +bereits existieren. Jedoch können Sie die Ausdrücke auf der rechten +Seite variieren und neue Anweisungen (Felder) hinzufügen. + +#a ("Ablauf")# Wenn Sie die Eingabe des Kopiermusters mit ESC 'q' verlas +sen, wird das Kopiermuster übersetzt. Dabei können Fehlermeldun +gen auftreten. Sie können dann die Fehler korrigieren, wobei Sie die +Fehlermeldungen gleichzeitig auf dem Bildschirm sehen können. War +das Kopiermuster korrekt, werden alle ausgewählten (bzw. markier +ten) Sätze der aktuellen Datei in die Zieldatei kopiert und diese +anschließend gegebenenfalls noch sortiert. + Die kopierten Sätze werden jeweils am Ende der Zieldatei ange +fügt. War die Zieldatei vorher schon sortiert, können Sie angeben, +daß die neuen Sätze zum Schluß noch einsortiert werden. Anderen +falls können Sie die Datei anschließend mit der Funktion 'Sortieren' +sortieren. + +#a ("ELAN-Ausdrücke")# Wenn Sie schon einmal programmiert haben, wird +Ihnen vielleicht aufgefallen sein, daß ein Kopiermuster einem +ELAN-Programm verdächtig ähnlich sieht. Diese Vermutung trügt Sie +nicht. Dies läßt den Schluß zu, daß Sie noch mehr ELAN hier an +bringen können. + Haben Sie noch nie programmiert, sollten Sie jetzt nicht in +Panik geraten, denn das Wichtigste dieses Abschnitts haben Sie +bereits gelernt. Vielleicht sind Ihnen die folgenden Beispiele bereits +ganz nützlich. Um alle Möglichkeiten auszunutzen, sollten Sie sich +aber irgendwann (später!) mit den Kapiteln 14 und 15 befassen, in +denen Sie Genaueres erfahren. + Zunächst sei festgestellt, daß der rechte Teil einer Kopieran +weisung ein beliebiger ELAN-Ausdruck sein kann, der einen TEXT +liefert. Den wichtigsten Ausdruck kennen Sie bereits: + +#beispiel# + f ("Feldname") +#text# + +liefert den Inhalt des Feldes 'Feldname' des aktuellen Satzes der +aktuellen Datei. Gibt es das Feld nicht, erscheint eine Fehlermel +dung bei der Ausführung. + Sie können jedoch auch einen konstanten Text angeben, der +dann für alle Sätze gleich ist. Dazu schließen Sie den Text einfach +in Anführungsstriche ein. Die folgende Kopieranweisung dient dazu, +ein neues Feld einzurichten, das aber vorläufig noch leer bleiben +soll: + +#beispiel# + "Feldname" K ""; +#text# + +Ebenso können Sie mehrere Felder zu einem neuen verbinden, zum +Beispiel: + +#beispiel# + "Wohnort" K f ("PLZ") + " " + f ("Ort"); +#text# + +Das Pluszeichen kennzeichnet die Aneinanderreihung von zwei Tex +ten. Denken Sie auch immer an das Semikolon am Ende. In gleicher +Weise können Sie viele andere Textfunktionen verwenden, die in +Kapitel 14 beschrieben sind. + Prinzipiell können Sie auch Bedingungen mit IF abfragen, wie +zum Beispiel in der folgenden Übersetzung: + +#beispiel# + IF f ("m/w") = "w" THEN + "Anrede" K "Frau" + ELSE + "Anrede" K "Herr" + END IF; +#text# + +Auf diese Weise können Sie Kodierungen verschiedenster Art auto +matisch umsetzen. Sie müssen hierbei jedoch unbedingt darauf ach +ten, daß innerhalb der IF-Konstruktion immer eine Kopieranweisung +ausgeführt wird. Falls nämlich kein Fall zutrifft und für ein Feld +keine Kopieranweisung ausgeführt wird, wird das Feld bei einer +neuen Datei auch nicht richtig eingerichtet. + + +#abschnitt ("11.3", "TRAGEN", "Tragen")# + +In Kapitel 6 hatten Sie gesehen, wie man einzelne Sätze aus der +aktuellen Datei in eine andere trägt, und auch, wie man sie wieder +zurückholen kann. Diese Funktion diente im wesentlichen dazu, +nicht mehr benötigte Sätze zu entfernen. + Sie haben aber auch die Möglichkeit, eine ganze Reihe von +Sätzen in einem Arbeitsgang zu tragen, nämlich alle durch das +Suchmuster ausgewählten beziehungsweise alle markierten Sätze. +Diese Funktion dient ebenfalls dazu, Sätze zu entfernen, beispiels +weise alle Sätze, die vor einem gewissen Stichtag liegen. Als wei +tere Anwendung können Sie beim Tragen aber auch Bedingungen +überprüfen. + Diese #on("i")#Prüfbedingungen#off("i")# sollen sicherstellen, daß die Daten in +einer Datei ganz bestimmten Richtlinien entsprechen. Zum Beispiel +kann geprüft werden, ob ein eingegebenen Datum stimmen kann, ob +ein Satz doppelt aufgenommen wurde oder ob eine Artikelnummer die +richtige Anzahl von Stellen hat. + Die Prüfbedingungen werden einer Datei fest zugeordnet. Sie +können mit der Funktion +#free (0.2)# +#beispiel# + P Prüfbed. +#text# +#free (0.2)# +im Menü 'Öffnen' eingegeben oder geändert werden. Die Prüfbedin +gungen werden als Text im Editor geschrieben. + +#a ("Ablauf")# Das ganze Verfahren läuft nun so ab: Sie fügen neue Sätze +immer erst in eine Zwischendatei ein, die die gleiche Struktur wie +die eigentliche Datei hat. Wenn Sie alle Sätze fertig eingegeben +haben, tragen Sie diese Datei komplett in die gewünschte Datei. +Dabei werden die Prüfbedingungen getestet. + Erfüllt ein Satz die Bedingungen, wird er anstandslos getragen. +Trifft eine Bedingung aber nicht zu, bleibt der Satz in der Zwi +schendatei und eine entsprechende Meldung wird ausgegeben. Die +Meldungen werden gespeichert, um Sie später nochmal abrufen zu +können. + Sie müssen jetzt in der Zwischendatei die notwendigen Ände +rungen durchführen, damit die Prüfbedingungen erfüllt werden. Beim +Aufruf der Funktion +#free (0.2)# +#beispiel# + A Ändern +#text# +#free (0.2)# +können Sie mit Hilfe der Tastenkombination ESC 'P' (großes P) die +Datei mit den Fehlermeldungen in einem kleinen Teilfenster editie +ren. Anhand dieser Hinweise können Sie dann den Satz korrigieren. +Die Meldungen bleiben bis zum nächsten Öffnen oder Tragen erhal +ten. + Nach der Korrektur können Sie den gleichen Vorgang erneut +aufrufen - es sind ja nur noch die zuerst fehlerhaften Sätze in der +Zwischendatei. Bei Bedarf können Sie diesen Vorgang wiederholen, +bis alle Sätze korrekt übernommen worden sind. + +#a ("Aufruf")# Das Tragen wird aufgerufen durch die Funktion +#free (0.2)# +#beispiel# + Satzauswahl + T Tragen +#text# +#free (0.2)# +Nach Eingabe des Zieldateinamens müssen Sie noch angeben, ob Sie +die Prüfbedingungen testen wollen. + +#a ("Prüfbedingungen")# Zu diskutieren bleibt noch die Form der Prüfbe +dingungen. Diese stellen ein kleines ELAN-Programm dar, in dem +einige spezielle Prozeduren zum Prüfen enthalten sind. Wenn Sie +nicht ELAN programmieren können, sollte Sie diese Bemerkung nicht +erschrecken: die Prüfbedingungen sind einfach genug. + Sie schreiben also die Prüfbedingungen jeweils untereinander. +Eine mögliche Bedingung ist + +#beispiel# + wertemenge ("Feldname", "Wert1,Wert2,Wert3,Wert4"); +#text# + +Diese Bedingung gibt an, daß das Feld einen der angegebenen Werte +haben muß. Die Werte werden untereinander durch Komma getrennt. +Es gibt jedoch keine Möglichkeit, Werte mit Komma darzustellen, da +das Komma immer als Trennung wirkt. Leerzeichen dürfen in den +Werten vorkommen, sie müssen dann aber auch genau so im Feld +stehen. + Wir könnten zum Beispiel eine Bedingung für unser Feld 'm/w' +wie folgt formulieren + +#beispiel# + wertemenge ("m/w", "m,w"); +#text# + +EUDAS würde sich dann beschweren, wenn das Feld leer wäre (ir +gendein Geschlecht muß die Person ja wohl haben). Wenn das Feld +auch leer sein darf, geben Sie einfach zwei Kommata hintereinander +oder ein Komma am Anfang an: + +#beispiel# + wertemenge ("m/w", ",m,w"); +#text# + +Eine andere Möglichkeit der Prüfbedingung besteht darin, eine +Maske für ein Feld zu definieren. Diese Maske gibt an, daß an be +stimmten Stellen des Feldes nur bestimmte Zeichen stehen dürfen. +So könnte man zum Beispiel folgende Maske für ein Datumsfeld +angeben: + +#beispiel# + feldmaske ("Datum", "99.99.99"); +#text# + +Die Neunen haben hier eine spezielle Bedeutung und und stehen für +eine beliebige Ziffer. Es gibt noch einige weitere Zeichen, die eine +reservierte Bedeutung haben, nämlich: + +#beispiel# + '9' für jede Ziffer (wie schon erwähnt) + 'X' für jedes Zeichen + 'A' für jeden Großbuchstaben + 'a' für jeden Kleinbuchstaben + '*' für eine Folge beliebiger Zeichen +#text# + +Alle anderen Zeichen im Muster stehen für sich selbst. Eine Sonder +stellung besitzt der Stern; er sollte sparsam verwendet werden, da +seine Benutzung etwas aufwendiger ist. Der Stern kann auch für +eine leere Zeichenfolge stehen. Als weiteres Beispiel könnte man +definieren + +#beispiel# + feldmaske ("Name", "A*"); +#text# + +damit immer ein Name angegeben ist, der noch dazu mit einem Groß +buchstaben beginnt. + Für Bedingungen, die sich nicht mit diesen beiden Prozeduren +formulieren lassen, gibt es noch + +#beispiel# + pruefe ("Feldname", Bedingung); +#text# + +Diese Prozedur erhält einen logischen (booleschen) Wert als Parame +ter, der einen Vergleich darstellt. Ist dieser Parameter falsch +(FALSE), wird eine entsprechende Fehlermeldung protokolliert. So +könnte man folgende Bedingung angeben: + +#beispiel# + pruefe ("Alter", wert ("Alter") > 18.0); +#text# + +Diese Bedingung würde sicherstellen, daß alle Personen in der Datei +volljährig sind ('wert' ist eine von EUDAS definierte Funktion, die +den Inhalt eines Feldes als REAL-Zahl liefert - denken Sie auch +daran, daß der ELAN-Compiler Zahlen mit Dezimalpunkt geschrieben +haben möchte). + Da die Prüfbedingungen ein ELAN-Programm sind, können Sie +natürlich sämtliche ELAN-Anweisungen verwenden. + Weiterhin haben Sie die Möglichkeit, Doppeleinträge zu verhin +dern. Dazu geben Sie mit Hilfe der Prozedur + +#beispiel# + eindeutige felder (n); +#text# + +wieviele Felder vom ersten an eindeutig sein sollen. Ein zu tragen +der Satz, der mit irgendeinem anderen Satz in diesen Feldern über +einstimmt, wird als fehlerhaft zurückgewiesen. In unserer Adressen +datei könnte man + +#beispiel# + eindeutige felder (2); +#text# + +angeben. Damit würde ein neuer Satz mit bereits vorhandenem Na +men und Vornamen abgelehnt. + +#a ("Limit")# Aus technischen Gründen können die Prüfbedingungen einer +Datei nur 2000 Zeichen umfassen. Wollen Sie aufwendigere Bedin +gungen konstruieren, sollten Sie sich diese als Prozedur definieren +und insertieren. In den Prüfbedingungen müssen Sie dann nur diese +Prozedur aufrufen. + + +#abschnitt ("11.4", "AUTOMATISCHE ÄNDERUNGEN", "Automatische Änderungen")# + +Mit EUDAS können Sie die geöffnete Datei nicht nur satzweise von +Hand ändern, sondern auch automatisch die ganze Datei. Dazu müs +sen Sie dem Rechner eine Vorschrift geben, nach der er handeln +kann. Ein solches #on("i")#Änderungsmuster#off("i")# stellt im Prinzip schon ein klei +nes Programm dar. Der Änderungsvorgang wird durch die Auswahl +#free (0.2)# +#beispiel# + V Verändern +#text# +#free (0.2)# +aufgerufen. Dabei wird der Name des Änderungsmusters erfragt. Dies +ist eine normale Textdatei. Existiert das Muster noch nicht, können +Sie den Inhalt an dieser Stelle im Editor angeben. Anschließend +werden alle ausgewählten Sätze nach der Vorschrift bearbeitet. +Dabei wird jeweils die aktuelle Satznummer ausgegeben. + +#a ("Änderungsmuster")# Da auch ein Kopiermuster ein Programm ist, ist +es nicht erstaunlich, daß Änderungsmuster ganz ähnlich aussehen. +Eine typische Zeile sieht etwa so aus: + +#beispiel# + "Feldname" V "neuer Inhalt"; +#text# + +Diese Zeile bedeutet: Ersetze den Inhalt des Feldes 'Feldname' +durch den Text 'neuer Inhalt'. Anstelle des neuen Textes kann +wieder ein beliebiger ELAN-Ausdruck stehen. Ein Beispiel, in dem +ein Feld einen Stern angehängt bekommt, sieht dann so aus: + +#beispiel# + "Feldname" V f ("Feldname") + "*"; +#text# + +Beachten Sie, daß Sie den Ausdruck auf der rechten Seite eventuell +in Klammern setzen müssen (obwohl der Operator 'V' die niedrigste +Priorität hat). Wenn Sie sich nicht sicher sind, können Sie den Aus +druck immer in Klammern einschließen. + Ebenso wie im Kopiermuster können Sie hier beliebige ELAN- +Ausdrücke verwenden. Auch IF-Abfragen und ähnliche Konstruktio +nen sind möglich, im Gegensatz zum Kopiermuster sogar ohne Be +schränkungen. + Im Vergleich zu einem separat geschriebenen ELAN-Programm +hat das Änderungsmuster den Vorteil, daß Sie nur die eigentlichen +Veränderungsanweisungen kodieren müssen. Die wiederholte Anwen +dung auf die ausgewählten Sätze erledigt EUDAS automatisch. Wol +len Sie eine solche Änderungsanweisung fest insertieren, so brau +chen Sie das Muster nur in eine Prozedur zu verpacken und EUDAS +zu übergeben (Näheres s. Referenzhandbuch). + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.12 b/app/eudas/4.4/doc/user-manual/eudas.hdb.12 new file mode 100644 index 0000000..b62dcbf --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.12 @@ -0,0 +1,431 @@ +#type ("prop")##limit (14.0)# +#format# +#page (123)# +#kapitel ("12", "Weitere", "Möglichkeiten", "zum Drucken")# + + + +#abschnitt ("12.1", "ANSCHLUSS AN DIE TEXTVERARBEITUNG", "Anschluß an die Textverarbeitung")# + +Auf zweierlei Art und Weise kann der EUDAS-Druckgenerator mit +den Programmen der EUMEL-Textverarbeitung zusammenarbeiten. +Zum ersten können Ausgabedateien des Druckprozesses anschließend +mit den Textkosmetik-Werkzeugen bearbeitet werden. Zum anderen +kann EUDAS im Editor direkt Daten aus einer EUDAS-Datei in die +editierte Datei importieren. + +#a ("Druckrichtung")# Wie Sie schon in Kapitel 7 gesehen haben, kann +man die Ausgabe des Druckgenerators statt auf den Drucker in eine +Datei umleiten. Die Datei erhält dann einen automatisch generierten +Namen. Sie können jedoch auch festlegen, daß die Ausgabe in eine +ganz bestimmte Datei geschrieben werden soll. Dazu wählen Sie die +Funktion +#f2# +#beispiel# + Ausgabe + R Richtung +#text# +#f2# +im Druckmenü. Es erscheint die Frage +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Ausgabe automatisch zum Drucker (j/n) ? +___________________________________________________________________________________________ +#text# + +Verneinen Sie die Frage und es erscheint +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Ausgabe in bestimmte Datei (j/n) ? +___________________________________________________________________________________________ +#text# + +Wenn Sie diese Frage auch verneinen, erhält die Ausgabedatei einen +automatisch generierten Namen. Wenn Sie die Frage aber bejahen, +können Sie anschließend den Namen der Ausgabedatei angeben. + Existiert die angegebene Datei schon, wird der Ausdruck am +Ende der Datei angefügt. Anderenfalls wird die Datei neu eingerich +tet. + Die Angabe der Ausgabedatei gilt jedoch nur für den folgenden +Druckvorgang. Wenn Sie mehrmals in die gleiche Datei drucken wol +len, müssen Sie den Namen immer wieder neu angeben. Falls Sie dies +vergessen, wird die folgenden Male wieder ein Name automatisch +generiert. + +#a ("Begrenzung der Dateigröße")# Für kleinere Systeme ist es vorteilhaft, +wenn die Druckausgabe nicht in einer großen Datei gesammelt wird, +sondern sich auf mehrere kleine Dateien verteilt. Da die Ausgabe +datei nach dem Drucken gelöscht wird, kann man auf diese Weise +einen Hintergrundengpaß vermeiden. Es besteht die Möglichkeit, die +maximale Größe der Ausgabedatei mit dem ELAN-Kommando +#f2# +#beispiel# + maxdruckzeilen (1000) +#text# +#f2# +auf eine bestimmte Zeilenzahl (maximal 4000) zu beschränken. Wenn +der Druckgenerator nach der Bearbeitung eines Satzes feststellt, +daß diese Maximalzahl überschritten wurde, wird die Ausgabedatei +direkt gedruckt (falls durch 'Richtung' eingestellt) und eine neue +Ausgabedatei eröffnet. + +#a ("Initialisierungsteil")# Dabei ist jedoch zu beachten, daß Drucker +steuerungsanweisungen, die im Vorspann eingestellt wurden, jetzt in +der neuen Datei nicht mehr vorhanden sind. In einem solchen Fall +würden die folgenden Teile der Ausgabe mit einer anderen Einstel +lung gedruckt. + Um dies zu vermeiden, können Sie solche Anweisungen in den +#on("i")#Initialisierungsteil#off("i")# schreiben. Der Initialisierungsteil umfaßt alle +Zeilen des Druckmusters bis zum ersten Abschnitt, also bis zur +ersten Anweisung. Zeilen im Initialisierungsteil werden beim Eröff +nen einer neuen Ausgabedatei an den Anfang dieser Datei ge +schrieben. + Druckersteuerungsanweisungen, die ein bestimmtes Schriftbild +der Ausgabe erzeugen ('type', 'limit', 'linefeed', 'start' usw.), sollten +also in den Initialisierungsteil vor Beginn aller Abschnitte ge +schrieben werden. + +#a ("Nachbearbeitung")# Wenn Sie in der Druckausgabe verschiedene +Schriften oder Proportionalschrift verwenden wollen, sollten Sie die +folgenden Hinweise beachten. Da EUDAS keine Informationen über +die Schriftbreiten und -größen hat, werden alle Schrifttypen gleich +behandelt. Dies gilt insbesondere für die Zeilenbreite, die ja durch +das Dateilimit des Druckmusters festgelegt ist. + So kann es passieren, daß Zeilen mit kleinen Schrifttypen zu +früh abgeschnitten werden, während Zeilen mit großen Schriften +nicht mehr auf das Blatt passen. Für diesen Fall sollten Sie das +größte benötigte Limit einstellen (zum Beispiel 135 bei Schmal +schrift auf DIN A 4) und die Ausgabedatei anschließend mit 'line +form' bearbeiten. + 'lineform' verteilt zu langen Text auf mehrere Zeilen. Außerdem +werden gegebenenfalls Trennungen durchgeführt. + 'lineform' benötigt zur Information Absatzmarken. Fehlt an +einer Zeile die Absatzmarke, wird die nächste Zeile so weit wie +möglich direkt angehängt. Die Absatzmarken in der Ausgabedatei +werden direkt aus dem Druckmuster übernommen (es ist nicht mög +lich, Absatzzeilen durch eingesetzte Leerzeichen zu erzeugen). Im +Normalfall sollten alle Zeilen im Druckmuster eine Absatzmarke +haben. + Wenn Sie seitenorientierte Überschriften haben möchten, kön +nen Sie auch 'pageform' einsetzen. Die gewünschten Überschrift +anweisungen können Sie im Initialisierungsteil angeben. + Die beiden Funktionen wählen Sie über den Menüpunkt +#f2# +#beispiel# + N Nachbearb. +#text# +#f2# +im Druckmenü. Dort können Sie den Namen der Ausgabedatei ange +ben, die Sie bearbeiten möchten. Es wird jeweils gefragt, ob Sie +'lineform' und 'pageform' anwenden wollen. Das Ergebnis der Bear +beitung können Sie danach ausdrucken. + +#a ("EUDAS im Editor")# Wenn Sie sich im Editor zum Zweck der Textver +arbeitung befinden, können Sie Daten aus einer EUDAS-Datei direkt +in die editierte Datei übernehmen. Dazu wählen Sie zunächst die +gewünschten Sätze aus - danach geben Sie den Namen eines Druck +musters an. EUDAS druckt die gewählten Sätze unter Beachtung des +Druckmusters direkt in die editierte Datei. + Wenn Sie das Kommando +#f2# +#beispiel# + eudas +#text# +#f2# +im Editor geben (nach ESC ESC), gelangen Sie in ein spezielles +Kurzprogramm, das alle notwendigen Information von Ihnen erfragt. + Zunächst müssen Sie den Namen der gewünschten EUDAS-Datei +angeben. Diese Datei wird dann automatisch geöffnet. Vorher geöff +nete Dateien werden nach Anfrage gesichert. Beachten Sie, daß +keine Datei mehr geöffnet ist, wenn Sie später EUDAS wieder normal +aufrufen. + Danach wird Ihnen eine Übersicht aller Sätze gezeigt - in einer +Form, die Sie aus der Funktion 'Übersicht' bereits kennen. Wie dort +wird Ihnen zunächst eine Auswahl der Felder angeboten, um die +Anzeige übersichtlich zu halten. Anschließend können Sie noch ein +Suchmuster angeben. + In der Übersicht können Sie sich dann zu einem bestimmten +Satz bewegen oder mehrere Sätze markieren. Nach dem Verlassen der +Übersicht können Sie den aktuellen Satz oder alle ausgewählten +(bzw. markierten) Sätze drucken. Natürlich können Sie auch beide +Fragen verneinen. + Zum Drucken wird der Name des Druckmusters erfragt. Dieses +muß bereits existieren. Die Ausgabe wird an der Stelle eingefügt, an +der der Cursor in der editierten Datei steht - die Zeile wird bei +Bedarf aufgesplittet. + Nach dem Drucken können Sie den Vorgang wiederholen, wenn +Sie zum Beispiel einen weiteren Satz drucken wollen. Dazu können +Sie auch ein neues Suchmuster angeben. Markierungen von Sätzen +werden nach dem Drucken gelöscht. + + +#abschnitt ("12.2", "SPALTENDRUCK", "Spaltendruck")# + +Für manche Anwendungen reicht es nicht aus, wenn die bearbeite +ten Sätze jeweils untereinander in der Ausgabe erscheinen. Häufig +stes Beispiel dafür ist der Etikettendruck. Hierfür werden vielfach +mehrbahnige Formulare eingesetzt. + In diesem Fall müssen die Sätze bis zur gewünschten Anzahl +von Spalten nebeneinander gesetzt werden - erst danach wird die +nächste Reihe angefangen. + EUDAS unterstützt diese Anwendung. Dazu wird hinter der +'%WIEDERHOLUNG'-Anweisung die Anzahl der Spalten als Parameter +geschrieben (durch Leerzeichen getrennt). Der Wiederholungsteil +wird dann mit der angegebenen Anzahl von Spalten gedruckt. Zu +beachten ist, daß Vorspann und Nachspann diese Spaltenanordnung +durchbrechen, also immer hinter dem bisher Gedruckten beginnen. + Die Spaltenbreite wird vom Dateilimit des Druckmusters be +stimmt. Die Zeilen eines Wiederholungsteils werden bis zum Limit +mit Leerzeichen aufgefüllt, wenn der nächste Wiederholungsteil +danebengesetzt wird. + Alternativ kann die Spaltenbreite in Zeichen auch als zweiter +Parameter angegeben werden. Der Wert gilt jedoch nur für den Wie +derholungsteil - Vor- und Nachspann richten sich immer nur nach +dem Dateilimit. + Es spielt keine Rolle, ob die nebeneinandergesetzten Wieder +holungsteile unterschiedliche Längen haben. Die kürzeren Teile +werden einfach bei Bedarf durch Leerzeilen ergänzt. Es ist jedoch zu +beachten, daß sich auf diese Weise unterschiedliche Längen für die +einzelnen Reihen ergeben können. + Beispiel: Das Ergebnis für Satz 1, 3, 4 und 5 sei vier Zeilen +lang, für Satz 2 aber fünf Zeilen. Bei zweispaltigem Druck wird die +erste Reihe eine Zeile länger als die folgenden (s. dazu Abb. 12-1). + +#beispiel# + Satz 1 Satz 2 + braucht braucht + vier Zeilen. ausnahmsweise + ---------------- fünf Zeilen. + ---------------- + Satz 3 Satz 4 + braucht braucht + vier Zeilen. vier Zeilen. + ---------------- ---------------- + Satz 5 + braucht + vier Zeilen. + ---------------- + +#center#Abb. 12-1 Seitenaufteilung beim Spaltendruck +#text# + +#a ("Beispiel")# Zum Abschluß noch als Beispiel ein Druckmuster für ein +dreibahniges Etikettenformular. Die Spaltenbreite und die Länge des +Wiederholungsteils richten sich natürlich nach dem verwendeten +Formular und müssen im Einzelfall ausprobiert werden. + +#beispiel# + % VORSPANN + \#start (1.0, 0.8)\# + % WIEDERHOLUNG 3 40 + + &Vorname %Name + &Strasse + + &PLZ %Ort + \#free (1.693)\# +#text# + + +#abschnitt ("12.3", "MODI", "Modi")# + +Gesetzt der Fall, Sie wollen eine Tabelle drucken, deren Einträge +auf jeden Fall in voller Länge erscheinen sollen, auch wenn sie die +Spaltenbreite überschreiten. Dies würde bedeuten, daß Tabellenein +träge nach rechts geschoben werden, wenn vorhergehende Einträge +länger sind. Für diesen Fall können also nur Feldmuster variabler +Position (mit '%') eingesetzt werden. Diese werden jedoch auch nach +links geschoben, wenn vorher kürzere Inhalte auftreten. + +#a ("Tabellenmodus")# Um dieses Linksschieben zu unterdrücken, können +Sie mit folgender Anweisung im Musterteil in den #on("i")#Tabellenmodus#off("i")# +umschalten: + +#beispiel# + % MODUS 2 +#text# + +Der so eingestellte Modus gilt bis zum Ende des jeweiligen Ab +schnitts. Zu Beginn eines Abschnitts ist der Modus 1 (Normalmodus) +eingestellt. + +#a ("Beispiel")# Um diese Anweisung auszuprobieren, sollten Sie folgendes +Druckmuster auf unsere Beispieldatei anwenden: + +#beispiel# + % WIEDERHOLUNG + % MODUS 2 + &Vorname %Name +#text# + +In der Ausgabe können Sie sehen, daß der Nachname nicht nach +links geschoben wird, so daß eine Tabelle entsteht. Ist der Vorname +jedoch zu lang, wird die Tabelleneinteilung durchbrochen und der +Nachname nach rechts geschoben, um den Vornamen nicht abschnei +den zu müssen: + +#beispiel# + Herbert Wegner + Helga Sandmann + Albert Katani + Peter Ulmen + Karin Regmann + Hubert Arken + Anna-Maria Simmern + Angelika Kaufmann-Drescher + Harald Fuhrmann + Friedrich Seefeld +#text# + +#a ("Zeilenfortsetzung")# Eine weitere Möglichkeit, überlange Feldinhalte +einzusetzen, besteht darin, daß der Rest des Inhaltes, der nicht +mehr in den reservierten Raum paßt, in der nächsten Zeile fortge +setzt wird. Dies wird im Modus 3 erreicht. Falls ein Feldinhalt ab +geschnitten werden müßte, wird in diesem Modus die gleiche Mu +sterzeile nochmal mit den restlichen Inhalten gedruckt. Dies wird +fortgesetzt, bis alle Inhalte abgearbeitet sind. + Damit die Fortsetzung sinnvoll ist, wird das letzte Wort ganz in +die nächste Zeile übernommen, falls es zerschnitten würde (ähnlich +wie im Editor). Der dadurch freiwerdende Raum in der vorigen Zeile +wird mit Leerzeichen gefüllt. Ist rechtsbündiges Einsetzen verlangt, +werden die einzelnen Teile jeweils rechtsbündig in ihrem reservier +ten Platz justiert. + Dieser Modus ist besonders interessant, wenn Sie längere Kom +mentare in eine EUDAS-Datei eintragen, die Sie dann natürlich auch +wieder drucken wollen. Den Text tragen Sie bereits in mehreren +Zeilen in die EUDAS-Datei ein. Beachten Sie, daß der Umbruch des +Textes im Druck nicht mit dem Umbruch des Textes am Bildschirm +übereinstimmt. Wollen Sie dies verhindern, müssen Sie jeden Absatz +des Textes in ein eigenes Feld schreiben. + Wie zu Anfang des Kapitels bereits angedeutet, kann der Um +bruch bei Proportionalschrift nicht korrekt sein, da EUDAS die Zei +chenbreiten nicht kennt. Um die nachfolgende Bearbeitung mit +'lineform' zu ermöglichen, werden bei fortgesetzten Feldern grund +sätzlich keine Absatzmarken an die Zeilen geschrieben. Lediglich die +letzte Fortsetzungszeile erhält eine Absatzmarke. + In den Fortsetzungszeilen, werden die Feldmuster, deren Inhalte +bereits abgearbeitet sind, leer eingesetzt. Die Mustertexte zwischen +den Feldmustern werden in den Fortsetzungszeilen durch Leerzei +chen ersetzt. + Die Anzahl der Fortsetzungszeilen kann durch die Anweisung + +#beispiel# + % MEHR n +#text# + +auf eine bestimmte Zahl 'n' festgelegt werden. Wenn alle Inhalte +abgearbeitet wurden, aber die Anzahl der Zeilen noch nicht erreicht +ist, werden entsprechend viele Zeilen mit leeren Inhalten erzeugt. + Die Zeilenwiederholung kann auch mit dem Tabellenmodus kom +biniert werden. Dies wird im Modus 4 erreicht. Felder variabler +Position werden auch in diesem Modus nicht nach links geschoben. +Außerdem werden aber in Fortsetzungszeilen die Mustertexte zwi +schen den Feldmustern wiederholt, um z.B. Tabellenbegrenzungen zu +erzeugen. + +#a ("Beispiele")# Zur Verdeutlichung hier noch einige Beispiele. Das fol +gende Druckmuster: + +#beispiel# + % WIEDERHOLUNG + % MODUS 3 + Kommentar: &Kommentar + ---------- +#text# + +könnte folgende Ausgabe bewirken: + +#beispiel# + Kommentar: Dies ist ein längerer Kommentar aus + einer EUDAS-Datei, der zum Drucken + auf eine Breite von 48 Zeichen + umbrochen worden ist. Nur die letzte + Zeile hat eine Absatzmarke. + ---------- +#text# + +Soll die Anzahl der Zeilen immer gleich bleiben, könnte man folgen +des Druckmuster verwenden: + +#beispiel# + % WIEDERHOLUNG + % MODUS 3 + % MEHR 5 + Kommentar: &Kommentar + ---------- +#text# + +Mit einem kürzeren Text ergäbe sich folgendes Bild: + +#beispiel# + Kommentar: Nur ein kurzer Text. + + + + + ---------- +#text# + +Für eine Tabelle würde man den Modus 4 benutzen: + +#beispiel# + % VORSPANN + -------------------------------------------------------- + ! Abk. ! Kommentar ! + !---------+--------------------------------------------! + % WIEDERHOLUNG + % MODUS 4 + ! &abk ! &Kommentar&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& ! + ----------+--------------------------------------------- +#text# + +Als Ausgabe könnte folgender Text erscheinen: + +#beispiel# + -------------------------------------------------------- + ! Abk. ! Kommentar ! + !---------+--------------------------------------------! + ! MA11 ! Dieser Kurs hat eine Menge an besonderen ! + ! ! Eigenschaften, die ihn für jüngere ! + ! ! Teilnehmer geeignet erscheinen lassen. ! + !---------+--------------------------------------------! + ! TD04 ! Stellt keine besonderen Anforderungen. ! + !---------+--------------------------------------------! + ! PM01 ! Seit dem 01.01. eingerichtet und noch ! + ! ! nicht voll besetzt. ! + ----------+--------------------------------------------- +#text# + +Beachten Sie hier, daß Tabelleneinträge hier nicht wie im Modus 2 +geschoben, sondern auf weitere Zeilen verteilt werden, wenn sie zu +lang sind. Außerdem werden die Tabellenbegrenzungen mit wieder +holt. Das Feldmuster für Kommentar muß jedoch mit fester Länge +angegeben werden, da sonst die rechte Tabellenbegrenzung bis zum +Dateilimit geschoben würde. + +#a ("Zusammenfassung")# Zum Abschluß dieses Abschnitts eine Zusammen +fassung aller möglichen Modi: + + Modus Effekt + + 1 Normalmodus. + '%'-Feldmuster werden auch nach links geschoben. + Keine Zeilenwiederholung. +#f2# + 2 Tabellenmodus. + '%'-Feldmuster werden nicht nach links geschoben. + Keine Zeilenwiederholung. +#f2# + 3 Normalmodus mit Zeilenwiederholung. + '%'-Feldmuster werden auch nach links geschoben. + Zeilenwiederholung ohne Zwischentexte. +#f2# + 4 Tabellenmodus mit Zeilenwiederholung. + '%'-Feldmuster werden nicht nach links geschoben. + Zeilenwiederholung mit Zwischentexten. + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.13 b/app/eudas/4.4/doc/user-manual/eudas.hdb.13 new file mode 100644 index 0000000..387d439 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.13 @@ -0,0 +1,734 @@ +#type ("prop")##limit (14.0)# +#format# +#page (133)# +#kapitel ("13", "Programmierung", "von", "Druckmustern")# + + + +#abschnitt ("13.1", "ABKÜRZUNGEN", "Abkürzungen")# + +In den vorigen Kapiteln haben Sie erfahren, daß man Feldmuster +von ganz bestimmter Länge definieren kann, deren Inhalt in genau +dieser Länge eingesetzt und bei Bedarf abgeschnitten wird. Bei der +Angabe dieser Länge spielt jedoch die Länge des Feldnamens eine +ganz entscheidende Rolle. Das kürzeste Feldmuster fester Länge, das +Sie definieren können, ist nämlich zwei Zeichen länger als der Feld +name (ein Musterzeichen vorher und eins nachher). + Hätte das Feld 'PLZ' den Namen 'Postleitzahl' bekommen, so +müßte ein solches Feldmuster mindestens eine Länge von 14 Zeichen +haben. Damit Sie mit diesem Feldnamen auch ein Feldmuster der +Länge 4 bekommen können (Postleitzahlen haben in den seltensten +Fällen mehr als 4 Stellen), haben Sie die Möglichkeit, den Namen +'Postleitzahl' für die Verwendung im Druckmuster geeignet abzu +kürzen. + Abkürzungen haben jedoch noch eine viel weitreichendere +Bedeutung. Mit ihnen ist es möglich, nicht nur die Feldinhalte einer +EUDAS-Datei einzusetzen, sondern auch jeden anderen Text, den Sie +mit einem ELAN-Programm erzeugen können. + Die einfachsten zusätzlichen Daten, die Sie verwenden können, +sind z.B. Datum und Uhrzeit. Für weitergehende Zwecke können Sie +die Inhalte der EUDAS-Datei auch für Berechnungen verwenden und +damit so umfangreiche Probleme wie das Schreiben von Rechnungen +oder statistische Auswertungen unter Verwendung eines Druck +musters lösen. + +#a ("Abkürzungsteil")# Abkürzungen werden in einem speziellen Abkür +zungsteil am Ende eines Abschnittes angegeben. Der Abkürzungsteil +wird durch die Anweisung + +#beispiel# + % ABKUERZUNGEN +#text# + +eingeleitet. Eine Abkürzungsdefinition hat eine ähnliche Form wie +ein Refinement (Falls Sie nicht wissen, was das ist, vergessen Sie +es). Zu Beginn steht der Name der Abkürzung in Form eines Feld +musters, beginnend in der ersten Spalte. Danach folgt, durch Leer +zeichen getrennt, ein Doppelpunkt in der gleichen Zeile. Daran +schließt sich ein beliebiger ELAN-Ausdruck an, der sich in freiem +Format über beliebig viele Zeilen erstrecken kann und mit einem +Punkt abgeschlossen werden muß. Dieser ELAN-Ausdruck muß ein +TEXT-Objekt liefern. + +#a ("Feldinhalt")# Für die Abfrage von Inhalten aus einer EUDAS-Datei +ist der Ausdruck +#f2# +#beispiel# + f ("Feldname") +#text# +#f2# +vordefiniert. Die Abkürzung des Feldes 'Postleitzahl' würde also als +Ausschnitt folgendermaßen aussehen: + +#beispiel# + % ABKUERZUNGEN + &p : f ("Postleitzahl") . +#text# + +Mit dieser Definition kann man im Muster so verfahren, als ob das +Feld 'Postleitzahl' auch 'p' hieße. Diese einfachste Form der Ab +kürzung können Sie natürlich variieren, indem Sie für 'p' und +'Postleitzahl' Ihre eigenen Namen einsetzen. + +#a ("Übersetzung")# Beachten Sie, daß das Druckmuster in ein ELAN-Pro +gramm umgeformt werden muß, da ELAN-Ausdrücke in ihm vorkom +men. Das automatisch erzeugte ELAN-Programm wird dann vom +ELAN-Compiler übersetzt und ausgeführt. Fehler in den ELAN-Aus +drücken im Abkürzungsteil können erst vom ELAN-Compiler ent +deckt werden. Dieser kennt jedoch das Druckmuster nicht und mel +det die Fehler anhand des generierten Programms. Sie müssen in +einem solchen Fall aufpassen, daß Sie die Fehlerquelle an der rich +tigen Stelle im Druckmuster lokalisieren (Hilfestellungen dazu sind +im Kapitel über die Übersetzung von Druckmustern zu finden). + +#a ("Beispiel")# Um die Verwendung von Abkürzungen zu demonstrieren, +wollen wir folgendes Druckmuster betrachten: + +#beispiel# + % VORSPANN + Adressenliste als Beispiel für Abkürzungen + Stand: &Datum + ------------------------------------------ + % ABKUERZUNGEN + &Datum : date . + + % WIEDERHOLUNG + &&l : &Vorname %Name + &Strasse + &&p& &Ort + ------------------------------------------ + % ABKUERZUNGEN + &l : lfd nr . + &p : f ("PLZ") . + + % NACHSPANN + &l Adressen gedruckt. +#text# + +Dieses Beispiel enthält eine ganze Reihe interessanter Details. Als +erstes sollten Sie registrieren, daß auch im Vorspann oder Nach +spann Feldmuster verwendet werden können. Soll in diesem Fall ein +Feldinhalt aus der EUDAS-Datei eingesetzt werden, so werden beim +Vorspann die Inhalte des ersten und beim Nachspann die Inhalte des +letzten durch Suchmuster ausgewählten Satzes verwendet. Daher +kann auch jeder Abschnitt einen Abkürzungsteil haben. Abkürzun +gen gelten jedoch für alle Abschnitte (s. '&l'); die Aufteilung in +mehrere Abkürzungsteile fördert im wesentlichen die Übersichtlich +keit. + Versuchen Sie, an diesem Beispiel die wichtigsten Unterschiede +zwischen dem #on("i")#Musterteil#off("i")# und dem #on("i")#Abkürzungsteil#off("i")# eines Abschnittes +zu verstehen. Das Format des Musterteiles soll in die Ausgabe +übernommen werden; daher ist dort die Stellung jedes Wortes wich +tig. Im Abkürzungsteil definieren Sie Abkürzungen ohne bestimm +tes Format - mit der einzigen Ausnahme, daß eine Abkürzungs +definition mit einem '&' in der ersten Spalte anfangen und ein +Leerzeichen vor dem Doppelpunkt haben muß. Wie Sie sehen, dürfen +dort Leerzeilen zur besseren Lesbarkeit eingefügt werden. +Sie sollten bei unserem Beispiel folgende Ausgabe erhalten: + +#beispiel# + Adressenliste als Beispiel für Abkürzungen + Stand: 28.12.84 + ------------------------------------------ + 1 : Herbert Wegner + Krämergasse 12 + 5000 Köln + ------------------------------------------ + 2 : Helga Sandmann + Willicher Weg 109 + 5300 Bonn 1 + ------------------------------------------ + 3 : Albert Katani + Lindenstr. 3 + 5210 Troisdorf + ------------------------------------------ + 4 : Peter Ulmen + Mozartstraße 17 + 5 Köln 60 + ------------------------------------------ + 5 : Karin Regmann + Grengelweg 44 + 5000 Köln 90 + ------------------------------------------ + 6 : Hubert Arken + Talweg 12 + 5200 Siegburg + ------------------------------------------ + 7 : Anna-Maria Simmern + Platanenweg 67 + 5 Köln 3 + ------------------------------------------ + 8 : Angelika Kaufmann-Drescher + Hauptstr. 123 + 53 Bonn 2 + ------------------------------------------ + 9 : Harald Fuhrmann + Glockengasse 44 + 5000 Köln 1 + ------------------------------------------ + 10 : Friedrich Seefeld + Kabelgasse + 5000 Köln-Ehrenfeld + ------------------------------------------ + 10 Adressen gedruckt. +#text# + +Nun zu den Abkürzungen im einzelnen. Das Feld 'PLZ' muß abge +kürzt werden, damit es rechtsbündig vor den Ort gedruckt werden +kann. Die Abkürzung 'p' benutzt die im vorigen Kapitel beschriebe +ne Form zur Abfrage des Feldinhaltes. + 'Datum' wird als Abkürzung für das aktuelle Datum definiert, +ein häufig benötigter Fall. 'date' ist der ELAN-Ausdruck, der das +Datum liefert. (Bemerkung für ELAN-Programmierer: der Name der +Abkürzung gehorcht nicht der ELAN-Syntax für Bezeichner). + Eine für Tabellen sinnvolle Funktion wird bei der Definition +von 'l' verwendet. Der von EUDAS definierte Ausdruck 'lfd nr' lie +fert die laufende Nummer des gerade gedruckten Satzes als Text. +Dabei ist zu beachten, daß die laufende Nummer nicht mit der Satz +nummer übereinstimmt, sondern nur während des Druckvorganges +von 1 an bei jedem gedruckten Satz hochgezählt wird. Diese Funk +tion dient dazu, die Sätze in der Liste durchzunumerieren. + Die laufende Nummer soll in der Liste rechtsbündig mit Doppel +punkt vor dem Namen stehen. Dazu wird das Feldmuster '&&l' be +nutzt, eine Form, die eigentlich keinen Sinn hat (die Kombination +'variable Länge' und 'rechtsbündig' gibt es nicht). Um ein möglichst +kurzes Feldmuster schreiben zu können, wird in diesem Fall jedoch +feste Länge unterstellt (auch ohne folgendes '&'). Damit hat das +kürzeste Feldmuster fester Länge drei Zeichen sowohl im linksbün +digen ('&l&') wie auch im rechtsbündigen Fall ('&&l'). + +#a ("Auswertungen")# Die Verwendung der Abkürzung 'l' im Nachspann +kann als erstes Beispiel für eine Auswertungsfunktion gelten. Da +für den Nachspann die Daten des letzten Satzes verwendet werden, +erscheint hier die laufende Nummer des letzten Satzes und somit die +Anzahl der Sätze, die gedruckt wurden. Das kann dazu benutzt +werden, die Sätze zu zählen, die eine bestimmte Suchbedingung +erfüllen. Folgendes Druckmuster zählt die Anzahl der Frauen oder +Männer in der Datei: + +#beispiel# + % NACHSPANN + &l Personen mit dem Geschlecht '%<m/w>' vorhanden. + % ABKUERZUNGEN + &l : lfd nr . +#text# + +Wenn Sie vor dem Drucken jetzt die Suchbedingung 'm' für das Feld +'m/w' einstellen, werden alle Männer ausgewählt. Das Drucken be +steht in diesem Fall nur aus dem Hochzählen der laufenden Nummer +für jeden Mann. Im Nachspann kann das Ergebnis dann ausgegeben +werden; zugleich soll der aktuelle Wert des Feldes 'm/w' gedruckt +werden, damit das Druckmuster auch für das Zählen der Frauen +verwendet werden kann. + Die beiden möglichen Ausgaben würden dann so aussehen: + +#beispiel# + 6 Personen mit dem Geschlecht 'm' vorhanden. + + 4 Personen mit dem Geschlecht 'w' vorhanden. +#text# + +#a ("Zusammenfassung")# Wir können die Erkenntnisse dieses Abschnittes +wie folgt zusammenfassen: +#f2# +#bsp("*")# Feldmuster können auch im Vorspann und Nachspann verwendet + werden. Im Vorspann werden die Daten des ersten, im Nachspann + die Daten des letzten ausgewählten Satzes verwendet. +#f2# +#bsp("*")# Der Musterteil eines Abschnittes definiert ein Format; der Ab + kürzungsteil ist formatfrei. +#f2# +#bsp("*")# 'lfd nr' dient zum Durchnumerieren aller gedruckten Sätze. +#f2# +#bsp("*")# Ein rechtsbündiges Feldmuster hat immer auch feste Länge. + +#a ("Komplexe Abkürzungen")# Mit Hilfe von Abkürzungen können wir +jetzt auch bessere Musterbriefe schreiben. Ein Problem, das bereits +angesprochen wurde, besteht darin, daß in der Anrede je nach Ge +schlecht 'Herr' oder 'Frau' stehen soll. Um dieses Problem zu lösen, +wird der Inhalt des Feldes 'm/w' benötigt. + Da in einer Abkürzung jede ELAN-Anweisung erlaubt ist, die +einen Text liefert, können natürlich auch #on("i")#IF-Anweisungen#off("i")# verwen +det werden. Mit diesen Informationen können wir jetzt die Abkür +zung 'Anrede' definieren: + +#beispiel# + % ABKUERZUNGEN + &Anrede : + IF f ("m/w") = "w" THEN + "Frau" + ELSE + "Herr" + END IF . +#text# + +Für Nicht-Programmierer: Die IF-Anweisung besteht aus einer Ab +frage und zwei Alternativen. Die Abfrage steht zwischen dem IF und +dem THEN und besteht in der Regel aus einer Abfrage, ob zwei +Dinge gleich oder ungleich (<>), größer oder kleiner sind. Außerdem +können mehrere Abfragen mit AND (und) und OR (oder) kombiniert +werden. Näheres dazu im Kapitel 14. + Die Alternative hinter dem THEN wird ausgewählt, wenn die +Abfrage zutrifft. An dieser Stelle sind wieder beliebige Ausdrücke +erlaubt, die einen Text liefern, einschließlich erneuter IF-Anwei +sungen (Schachtelung). Die Alternative zwischen ELSE und END IF +wird ausgewählt, wenn die Abfrage nicht zutrifft. + +#a ("Textkonstanten")# Bisher wurden nur ELAN-Funktionen als Textlie +feranten betrachtet ('date', 'lfd nr', 'f'). In unserem Fall werden +aber #on("i")#Textkonstanten#off("i")# in den Alternativen der IF-Anweisung benö +tigt. Textkonstanten werden in ELAN in Anführungsstriche einge +schlossen, die aber nicht zum Text gehören. Innerhalb einer Text +konstanten werden Leerzeichen wie alle anderen Zeichen angesehen +(erscheinen also auch nachher in der Ausgabe). + Bei solchen Abkürzungen, die längere Anweisungen umfassen, +sollten Sie das freie Format ausnutzen und eine möglichst über +sichtliche Darstellung wählen. Wie Sie sehen, muß nur der Doppel +punkt noch in der ersten Zeile stehen, der Rest kann sich beliebig +auf die folgenden Zeilen erstrecken. + +#a ("Beispiel")# Ein typischer Einsatz einer IF-Anweisung für die Anrede +sieht so aus: + +#beispiel# + % WIEDERHOLUNG + + Sehr geehrte&Anrede %<Name>! + + ... + % ABKUERZUNGEN + &Anrede : + IF f ("m/w") = "m" THEN + "r Herr" + ELSE + " Frau" + END IF . +#text# + +Sie sollten jetzt diese Konstruktion in einen Musterbrief einfügen +können. Probieren Sie ihn dann als Beispiel aus ! + +#a ("Weitere Möglichkeiten")# Durch Verwendung von Abkürzungen ist es +auch möglich, rechtsbündige Felder mit einer Länge von weniger als +3 Zeichen zu simulieren. Dies geschieht mit Hilfe der Textoperatio +nen von ELAN. Ohne ELAN-Vorkenntnisse können Sie dieses Bei +spiel überlesen. In unserer Liste im obigen Beispiel sind die laufen +den Nummern höchstens zweistellig und sollten deshalb auch nur +zwei Stellen belegen. Dies würde folgende Abkürzung ermöglichen: + +#beispiel# + % ABKUERZUNGEN + &l : text (lfd nr als zahl, 2) . + lfd nr als zahl : int (lfd nr) . +#text# + +Die Prozedur 'text' wird dazu benutzt, eine Zahl rechtsbündig auf +zwei Stellen zu formatieren (s. EUMEL-Benutzerhandbuch). Da die +Abkürzung immer eine Länge von zwei Zeichen hat, kann sie auch in +einem Feldmuster variabler Länge eingesetzt werden. Die Attribute +'feste Länge' und 'rechtsbündig' werden in diesem Fall also nicht +durch das Feldmuster, sondern durch die Abkürzung selbst erzeugt. + Um die Prozedur 'text' anwenden zu können, muß die laufende +Nummer als Zahl (sprich: INT-Objekt) vorliegen. Diese Umwandlung +wird mit der Prozedur 'int' vorgenommen, die einen Text in eine +Zahl umwandelt. Obwohl man 'int (lfd nr)' direkt in den Aufruf von +'text' hätte schreiben können, wird hier als Demonstration dafür ein +Refinement verwendet. + Refinements können in einem Abkürzungsteil neben Abkürzun +gen stehen und von allen Abkürzungen benutzt werden. Sie werden +ähnlich geschrieben wie Abkürzungen, nur ihr Name muß in Klein +buchstaben geschrieben werden, dafür muß er nicht in der ersten +Spalte anfangen und kann Leerzeichen enthalten. Bei komplizierte +ren Ausdrücken sollten Refinements zur besseren Lesbarkeit einge +setzt werden. + Sie können die IF-Anweisung auch mit beliebig vielen ELIF- +Teilen versehen. Achten Sie jedoch darauf, daß die IF-Anweisung +#on("i")#immer#off("i")# irgendeinen Wert liefern muß. Sie dürfen also den ELSE-Teil +nicht weglassen. Statt einer IF-Anweisung können Sie natürlich +auch eine SELECT-Anweisung verwenden. Es stehen Ihnen im Prin +zip alle werteliefernden Anweisungen von ELAN zur Verfügung. + Die Programmiersprache ELAN bietet Ihnen noch weit mehr +Möglichkeiten, als hier beschrieben werden können. So können Sie +sich eigene Prozeduren definieren und diese dann in Abkürzungen +verwenden. In Kapitel 14 und 15 finden Sie eine Einführung in die +wichtigsten Konstrukte, die für EUDAS gebraucht werden. + + +#abschnitt ("13.2", "BEDINGTE MUSTERTEILE", "Bedingte Musterteile")# + +Wenn größere Teile des Druckmusters in Abhängigkeit von bestimm +ten Daten unterschiedlich ausfallen sollen, werden die dazu benö +tigten Abkürzungen sehr umfangreich. Für solche Fälle kann man +IF-Anweisungen auch im Musterteil eines Abschnitts verwenden. In +diesem Fall werden die Alternativen der IF-Anweisung durch +Musterzeilen dargestellt. + Im Musterteil müssen jedoch die Zeilen, die Teil der IF-An +weisung sind, von den Musterzeilen unterschieden werden. Deshalb +werden die Anweisungszeilen durch ein '%'-Zeichen in der ersten +#on("i")#und#off("i")# zweiten Spalte gekennzeichnet. Das zweite '%'-Zeichen dient +zur Unterscheidung von Anweisungen an den Druckgenerator, die +nicht an den ELAN-Compiler übergeben werden sollen. + Mit einer IF-Anweisung im Musterteil kann man das Anredepro +blem auch folgendermaßen lösen: + +#beispiel# + % WIEDERHOLUNG + %% IF f ("m/w") = "w" THEN + Sehr geehrte Frau &<Name>! + %% ELSE + Sehr geehrter Herr &<Name>! + %% END IF; +#text# + +Beachten Sie den Unterschied, daß die IF-Anweisung hier mit einem +Semikolon abgeschlossen werden muß - in Abkürzungen mußte ja ein +Punkt danach folgen. Außerdem darf hier der ELSE-Teil (die zweite +Alternative) fehlen, während in einer Abkürzung in jeder Alternati +ve etwas stehen muß (zumindest der leere Text ""). + Falls sich der IF-THEN-Teil über mehr als eine Zeile erstrek +ken soll, muß jede dieser Zeilen mit '%%' beginnen, da die Folgezei +len sonst als Musterzeilen gedruckt würden. Benutzen Sie in einem +solchen Fall jedoch besser ein Refinement, das Sie im Abkürzungs +teil definieren müssen. + Sie können im Musterteil auch andere ELAN-Anweisungen +verwenden. Der Unterschied zu Abkürzungen liegt darin, daß die +Musterzeilen nicht als Werte angesehen werden, die die Anweisung +liefern muß, sondern als Anweisungen, die dort aufgeführten Mu +sterzeilen einzusetzen und zu drucken. Daher kann im Musterteil +auch eine FOR-Schleife sinnvoll sein, wenn in Abhängigkeit eines +Wertes eine bestimmte Anzahl von Zeilen gedruckt werden soll. + + +#abschnitt ("13.3", "ÜBERSETZUNG", "Übersetzung")# + +Wenn Sie bis jetzt auch als ELAN-Programmierer immer noch nicht +ganz durchblicken, wie Sie welche ELAN-Anweisungen verwenden +können, dann ist das noch kein Anlaß zur Sorge. Es ist kaum mög +lich, die genauen Auswirkungen beliebiger Anweisungen zu be +schreiben, ohne den Übersetzungsprozeß zu schildern, der diese +Anweisungen zu einem ELAN-Programm zusammenbindet. Daher soll +diese Übersetzung jetzt genauer erklärt werden. + +#a ("Übersetzungsmechanismus")# Alle Zeilen eines Abkürzungsteils wer +den direkt in das Programm übernommen, wobei der Name einer Ab +kürzung durch einen beliebig gewählten Refinementnamen ersetzt +wird ('abk' + eine laufende Nummer). Alle Abkürzungen und Re +finements werden als globale Refinements definiert, also außerhalb +von Prozeduren. Dadurch wird erreicht, daß sie an jeder Stelle +verwendet werden können. + Damit eine Abkürzung richtig als Refinement übersetzt wird, +muß sie ein TEXT-Objekt als Wert liefern. Die anderen Refinements +sind beliebig, da Sie nur in selbstdefinierten Anweisungen verwen +det werden. Die Refinements der Abkürzungen werden in einer Zu +weisung an eine TEXT-Variable verwendet, damit der Druckgenera +tor auf den entsprechenden Wert zugreifen kann. + Jeder Abschnitt wird dagegen als eine Prozedur übersetzt. Jede +Folge von Musterzeilen wird in eine Anweisung übersetzt, diese +Musterzeilen einzusetzen und zu drucken. Jede '%%'-Anweisung +wird einfach unverändert dazwischen geschrieben. Die Vorspann- +Prozedur wird einmal zu Anfang aufgerufen, die Prozedur für den +Wiederholungsteil einmal für jeden ausgewählten Satz und die Nach +spann-Prozedur einmal am Schluß. + Bei Fehlern im ELAN-Teil zeigt der Compiler das erzeugte Pro +gramm zusammen mit seinen Fehlermeldungen im Paralleleditor. Sie +müssen nun die Fehlermeldung lokalisieren und anhand der eben +gegebenen Hinweise in das ursprüngliche Druckmuster zurücküber +setzen, damit Sie dort den Fehler korrigieren können. + +#a ("Beispiel")# Nun müßten Sie genug Informationen haben, um beliebige +ELAN-Anweisungen in das Druckmuster einfügen zu können. Als +Beispiel wollen wir versuchen, alle Männer und Frauen in der +Adressendatei zu zählen, ohne ein Suchmuster einstellen zu müssen +und ohne den Druckvorgang zweimal ablaufen zu lassen (wie dies +bei dem obigen Beispiel der Fall war). Ein erster Versuch könnte so +aussehen: + +#beispiel# + % VORSPANN + %% INT VAR maenner, frauen; + %% maenner := 0; + %% frauen := 0; + % WIEDERHOLUNG + %% IF f ("m/w") = "m" THEN + %% maenner INCR 1 + %% ELSE + %% frauen INCR 1 + %% END IF + % NACHSPANN + &maenner Männer und %frauen Frauen vorhanden. +#text# + +Aber Vorsicht! In diesem Beispiel sind mehrere Fehler eingebaut. +Finden Sie sie! + +#a ("Fehler im Beispiel")# Der erste Fehler befindet sich im Nachspann. +Hier wird versucht, die Namen der beiden Variablen 'maenner' und +'frauen' direkt in einem Feldmuster zu verwenden. Diese beiden +Namen sind dem Druckgenerator nicht bekannt, sondern nur dem +ELAN-Compiler. Um die Werte der beiden Variablen einsetzen zu +können, müssen Sie also zwei geeignete Abkürzungen definieren. + Der zweite Fehler ist schwieriger zu finden. Wie oben gesagt, +wird jeder Abschnitt in eine Prozedur übersetzt. Die in einem Ab +schnitt definierten Variablen können also nur in diesem Abschnitt +verwendet werden (sie sind lokal) und auch nicht im Abkürzungs +teil, da dieser wieder global vereinbart wird. Die beiden im Vor +spann definierten Variablen stehen also im Wiederholungsteil und im +Nachspann nicht zur Verfügung. + +#a ("Anweisungen im Initialisierungsteil")# Für diesen Fall gibt es die +Möglichkeit, ELAN-Anweisungen vor allen Abschnitten im Initiali +sierungsteil zu definieren. Diese Anweisungen sind dann ebenfalls +global. Das richtige Druckmuster finden Sie auf der nächsten Seite. + Natürlich könnten Sie die Initialisierung der beiden Variablen +auch noch aus dem Vorspann herausnehmen. Denken Sie daran, daß +Sie aus INT-Variablen erst einen Text machen müssen, ehe Sie sie +in eine Musterzeile einsetzen können. Beachten Sie Schreibweise der +Variablen: in ELAN können die Umlaute nicht in Bezeichnern ver +wendet werden, daher muß die Variable mit 'ae' geschrieben wer +den. Im Mustertext und in Abkürzungs- und Feldnamen können die +Umlaute jedoch frei verwendet werden. + +#beispiel# + %% INT VAR maenner, frauen; + % VORSPANN + %% maenner := 0; + %% frauen := 0; + % WIEDERHOLUNG + %% IF f ("m/w") = "m" THEN + %% maenner INCR 1 + %% ELSE + %% frauen INCR 1 + %% END IF + % NACHSPANN + &m Männer und %f Frauen vorhanden . + % ABKUERZUNGEN + &m : text (maenner) . + &f : text (frauen) . +#text# + + +#abschnitt ("13.4", "GRUPPEN", "Gruppen")# + +Der Druckgenerator bietet die Möglichkeit, Vorspann und Nachspann +nicht nur am Anfang und am Ende, sondern auch an bestimmten +Stellen zwischen Sätzen zu drucken. Diese Stellen sind dadurch +bestimmt, daß ein bestimmtes Merkmal (z.B. ein Feldinhalt) seinen +Wert ändert. Ein solches Merkmal wird im Druckmuster #on("i")#Gruppe#off("i")# ge +nannt. + Ein Beispiel für die Verwendung von Gruppen ist eine Schüler +datei, die nach Klassen geordnet ist. Definiert man das Feld 'Klas +se' als Gruppe, so wird jeweils am Ende einer Klasse ein Nachspann +und am Beginn einer Klasse ein Vorspann gedruckt. + Dieses Verfahren ist eine Erweiterung der bisher beschriebenen +Methode, indem eine Datei quasi in mehrere Dateien untergliedert +wird, die jedoch in einem Arbeitsgang gedruckt werden können. +Voraussetzung dafür ist jedoch, daß die Datei nach dem Gruppen +merkmal geordnet ist - der Druckgenerator sammelt nicht erst alle +Schüler einer Klasse aus der Datei, sondern erwartet sie hinter +einander. + +#a ("Gruppendefinition")# Eine Gruppe wird im Initialisierungsteil des +Druckmusters (also vor allen Abschnitten) definiert. Notwendige +Daten sind eine Nummer zur Identifizierung und das Merkmal. Die +Nummer sollte am sinnvollsten von 1 an vergeben werden; die mög +lichen Werte sind nach oben hin beschränkt. Das Merkmal ist ein +beliebiger ELAN-Ausdruck, der einen Text liefert. Sinnvollerweise +wird er den Inhalt eines Feldes enthalten. + Gruppendefinitionen müssen nach allen ELAN-Anweisungen im +Initialisierungsteil folgen, und zwar, weil die Gruppendefinitionen +alle in einer Prozedur zusammengefaßt werden, die bei jedem neuen +Satz auf Gruppenwechsel testet. + Unter der Annahme, daß die oben erwähnte Schülerdatei ein +Feld 'Klasse' besitzt, würde die Gruppe wie folgt definiert: + +#beispiel# + % GRUPPE 1 f ("Klasse") +#text# + +Nach der Anweisung 'GRUPPE' folgt die Gruppennummer und dann +ein ELAN-Ausdruck. Die ganze Definition muß in einer Zeile stehen; +reicht der Platz nicht aus, müssen Sie in einem Abkürzungsteil ein +Refinement definieren. + +#a ("Klassenliste")# Das komplette Druckmuster für die Klassenliste könn +te folgendes Aussehen haben, wenn außer 'Klasse' auch noch die +Felder 'Name' und 'Vorname' vorhanden sind: + +#beispiel# + % GRUPPE 1 f ("Klasse") + % VORSPANN + Klassenliste für Klasse &Klasse + ---------------------------- + % WIEDERHOLUNG + &Vorname %Name + % NACHSPANN + \#page\# +#text# + +Wenn eine Gruppe definiert ist, werden im Nachspann immer die +Feldinhalte des letzten Satzes vor dem Gruppenwechsel gedruckt, im +Vorspann die Inhalte des ersten Satzes nach dem Wechsel. Daher +kann hier im Vorspann die Klasse gedruckt werden, da sie sich erst +ändert, wenn schon wieder der nächste Vorspann gedruckt wird. + +#a ("Mehrere Gruppen")# Wie die Identifikation über eine Gruppennummer +vermuten läßt, können Sie mehrere Gruppen definieren. Nachspann +und Vorspann werden jeweils gedruckt, wenn sich das Merkmal ir +gendeiner Gruppe ändert. Ob eine bestimmte Gruppe gewechselt hat, +kann mit der Abfrage + +#beispiel# + BOOL PROC gruppenwechsel (INT CONST gruppennummer) +#text# + +in einer IF-Anweisung ermittelt werden. Vor dem ersten und nach +dem letzten Satz wechseln automatisch alle Gruppen. + Die ganze Datei bildet eine Quasi-Gruppe mit der Nummer 0. +Sie ist immer definiert und wechselt nur vor dem ersten und nach +dem letzten Satz. Sie ist es, die bewirkt, daß Vorspann und Nach +spann in ihrer normalen Weise gedruckt werden. + +#a ("Anwendungsbeispiel")# Um einige der Möglichkeiten zu illustrieren, +die durch Gruppen geschaffen werden, wollen wir als Beispiel eine +Anwendung betrachten, die neue Wege für die Benutzung von EUDAS +aufzeigt. + Aus einer Datei, in der für jede Bestellung der Kunde, der Ar +tikel, die bestellte Menge und der Einzelpreis des Artikels einge +tragen werden, sollen anschließend Rechnungen gedruckt werden. +Die Datei soll folgende Felder haben: + +#beispiel# + 'Kundennummer' + 'Artikelnummer' + 'Einzelpreis' + 'Menge' +#text# + +Als Voraussetzung müssen die Bestellungen in der Datei jeweils +nach Kunden geordnet vorliegen. Die Kundennummer wird als Gruppe +definiert, so daß die Bestellungen eines Kunden zu einer Rechnung +zusammengefaßt werden können. Das Druckmuster rechnet dann die +einzelnen Preise zusammen und gibt eine Endsumme aus. + Damit in der Rechnung Name und Adresse des Kunden auftau +chen können, wird zu der Bestellungsdatei die Kundendatei gekop +pelt, die folgende Felder haben soll: + +#beispiel# + 'Kundennummer' + 'Name' + 'Vorname' + 'Strasse' + 'PLZ' + 'Ort' +#text# + +Stellen Sie sich zum Ausprobieren des folgenden Druckmusters ge +gebenenfalls eigene Daten zusammen. Hier nun das Druckmuster: + +#beispiel# + %% REAL VAR gesamtpreis, summe; + % GRUPPE 1 f ("Kundennummer") + % VORSPANN + %% summe := 0.0; + Fa. Kraus & Sohn + Schotterstr. 10 + + 5000 Köln 1 + &Vorname %Name + &Strasse + + &PLZ &Ort &Datum + + R E C H N U N G + =============== + + Menge Artikelnr. Einzelpreis Gesamtpreis + ------------------------------------------------ + % ABKUERZUNGEN + &Datum : date . + + % WIEDERHOLUNG + %% gesamtpreis := round + %% (wert ("Einzelpreis") * wert ("Menge"), 2); + %% summe INCR gesamtpreis; + &Menge &Artikelnummer &&&&epr&& &&&&gpr&& + % ABKUERZUNGEN + &epr : f ("Einzelpreis") . + &gpr : zahltext (gesamtpreis, 2) . + + % NACHSPANN + ------------------------------------------------ + Summe: &&&&sum&& + + 14% MWSt. &&&Mwst&& + ========= + Endbetrag &&&&end&& + \#page\# + % ABKUERZUNGEN + &sum : zahltext (summe, 2) . + &Mwst : zahltext (mwst, 2) . + &end : zahltext (summe + mwst, 2) . + mwst : round (summe * 0.14, 2) . +#text# + +Im Initialisierungsteil dieses Druckmusters wird die Kundennummer +als Gruppe definiert. Dies hat zur Folge, daß für jeden neuen Kun +den eine neue Rechnung begonnen wird, nachdem vorher im Nach +spann die Rechnungssumme des vorherigen Kunden berechnet und +ausgedruckt wurde. Vor dieser Gruppendefinition sind 'gesamtpreis' +und 'summe' definiert, die später als globale Variablen zur Verfü +gung stehen sollen. Diese Zeile darf nicht nach der Gruppendefini +tion stehen. + Im Vorspann wird der Kopf der Rechnung angegeben. Dieser +enthält neben den Daten des Kunden (aus der gekoppelten Kun +dendatei) noch das Datum. Die Kundennummer wird nur zum Kop +peln und als Gruppenmerkmal benötigt, erscheint also nicht auf der +Rechnung. + Es fällt auf, daß im Firmennamen ein '&'-Zeichen auftaucht, +das doch für die Markierung von Feldmustern reserviert ist. Die +beiden Musterzeichen können jedoch im normalen Text auftauchen, +wenn ihnen direkt ein Leerzeichen folgt. In diesem Fall werden Sie +nicht als Beginn eines Feldmusters interpretiert, sondern unverän +dert gedruckt. Der gleiche Fall taucht noch mit '%' im Nachspann +auf. + Im Wiederholungsteil wird zunächst aus dem Einzelpreis und der +Menge des jeweiligen Artikels der Gesamtpreis für diesen Artikel +berechnet. Für die Abfrage der Feldinhalte wird die Funktion 'wert' +verwendet, die wie 'f' funktioniert, jedoch gleich einen REAL-Wert +liefert. + Zu beachten ist, daß 'wert' wie beim Sortieren von Zahl alle +Sonderzeichen ignoriert. Weiterhin müssen die Zahlen mit dem ein +gestellten Dezimalkomma geschrieben werden (also normalerweise +mit Komma), damit ihr Wert richtig erkannt wird. Anderenfalls soll +ten Sie den Dezimalpunkt einstellen (s. 11.1). + Damit kaufmännisch richtig gerechnet wird, wird der Gesamt +preis auf 2 Nachkommastellen gerundet und erst dann aufsummiert. +Würde der Gesamtpreis nur zum Einsetzen gerundet, könnten bei der +anschließenden Addition der nicht gerundeten Werte eine falsche +Gesamtsumme entstehen. + Erst nach diesen Berechnungen kann die Musterzeile folgen, in +die die Werte dann eingesetzt werden. Um eine Ausgabe mit zwei +Nachkommastellen zu erzeugen, wird die von EUDAS definierte +Funktion 'zahltext' benutzt. Diese erzeugt aus einem REAL-Wert +einen Text mit der angegebenen Anzahl von Kommastellen und setzt +das korrekte Dezimalkomma ein. Das Ergebnis dieser Funktion wird +dann rechtsbündig eingesetzt. + Im Nachspann wird dann der summierte Wert mit aufgeschlage +ner Mehrwertsteuer gedruckt. Die Mehrwertsteuer muß ebenfalls auf +zwei Nachkommastellen gerundet werden. + +#a ("Erweiterung")# Zur Erweiterung könnten Sie die Bestelldatei noch mit +einer Artikeldatei koppeln, die etwa folgende Struktur haben würde: + +#beispiel# + 'Artikelnummer' + 'Bezeichnung' + 'Einzelpreis' +#text# + +In diesem Fall könnten Sie noch jeweils die Artikelbezeichnung in +eine Rechnungszeile drucken. Außerdem würde der Preis zentral +gespeichert. Eine entsprechende Änderung des Druckmusters sollte +Ihnen keine Schwierigkeiten bereiten. + + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.14 b/app/eudas/4.4/doc/user-manual/eudas.hdb.14 new file mode 100644 index 0000000..895d7d9 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.14 @@ -0,0 +1,697 @@ +#type ("prop")##limit (14.0)# +#format# +#page (151)# +#kapitel ("14", "Ausdrücke", "in", "ELAN")# + + + +#abschnitt ("14.1", "WAS SIND AUSDRÜCKE ?", "Was sind Ausdrücke ?")# + +In diesem Kapitel wollen wir uns mit ELAN-Ausdrücken beschäfti +gen, wie sie für EUDAS gebraucht werden. Natürlich kann dies keine +ernsthafte Einführung für ELAN-Programmierer sein - mit solchen +Ambitionen halten Sie sich am besten an die entsprechende ELAN- +Literatur. + Dieser Text richtet sich eher an den Benutzer, der kaum Erfah +rung mit ELAN hat, aber die Möglichkeiten von EUDAS optimal nut +zen will. Viele fortgeschrittene Fähigkeiten von EUDAS laufen ja +über ELAN-Programme. + +#a ("Vorkommen")# Sie haben ELAN-Ausdrücke bereits an verschiedenen +Stellen eingesetzt, wenn Sie sich mit den vorhergehenden Kapiteln +befaßt haben. ELAN-Ausdrücke werden in nahezu allen Verarbei +tungsfunktionen benötigt. + Im Druckmuster dienen sie dazu, den Inhalt eines Feldmusters +festzulegen. Die Definition einer Abkürzung besteht immer aus dem +Namen der Abkürzung und einem Ausdruck. Ebenso wird in einer +Gruppendefinition ein Ausdruck angegeben. + Beim Kopiermuster und beim Änderungsmuster besteht jeweils +die rechte Seite einer Anweisung aus einem Ausdruck. Weiterhin +werden Ausdrücke auch in anderen ELAN-Konstruktionen benötigt, +wie zum Beispiel direkt am Anfang einer IF-Anweisung. + +#a ("Bedeutung")# Ein Ausdruck steht allgemein für einen Wert. Im ein +fachsten Fall kann dies eine Konstante sein, der Wert des Aus +drucks ändert sich also nicht. Anderenfalls spricht man von einem +zusammengesetzten Ausdruck. Dessen Wert ergibt sich dann durch +die Ausführung der im Ausdruck angegebenen Operationen. Dieser +Wert kann je nach dem aktuellen Zustand des Systems verschieden +sein, da er jedes Mal neu berechnet wird, wenn er gebraucht wird. + Ein Beispiel für einen zusammengesetzten Ausdruck ist #bsp ("2+2")# +Dieser Ausdruck steht für den Wert 4. + Der Wert eines Ausdrucks ist das, was uns eigentlich interes +siert. Beim Druckvorgang wird dieser Wert dann gedruckt, beim +Kopieren und Verändern in ein Feld eingetragen. + +#a ("Zusammensetzung")# Ausdrücke lassen sich aus verschiedenen Ele +menten zusammensetzen. Grundlage bilden die Konstanten. Konstan +ten können durch #on("i")#Operatoren#off("i")# miteinander verknüpft werden. So ist +in dem Ausdruck #bsp ("2+3")# das #bsp ("'+'")# ein Operator, der die Konstanten #bsp("2")# +und #bsp("3")# verknüpft. Das Ergebnis der Verknüpfung hängt natürlich vom +jeweiligen Operator ab. + Wie Sie schon in der Schule gelernt haben ("Punktrechnung vor +Strichrechnung"), muß man die Reihenfolge der Operatoren festlegen, +wenn mehrere Operatoren im Spiel sind. Ähnliche Regeln gibt es für +alle Operatoren in ELAN. + Wenn eine andere Reihenfolge der Operatoren erwünscht ist, +können Sie diese durch Einsatz von Klammern verändern. Auch dies +dürfte Ihnen aus der Schule noch in Erinnerung sein. Der Unter +schied in ELAN ist lediglich, daß es dort einige zusätzliche Opera +toren gibt, die Ihnen nicht aus der Mathematik vertraut sind. + Ein weiteres Konstruktionselement von Ausdrücken sind #on("i")#Funk +tionen#off("i")#. Auch diese kennen Sie aus der Schule. Lediglich die +Schreibweise muß für den "dummen" Computer etwas ausführlicher +gehalten werden (Beispiel: #bsp ("sin (3.14 * x)")#). + Die Argumente der Funktion hinter dem Funktionsnamen müssen +auf jeden Fall in Klammern stehen. In der Terminologie der Pro +grammiersprachen spricht man von #on("i")#Parametern#off("i")#. Parameter können +wieder komplexe Ausdrücke sein. Bei Funktionen mit mehreren +Parametern werden diese durch Komma getrennt: +#f2# +#beispiel# + min (2.5 * x, x + 1.25) +#text# + + +#abschnitt ("14.2", "DATENTYPEN", "Datentypen")# + +Bevor wir beginnen, konkrete Ausdrücke zu behandeln, müssen wir +erst das Konzept der #on("i")#Datentypen#off("i")# einführen. Grundidee dabei ist, +daß es verschiedene Klassen von Werten gibt, die nicht einfach +untereinander gemischt werden können. + So gibt es in ELAN einen grundlegenden Unterschied zwischen +#on("i")#Zahlen#off("i")# und #on("i")#Texten#off("i")#. Texte bestehen aus einer beliebigen Aneinan +derreihung von Zeichen, die im Normalfall nur für den betrachten +den Menschen eine Bedeutung haben. Mit Zahlen kann man dagegen +Berechnungen anstellen. + Der tiefere Grund für die Trennung in verschiedene Typen ist +also, daß für jeden Typ gewisse Operationen definiert snd, die nur +für diesen Typ sinnvoll sind. So ist zum Beispiel die Addition der +beiden Texte #bsp("""abc""")# und #bsp("""-/-""")# völlig sinnlos. + Aber nicht nur die Operationen sind verschieden, sondern auch +die interne Darstellung im Rechner. So werden der Text #bsp ("""1234""")# und +die Zahl #bsp ("1234")# völlig anders gespeichert, obwohl man ihnen die glei +che Bedeutung beimessen könnte. + +#a ("Grundtypen")# In ELAN gibt es vier verschiedene Grundtypen, die für +uns wichtig sind. Sie können sich in ELAN auch eigene Typen +schaffen, dies geht jedoch weit über unsere Bedürfnisse hinaus. + Der in EUDAS am meisten verwendete Typ heißt #on("i")#TEXT#off("i")#. TEXT- +Objekte bestehen aus einer Folge von 0 bis 32000 Zeichen. Die Zei +chen entstammen einem Satz von 256 verschiedenen Symbolen, die +jeweils eine andere Darstellung haben. Einige der Zeichen lassen +sich überhaupt nicht darstellen, sondern führen bestimmte Funktio +nen aus (zum Beispiel Bildschirm löschen). + Sämtliche Feldinhalte einer EUDAS-Datei sind TEXTe, ebenso +die Zeilen von Textdateien. Auch Datei- und Feldnamen sind +TEXTe. Von daher besteht eigentlich kein Grund, warum Sie sich +außer zur Programmierung noch mit anderen Datentypen beschäfti +gen sollten. + Neben den Texten gibt es noch die Zahlen. Diese sind in ihrer +internen Darstellung so beschaffen, daß ein effizientes Rechnen mit +ihnen möglich ist. Andererseits können sie nicht mehr beliebige +Informationen darstellen, sondern haben eine sehr eingeschränkte +Bedeutung. + Um unterschiedichen Bedürfnissen gerecht zu werden, gibt es in +ELAN zwei verschiedene Zahltypen. Der Typ #on("i")#INT#off("i")# umfaßt nur ganze +Zahlen ohne Kommastellen. Damit die Zahl möglichst wenig Spei +cherplatz belegt, ist der Wertebereich bei den meisten Rechnern auf +-32768..32767 beschränkt (die krummen Zahlen ergeben sich wegen +der Binärarithmetik des Rechners). Dieser Typ eignet sich am besten +zum Abzählen und zum Auswählen aus einer festen Anzahl von +Objekten (zum Beispiel Feld 1 bis Feld 255). + Zum eigentlichen Rechnen gibt es den Typ #on("i")#REAL#off("i")#. Dieser umfaßt +auch Kommazahlen. Genauigkeit, Wertebereich und Darstellung sind +nahezu identisch mit den Möglichkeiten eines Taschenrechners. der +Typ REAL wird immer dann verwendet, wenn mit realen Größen +(Geldbeträge, physikalische Werte) gerechnet werden muß. + Zuletzt gibt es noch den Typ #on("i")#BOOL#off("i")#. Er hat nur zwei mögliche +Werte, nämlich TRUE (wahr) und FALSE (falsch). Er wird dazu benö +tigt, Ausdrücke zu schreiben, die den Zweig einer IF-Anweisung +bestimmen. + +#a ("Denotation")# ELAN verfügt über einen strengen Typenschutz; das +heißt, Objekte verschiedenen Typs dürfen nicht gemischt werden. +Daher muß schon bei der Schreibweise der Konstanten festgelegt +sein, welchen Typ die Konstante hat. + Bei Texten geschieht dies durch den Einschluß in Anführungs +striche. Die Anführungsstriche sorgen gleichzeitig auch für eine +Abgrenzung der Zeichen des Textes und des umgebenden Programms. +Sie kennen diese Schreibweise bereits von vielen Stellen in EUDAS. + Ebenfalls keine Probleme bereitet der Typ BOOL, da die +Schreibweise der beiden möglichen Werte TRUE und FALSE eindeutig +ist. + Problematisch wird es bei den Zahlen. Da die ganzen Zahlen in +den rationalen Zahlen enthalten sind, muß für die ganzen Zahlen +durch die Schreibweise festgelegt werden, zu welchem der beiden +Typen sie gehören. Man hat festgelegt, daß REAL-Zahlen immer mit +Komma geschrieben werden müssen, während Zahlen ohne Komma den +Typ INT haben (das Komma wird in ELAN bei den REAL-Zahlen in +internationaler Schreibweise als Punkt notiert). + So ist #bsp("4")# eine INT-Zahl, während #bsp("4.0")# den Typ REAL besitzt. +Denken Sie in Zukunft immer daran, welcher Zahltyp jeweils ver +langt wird und richten Sie die Schreibweise danach. + +#a ("Unterschied zu Feldtypen")# Verwechseln Sie die hier vorgestellten +Datentypen nicht mit den Feldtypen einer EUDAS-Datei. Die Feld +typen beziehen sich immer auf den gleichen Datentyp, nämlich +TEXT. Die Feldtypen bestimmen lediglich die spezielle Behandlung +des Feldes beim Suchen und Sortieren, während Datentypen tat +sächlich Unterschiede in der Speicherung und den anwendbaren +Operationen bedeuten. + Daher können Sie Feldtypen auch nach Bedarf ändern, während +der Datentyp eines Objekts ein für alle Mal feststeht. Merken Sie +sich, daß Feldinhalte in EUDAS immer den Typ TEXT haben. + +#a ("Umwandlungen")# Obwohl verschiedene Datentypen nicht miteinander +gemischt werden dürfen, können sie mit speziellen Funktionen in +einander umgewandelt werden. So ist zum Beispiel die Addition von +#bsp("1")# und #bsp("1.5")# verboten, aber der folgende Ausdruck +#f2# +#beispiel# + real (1) + 1.5 +#text# +#f2# +liefert den Wert #bsp("2.5")# mit dem Typ REAL. Umgekehrt geht die Um +wandlung mit der Funktion 'int', dabei werden jedoch die Nachkom +mastellen abgeschnitten. Weitere Hinweise dazu erhalten Sie im +Abschnitt 14.4. + Wichtiger jedoch ist die Umwandlung von Zahlen in TEXT-Ob +jekte. Was Sie auf Ihrem Bildschirm oder Ausdruck sehen, sind ja +immer nur Zeichenfolgen und damit Texte. Zahlen (INT oder REAL) +in ihrer internen Darstellung können Sie prinzipiell nicht sehen. Sie +müssen zur Darstellung immer in Texte umgewandelt werden. + Auch beim Rechnen mit Werten aus EUDAS-Dateien müssen +mehrere Umwandlungen stattfinden. Der Feldinhalt, der ja ein TEXT +ist, muß zunächst in eine Zahl umgewandelt werden. Dann wird mit +dieser Zahl gerechnet. Wenn das Ergebnis wieder in ein Feld einge +tragen oder gedruckt werden soll, muß eine Rückumwandlung in +einen Text vorgenommen werden. + Die zum Umwandeln benötigten Funktionen werden ebenfalls im +Abschnitt 14.4 besprochen. + +#a ("Funktionsbeschreibung")# In den zwei folgenden Abschnitten sollen +die wichtigsten Funktionen und Operatoren anhand von Beispielen +beschrieben werden. Da jede Funktion nur auf bestimmte Datentypen +angewendet werden kann, gibt es eine Notation, die genau die Form +eines Funktionsaufrufs festlegt. +#f2# +#beispiel# + INT PROC min (INT CONST a, b) +#text# +#f2# +Die obige Schreibweise hat folgende Bedeutung: Spezifiziert wird die +Funktion 'min', die als Ergebnis einen INT-Wert liefert (das INT +ganz links). Die Bezeichnung PROC gibt an, daß es sich um eine +Funktion handelt. In Klammern ist dann angegeben, welche Parame +ter verwendet werden müssen. Die Funktion hat zwei Parameter, +beide vom Typ INT. Die Bezeichnung CONST gibt an, daß auch Kon +stanten verwendet werden dürfen (Normalfall). + Zu beachten ist, daß bei jedem Aufruf beide Parameter vorhan +den und vom Typ INT sein müssen. Anderenfalls gibt es eine Feh +lermeldung. + Die gleiche Schreibweise wird auch zur Spezifikation von Ope +ratoren verwendet: +#f2# +#beispiel# + INT OP + (INT CONST a, b) +#text# +#f2# +Jedoch dürfen Operatoren nicht mit Parametern in Klammern ge +schrieben werden, sondern der Operator wird zwischen die Parameter +geschrieben. + Eine Besonderheit von ELAN ist es, daß es verschiedene Opera +toren und Funktionen mit gleichem Namen geben kann. Die Funktio +nen werden nur unterschieden nach dem Typ ihrer Parameter. So +gibt es nicht nur den oben genannten Operator #bsp("'+'")#, sondern auch +den folgenden: +#f2# +#beispiel# + REAL OP + (REAL CONST a, b) +#text# +#f2# +Obwohl im Aussehen gleich, handelt es sich doch um verschiedene +Operatoren mit möglicherweise völlig verschiedener Wirkung. Dies +sieht man an diesem Beispiel: +#f2# +#beispiel# + TEXT OP + (TEXT CONST a, b) +#text# +#f2# +Dieser Operator führt nun keine Addition aus, sondern eine #on("i")#Verket +tung#off("i")# zweier Texte. Je nach Typ der Parameter wird der entspre +chende Operator ausgesucht. + + +#abschnitt ("14.3", "TEXT-FUNKTIONEN", "TEXT-Funktionen")# + +In diesem Abschnitt wollen wir die wichtigsten Funktionen und +Operatoren zur Behandlung von Texten beschreiben. Wie Sie noch +sehen werden, spielt dabei aber auch der Typ INT eine gewisse +Rolle. + +#a ("EUDAS-Abfragen")# Die wichtigste Funktion zur Abfrage von Inhal +ten der aktuellen Datei sollten Sie bereits kennen: +#f2# +#beispiel# + TEXT PROC f (TEXT CONST feldname) +#text# +#f2# +Neu ist eigentlich nur die Schreibweise der Spezifikation. Sie sollten +aber in der Lage sein, daraus einen konkreten Ausdruck zu kon +struieren. Bisher haben wir immer die Schreibweise +#f2# +#beispiel# + f ("Feldname") +#text# +#f2# +verwendet. Dies ist jedoch nur ein Beispiel. Die korrekte Angabe +finden Sie oben. + Die Funktion 'f' darf natürlich nicht angewendet werden, wenn +keine Datei geöffnet ist. In die Verlegenheit kommen Sie aber nur +beim Ausprobieren, denn alle gefährlichen EUDAS-Funktionen sind +sonst gesperrt. + Falls das angegebene Feld nicht existiert, wird mit einer Feh +lermeldung abgebrochen. Beachten Sie, daß dies immer erst bei der +Ausführung festgestellt werden kann. Bei der Eingabe, zum Beispiel +eines Druckmusters, kann dies noch nicht überprüft werden. + Eine weitere Abfrage, die EUDAS während des Druckens ermög +licht, ist die Funktion +#f2# +#beispiel# + TEXT PROC lfd nr +#text# +#f2# +Diese hat keine Parameter und liefert die laufende Nummer des +gedruckten Satzes #on("i")#als Text#off("i")#. + Diese beiden Funktionen können als Ausgangsbasis dienen zur +Manipulation mit weiteren Funktionen. + +#a ("Verkettung")# Zur Verkettung von Teiltexten gibt es den oben schon +beschriebenen Operator '+'. Wenn Sie mehr als zwei Texte verketten +wollen, können Sie den Operator beliebig hintereinander verwenden: +#f2# +#beispiel# + f ("PLZ") + " " + f ("Ort") +#text# +#f2# +Wie in diesem Beispiel können Sie sowohl Konstanten als auch Tex +te, die von anderen Funktionen geliefert werden, verketten. Beach +ten Sie, daß die Texte immer ohne Zwischenraum aneinandergehängt +werden; daher wird im obigen Beispiel ein Leerzeichen extra ange +geben. + Wenn Sie eine bestimmte Anzahl von gleichen Zeichen haben +möchten (zum Beispiel für horizontale Linien oder große Zwischen +räume), können Sie dafür folgenden Operator verwenden: +#f2# +#beispiel# + TEXT OP * (INT CONST anzahl, TEXT CONST einzeltext) +#text# +#f2# +Hier sehen Sie als Beispiel einen Operator, der mit verschiedenen +Datentypen arbeitet. Sie müssen die Parameter jedoch immer in der +angegebenen Reihenfolge benutzen. Das folgende Beispiel ist kor +rekt: +#f2# +#beispiel# + 20 * "-" +#text# +#f2# +während dies nicht erlaubt ist: +#f2# +#beispiel# + "-" * 20 +#text# +#f2# +Wieder können Sie diesen Operator mit anderen Funktionen verknü +pfen: +#f2# +#beispiel# + "!" + 10 * " " + "!" + 5 * "-" + "!" +#text# +#f2# +Da der Multiplikationsoperator Vorrang vor der Addition hat, kom +men Sie hier sogar ohne Klammern aus (überlegen Sie sich, wo ein +Fehler auftreten würde, wenn dies nicht so wäre). Als Ergebnis +dieses komplexen Ausdrucks ergäbe sich der folgende Text: +#f2# +#beispiel# + "! !-----!" +#text# + +#a ("Teiltexte")# Um auch Teile von Texten bearbeiten zu können, werden +die Zeichen eines Textes von 1 an (mit INT-Zahlen) durchnumeriert. +Anhand dieser Positionen können Sie Teiltexte extrahieren. + Damit Sie die Position des letztes Zeichens (und damit die An +zahl der Zeichen) erfragen können, gibt es die Funktion +#f2# +#beispiel# + INT PROC length (TEXT CONST text) +#text# +#f2# +Wieviel Zeichen in einem Feld stehen, können Sie also mit +#f2# +#beispiel# + length (f ("Feldname")) +#text# +#f2# +erfahren. + Einen Teiltext bekommen Sie mit der Funktion 'subtext'. Diese +gibt es in zwei Ausführungen. +#f2# +#beispiel# + TEXT PROC subtext (TEXT CONST text, INT CONST anfang) +#text# +#f2# +liefert den Teiltext von einer bestimmten Position an (einschließ +lich) bis zum Textende. Mit +#f2# +#beispiel# + TEXT PROC subtext (TEXT CONST t, INT CONST anf, ende) +#text# +#f2# +können Sie auch die Position des letzten Zeichens (einschließlich) +angeben. Daher würden die beiden folgenden Aufrufe +#f2# +#beispiel# + subtext (f ("Feldname"), 1) + subtext (f ("Feldname"), 1, length (f ("Feldname"))) +#text# +#f2# +den Feldinhalt unverändert liefern. Ein weiteres Beispiel: +#f2# +#beispiel# + subtext ("Ein Text als Beispiel", 5, 8) +#text# +#f2# +liefert als Ergebnis #bsp("""Text""")#. + Es gibt noch den Operator 'SUB', der jeweils nur ein Zeichen +aus dem Text liefert: +#f2# +#beispiel# + TEXT OP SUB (TEXT CONST text, INT CONST stelle) +#text# +#f2# +Der Aufruf ist gleichwertig zu einem Aufruf von 'subtext', in dem +beide Stellen gleich sind. + Bei beiden Funktionen wird nicht vorhandener Text einfach +ignoriert. So liefert +#f2# +#beispiel# + subtext ("Hallo", 4, 8) +#text# +#f2# +das Ergebnis #bsp ("""lo""")# und +#f2# +#beispiel# + "Hallo" SUB 10 +#text# +#f2# +den leeren Text #bsp("""""")#. + +#a ("Verschachtelte Ausdrücke")# Wie Sie bereits gesehen haben, kann +man Ausdrücke ineinander verschachteln. Dies ist in unserem Fall +sehr nützlich, wenn Teiltexte bestimmt werden sollen, deren Posi +tion nicht konstant ist. Ein Beispiel, in dem 'length' bei der Fest +legung der Endposition verwendet wird, haben Sie weiter oben +bereits gesehen. + Als weitere Möglichkeit können Sie mit Positionen, die ja INT- +Zahlen sind, ganz normal rechnen. Folgender Ausdruck liefert zum +Beispiel die letzten drei Zeichen eines Feldes: +#f2# +#beispiel# + subtext (f ("Feldname"), length (f ("Feldname")) - 2) +#text# +#f2# +Wichtig ist, daß ein Ausdruck, der wieder als Parameter für einen +anderen Ausdruck verwendet werden soll, den richtigen Typ hat, +der von dem anderen Ausdruck verlangt wird. + In dem obigen Beispiel muß als Position ein INT verwendet +werden. Diese Position wird vom Operator '-' berechnet. Es gibt +aber nur einen Subtraktionsoperator, der einen INT liefert, nämlich +den, der wiederum zwei INTs subtrahiert. Glücklicherweise sind +sowohl 'length' als auch die 2 vom Typ INT, anderenfalls wäre der +Ausdruck fehlerhaft. 'length' wiederum benötigt einen TEXT als +Parameter, der von der Funktion 'f' stammt, die als Parameter eben +falls einen TEXT verlangt. + Wie Sie sehen, kann es durchaus verwickelt zugehen, wenn ein +Ausdruck aus den verschiedensten Teilausdrücken unterschiedlichen +Typs zusammengesetzt ist. Die gleiche Überprüfung wie eben ge +schildert sollten Sie bei jedem Ausdruck vornehmen, damit keine +Fehlermeldung erscheint. + +#a ("Variable Positionen")# Zur Berechnung von Positionen gibt es noch +eine weitere nützliche Prozedur, nämlich +#f2# +#beispiel# + INT PROC pos (TEXT CONST text, teiltext) +#text# +#f2# +Sie liefert die Position, an der der angegebene Teiltext zum ersten +Mal in dem Text vorkommt, oder 0, wenn der Teiltext nicht darin +vorkommt. So ist +#f2# +#beispiel# + pos ("Hallo", "l") = 3 +#text# +#f2# +und +#f2# +#beispiel# + pos ("Hallo", "lo") = 4 +#text# +#f2# +und +#f2# +#beispiel# + pos ("Hallo", "xx") = 0 +#text# +#f2# +Diese Funktion kann zum Beispiel dazu verwendet werden, ein Feld +in mehrere Teile aufzuspalten. Sind zum Beispiel Name und Vorname +in einem Feld durch Leerzeichen getrennt hintereinandergeschrie +ben, liefert +#f2# +#beispiel# + subtext (f ("Name"), 1, pos (f ("Name"), " ") - 1) +#text# +#f2# +den Vornamen und entsprechend +#f2# +#beispiel# + subtext (f ("Name"), pos (f ("Name"), " ") + 1) +#text# +#f2# +den Nachnamen. Soll die Position erst ab einer gewissen Stelle ge +sucht werden, gibt es noch die folgende Variation der Funktion: +#f2# +#beispiel# + INT PROC pos (TEXT CONST text, teiltext, INT CONST ab) +#text# +#f2# +Bei dieser Funktion wird erst ab der angegebenen Stelle einschließ +lich gesucht. + + +#abschnitt ("14.4", "RECHENFUNKTIONEN", "Rechenfunktionen")# + +#a ("Umwandlungen")# Bevor mit dem Inhalt eines Feldes gerechnet wer +den kann (auch wenn das Feld den Feldtyp ZAHL hat), muß der Wert +des Feldinhaltes als REAL-Zahl berechnet werden. Dazu gibt es die +Funktion +#f2# +#beispiel# + REAL PROC wert (TEXT CONST feldname) +#text# +#f2# +Die Funktion 'wert' ignoriert alle Sonderzeichen in dem Feld außer +dem Minuszeichen (als Vorzeichen) und dem eingestellten Dezimal +komma. Wenn das Feld 'Summe' beispielsweise #bsp("""-***20,09 DM""")# ent +hält, ergibt sich +#f2# +#beispiel# + wert ("Summe") = 20.09 +#text# +#f2# +Zum kaufmännischen Rechnen ist es manchmal erforderlich, den Wert +auf eine bestimmte Anzahl von Nachkommastellen zu runden. Diese +Anzahl kann man bei einer Variante von 'wert' als Parameter ange +ben: +#f2# +#beispiel# + REAL PROC wert (TEXT CONST feldname, + INT CONST kommastellen) +#text# +#f2# +Mit den so erhaltenen Werten können Sie dann die weiter unten +beschriebenen Berechnungen durchführen. Bevor Sie das Ergebnis +jedoch drucken oder in ein Feld eintragen können, müssen Sie den +REAL-Wert wieder in einen TEXT verwandeln. Dazu dient die Funk +tion +#f2# +#beispiel# + TEXT PROC zahltext (REAL CONST wert, + INT CONST kommastellen) +#text# +#f2# +Der übergebene Wert wird mit der gewünschten Anzahl von Komma +stellen als Text formatiert. Dazu wird der Wert gerundet. Außerdem +wird statt eines Punktes das eingestellte Dezimalkomma eingesetzt. +Die Länge des Textes richtet sich nach der Anzahl von benötigten +Stellen, es werden also keine führenden Nullen oder Leerzeichen +eingesetzt (dafür kann man den Text beim Drucken ja rechtsbündig +einsetzen). + Wird 0 als Kommastellen angegeben, wird auch kein Dezimal +komma erzeugt (Darstellung wie ein INT). Als Abkürzung können Sie +auch +#f2# +#beispiel# + TEXT PROC zahltext (TEXT CONST feldname, + INT CONST kommastellen) +#text# +#f2# +als Ersatz für +#f2# +#beispiel# + zahltext (wert ("Feldname"), kommastellen) +#text# +#f2# +verwenden. So kann ein Feld einheitlich zum Drucken formatiert +werden. + +#a ("Arithmetik")# Sowohl mit INT- als auch mit REAL-Zahlen (jedoch +nicht gemischt) können Sie die üblichen Rechenoperatoren #bsp("'+'")#, #bsp("'-'")# +und #bsp("'*'")# verwenden. Auch Minimum ('min') und Maximum ('max') sind +für zwei Parameter dieser Typen definiert. + Lediglich die Division wird bei beiden Typen unterschiedlich +gehandhabt. Für REAL-Zahlen gibt es den Operator #bsp("'/'")# für die +übliche Division. Da die ganzzahlige Division eine andere Bedeutung +hat, wird dafür der Operator 'DIV' verwendet. Den Rest der ganz +zahligen Division liefert 'MOD'. + 'abs' liefert den Wert eines REAL oder INT ohne das Vorzeichen. +Die Umwandlungsfunktionen 'int' und 'real' hatten wir ja bereits +weiter oben erwähnt. + Für REAL-Zahlen gibt es noch weitere mathematische Funktio +nen (Exponentialfunktion, Trigonometrie), die Sie am besten im +EUMEL-Benutzerhandbuch nachschlagen, wenn Bedarf dafür besteht. + + +#abschnitt ("14.5", "ABFRAGEN", "Abfragen")# + +#a ("IF-Abfragen")# Wie Sie schon im vorigen Kapitel gesehen haben, +kann man in Druckmustern auch IF-Abfragen als Ausdrücke ver +wenden. Die IF-Abfragen können zwar auch ineinander verschach +telt werden, sie dürfen jedoch nicht mehr innerhalb eines normalen +Ausdrucks angewendet werden. + Eine IF-Abfrage enthält 3 Teilausdrücke in folgender Form: + +#beispiel# + IF 'BOOL-Ausdruck' THEN + 'Ausdruck1' + ELSE + 'Ausdruck2' + END IF +#text# + +Der erste Ausdruck muß einen Wert vom Typ BOOL liefern, der ent +scheidet, welcher der beiden Teilausdrücke ausgewertet wird. Wir +werden gleich noch sehen, was für Möglichkeiten es da gibt. + Die beiden Teilausdrücke dürfen auch wieder IF-Abfragen sein, +sind sie es jedoch nicht, dürfen in ihnen dann keine IF-Abfragen +mehr vorkommen. Die IF-Abfragen liegen also immer auf der äußer +sten Ebene. + Die beiden Teilausdrücke dürfen einen beliebigen Typ haben, er +muß jedoch für beide gleich sein. + Als Ergebnis der IF-Abfrage wird 'Ausdruck1' geliefert, wenn +der BOOL-Ausdruck wahr ist, sonst 'Ausdruck2'. + +#a ("Vergleiche")# Die wesentlichen Operationen, die boolesche Ausdrücke +zur Verwendung in IF-Abfragen bilden, sind die Vergleichsoperato +ren: + +#beispiel# + = <> <= >= < > +#text# + +Sie vergleichen jeweils zwei Elemente vom Typ TEXT, INT oder REAL +und liefern TRUE (wahr) oder FALSE (falsch). Selbstverständlich +können auch sie zwei zusammengesetzte Teilausdrücke vergleichen. + Eine Anwendung ist zum Beispiel der Test, ob ein Text in einem +anderen enthalten ist: + +#beispiel# + IF pos (f ("Betrag"), "DM") > 0 THEN + "deutsches Geld" + ELSE + "ausländisches Geld" + END IF +#text# + +Die Funktion 'pos' wird hier dazu benutzt, festzustellen, ob es sich +um deutsches oder ausländisches Geld handelt. + Oft müssen jedoch mehrere Vergleiche miteinander kombiniert +werden. Zu diesem Zweck gibt es die beiden Operatoren AND (und) +und OR (oder). Damit AND das Ergebnis TRUE liefert, müssen beide +Vergleiche wahr sein, bei OR muß mindestens einer der beiden wahl +sein. + Die Reihenfolge aller dieser Operatoren ist so gewählt, daß +normalerweise keine Klammern benötigt werden. Funktionen haben +immer Vorrang vor Operatoren, bei den Operatoren kommt die Multi +plikation vor der Addition, dann kommen die Vergleiche, danach das +AND und danach das OR. Alle anderen Operatoren (#on("i")#insbesondere +SUB#off("i")#) teilen sich den letzten Rang. + Wenn Sie also in einem Ausdruck mehrere Vergleiche mit AND +und OR verknüpfen, und das OR soll stärker binden als das AND, +müssen Sie dies durch Klammern ausdrücken. + Den oben besprochenen Operator SUB sollten Sie immer in +Klammern setzen, wenn Sie ihn in einem Vergleich benutzen. Da er +die niedrigste Priorität hat, gäbe es sonst mit Sicherheit Fehler: + +#beispiel# + IF (f ("Name") SUB 1) = "M" THEN + "vielleicht Müller" + ELSE + "bestimmt nicht" + END IF +#text# + +#a ("Refinements")# Bisher hatten wir gesagt, daß IF-Abfragen nicht +innerhalb von anderen Ausdrücken verwendet werden dürfen. Diese +Einschränkung kann man umgehen, indem man #on("i")#Refinements#off("i")# verwen +det. + Ein Refinement hat im Druckmuster eine ähnliche Wirkung wie +eine Abkürzung, lediglich der Name darf nur mit Kleinbuchstaben +und Ziffern geschrieben sein und kann nicht als Feldmuster ver +wendet werden. + +#beispiel# + &abk : + subtext (f ("Name"), namensanfang) . + namensanfang : + IF pos (f ("Name"), " ") > 0 THEN + pos (f ("Name"), " ") + 1 + ELSE + length (f ("Name")) + END IF . +#text# + +Innerhalb von Refinements dürfen auch wieder andere Refinements +verwendet werden. + Auch in Kopier- und Änderungsmustern können Sie Refinements +verwenden. Hier müssen Sie jedoch darauf achten, daß alle Refine +ments am Ende gesammelt werden und vor dem ersten Refinement +ein Punkt stehen muß. Ebenso müssen die Refinements wie im +Druckmuster durch Punkte voneinander getrennt sein: + +#beispiel# + "Anrede" K anrede; + . + anrede : + IF f ("m/w") = "w" THEN + "Frau" + ELSE + "Herr" + END IF . +#text# + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.15 b/app/eudas/4.4/doc/user-manual/eudas.hdb.15 new file mode 100644 index 0000000..c15fb9a --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.15 @@ -0,0 +1,269 @@ +#type ("prop")##limit (14.0)# +#format# +#page (165)# +#kapitel ("15", "Anweisungen", "in", "ELAN")# + + + +#abschnitt ("15.1", "VARIABLEN UND ZUWEISUNGEN", "Variablen und Zuweisungen")# + +Im vorigen Kapitel haben wir Ausdrücke in ELAN kennengelernt. Der +Wert eines Ausdrucks wird bei jeder Verwendung erneut berechnet. +Wenn wir den Wert eines Ausdrucks aufbewahren wollen, müssen wir +ihn schon in eine EUDAS-Datei schreiben. + Oft tritt jedoch die Notwendigkeit auf, Werte zu merken, ohne +sie in einer Datei zu speichern. Beispiel dafür ist ein Zählvorgang im +Druckmuster. In jedem Wiederholungsteil muß der dazukommende +Wert zum bisherigen, aufsummierten und aufbewahrten Wert addiert +werden. Das Zwischenergebnis der Zählung muß also irgendwo ge +speichert werden. + +#a ("Variablen")# Zu diesem Zweck gibt es Variablen. Sie sind ähnlich wie +Felder in einer Datei. Ihre Existenz ist jedoch unabhängig von einer +Datei. Außerdem sind sie zu Anfang nicht einfach leer, sondern +haben einen undefinierten Wert. + Variablen müssen im Programm definiert werden. Sie existieren +dann während der Ausführung dieses Programms und gehen an +schließend verloren. Zu Beginn des Programms sind sie, wie schon +gesagt, undefiniert. + Eine Variable muß immer einen Typ haben. Dieser Typ ist für +die Lebensdauer der Variable unveränderlich. Die Variable kann +natürlich nur Werte dieses Typs annehmen. + Eine Variablendefinition (oder auch -deklaration) besteht aus +der Angabe eines Typs, dem Schlüsselwort #bsp ("VAR")# und einem freige +wählten Namen. Wie schon bei den Refinements darf ein solcher +Name nur aus Kleinbuchstaben (keine Umlaute) und eventuell Zif +fern bestehen. Dagegen darf der Name Leerzeichen enthalten. +Beispiel: + +#beispiel# + INT VAR zaehler; + TEXT VAR feldname; + REAL VAR mein ergebnis 1; +#text# + +Das Semikolon am Ende beschließt die Definition. + Die Lebensdauer einer Variablen hängt davon ab, an welcher +Stelle sie definiert ist. Eine Variable, die im Druckmuster im Initia +lisierungsteil definiert ist, behält ihren Wert für die gesamte Dauer +des Druckvorgangs. Eine Variable in einem Abschnitt lebt dagegen +nur für eine Abarbeitung dieses Abschnitts. Bei der nächsten Abar +beitung ist sie wieder undefiniert. + Das gleiche gilt für Kopier- und Änderungsmuster. Auch hier +sind Variablen nur für die Dauer der Bearbeitung eines Satzes +gültig. + +#a ("Zuweisung")# Um einer Variablen einen Wert zu geben, führt man eine +#on ("i")#Zuweisung#off("i")# aus. Die Zuweisung wird durch Doppelpunkt und Gleich +heitszeichen aneinandergeschrieben gekennzeichnet. Auf der linken +Seite steht die Variable, auf der rechten Seite eine Ausdruck: + +#beispiel# + zaehler := 1; +#text# + +Wie oben schließt das Semikolon die Anweisung ab. Nach der Aus +führung hat die Variable den Wert 1. Der Wert vorher ist für die +Zuweisung egal, er kann definiert oder undefiniert sein. + Eine Variable kann in einem Ausdruck verwendet werden, indem +man einfach den Namen hinschreibt. Der Ausdruck + +#beispiel# + zaehler + 1 +#text# + +hat nach der obigen Zuweisung den Wert 2. Eine Variable muß bei +der Verwendung definiert sein, sonst können beliebige Fehler ent +stehen. Es muß also vor der ersten Verwendung ausdrücklich eine +Zuweisung erfolgt sein. + Da Variablen in Ausdrücken verwendet werden können und +Ausdrücke auf der rechten Seite einer Zuweisung stehen, ist folgen +de Konstruktion möglich: + +#beispiel# + zaehler := zaehler + 1; +#text# + +Diese Zeile bewirkt, daß der Wert der Variable um 1 erhöht wird. +Zuerst wird bei der Zuweisung der Wert des Ausdrucks auf der rech +ten Seite bestimmt. Zu diesem Zeitpunkt habe die Variable bei +spielsweise den Wert 1. Der Ausdruck hat dann den Wert 2 (1+1). +Dieser Wert wird der neue Wert der Variablen. + Bei der nächsten Ausführung würde sich der gleiche Vorgang +wiederholen, so daß die Variable anschließend den Wert 3 hat. + Auch bei der Zuweisung gilt natürlich, daß die Variable auf der +linken Seite den gleichen Datentyp haben muß wie der Ausdruck auf +der rechten Seite. + +#a ("Initialisierung")# Sie können Variablendeklaration und Zuweisung +auch miteinander verknüpfen, so daß die Variable gleich zu Anfang +einen Wert erhält: + +#beispiel# + INT VAR zaehler := 0; +#text# + +Dieses Verfahren ist eine gute Vorsichtsmaßregel, damit Sie keine +undefinierten Variablen verwenden. + +#a ("Inkrement")# Da der Fall so häufig auftritt, daß der Wert einer Vari +ablen um einen bestimmten Wert erhöht wird (bei allen Zählvorgän +gen), gibt es auch dafür eine Abkürzung, und zwar die beiden Ope +ratoren INCR und DECR. + +#beispiel# + zaehler INCR 1; + mein ergebnis 1 DECR 24.4; +#text# + +Die Operatoren sind für REALs und INTs definiert. INCR erhöht um +einen Betrag, DECR erniedrigt. Auf der rechten Seite darf wieder ein +beliebiger Ausdruck stehen. + Für TEXTe gibt es eine ähnliche Abkürzung, allerdings nur für +die Addition (Verkettung). Hier heißt der Operator CAT. Die beiden +folgenden Zeilen haben die gleiche Bedeutung: + +#beispiel# + feldname := feldname + "."; + feldname CAT "."; +#text# + + +#abschnitt ("15.2", "WEITERE KONSTRUKTIONEN", "Weitere Konstruktionen")# + +#a ("IF")# Die Ihnen bereits bekannte IF-Konstruktion dient nicht nur +dazu, Werte zu liefern, sondern steuert auch die Abarbeitung von +beliebigen Anweisungen. Diese Anweisungen können Kopier- und +Änderungsanweisungen sein (s. Kapitel 11), oder die oben beschrie +benen Zuweisungen. + In einem Teil der IF-Konstruktion können auch mehrere Anwei +sungen stehen. Diese müssen dann jedoch unbedingt durch Semiko +lon getrennt sein. Mehrere Anweisungen hintereinander haben ein +fach die Bedeutung der Ausführung in der notierten Reihenfolge. + Als drittes kann auch der ELSE-Teil weggelassen, da nicht in +jedem Fall ein Ergebnis erwartet wird. Falls die Bedingung nicht +zutrifft, muß nicht unbedingt etwas ausgeführt werden. + +#beispiel# + IF zaehler > 0 THEN + zaehler DECR 1; + mein ergebnis 1 INCR wert ("zaehlfeld") + END IF; +#text# + +Auch diese IF-Konstruktion kann wieder geschachtelt werden. Für +viele Fälle gibt es jedoch einen ELIF-Teil, der die Verschachtelung +erspart: + +#beispiel# + IF f ("m/w") = "m" THEN + maenner INCR 1 + ELIF f ("m/w") = "w" THEN + frauen INCR 1 + ELSE + zweifelhaft INCR 1 + END IF; +#text# + +Der ELIF-Teil beinhaltet noch einmal einen Test. Dieser Test wird +jedoch nur dann durchgeführt, wenn die erste Bedingung falsch war. +Gibt es noch mehr Wahlmöglichkeiten, können Sie beliebig viele +ELIF-Teile benutzen. + Beachten Sie, daß die letzte Anweisung in einem Teil der IF- +Konstruktion nicht unbedingt ein folgendes Semikolon haben muß +(das Semikolon soll nur trennen). Ein Semikolon an dieser Stelle +kann aber auch nicht schaden. + +#a ("Werteliefernde Programme")# Nicht nur Ausdrücke können Werte lie +fern, sondern auch ganze Anweisungsfolgen. Dies ist eine Erweite +rung der werteliefernden IF-Konstruktion. Sie können dies für Ab +kürzungen oder Refinements ausnutzen. + +#beispiel# + endergebnis : + gesammelte zeichen CAT "."; + gesammelte zeichen . +#text# + +In diesem Beispiel werden in einer Textvariable bestimmte Zeichen +gesammelt. Zum Schluß soll ein Punkt angefügt werden und dieser +Text dann als Ergebnis des Refinements geliefert werden. + Damit eine Anweisungsfolge einen Wert liefert, muß am Ende +der Anweisungsfolge ein Ausdruck stehen. Der Wert des Ausdrucks +nach Abarbeitung der Anweisungen ist dann der Wert der Anwei +sungsfolge. + Allerdings kann man den gleichen Wert oft verschieden aus +drücken. Folgendes Refinement hat die gleiche Wirkung wie oben: + +#beispiel# + endergebnis : + gesammelte zeichen + "." . +#text# + +In manchen Fällen ist eine Formulierung als werteliefernde Anwei +sungsfolge jedoch übersichtlicher. + +#a ("Beispiel")# Zum Abschluß dieses Kapitels wollen wir als Beispiel eine +statistische Auswertung einer Zahlenreihe als Druckmuster formu +lieren. + Gegeben sei eine Datei mit folgenden Feldern: + +#beispiel# + "Meßwert 1" + "Meßwert 2" +#text# + +Wir wollen als Ergebnis Mittelwert und Standardabweichung der +beiden Meßwerte ausdrucken. Dazu dient das Druckmuster auf der +folgenden Seite. + Im Initialisierungsteil des Druckmusters werden die notwendi +gen Variablen definiert und initialisiert. Beachten Sie hier, daß in +einer Definition mehrere Variablen durch Komma getrennt aufgeführt +werden können, wenn sie den gleichen Typ haben. + Im Wiederholungsteil müssen dann jeweils die Zwischensummen +aktualisiert werden. Da mit der Funktion 'wert' eine relativ auf +wendige Umwandlung verbunden ist, wird der Wert des jeweiligen +Feldes erst einmal in einer Variable zwischengespeichert, da er +mehrmals benötigt wird. Diese Zwischenspeicherungsvariable muß +nicht initialisiert werden + Im Nachspann werden dann die Ergebnisse gedruckt. Die Formeln +sind jeweils als Abkürzungen definiert. Die Funktion 'zahltext' sorgt +dafür, daß die Werte mit drei Nachkommastellen (gerundet) aufge +führt werden. + Da die Formeln relativ komplex sind, werden sie auf mehrere +Zeilen verteilt (in ELAN hat das Zeilenende keine Bedeutung). + +#beispiel# + %% REAL VAR + %% messwert, + %% summe 1 := 0.0, quadratsumme 1 := 0.0, + %% summe 2 := 0.0, quadratsumme 2 := 0.0; + %% INT VAR anzahl := 0; + % WIEDERHOLUNG + %% anzahl INCR 1; + %% messwert := wert ("Meßwert 1"); + %% summe 1 INCR messwert; + %% quadratsumme 1 INCR messwert * messwert; + %% messwert := wert ("Meßwert 2"); + %% summe 2 INCR messwert; + %% quadratsumme 2 INCR messwert * messwert; + % NACHSPANN + &anz Meßwerte. + Meßwert 1 Meßwert 2 + Mittelwert &&mw1&&&& &&mw2&&&& + Standardabweichung &&st1&&&& &&st2&&&& + % ABKUERZUNGEN + &mw1 : zahltext (summe 1 / real (anzahl), 3) . + &mw2 : zahltext (summe 2 / real (anzahl), 3) . + &st1 : zahltext + (sqrt ((quadratsumme 1 - summe 1 * summe 1 / + real (anzahl)) / real (anzahl - 1)), 3) . + &st2 : zahltext + (sqrt ((quadratsumme 2 - summe 2 * summe 2 / + real (anzahl)) / real (anzahl - 1)), 3) . +#text# + +Mit entsprechenden Formeln können Sie dieses Beispiel für Ihre +eigenen Statistiken erweitern. Die Beispiele der letzten beiden Ka +pitel sollten Ihnen genügend Anregungen dafür gegeben haben. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.16 b/app/eudas/4.4/doc/user-manual/eudas.hdb.16 new file mode 100644 index 0000000..b0e84ee --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.16 @@ -0,0 +1,329 @@ +#type ("prop")##limit (14.0)# +#format# +#page (171)# +#kapitel ("16", "Dateiverwaltung", "mit", "EUDAS")# + + + +#abschnitt ("16.1", "DATEIEN IM SYSTEM", "Dateien im System")# + +Zum Bearbeiten von Dateien innerhalb des Systems gibt es das Menü +'Dateien', das Sie bereits in Kapitel 4 kurz kennengelernt haben. +An dieser Stelle sollen die übrigen Funktionen dieses Menüs be +sprochen werden. + +#beispiel# + -------------- + Dateien System + U Übersicht + -------------- + Datei + L Löschen + N Umbenennen + K Kopieren + P Platzbedarf + A Aufräumen + -------------- + +#center#Abb. 16-1 Menü 'Dateien' +#text# + +Beachten Sie, daß alle Funktionen in diesem Menü mit Dateien +beliebiger Struktur arbeiten können, also sowohl mit Textdateien +als auch EUDAS-Dateien (und anderen). Dies liegt daran, daß +Dateien an dieser Stelle einfach als "schwarze Kästen" mit beliebi +gem Inhalt betrachtet werden. + +#a ("Übersicht")# Die Funktion 'Übersicht' haben Sie bereits ausprobiert. +Sie zeigt in einem Editorfenster an der rechten Seite alle Dateien, +die sich in Ihrer Task befinden. Falls nicht alle Dateien auf den +Bildschirm passen, können Sie das Fenster mit HOP OBEN und HOP +UNTEN rollen. Sie verlassen die Übersicht wie üblich mit ESC 'q'. + +#a ("Löschen")# Auch die Funktion 'Löschen' sollten Sie schon kennen. +Mit dieser Funktion verschwindet eine Datei auf Nimmerwieder +sehen. Daher werden Sie sicherheitshalber immer gefragt, ob Sie die +Datei wirklich löschen wollen. Sie können in einer Auswahl auch +alle zu löschenden Dateien ankreuzen (dann wird trotzdem nochmal +gefragt). + Eine EUDAS-Datei, die gerade geöffnet ist, können Sie nicht +löschen (sonst würde EUDAS zumindest durcheinanderkommen). Sie +müssen die Datei zuerst sichern - oder nicht sichern, aber die +Arbeitskopien löschen. + +#a ("Umbenennen")# Mit der Funktion 'Umbenennen' können Sie einer Datei +einen neuen Namen geben. Sie werden zuerst aufgefordert, den alten +Namen der Datei einzugeben. Alternativ können Sie hier wieder die +umzubenennenden Dateien auswählen. Danach wird Ihnen (für jede +ausgewählte Datei) der alte Dateiname zum Überschreiben angebo +ten. + Sie können diesen Namen mit den üblichen Editierfunktionen +verändern oder mit HOP RUBOUT löschen und ganz neu eingeben. +Auf diese Weise sparen Sie sich erheblichen Tippaufwand, wenn Sie +einen langen Dateinamen an nur einer Stelle verändern wollen. + +#a ("Kopieren")# Wie in Abschnitt 11.2 bereits angedeutet, gibt es eine +Funktion zum logischen Kopieren von Dateien. Dies ist eine Funk +tion, die sich auf spezielle Eigenschaften des EUMEL-Systems +stützt. Wenn Sie eine Datei #on("i")#logisch#off("i")# kopieren, wird lediglich ein +Verweis kopiert. Die Daten werden zunächst nur einmal für beide +Dateien gespeichert. + Natürlich hätte das Ganze wenig Sinn, wenn danach bei Ände +rungen immer beide Dateien geändert würden. Bei Änderungen an +einer Datei werden jedoch nur die geänderten Daten getrennt ange +legt, der Rest wird weiterhin gemeinsam benutzt. Die beiden Dateien +sind also nach außen hin komplett unabhängig, intern werden je +doch gemeinsame Daten so weit wie möglich geteilt. Auf diese Weise +wird sowohl Zeit als auch Speicherplatz gespart. + Dieses Verfahren ist besonders dann sinnvoll, wenn Sie sich +einen bestimmten Stand einer Datei aufbewahren wollen. In diesem +Fall stellen Sie sich eine logische Kopie her und arbeiten mit dem +Original weiter. Es werden dann nur die Daten zusätzlich angelegt, +die Sie seit der Kopie verändert haben. + EUDAS benutzt die gleiche Funktion auch für die Arbeitskopie. +Die Arbeitskopie teilt ebenfalls ihre Daten mit dem Original. Ande +renfalls wäre es ja auch zeitlich gar nicht möglich, beim Öffnen eine +Arbeitskopie anzufertigen. + Beim Aufruf der Funktion 'Kopieren' werden Sie zunächst nach +dem Namen der Datei gefragt (wie üblich mit Auswahlmöglichkeit). +Dann können Sie einen neuen Namen für die Kopie angeben. Dieser +neue Name darf jedoch nicht für eine andere Datei vergeben sein. +Wollen Sie eine andere Datei überkopieren, müssen Sie diese zu +nächst löschen. + Denken Sie daran, daß die hier beschriebene Funktion sich +wesentlich vom Kopieren im Menü 'Gesamtdatei' unterscheidet. Dort +wird nämlich eine tatsächliche Kopie durchgeführt, dafür können Sie +sich dann auch selektiv bestimmte Daten herausgreifen. Außerdem +gilt die dortige Funktion nur für EUDAS-Dateien. + +#a ("Platzbedarf")# Zu Ihrer Information können Sie sich auch den Platz +bedarf anzeigen lassen, den eine Datei auf dem Speichermedium hat. +Wenn Sie den Namen der Datei angegeben haben, wird Ihnen die +Größe in "Kilobyte" (KB) angegeben. Ein KB entspricht etwa 1000 +Zeichen, also einer halben vollgeschriebenen Bildschirmseite. + Bei logisch kopierten Dateien wird für jede Datei der benötigte +Platz separat angegeben. Sie können die Zahlen also nicht einfach +addieren, um den Gesamtspeicherbedarf zu ermitteln, da Sie dann +die gemeinsam benutzten Bereiche doppelt zählen würden. + +#a ("Aufräumen")# Wenn eine Datei viel geändert wurde, führen zwei +Effekte zu einer langsameren Verarbeitung dieser Datei. Zum einen +wird durch Textleichen der Platzbedarf größer. Dies tritt vor allem +dann auf, wenn zu einzelnen Sätzen immer etwas hinzugefügt wurde +(eine Folge der Flexibilität, mit variablen Textlängen operieren zu +dürfen). + Da der Platzbedarf der Datei also wächst, sind mehr Speicher +zugriffe notwendig, als es dem Inhalt entspricht. Doch nicht nur der +Platz, sondern auch die Verteilung der Sätze machen sich unange +nehm bemerkbar. Da vergrößerte Sätze intern am Ende der Datei +gespeichert werden, werden logisch aufeinanderfolgende Sätze phy +sikalisch weit verstreut. + Der gleiche Effekt ensteht auch durch Umsortieren oder Ein +fügen von Sätzen. Um die Datei sequentiell zu bearbeiten, sind also +ständig wechselnde Speicherzugriffe erforderlich. + Die beiden beschriebenen Effekte führen zur Geschwindigkeits +verringerung. Dies kann verhindert werden, indem die Datei in eine +frische Datei umkopiert wird. Diesen Vorgang nennt man #on("i")#Reorgani +sieren#off("i")#. Dafür gibt es die Funktion 'Aufräumen'. + Während des Umkopierens werden die Satznummern ausgegeben. +Achten Sie darauf, daß zum Reorganisieren genügend Platz auf dem +System vorhanden ist, um eine komplette Kopie der zu reorganisie +renden Datei aufzunehmen. + Zum Reorganisieren muß nämlich tatsächlich eine physikalische +Kopie angefertigt werden. Eine logische Kopie oder das Schreiben +auf das Archiv reorganisieren eine Datei dagegen nicht, wohl aber +die Funktion 'Kopieren' im Menü 'Gesamtdatei'. + Da der Inhalt gelesen werden muß, funktioniert die Funktion +'Aufräumen' im Gegensatz zu den oben gemachten Versprechungen +nur für Textdateien oder EUDAS-Dateien, nicht aber für andere +Dateitypen. Die Unterscheidung der Dateitypen wird automatisch +vorgenommen. + + +#abschnitt ("16.2", "DATEIEN AUF DEM ARCHIV", "Dateien auf dem Archiv")# + +Mit den Funktionen im Menü 'Archiv' können Sie nicht nur Dateien +auf dem Archiv behandeln, sondern auch in anderen Tasks oder per +EUMEL-Netz sogar auf anderen Rechnern. + +#beispiel# + -------------- + Dateien Archiv + U Übersicht + D Üb. Drucken + -------------- + Datei + K Kopieren + vom Archiv + S Schreiben + auf Archiv + L Löschen + auf Archiv + -------------- + Archivdiskette + I Init + -------------- + Z Zielarchiv + P Paßwort + R Reservieren + -------------- + +#center#Abb. 16-2 Menue 'Archiv' +#text# + +#a ("Zielarchiv")# Dazu können Sie die Task einstellen, mit der Sie arbei +ten möchten. Normaleinstellung ist die Task 'ARCHIVE', die Ihre +Archivdiskette bedient. Dies wird auch in der untersten Bildschirm +zeile angezeigt. + Die Task stellen Sie mit der Funktion 'Zielarchiv' ein. Sie +werden dann nach dem Namen der Task gefragt. Diese Task muß +eine Managertask sein (also unabhängig vom Bildschirm arbeiten) +und sie muß bereits existieren. + Wenn Sie auf Ihrem Rechner das EUMEL-Netz installiert haben, +werden Sie auch nach der Nummer der Zielstation gefragt, also der +Nummer des Rechners, auf dem die gewünschte Task arbeitet. Durch +Drücken von RETURN wird automatisch Ihre eigene Stationsnummer +verwendet. + Nun gibt es zwei Arten von Managertasks, mit denen EUDAS +zusammenarbeiten kann, #on("i")#Archivmanager#off("i")# und normale Dateimanager. +Der Unterschied besteht darin, daß ein Archivmanager für einen +Benutzer reserviert werden muß, damit man nicht auf Disketten +eines anderen Benutzers zugreifen kann. Normale Dateimanager +können und sollen dagegen von mehreren Benutzern in beliebiger +Reihenfolge angesprochen werden. + Manche Rechner haben mehrere Archivmanager für mehrere +Diskettenlaufwerke. Durch das Einstellen des Zielarchivs können Sie +auf verschiedenen Laufwerken archivieren. Ein Archivmanager kann +sich natürlich auch auf einem anderen Rechner befinden. Sie benut +zen dann dessen Diskettenlaufwerk. + Beim Einstellen des Zielarchivs wird als letztes gefragt, ob die +Zieltask ein Archivmanager ist oder nicht. Im Normalfall sollten Sie +die Frage bejahen, wenn Sie 'ARCHIVE' einstellen, und ansonsten +verneinen (s. die obigen Ausnahmefälle). + Das eingestellte Zielarchiv wird jeweils in der untersten Bild +schirmzeile angezeigt. + Die Reservierung eines Archivmanagers findet beim ersten Zu +griff statt. Beim Umschalten des Zielarchivs oder Verlassen des +Menüs wird die Reservierung automatisch wieder aufgehoben. + +#a ("Übersicht")# Mit der Funktion 'Übersicht' können Sie eine Auflistung +aller Dateien abrufen, die sich auf der Archivdiskette (bzw. in dem +eingestellten Manager) befinden. Wie die Dateiübersicht im System +können Sie die Darstellung wie im Editor rollen und mit ESC 'q' +verlassen. + Wollen Sie die Übersicht gedruckt haben, rufen Sie die Funktion +'Übersicht drucken' auf. Die Übersicht wird dann nochmals zusam +mengestellt und gleich gedruckt. + +#a ("Schreiben und Lesen")# Mit den Funktionen 'Kopieren vom Archiv' +und 'Schreiben auf Archiv' können Sie Dateien zwischen dem Archiv +und Ihrer Task hin und her transportieren. Es wird jeweils eine +Kopie angefertigt, das heißt das Original auf der Diskette oder in +Ihrer Task wird nicht verändert. + Wenn die transportierte Datei an ihrem Ziel schon existiert, +wird gefragt, ob die vorher existierende Datei gelöscht (überschrie +ben) werden soll. Überschreiben aus Versehen ist nicht möglich, +wenn Sie die Frage sorgfältig beantworten. + Beim Aufruf der Funktionen können Sie den gewünschten Da +teinamen angeben oder in der Auswahl ankreuzen. Die Auswahl ist +hier besonders sinnvoll, wenn Sie mehrere Dateien (eventuell sogar +in einer bestimmten Reihenfolge) sichern müssen. Außerdem können +Sie ja keine Datei transportieren, die nicht existiert; alle Möglich +keiten werden Ihnen also durch Ankreuzen angeboten. + Beachten Sie, daß beim Überschreiben einer Datei auf einer +Archivdiskette der Speicherplatz der alten (überschriebenen) Ver +sion im allgemeinen nicht wiederverwendet werden kann. In diesem +Fall kann das Archiv voll werden, obwohl eigentlich genügend Platz +da wäre. + +#a ("Löschen")# Das gleiche Problem tritt auf beim Löschen einer Datei +auf dem Archiv. Mit der Funktion 'Löschen auf Archiv' können Sie +zwar die Datei auf der Diskette ungültig machen, der Platz wird +jedoch nur dann wiederverwendet, wenn es die letzte Datei auf der +Diskette war. Anderenfalls bleiben "Leichen" übrig, die Sie in der +Archivübersicht als Striche erkennen können. + Diese Probleme treten jedoch mit anderen Managern nicht auf, +da diese Ihren Speicherplatz intelligenter verwalten können. + +#a ("Initialisieren")# Als Abhilfe bei einem übergelaufenen Archiv müssen +Sie das ganze Archiv initialisieren und neu beschreiben. Dazu gibt +es die Funktion 'Init'. + Diese Funktion müssen Sie auch dann verwenden, wenn Sie eine +Archivdiskette zum ersten Mal verwenden. Auf dem Archiv muß +nämlich als erstes der Archivname eingetragen werden, ehe es be +nutzt werden kann. Diesen Namen müssen Sie hier angeben. + Alle alten Daten des Archivs werden komplett gelöscht. Daher +müssen Sie vorher die noch gültigen Daten vom Archiv ins System +kopiert haben. Wenn das Archiv vorher schon beschrieben war, +werden Sie anhand des Namens gefragt, ob Sie die richtige Diskette +zum Überschreiben eingelegt haben. + Wenn Sie eine fabrikneue Diskette aus der Verpackung nehmen, +müssen Sie diese vor der Initialisierung #on("i")#formatieren#off("i")#. Dabei wird die +Diskette auf ein bestimmtes physikalisches Format eingestellt. Ohne +diese Operation ist weder Schreiben noch Lesen überhaupt möglich. + In der Regel muß eine Diskette nur einmal formatiert werden. +Sie können sie jedoch jederzeit wieder formatieren (wenn Sie zum +Beispiel nicht wissen, was Ihnen da für eine alte Diskette in die +Finger geraten ist). + Am Anfang des Initialisierens werden Sie gefragt, ob Sie die +Diskette formatieren wollen. Manche Rechner unterstützen diese +Operation innerhalb des EUMEL-Systems nicht. In diesem Fall (und +natürlich auch sonst normalerweise) müssen Sie die Frage vernei +nen. Das Formatieren muß dann vorher irgendwie außerhalb des +Systems geschehen sein. + Das Initialisieren funktioniert natürlich nur bei Archivmana +gern. Bei einer anderen Zieltask ist diese Funktion gesperrt. + +#a ("Paßwort")# Dateien in einem allgemeinen Dateimanager (nicht jedoch +auf dem Archiv) können Sie mit einem Paßwort gegen unbefugten +Zugriff sichern. Sinnvolle Voraussetzung dafür ist, daß der Datei +manager selbst mit einem anderen Paßwort gegen Betreten gesichert +ist. + Das von Ihnen verwendete Paßwort geben Sie mit der Funktion +'Paßwort' ein. Damit Ihnen niemand über die Schulter schauen +kann, werden alle Zeichen auf dem Bildschirm als Punkte darge +stellt. Anschließend müssen Sie das Paßwort noch einmal eingeben, +damit sich kein unbemerkter Schreibfehler eingeschlichen hat. + Das Paßwort wird dann bei allen Transport- und Löschopera +tionen abgefragt. Eine Datei im Manager erhält Ihr Paßwort zuge +wiesen, wenn Sie sie das erste Mal im Manager ablegen. Bei allen +folgenden Zugriffen muß das gleiche Paßwort eingestellt sein, sonst +wird der Zugriff verweigert. + Natürlich können Sie für verschiedene Dateien verschiedene +Paßwörter einstellen. Trotz Einstellung eines Paßworts können auch +andere Benutzer ihre Dateien im gleichen Manager ablegen. + Sie können auch für Schreiben (und Löschen) sowie Lesen +unterschiedliche Paßwörter einstellen. Dazu benutzen Sie einfach +einen Trennstrich in der Form +#f2# +#beispiel# + Schreibpaßwort/Lesepaßwort +#text# +#f2# +Soll eine Datei überhaupt nicht überschrieben oder gelöscht werden +können, können Sie '-' als Schreibpaßwort verwenden: +#f2# +#beispiel# + -/Lesepaßwort +#text# +#f2# +Die Datei kann dann nur beim direkten Betreten der Managertask +verändert werden. + Wollen Sie die Paßworteinstellung wieder aufheben, drücken Sie +bei der Paßworteingabe nur RETURN, da der leere Text als "kein +Paßwort" interpretiert wird. + +#a ("Reservieren")# Wollen Sie eine Task als Zieltask verwenden, die zwar +kein Archivmanager ist, aber reserviert werden muß (zum Beispiel +'DOS' zum Ansprechen fremder Diskettenformate) müssen Sie die +Reservierung mit der Funktion 'Reservieren' selbst vornehmen. Die +Zieltask darf nicht als Archivmanager gekennzeichnet sein (dann ist +die Funktion 'Reservieren' nämlich gesperrt). + Bei der Reservierung müssen Sie den Reservierungsparameter +(abhängig von der Art der Zieltask - bei 'DOS' beispielsweise den +Modus) als Text eingeben. Nach der Reservierung können Sie die +anderen Funktionen des Archivmenüs verwenden. + Die Freigabe der Zieltask erfolgt automatisch beim Verlassen +des Menüs oder beim Einstellen einer neuen Zieltask. + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.2 b/app/eudas/4.4/doc/user-manual/eudas.hdb.2 new file mode 100644 index 0000000..a72ba81 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.2 @@ -0,0 +1,164 @@ +#type ("prop")##limit (14.0)# +#format# +#page (11)# +#kapitel ("2", "Installation", "des", "Programms")# + + + +Bevor Sie EUDAS auf Ihrem System benutzen können, müssen Sie das +Programm zuvor installieren. Wenn EUDAS schon auf Ihrem System +zur Verfügung steht, können Sie dieses Kapitel getrost überlesen. + + +#abschnitt ("2.1", "LIEFERUMFANG", "Lieferumfang")# + +EUDAS wird auf einer Diskette geliefert, die alle notwendigen Pro +gramme enthält. Um den Inhalt der Diskette feststellen zu können, +starten Sie Ihr System und bringen es dazu, daß 'gib kommando:' +erscheint. Dann legen Sie die Diskette ein und geben das Kommando + +#beispiel# + archive ("EUDAS"); list (archive); release (archive) +#text# + +Anschließend erscheint eine Übersicht der auf dem Archiv vorhan +denen Programmteile. Folgende Namen sollten sich in dieser Über +sicht wiederfinden: + +#beispiel# + "eudas.1" + "eudas.2" + "eudas.3" + "eudas.4" + "eudas.init" + "eudas.generator" + "Adressen" +#text# + +Eventuell können noch weitere Namen in der Übersicht auftauchen. +Sollte einer der angegebenen Namen nicht vorhanden sein, rekla +mieren Sie die Diskette. Falls Sie statt der Übersicht eine Fehler +meldung erhalten, sollten Sie überprüfen, ob die Diskette das rich +tige Format besitzt oder Ihr Diskettenlaufwerk Probleme bereitet. + Wenn Sie so den Inhalt der Diskette kontrolliert haben, können +Sie EUDAS installieren. Je nachdem, ob Sie ein Single-User oder ein +Multi-User System benutzen, sind die Anweisungen unterschiedlich. +Sie brauchen nur den Sie betreffenden der beiden folgenden Ab +schnitte zu lesen. Falls Sie nicht wissen, welches System Sie benut +zen: ein Multi-User System wird auf der Systemdiskette und am +Bildschirm durch die Kennzeichnung 'EUMEL x.y.z/M' identifiziert, +bei einem Single-User System steht als letztes Zeichen ein 'S'. + + +#abschnitt ("2.2", "SINGLE-USER", "Single-User")# + +Dieser Abschnitt betrifft Sie nur, wenn Sie EUDAS auf einem +Single-User System installieren wollen. + Sie können EUDAS immer nur auf einer bestimmten Hinter +grunddiskette installieren. Auf dieser Diskette sollten noch min +destens 250 KB frei sein (stellen Sie dies durch das Kommando +'storage info' sicher). EUDAS kann anschließend auch nur auf dieser +Diskette verwendet werden. + Starten Sie nun die gewünschte Diskette. Dann legen Sie die +Diskette, auf der EUDAS sich befindet, in das Archivlaufwerk. Geben +Sie dann das Kommando + +#beispiel# + archive ("EUDAS"); fetch ("eudas.generator", archive); run +#text# + +Sie haben damit das Generatorprogramm gestartet, das die Installa +tion automatisch durchführt. Lassen Sie während dieses Vorganges +das EUDAS-Archiv eingelegt. Sie werden benachrichtigt, wenn die +Generierung abgeschlossen ist. + Wenn Sie EUDAS auf allen Ihren Hintergrunddisketten haben +möchten, können Sie das so erzeugte System als Muttersystem +sichern. Mit dem Kommando 'save system' können Sie den Hinter +grund komprimiert auf eine leere Archivdiskette schreiben. Mit +dieser Sicherung können Sie dann jederzeit neue Systemdisketten +wie von Ihrem Originalsystem herstellen. + +#a("Einschränkungen")# Aus Platzgründen hat die Single-User-Version +von EUDAS folgende Einschränkungen: +#free (0.2)# +#bsp("*")# Sie können die Funktionen Ketten und Koppeln nicht verwenden. +#free (0.2)# +#bsp("*")# Sie können im Druckmuster keine ELAN-Anweisungen und -Aus + drücke verwenden. +#free (0.2)# +#bsp("*")# Es stehen nur einige allgemeine Hilfstexte zur Verfügung. +#free (0.2)# +#bsp("*")# Funktionen, die mehrere Tasks vorausssetzen, sind ebenfalls + gesperrt. +#free (0.2)# +Die betreffenden Funktionen sind zwar gegebenenfalls im Menü +enthalten, lassen sich aber nicht aufrufen. + + +#abschnitt ("2.3", "MULTI-USER", "Multi-User")# + +Dieser Abschnitt betrifft Sie nur, wenn Sie EUDAS auf einem Mul +ti-User System installieren wollen. + EUDAS muß in einer bestimmten Task installiert werden. Alle +neuen Söhne und Enkel dieser Task können dann EUDAS aufrufen. +Im Normalfall wird diese Task 'PUBLIC' sein. + Zum Installieren müssen Sie in diese Task gehen (in diesem +Beispiel 'PUBLIC'). Dazu rufen Sie durch Tippen der SV-Taste den +Supervisor und geben das Kommando + +#beispiel# + continue ("PUBLIC") +#text# + +Stelle Sie mit Hilfe des 'storage info'-Kommandos fest, ob auf Ihrem +Hintergrund noch mindestens 300 KB frei sind (dieser Platz wird zur +Generierung benötigt). Dann legen Sie die EUDAS-Archivdiskette ein +und geben folgendes Kommando + +#beispiel# + archive ("EUDAS"); fetch ("eudas.generator", archive); run +#text# + +Falls die Task 'PUBLIC' Söhne besitzt, werden Sie gefragt, ob Sie +diese löschen wollen. EUDAS steht nämlich nur in den Söhnen zur +Verfügung, die #on("i")#nach#off("i")# der Installation eingerichtet wurden. Antworten +Sie auf die Frage durch einfaches Tippen von 'j' oder 'n'. wenn Sie +die Frage verneinen, können Sie die Generierung zu diesem Zeit +punkt auch noch abbrechen und zunächst die Söhne aufräumen. + Es erscheint die Frage +#f2# +#beispiel# + Ausführliche Hilfstexte installieren ? (j/n) +#text# +#f2# +Verneinen Sie die Frage, wenn in Ihrem System der Speicherplatz +kritisch ist (zum Beispiel wenn Sie keine Festplatte haben). Es +werden dann nur die wichtigsten allgemeinen Hilfstexte installiert +(Ersparnis etwa 40 KByte). + Anschließend wird die automatische Generierung gestartet. +Lassen Sie die EUDAS-Archivdiskette eingelegt. Die Generierung ist +beendet, wenn das EUMEL-Bild erscheint. Die Task, in der die +Generierung stattfindet, wird automatisch zu einer Managertask, das +heißt, daß man von ihr Söhne einrichten kann. + Sie können das so erweiterte System auch mit 'save system' auf +einer oder mehreren Archivdiskette sichern. Lesen Sie dazu die +Hinweise zur Systemsicherung im EUMEL-Systemhandbuch. + +#a ("Korrekturversionen")# Falls Sie später einmal eine Korrekturversion +von EUDAS bekommen, sollten Sie vor der neuen Generierung die +Task, in der EUDAS vorher generiert war, löschen (Vorsicht: alle +Söhne werden mitgelöscht) und wieder neu einrichten. Anderenfalls +bleibt die alte Version als unzugängliche "Leiche" auf Ihrem System +liegen. + In diesem Fall und auch, wenn Sie mehrere Programme in der +gleichen Task installieren, kann es zum Überlauf der internen Über +setzertabellen kommen. Für größere Installationen oder wenn Sie +viele verschiedene Programme benutzen, empfiehlt es sich, zur +Generierung eine eigene Task 'EUDAS' als Sohn von 'PUBLIC' zu +verwenden. Sie dürfen dann aber in 'PUBLIC' nicht zu viel insertie +ren, da 'EUDAS' ja alle Programme von 'PUBLIC' erbt. Denken Sie +daran, daß Sie EUDAS nur in Tasks benutzen können, die unter der +Task 'EUDAS' eingerichtet wurden. + + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.3 b/app/eudas/4.4/doc/user-manual/eudas.hdb.3 new file mode 100644 index 0000000..51da351 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.3 @@ -0,0 +1,504 @@ +#type ("prop")##limit (14.0)# +#format# +#page (15)# +#kapitel ("3", "Ein Beispiel", "zum", "Ausprobieren")# + + + +Bevor Sie in die tieferen Geheimnisse von EUDAS einsteigen, sollen +Sie in diesem Kapitel erst einige Erfahrungen mit der Bedienung +sammeln. Dadurch erhalten Sie Sicherheit im Umgang mit dem Pro +gramm und haben bereits einen Eindruck dessen, was Sie anschlie +ßend erwartet. + Das Durchlesen dieses Kapitels ist nur dann sinnvoll, wenn Sie +die Anweisungen selbst am Rechner ausprobieren. Anderenfalls +beginnen Sie besser mit dem nächsten Kapitel. + Im folgenden sind die Eingaben, die Sie machen sollen, kursiv +gedruckt, während Ausgaben des Rechners normal erscheinen. +Außerdem erscheinen spezielle Tasten in spitzen Klammern: +#f2# +#beispiel# + <RET> +#text# +#f2# +Bitte tippen Sie nicht die eckigen Klammern oder Großbuchstaben, +sondern die entsprechende Taste. Oft haben die Sondertasten auch +etwas andere Bezeichnungen (die obige zum Beispiel 'CR', 'Carriage +Return', 'RETURN', 'ENTER'). Bitte fragen Sie bei Unklarheiten Ihren +Systemlieferanten oder -betreuer. + + +#abschnitt ("3.1", "START", "Start")# + +Die Anweisungen zum Starten von EUDAS sind unterschiedlich, je +nachdem wie Ihr System eingerichtet ist. Bitte beachten Sie daher +die verschiedenen Fälle. + +1. Falls Sie EUDAS nicht selbst installiert haben, fragen Sie am + besten Ihren Systembetreuer. Ansonsten verhalten Sie sich wie + unter 2. + +2. Falls Sie EUDAS nach den Anweisungen von Kapitel 2 in einem + Multi-User-System eingerichtet haben, müssen Sie zunächst eine + Arbeitstask (Arbeitsbereich) einrichten. Dazu tippen Sie die + SV-Taste (diese trägt häufig die unterschiedlichsten Bezeich + nungen). Es erscheint + +#beispiel# + EUMEL x.y.z/M + + gib supervisor kommando : +#text# + + Sie tippen nun folgendes Kommando: + +#beispiel# + #on("i")#begin ("arbeit")#off("i")#<RET> +#text# + + Vergessen Sie nicht die RETURN-Taste am Schluß. Machen Sie + jetzt weiter bei Punkt 4. + +3. Falls Sie ein Single-User-System besitzen, starten Sie die + Systemdiskette und geben das Datum ein. Dann machen Sie wei + ter mit Punkt 4. + +4. Danach erscheint: + +#beispiel# + gib kommando : +#text# + + und Sie tippen: + +#beispiel# + #on("i")#eudas#off("i")#<RET> +#text# + + Als Ergebnis wird das EUDAS-Eingangsmenü angezeigt (s. Abb. + 3-1 auf der nächsten Seite). + + +#abschnitt ("3.2", "DATEN EINTRAGEN", "Daten eintragen")# + +Als Beispiel sollen Sie eine kleine Adressenkartei einrichten. Der +Fachausdruck für eine elektronische Kartei ist #on("i")#Datei#off("i")#. +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + EUDAS-Datei : + O Öffnen : + - Ketten : + - Koppeln : EEEEE U U DDDD A SSSS + --------------: E U U D D A A S + Arbeitskopie : EEE U U D D AAAAA SSS + - Sichern : E U U D D A A S + --------------: EEEEE UUU DDDD A A SSSS + Aktuelle Datei: + - Notizen : Version 4.3 + - Feldstrukt. : Stand: 14.07.87 + - Prüfbeding. : + --------------: (C) Copyright + Mehrbenutzer : Thomas Berlage + M Manager : Software-Systeme + --------------: + : + : + : + : + : + Akt.Datei: Manager: Datum: 22.07.87 +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 3-1 EUDAS-Eingangsmenü +#text# + + Zunächst müssen Sie eine neue Datei einrichten. Dazu tippen +Sie die Leertaste. Dadurch wird die invers dargestellte Funktion +'Öffnen' ausgeführt. Folgen Sie bitte dem nachstehenden Dialog auf +der rechten Bildschirmseite: + +#beispiel# + Name der Datei: #on ("i")#Mitglieder#off("i")#<RET> + "Mitglieder" neu einrichten ? (j/n) #on("i")#j#off("i")# +#text# + +Unter der Überschrift 'Neue Feldnamen' tippen Sie jetzt folgendes +(bitte keine Leerstellen vor den Namen tippen): + +#beispiel# + #on("i")#Name#off("i")#<RET> + #on("i")#Vorname#off("i")#<RET> + #on("i")#PLZ#off("i")#<RET> + #on("i")#Ort#off("i")#<RET> + #on("i")#Strasse#off("i")#<RET> + #on("i")#m/w#off("i")#<ESC>#on("i")#q#off("i")# +#text# + +Zum Schluß beantworten Sie noch eine Frage: + +#beispiel# + Feldnamen oder Feldtypen aendern ? (j/n) #on("i")#n#off("i")# +#text# + +Damit ist die neue Datei eingerichtet. + Nun tippen Sie die Pfeiltaste #bsp("<RECHTS>")#. Es erscheint ein neues +Menübild (s. Abb. 3-2). +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: Satz 1 .........ENDE... Mitglieder .......... Feld 1 + Positionieren : Name + W Weiter : Vorname + Z Zurück : PLZ + N Satz.Nr : Ort + --------------: Strasse + Suchbedingung : m/w + S Setzen : ........................................................... + L Löschen : + M Markierung : + --------------: + Datensatz : + E Einfügen : + A Ändern : + T Tragen : + H Holen : + --------------: + F Feldauswahl : + --------------: + : + : + : + +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 3-2 Menü 'Einzelsatz' +#text# + +Nun tippen Sie so lange die Pfeiltaste #bsp("<UNTEN>")#, bis die Funktion +'Einfügen' invers markiert ist. Dann tippen Sie die Leertaste zum Aus +führen dieser Funktion. Die Schreibmarke springt nach rechts ins +Datenfeld zum Eingeben. Geben Sie jetzt den ersten Datensatz wie +folgt ein: + +#beispiel# + #on("i")#Wegner#off("i")#<RET> + #on("i")#Herbert#off("i")#<RET> + #on("i")#5000#off("i")#<RET> + #on("i")#Köln#off("i")#<RET> + #on("i")#Krämergasse 12#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#w#off("i")# +#text# + +Anschließend wird das Datenfeld wieder freigemacht, so daß Sie +gleich den zweiten Datensatz eingeben können. Dies tun Sie auf die +gleiche Weise, nur mit anderen Daten: + +#beispiel# + #on("i")#Sandmann#off("i")#<RET> + #on("i")#Helga#off("i")#<RET> + #on("i")#5300#off("i")#<RET> + #on("i")#Bonn 1#off("i")#<RET> + #on("i")#Willicher Weg 109#off("i")#<RET> + #on("i")#w#off("i")#<ESC>#on("i")#w#off("i")# +#text# + +Ebenso verfahren Sie dann weiter mit den folgenden Daten. Falls Sie +sich vertippt haben, können Sie mit den vier Pfeiltasten an die +entsprechende Stelle gehen und die falschen Buchstaben über +schreiben. + +#beispiel# + #on("i")#Katani#off("i")#<RET> + #on("i")#Albert#off("i")#<RET> + #on("i")#5210#off("i")#<RET> + #on("i")#Troisdorf#off("i")#<RET> + #on("i")#Lindenstr. 3#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Ulmen#off("i")#<RET> + #on("i")#Peter#off("i")#<RET> + #on("i")#5#off("i")#<RET> + #on("i")#Köln 60#off("i")#<RET> + #on("i")#Mozartstraße 17#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Regmann#off("i")#<RET> + #on("i")#Karin#off("i")#<RET> + #on("i")#5000#off("i")#<RET> + #on("i")#Köln 90#off("i")#<RET> + #on("i")#Grengelweg 44#off("i")#<RET> + #on("i")#w#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Arken#off("i")#<RET> + #on("i")#Hubert#off("i")#<RET> + #on("i")#5200#off("i")#<RET> + #on("i")#Siegburg#off("i")#<RET> + #on("i")#Talweg 12#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Simmern#off("i")#<RET> + #on("i")#Anna-Maria#off("i")#<RET> + #on("i")#5#off("i")#<RET> + #on("i")#Köln 3#off("i")#<RET> + #on("i")#Platanenweg 67#off("i")#<RET> + #on("i")#w#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Kaufmann-Drescher#off("i")#<RET> + #on("i")#Angelika#off("i")#<RET> + #on("i")#53#off("i")#<RET> + #on("i")#Bonn#off("i")#<RET> + #on("i")#Hauptstr. 123#off("i")#<RET> + #on("i")#w#off("i")#<ESC>#on("i")#w#off("i")# + + #on("i")#Fuhrmann#off("i")#<RET> + #on("i")#Harald#off("i")#<RET> + #on("i")#5000#off("i")#<RET> + #on("i")#Köln 1#off("i")#<RET> + #on("i")#Glockengasse 44#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#w#off("i")# +#text# + +Bei der letzten Adresse ist die letzte Taste unterschiedlich, da Sie +keine weiteren Daten mehr eintragen wollen. Bitte beachten Sie dies. + +#beispiel# + #on("i")#Seefeld#off("i")#<RET> + #on("i")#Friedrich#off("i")#<RET> + #on("i")#5000#off("i")#<RET> + #on("i")#Köln-Ehrenfeld#off("i")#<RET> + #on("i")#Kabelgasse#off("i")#<RET> + #on("i")#m#off("i")#<ESC>#on("i")#q#off("i")# +#text# + +Damit die neu eingetragenen Daten permanent gespeichert sind, +müssen Sie sie #on("i")#sichern#off("i")#. Dazu kehren Sie durch Tippen von #bsp("<LINKS>")# +in das erste Menü zurück. Dort tippen Sie wieder so lange #bsp("<UNTEN>")#, +bis die Funktion 'Sichern' markiert ist. Tippen Sie dann die Leer +taste zum Ausführen und folgen dem nachstehenden Dialog: + +#beispiel# + Arbeitskopie "Mitglieder" veraendert! Sichern ? (j/n) #on("i")#j#off("i")# + Alte Version ueberschreiben ? (j/n) #on("i")#j#off("i")# + Interne Arbeitskopien loeschen ? (j/n) #on("i")#j#off("i")# +#text# + +Damit steht Ihnen nun eine Mitgliederdatei mit 10 Einträgen zur +weiteren Verfügung. + + +#abschnitt ("3.3", "DATEN ABFRAGEN", "Daten abfragen")# + +Um Daten abzufragen, müssen Sie die Datei zunächst wieder öffnen. +Dazu bewegen Sie die inverse Markierung durch mehrmaliges Tippen +von #bsp("<OBEN>")# nach oben bis zur Funktion 'Öffnen' und tippen Sie die +Leertaste. Danach ergibt sich folgender Dialog: + +#beispiel# + Name der Datei: #on("i")#Mitglieder#off("i")#<RET> + Wollen Sie etwas aendern (eine Arbeitskopie einrichten) + ? (j/n) #on("i")#n#off("i")# +#text# + +Danach gehen Sie durch Tippen von #bsp ("<RECHTS>")# in das zweite Menü. +Dort erscheint jetzt die zehnte Adresse. + Zunächst sollen Sie an den Anfang gehen. Dazu schieben Sie +die Markierung auf die Funktion 'Satz.Nr' mit Hilfe der Pfeiltasten +und tippen dann die Leertaste. Nach folgender Angabe + +#beispiel# + Neue Satznummer: #on("i")#1#off("i")#<RET> +#text# + +erscheint die erste Adresse. Nun sollen Sie nach der Adresse von +Harald Fuhrmann suchen. Dazu bringen Sie die Markierung auf die +Funktion 'Suchbedingung Setzen' und tippen die Leertaste. Die +Schreibmarke springt wieder in das Datenfeld. Dort geben Sie ein: + +#beispiel# + #on("i")#Fuhrmann#off("i")#<ESC>#on("i")#q#off("i")# +#text# + +In der markierten Überschrift erscheint 'SUCH-' zum Zeichen, daß +eine Suchbedingung eingestellt ist. Dann schieben Sie die Markie +rung auf die Funktion 'Weiter' und tippen die Leertaste. Kurz da +nach erscheint die Adresse von Herrn Fuhrmann mit dem Hinweis +'SUCH+' (gefunden). + Führen Sie dann die Funktion 'Zurück' aus (Verschieben der +Markierung und Tippen der Leertaste). Es erscheint wieder die erste +Adresse mit dem Hinweis 'SUCH-' (kein weiterer Fuhrmann gefun +den). Führen Sie dann die Funktion `Suchbedingung Löschen' aus. +Der 'SUCH'-Hinweis verschwindet wieder. + Als nächstes sollen Sie die Daten nach allen weiblichen Mit +gliedern durchsuchen. Dazu führen Sie wieder die Funktion 'Such +bedingung Setzen' aus. Diesmal tippen Sie im Datenfeld fünfmal die +Pfeiltaste #bsp ("<UNTEN>")#, bis die Schreibmarke neben der Bezeichnung +'m/w' steht. Dort tippen Sie + +#beispiel# + #on("i")#w#off("i")#<ESC>#on("i")#q#off("i")# +#text# + +Wenn Sie jetzt die Funktion 'Weiter' ausführen, erscheint das erste +weibliche Mitglied, Frau Sandmann. Da aber noch weitere Frauen in +der Datei vorkommen, führen Sie erneut 'Weiter' aus und es erschei +nen die nächsten weiblichen Mitglieder. + Wenn kein gesuchtes Mitglied mehr gefunden wurde, erscheint +ein leeres Datenfeld mit den Bezeichnungen 'ENDE' und 'SUCH-' in +der Überschrift. Durch mehrmaliges Ausführen von 'Zurück' können +Sie die weiblichen Mitglieder wieder in der umgekehrten Reihenfolge +ansehen, bis Sie an den Anfang der Datei kommen. + Bitte lassen Sie die Suchbedingung eingestellt, denn im näch +sten Abschnitt wollen wir alle weiblichen Mitglieder ausdrucken. + + +#abschnitt ("3.4", "DRUCKEN", "Drucken")# + +Zuerst begeben Sie sich durch zweimaliges Tippen von #bsp ("<RECHTS>")# in +das Druckmenü, das in Abb. 3-3 gezeigt wird. +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + Satzauswahl : + D Drucken : + --------------: + Druckausgabe : + R Richtung : + --------------: + Textdatei : + E Editieren : + A Ausdrucken : + N Nachbearb. : + --------------: + : + : + : + : + : + : + : + : + : + : + Akt.Datei: "Mitglieder" Datum: 22.07.87 +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 3-3 Menü 'Drucken' +#text# + +Zunächst müssen Sie ein Druckmuster erstellen, das angibt, wie der +Druck aussehen soll. Dazu führen Sie die Funktion 'Textdatei Edi +tieren' aus. Es erscheint die Aufforderung: + +#beispiel# + Name der Datei: #on("i")#liste#off("i")#<RET> +#text# + +Dann wird der Bildschirm gelöscht und Sie können folgendes einge +ben: + +#beispiel# + #on("i")#% VORSPANN#off ("i")#<RET> + #on("i")#Liste der weiblichen Mitglieder#off ("i")#<RET> + #on("i")#-------------------------------#off ("i")#<RET> + #on("i")#% WIEDERHOLUNG#off ("i")#<RET> + #on("i")#&Vorname %Name#off ("i")#<ESC>#on("i")#q#off("i")# +#text# + +Ebenso wie beim Eingeben von Daten können Sie hier mit den Pfeil +tasten auf fehlerhafte Stellen zurückgehen und dort korrigieren. + Nun sollten Sie sich vergewissern, ob Ihr Drucker eingeschaltet +und bereit (Ready) ist. Falls Sie keinen Drucker haben, folgen Sie +bitte den Anweisungen unter 2. Anderenfalls gehen Sie wie folgt +vor. + +1. Rufen Sie die Funktion 'Richtung' auf und beantworten Sie + folgende Frage: + +#beispiel# + Ausgabe automatisch zum Drucker ? (j/n) #on("i")#j#off("i")# +#text# + + Dann rufen Sie die Funktion 'Drucken' auf und geben den Namen + des Druckmusters an: + +#beispiel# + Name des Druckmusters: #on("i")#liste#off ("i")#<RET> +#text# + + Als Ergebnis sollte folgende Liste auf Ihrem Drucker erscheinen: + +#beispiel# + Liste der weiblichen Mitglieder + ------------------------------- + Helga Sandmann + Karin Regmann + Anna-Maria Simmern + Angelika Kaufmann-Drescher +#text# + +2. Rufen Sie die Funktion 'Richtung' auf und beantworten Sie + folgende Fragen: + +#beispiel# + Ausgabe automatisch zum Drucker ? (j/n) #on("i")#n#off("i")# + Ausgabe in bestimmte Datei ? (j/n) #on("i")#n#off("i")# +#text# + + Dann rufen Sie die Funktion 'Drucken' auf und geben den Namen + des Druckmusters an: + +#beispiel# + Name des Druckmusters: #on("i")#liste#off ("i")#<RET> +#text# + + Nach dem Ende des Druckprozesses (wenn das Sternchen vor + 'Drucken' wieder durch ein 'D' ersetzt worden ist), rufen Sie + wieder die Funktion 'Textdatei Editieren' auf und geben folgen + den Namen an: + +#beispiel# + Name der Datei: #on("i")#liste.a$1#off("i")#<RET> +#text# + + Es erscheint die gleiche Ausgabe wie unter 1 beschrieben auf + dem Bildschirm. Wenn Sie die Ausgabe genug gesehen haben, + kehren Sie durch + +#beispiel# + <ESC>#on("i")#q#off("i")# +#text# + + wieder in das Menü zurück. + + +#abschnitt ("3.5", "ERGEBNIS", "Ergebnis")# + +Da Sie sich wieder im Menü befinden, könne Sie EUDAS durch +#f2# + <ESC>#on("i")#q#off("i")# +#f2# +wieder verlassen. Danach können Sie Ihre Sitzung beenden, etwas +Anderes tun oder EUDAS erneut aufrufen. + + Sie haben nun selbst ausprobiert, wie Sie unter EUDAS Daten +eingeben können, wie Sie diese Daten abrufen und in ihnen suchen +können. Sie haben die Daten auch schon ausgedruckt. + Damit Sie besser verstehen, was Sie soeben gemacht haben, +werden Sie in den folgenden vier Kapiteln die Grundfunktionen von +EUDAS mit den dazugehörigen Erläuterungen kennenlernen. + Danach können Sie dann selber Ihre eigene Anwendung entwer +fen und EUDAS zu Ihrer Arbeitserleichterung einsetzen. + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.4 b/app/eudas/4.4/doc/user-manual/eudas.hdb.4 new file mode 100644 index 0000000..dc86791 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.4 @@ -0,0 +1,676 @@ +#type ("prop")##limit (14.0)# +#format# +#page (27)# +#kapitel ("4", "Umgang mit", "Dateien", "und Menüs")# + + + +Zu Anfang dieses Teils sollen Sie zunächst die Terminologie von +EUDAS kennenlernen. Das Karteikartenmodell des ersten Kapitels +muß ja auf einem Rechner realisiert werden. Dazu müssen erst eini +ge Ausdrücke erklärt werden. + + +#abschnitt ("4.1", "EUDAS-DATEIEN", "EUDAS-Dateien")# + +Der wichtigste Ausdruck, der Ihnen noch sehr häufig begegnen wird, +ist #on("i")#Datei#off("i")#. Eine Datei ist eine Sammlung von Informationen in einem +Computer, die als ein Objekt transportiert und behandelt werden +können. Dieser Name wurde analog zu "Kartei" gebildet, mit dem +Unterschied, daß eine "Daten-Kartei" gemeint ist. + Jede Datei hat einen eigenen Namen, durch den sie identifiziert +wird. Der Name ist oft in Anführungsstriche eingeschlossen - die +Anführungsstriche gehören jedoch nicht zum Namen, sondern dienen +nur zur Abgrenzung, welche Zeichen zum Namen gehören. Der Name +ist also wie die Aufschrift auf einem Aktenordner. Wenn alle Ordner +im Schrank stehen, können Sie anhand des Namens den richtigen +Ordner finden, anderenfalls müßten Sie alle Ordner öffnen. + +#a ("Dateiarten")# Dateien werden nun für viele verschiedene Arten von +Informationen benutzt. Sie können einerseits Texte enthalten oder +auch Karteien, Grafiken, Formeln oder Zahlenkolonnen. Sie haben +bereits im ersten Kapitel den Unterschied zwischen Datenverwaltung +und Textverarbeitung kennengelernt. In diesem Zusammenhang sind +die beiden ersten Verwendungsweisen wichtig. + +#limit (12.0)# + #on("i")#Textdateien#off("i")# + sind Dateien, die normale Texte enthalten, die mit + dem Editor verändert und einfach ausgedruckt + werden können. In ihnen werden also Informationen + gespeichert, wie die Textverarbeitung sie benötigt. + + #on("i")#EUDAS-Dateien#off("i")# + sind dagegen Dateien, die Informationen in der + Form von Karteikarten enthalten. Sie haben also + die Struktur, wie sie von der Datenverwaltung be + nötigt wird. +#limit (13.5)# + + Der Computer kann aber auch alle Arten von Dateien gleich +behandeln, und zwar dann, wenn der Inhalt der Dateien nicht be +trachtet werden muß. + Ein häufiger Fall ist zum Beispiel, wenn Dateien zur Sicherung +auf eine Diskette geschrieben werden sollen. In diesem Fall genügt +die Angabe des Namens; dem Rechner ist es egal, welchen Inhalt die +Datei hat. + Anders ist es aber, wenn Sie den Inhalt betrachten wollen. +Dazu brauchen Sie dann ein Programm, das die innere Struktur der +Datei kennt. Textdateien können Sie zum Beispiel mit dem Editor +ansehen. EUDAS-Dateien müssen Sie jedoch mit EUDAS ansehen, da +der Editor die EUDAS-Struktur nicht kennt. Es ist in vielen Fällen +sinnvoll, durch einen Zusatz im Dateinamen zu kennzeichnen, ob es +sich um eine Textdatei oder eine EUDAS-Datei handelt. + +#beispiel# +#free (3.7)# + +#center#Abb. 4-1 Struktur einer EUDAS-Datei +#text# + +#a ("Terminologie")# EUDAS verwendet bestimmte Ausdrücke, um die +Strukturelemente einer EUDAS-Datei zu kennzeichnen. Die Struktur +einer EUDAS-Datei ist schematisch in Abb. 4-1 dargestellt. Die +Ausdrücke wurden nun nicht direkt aus dem Karteikartenmodell +übernommen, da es auch noch andere Modelle gibt und keine fal +schen Assoziationen auftreten sollen. + EUDAS verwendet die Bezeichnung #on("i")#Satz#off("i")# für eine Karteikarte. +Eine EUDAS-Datei besteht also aus einer Anzahl von gleichartigen +Sätzen. Zur Veranschaulichung kann man sich diese nebeneinander +gelegt vorstellen. + Jeder Satz ist unterteilt in sogenannte #on("i")#Felder#off("i")#. Ein Feld ent +spricht einem Attribut bzw. einem Eintrag auf der Karteikarte. Ein +Feld ist wiederum unterteilt in einen #on("i")#Feldnamen#off("i")# und einen #on("i")#Feldin +halt#off("i")#. + Der Feldname identifiziert ein bestimmtes Feld innerhalb eines +Satzes. Die Feldnamen sind natürlich für alle Sätze gleich. Die +Feldnamen einer EUDAS-Datei sind beliebig und können von Ihnen +selbst festgelegt werden. + Der Feldinhalt enthält die eigentliche Information des entspre +chenden Attributs. Der Feldinhalt darf ebenfalls aus beliebig vielen +Zeichen bestehen. Die Feldinhalte sind natürlich für jeden Satz +verschieden und stellen die eigentliche gespeicherte Information +dar. + +#a ("Grenzen")# Aus technischen Gründen gibt es natürlich auch einige +Beschränkungen, die hier nicht verschwiegen werden sollen. Eine +Datei kann maximal etwa 5000 Sätze enthalten, ein Satz darf aus +maximal 255 Feldern bestehen. Insgesamt kann ein Satz etwa 32000 +Zeichen umfassen. Die einzelnen Sätze in der EUDAS-Datei werden +durch ihre jeweilige Positionsnummer identifiziert, also quasi von 1 +bis 5000 durchnumeriert. + + +#abschnitt ("4.2", "EUDAS-MENÜS", "EUDAS-Menüs")# + +In den folgenden Abschnitten sollen Sie lernen, wie die Bedienung +von EUDAS funktioniert. Dazu sollen Sie eine EUDAS-Beispieldatei +von der EUDAS-Diskette in Ihr System holen. Diese Datei brauchen +Sie dann später, um die Funktionen von EUDAS zu kennenzulernen. + Die Beispieldatei hat den gleichen Inhalt wie die in Kapitel 3 +von Ihnen erstellte Datei. Falls Ihnen also die EUDAS-Archiv +diskette nicht zur Verfügung steht, können Sie in diesem Kapitel +auch jede andere Archivdiskette verwenden. + Bitte beachten Sie im folgenden, daß Sie einfache Anführungs +striche nicht mit eingeben, doppelte Anführungsstriche aber wohl. + +#a ("EUDAS-Aufruf")# Zuerst müssen Sie EUDAS aufrufen. Dazu begeben +Sie sich in die in Kapitel 3 eingerichtete Task ('continue ("arbeit")') +und geben bei 'gib kommando:' das Kommando 'eudas': + +#beispiel# + gib kommando: + #on("i")#eudas#off("i")#<RET> +#text# + +Falls Ihr System über Menüs gesteuert wird, müssen Sie eine ent +sprechende Funktion wählen. Anschließend erscheint folgendes +Menü: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + EUDAS-Datei : + O Öffnen : + - Ketten : + - Koppeln : + --------------: + Arbeitskopie : + - Sichern : + --------------: + Aktuelle Datei: + - Notizen : + - Feldstrukt. : + - Prüfbeding. : + --------------: + Mehrbenutzer : + M Manager : + --------------: + : + : + : + : + : + Akt.Datei: Manager: Datum: 22.07.87 +___________________________________________________________________________________________ +#text# + +#a ("Menüs")# Ein #on("i")#Menü#off("i")# ist eine Auswahl für einige verschiedene Funk +tionen. Die Funktionen sind jeweils benannt und werden durch einen +davorstehenden Buchstaben oder ein Minuszeichen gekennzeichnet. +Eine der Funktionen ist immer durch inverse Darstellung markiert. + Diese Markierung können Sie nun mit Hilfe der Pfeiltasten OBEN +und UNTEN verschieben. Auf diese Weise können Sie sich die ge +wünschte Funktion auswählen. Die Funktionen werden jedoch durch +das Markieren nicht ausgeführt. Sie können also beliebig mit den +Pfeiltasten herumexperimentieren. + Ausgeführt wird die markierte Funktion, wenn Sie die Leertaste +drücken. Sofort erscheint ein Stern vor dem Funktionsnamen, um +anzuzeigen, daß die Ausführung beginnt. Probieren Sie dies jetzt +nicht aus, dazu ist später Gelegenheit. + Funktionen mit einem Minuszeichen davor können Sie zwar +anwählen (markieren), aber nicht ausführen. Solche Funktionen sind +momentan gesperrt, weil ihre Ausführung keinen Sinn hat oder sogar +Fehler erzeugen würde. + Mit den Pfeiltasten LINKS und RECHTS können Sie im Menüzu +stand weitere EUDAS-Menüs abrufen. Welche Menüs zur Verfügung +stehen, zeigt Ihnen die oberste Bildschirmzeile. Das aktuelle Menü +ist jeweils invers dargestellt. + +#a ("Hilfe")# Wenn Sie nun wissen möchten, welche Bedeutung die mar +kierte Funktion hat (die Funktionsbezeichnungen sind aus Platz +gründen sehr kurz gehalten), können Sie einen #on("i")#Hilfstext#off("i")# zu dieser +Funktion abrufen. Dies erfolgt durch die Betätigung der Tasten ESC +und '?' hintereinander. Diese doppelten Tastenkombinationen mit der +ESC-Taste am Anfang werden Ihnen noch sehr häufig begegnen - +denken Sie immer daran, die Tasten hintereinander und nicht +gleichzeitig zu tippen. Der zeitliche Abstand zwischen den Tasten +drücken kann beliebig lang sein; hingegen sollten Sie eine Taste +nicht zu lange drücken, da sonst eventuell eine automatische Wie +derholfunktion Ihrer Tastatur startet. + Probieren Sie nun die Tastenkombination ESC '?' aus. Als Reak +tion erscheint in der rechten Hälfte des Bildschirms ein Text. Dieser +sollte Ihnen die gewünschten Informationen bieten. + Gleichzeitig hat sich aber auch die oberste Bildschirmzeile +verändert. Sie zeigt jetzt folgendes Bild: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + HILFE: Beenden: ESC q Seite weiter: ESC w Seite zurueck: ESC z +___________________________________________________________________________________________ +#text# + +#a ("Zustände")# Wenn Sie sich nicht im Menü befinden, fungiert die ober +ste Zeile als sogenannte #on("i")#Statuszeile#off("i")#. Diese Zeile zeigt immer an, in +welchem #on("i")#Zustand#off("i")# das Programm sich befindet. Der Zustand des Pro +gramms hat nämlich Einfluß darauf, welche Tasten Sie drücken +können und wie das Programm darauf reagiert. Die Statuszeile zeigt +daher außer dem Zustand auch die wichtigsten Tastenfunktionen. + Sie kennen jetzt also schon zwei Zustände von EUDAS: den +Menüzustand und den Hilfe-Zustand. + +#a ("Hilfe-Zustand")# Vom Menüzustand kommen Sie über die Tastenkom +bination ESC '?' in den Hilfe-Zustand. Im Hilfe-Zustand haben die +Pfeiltasten OBEN und UNTEN keine Wirkung mehr (probieren Sie dies +aus). + Ein Hilfstext besteht im allgemeinen aus mehreren Seiten. Die +erste Seite enthält dabei die speziellen Informationen, danach +folgen dann allgemeine Informationen. Mit den Tastenkombinationen +ESC 'w' und ESC 'z' können Sie zwischen den Seiten umschalten +(denken Sie daran, was oben über Tastenkombinationen gesagt +wurde). Wenn Sie dies ausprobieren, werden Sie auf der zweiten +Seite allgemeine Hinweise zur Menübedienung finden. Auf der letz +ten Seite wird ESC 'w' ignoriert, ebenso ESC 'z' auf der ersten Seite. + Mit der Tastenkombination ESC 'q' (quit) kehren Sie aus dem +Hilfezustand in den vorherigen Zustand zurück. Diese Tastenkombi +nation löst allgemein in EUDAS die Rückkehr in den alten Zustand +aus. Wenn Sie ESC 'q' getippt haben, erscheint die alte Menüzeile +und Sie können wieder Funktionen auswählen. + Der Hilfszustand läßt sich von nahezu allen (noch zu bespre +chenden) Zuständen mit ESC '?' aufrufen. Es wird jeweils ein zum +aktuellen Zustand passender Hilfstext ausgegeben. + Die möglichen Zustandsübergange sind nochmal in Abb. 4-2 +zusammengefaßt. + +#beispiel# +#free (2.5)# + +#center#Abb. 4-2 Menü- und Hilfezustand +#text# + +#a ("EUDAS verlassen")# Im Menüzustand können Sie EUDAS jederzeit +durch Tippen von ESC 'q' verlassen. Sie landen dann wieder bei 'gib +kommando:'. + + +#abschnitt ("4.3", "ARCHIVMENÜ", "Archivmenü")# + +#a ("System/Archiv")# An dieser Stelle müssen Sie sich die Begriffe #on("i")#Archiv#off("i")# +und #on("i")#System#off("i")# klarmachen. Als Archiv bezeichnet man die Möglichkeit, +bei Bedarf Disketten in Ihren Rechner einlegen können, um Dateien +(und Programme) von anderen Rechnern zu übernehmen. Um diese +Dateien bearbeiten zu können, müssen Sie sie in das System (Ihre +Festplatte oder Hintergrunddiskette) kopieren. + Die wichtigste Aufgabe des Archivs ist es, Daten vor Beschädi +gung zu sichern. Durch Fehlbedienung oder Systemfehler kann es +nämlich leicht geschehen, daß die Daten in Ihrem System verloren +gehen oder zerstört werden. Wenn Sie die Daten jedoch auf einer +Diskette gesichert und die Diskette sicher verwahrt haben, können +Sie die Daten wiederherstellen. + Es ist sehr wichtig, daß Sie Ihre Dateien auf Archivdisketten +sichern, denn ein einziger Hardwarefehler kann die Arbeit von +Jahren vernichten (Sagen Sie nicht: "Mir passiert so etwas nicht" - +bis jetzt hat es noch jeden erwischt). + +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + Dateien Archiv: + U Übersicht : + D Üb. Drucken : + --------------: + Datei : + K Kopieren : + vom Archiv : + S Schreiben : + auf Archiv : + L Löschen : + auf Archiv : + --------------: + Archivdiskette: + I Init : + --------------: + Z Zielarchiv : + P Paßwort : + - Reservieren : + --------------: + : + : + Akt.Datei: Ziel: "ARCHIVE" Datum: 22.07.87 +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 4-3 Archivmenü +#text# + +#a ("Archivmenü")# Wenn Sie EUDAS aufrufen, befinden Sie sich immer im +ersten Menü. Sie benötigen jedoch jetzt Funktionen aus dem sech +sten Menü 'Archiv'. Wählen Sie dieses Menü jetzt an. Es erscheint +das in Abb. 4-3 dargestellte Bild. Die Funktionen in diesem Menü +befassen sich mit beliebigen Dateien auf dem Archiv. + Für den Versuch legen Sie bitte die EUDAS-Archivdiskette ein. +Dann wählen Sie die Funktion 'Übersicht' in dem Menü an, wenn sie +nicht schon markiert ist. Sie können nun die ausgewählte Funktion +durch Tippen der Leertaste ausführen. + In der obersten Zeile erscheint nun der Hinweis 'Bitte war +ten..'. Er zeigt an, daß nun eine Funktion ausgeführt wird, bei der +Sie zunächst nichts tun können. Sie sollten in diesem Zustand keine +Tasten drücken, denn EUDAS kann nicht darauf reagieren. + +#a ("Archivübersicht")# Nach einer mehr oder minder langen Aktivitäts +phase Ihres Diskettenlaufwerks erscheint dann die Archivübersicht. +Das Erscheinungsbild mit dem markierten Editorbalken in der ober +sten Zeile kommt Ihnen vielleicht bekannt vor. Sie haben nämlich +nichts anderes als das EUMEL-Kommando 'list (archive)' ausgeführt. +Neu ist lediglich die Statuszeile: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + ZEIGEN: Blättern: HOP OBEN, HOP UNTEN Beenden: ESC q Hilfe: ESC ? +___________________________________________________________________________________________ +#text# + +Wenn Sie sich die Übersicht angeschaut haben, verlassen Sie den +Editor wieder mit ESC 'q'. + Beachten Sie, daß Sie unter EUDAS das Archiv nicht extra an +melden müssen; dies geschieht automatisch, wenn Sie eine Funktion +aufrufen. Bei Leseoperationen müssen Sie nicht einmal den Archiv +namen wissen. Das Archiv wird automatisch wieder abgemeldet, +wenn Sie das Archivmenü verlassen. + +#a ("Archiv lesen")# Unter den in der Übersicht aufgelisteten Dateien +sollten Sie auch die Datei finden, die Sie brauchen. Sie heißt +'Adressen'. An dieser Stelle ein kleiner Hinweis: An vielen Stellen +werden Sie sehen, daß Dateinamen in Anführungsstriche einge +schlossen sind. Die Anführungsstriche gehören jedoch #on("i")#nicht#off("i")# zum +Namen. Sie dienen nur zur Abgrenzung, da in Dateinamen beliebige +Zeichen erlaubt sind. Wenn Sie aufgefordert werden, einen Datei +namen einzugeben, müssen Sie dies immer ohne Anführungsstriche +tun. + Hoffentlich haben Sie in der ganzen Diskussion nicht das Ziel +aus den Augen verloren: Sie sollten eine Datei ins System holen, um +nachher mit ihr zu experimentieren. Zu diesem Zweck gibt es im +Archivmenü die Funktion +#free (0.2)# +#beispiel# + K Kopieren + (vom Archiv) +#text# +#free (0.2)# +Wählen Sie diese Funktion jetzt mit den Pfeiltasten aus und drücken +Sie zum Ausführen die Leertaste. + +#a ("Eingabezustand")# Nach kurzem 'Bitte warten..'-Zustand werden Sie +im rechten Bildschirmteil nach dem Namen der Datei gefragt. Gleich +zeitig erscheint eine neue Statuszeile. Es ergibt sich folgendes Bild: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EINGABE: Bestätigen: RETURN Zeigen: ESC z Abbrechen: ESC h Hilfe: ESC ? + --------------:Dateiname: + Dateien Archiv: + U Übersicht : + D Üb. drucken : + --------------: + Datei : + * Kopieren : + vom Archiv : + ... + +___________________________________________________________________________________________ +#text# + +Sie können in diesem Zustand den Namen der gewünschten Datei +eingeben. Außer den in der Statuszeile genannten Funktionen kön +nen Sie die aus dem Editor bekannten Tasten benutzen, um den +Text in der Zeile gegebenenfalls zu korrigieren (Pfeiltasten LINKS +und RECHTS, RUBOUT, RUBIN). Die Schreibmarke (Cursor) zeigt Ihnen +an, wo das nächste Zeichen plaziert wird. + +#a ("Abbruch")# Eine Tastenkombination verdient noch besondere Beach +tung: Mit ESC 'h' können Sie in vielen Situationen eine Funktion +noch abbrechen - zum Beispiel wenn Sie irrtümlich die falsche +Funktion gewählt haben. + Im Gegensatz zu ESC 'q' erfolgt hier die sofortige Rückkehr aus +der Funktion ins Menü, möglichst ohne daß die Funktion Auswir +kungen hinterläßt. Bei einem Abbruch bleibt also in der Regel das +System unverändert. + +#a ("Fehlerzustand")# Um auch die Fehlerbehandlung von EUDAS auszu +probieren, sollten Sie hier einen falschen Namen eingeben, zum +Beispiel: +#free (0.2)# +#beispiel# + Dateiname: #on("i")#Adresen#off("i")#<RET> +#text# +#free (0.2)# +EUDAS sucht jetzt auf der Diskette nach einer Datei dieses Namens, +findet sie aber nicht. Als Reaktion erscheint dann die Meldung: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + !!! FEHLER !!! Quittieren: ESC q Hilfe zur Meldung: ESC ? + --------------:Dateiname: Adresen + Dateien Archiv:>>> "Adresen" gibt es nicht + U Übersicht : + D Üb. drucken : + --------------: + ... + +___________________________________________________________________________________________ +#text# + +Im Normalfall sollten Sie die Fehlermeldung mit ESC 'q' quittieren, +damit Sie den Befehl erneut versuchen können. Auch hier haben Sie +die Möglichkeit, eine besondere Information zu dem Fehler abzurufen +(es liegen jedoch nicht für alle möglichen Fehler spezielle Texte +vor). + Nach dem Quittieren des Fehlers befinden Sie sich wieder im +Menüzustand. Wiederholen Sie jetzt die Funktion, indem Sie die +Leertaste tippen. Sie werden dann erneut nach dem Namen gefragt. + +#a ("Auswahlzustand")# Um endlich ans Ziel zu kommen, benutzen Sie +diesmal eine sehr komfortable Abkürzung, die EUDAS Ihnen bietet. +Durch Drücken von ESC 'z' können Sie sich nämlich alle möglichen +Namen anzeigen lassen und den gewünschten einfach ankreuzen. + Anschließend sieht der Bildschirm wie in Abb. 4-4 aus. In die +sem Zustand können Sie mit den Pfeiltasten den Cursor zur ge +wünschten Datei bewegen und diese ankreuzen. Da Sie auch meh +rere Dateien in beliebiger Folge ankreuzen können, erscheint eine +'1' vor der Datei zur Anzeige der Reihenfolge. Sie wollen aber nur +diese eine Datei 'Adressen' holen und beenden die Auswahl daher +mit ESC 'q'. Wenn alles glattgeht, wird jetzt die Datei vom Archiv +ins System kopiert. + +#a ("Archiv schreiben")# Auf nahezu gleiche Weise können Sie mit der +Funktion +#f2# +#beispiel# + S Schreiben + auf Archiv +#text# +#f2# +eine Datei wieder auf die Diskette schreiben. Als erstes müssen Sie +dann den Namen der Archivdiskette eingeben, damit Sie nicht aus +Versehen auf eine falsche Archivdiskette schreiben. + Auch hier können Sie die gewünschten Dateien ankreuzen (na +türlich bietet EUDAS dann die Dateien des Systems an). Sie brau +chen keine Angst zu haben, aus Versehen eine Datei mit gleichem +Namen zu überschreiben - EUDAS fragt in solchen Fällen immer +nochmal an. + +#bildschirm# +___________________________________________________________________________________________ + + AUSWAHL: Ankreuzen: 'x' Durchstreichen: 'o' Beenden: ESC q Hilfe: ESC ? + --------------:-------------------------------------------------------------- + Dateien Archiv: Auswahl der Dateien auf dem Archiv. + U Übersicht : Gewuenschte Datei(en) bitte ankreuzen: + D Üb. Drucken :-------------------------------------------------------------- + --------------: o "eudas.1" + Datei : o "eudas.2" + * Kopieren : o "eudas.3" + vom Archiv : o "eudas.4" + S Schreiben : o "eudas.init" + auf Archiv : o "eudas.generator" + L Löschen : o "Adressen" + auf Archiv :-------------------------------------------------------------- + --------------: + Archivdiskette: + I Init : + --------------: + Z Zielarchiv : + P Paßwort : + - Reservieren : + --------------: + : + : + Akt.Datei: Ziel: "ARCHIVE" Datum: 22.07.87 +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 4-4 Dateiauswahl +#text# + + +#abschnitt ("4.4", "DATEIVERWALTUNG", "Dateiverwaltung")# + +So: nach dieser anstrengenden Arbeit sollen Sie sich überzeugen, +daß die Datei 'Adressen' nun wirklich im System zur Verfügung +steht. Dazu gehen Sie mit LINKS ein Menü zurück. Dieses Menü +beschäftigt sich mit Dateien im System und ist in Abb. 4-5 gezeigt. + Auch hier finden Sie eine Funktion "Übersicht". Rufen Sie diese +auf. Ganz analog zum Archiv erscheint eine Übersicht aller Dateien +im Editor. Verlassen Sie die Übersicht wieder mit ESC 'q'. +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + Dateien System: + U Übersicht : + --------------: + Datei : + L Löschen : + N Umbenennen : + K Kopieren : + P Platzbedarf : + A Aufräumen : + --------------: + : + : + : + : + : + : + : + : + : + : + : + Akt.Datei: Task: "arbeit" Datum: 22.07.87 +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 4-5 Menü 'Dateien' +#text# + +#a ("Datei löschen")# Eine weitere Funktion aus diesem Menü werden Sie +ebenfalls noch öfter brauchen, nämlich +#free (0.2)# +#beispiel# + L Löschen +#text# +#free (0.2)# +Mit dieser Funktion können Sie eine Datei wieder aus dem System +entfernen - zum Beispiel wenn Sie sich die Adressen angesehen +haben und danach den Speicherplatz nicht weiter verschwenden +wollen. Als letztes Beispiel sollen Sie auch diese Funktion aufrufen +(keine Angst, wir löschen die Datei nicht wirklich, es gibt vorher +noch eine Notbremse). + +#a ("Fragezustand")# Als erstes werden Sie wieder nach dem Dateinamen +gefragt (dies ist Ihnen schon bekannt). Hier haben Sie jetzt die +Wahl, ob Sie den Namen eingeben oder mit ESC 'z' ankreuzen. Da das +Löschen unwiederbringlich ist, werden Sie anschließend zur Sicher +heit gefragt, ob Sie die Datei wirklich löschen wollen: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + FRAGE: Bejahen: j,J Verneinen: n,N Abbrechen: ESC h Hilfe: ESC ? + --------------:Dateiname: Adressen + Dateien System:"Adressen" im System loeschen (j/n) ? + U Übersicht : + --------------: + ... + +___________________________________________________________________________________________ +#text# + +Diese Frage können Sie bejahen oder verneinen (oder die Funktion +ohne Auswirkungen abbrechen). In diesem Fall sollten Sie die Frage +verneinen - es sei denn, Ihnen hat das Spielen mit EUDAS so gut +gefallen, daß Sie die ganze Prozedur wiederholen und die Datei +nochmal vom Archiv holen wollen. + + +#abschnitt ("4.5", "BEDIENUNGSREGELN", "Bedienungsregeln")# + +Mit dieser letzten Demonstration haben Sie jetzt schon fast alle +Arten des Umgangs mit EUDAS kennengelernt. Sicher ist dies beim +ersten Mal sehr verwirrend. Mit vier Regeln können Sie jedoch +EUDAS immer bedienen: + +#limit (12.0)# + 1. Achten Sie darauf, welche möglichen Tastendrücke + in der Statuszeile stehen. Richten Sie sich danach! +#free (0.2)# + 2. Sind Sie sich unsicher, rufen Sie Hilfsfunktion mit + ESC '?' auf. Damit erhalten Sie weitere Informatio + nen. +#free (0.2)# + 3. Funktioniert diese Tastenkombination nicht (geben + Sie dem Rechner eine kurze Zeit zum Reagieren), + versuchen Sie die Tastenkombinationen ESC 'h' (Ab + bruch) oder ESC 'q' (Verlassen). Falls sich daraufhin + etwas verändert, fangen Sie wieder mit 1. an. +#free (0.2)# + 4. Erfolgt darauf keine Reaktion, drücken Sie die SV- + Taste und versuchen Sie das Programm mit 'halt' zu + stoppen. Führt auch das nicht zum Erfolg, hat sich + Ihr Rechner "aufgehängt". Sie müssen den Rechner + dann neu starten. Wenn Sie keine Erfahrung mit + einer solchen Situation haben, wenden Sie sich an + Ihren Händler oder Systembetreuer. +#limit (13.5)# + +Im Zusammenhang mit dem letzten Punkt sei nochmal auf die Wich +tigkeit einer regelmäßigen Datensicherung auf Archivdisketten +hingewiesen. Im Normalfall sollten Sie aber mit den Punkten 1 bis 3 +zurechtkommen. + +#a ("Zustände")# Im letzten Abschnitt haben Sie eine ganze Reihe von +Zuständen kennengelernt, die EUDAS einnehmen kann. In jedem +Zustand haben Sie verschiedene Möglichkeiten zur Reaktion. Glück +licherweise erscheinen diese Möglichkeiten zum großen Teil in der +Statuszeile. + Damit Sie die verwirrenden Erfahrungen des letzten Abschnitts +etwas ordnen können, wollen wir an dieser Stelle die verschiedenen +Zustände noch einmal zusammenfassen. Der Beschreibung vorange +stellt ist die jeweilige Kennzeichnung am Beginn der Statuszeile. + +#bsp ("EUDAS:")# Menüzustand. Sie können Menü und Funktion mit den Pfeil + tasten anwählen und eine Funktion durch Tippen der Leertaste + ausführen. ESC '?' gibt Hilfestellung zu jeder Funktion. ESC 'q' + beendet EUDAS. + +#bsp ("HILFE:")# Sie können mit ESC 'w' und ESC 'z' im Hilfstext blättern. Mit + ESC 'q' kommen Sie in den alten Zustand. + +#bsp ("AUSWAHL:")# Hier können Sie die gewünschten Namen mit 'x' ankreuzen + und mit 'o' wieder entfernen. Normales Beenden mit ESC 'q'. + Hilfestellung durch ESC '?'. Abbruch der gesamten Funktion mit + ESC 'h'. + +#bsp ("EINGABE:")# Hier können Sie eine einzelne Zeile eingeben oder ändern + (wie im Editor). Einfügen und Löschen mit RUBIN und RUBOUT. + Abbruch und Hilfestellung möglich. + +#bsp ("FRAGE:")# Beantworten Sie die gestellte Frage mit 'j' oder 'n'. Abbruch + (ESC 'h') und Hilfestellung (ESC '?') möglich. + +#bsp ("ZEIGEN:")# Mit HOP OBEN und HOP UNTEN können Sie in der Übersicht + blättern. Ende der Übersicht mit ESC 'q'. Hilfestellung möglich. + +#bsp ("!!! FEHLER !!!")# Quittieren Sie die Meldung mit ESC 'q'. Hilfestellung + möglich. + +#bsp ("Bitte warten..")# In diesem Zustand keine Taste drücken, der Rechner + ist beschäftigt. + +Drei weitere Zustände, die Sie noch nicht kennengelernt haben, sind +hier schon mal der Vollständigkeit halber aufgeführt: + +#bsp ("SATZ ÄNDERN:")# +#bsp ("SATZ EINFÜGEN:")# +#bsp ("SUCHMUSTER EINGEBEN:")# Satzeditor zum Eingeben von Feldinhalten. + Normales Verlassen mit ESC 'q'. Abbruch und Hilfestellung mög + lich. Beschreibung s. 6.2. + +#bsp ("EDITIEREN:")# EUMEL-Editor mit Änderungsmöglichkeit für beliebige + Texte. Normales Verlassen mit ESC 'q'. Hilfestellung möglich. + Beschreibung der Möglichkeiten siehe EUMEL-Benutzerhand + buch. + +#bsp ("Gib Kommando:")# Hier können Sie ein beliebiges ELAN-Kommando ein + geben und mit RETURN bestätigen. Abbruch und Hilfestellung + möglich. Kann im Menü durch ESC ESC aufgerufen werden. + +Wie Sie sehen, werden auch hier wieder die gleichen Tastenkombi +nationen verwendet, die Sie schon kennen. + In dieser Übersicht sind jeweils nur die wichtigsten Tastenkom +binationen aufgeführt. Informieren Sie sich gegebenenfalls mit ESC +'?'. Einige weitere Tastenfunktionen werden Sie im folgenden noch +kennenlernen. Eine vollständige Übersicht finden Sie im Referenz +handbuch. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.5 b/app/eudas/4.4/doc/user-manual/eudas.hdb.5 new file mode 100644 index 0000000..f3abc69 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.5 @@ -0,0 +1,373 @@ +#type ("prop")##limit (14.0)# +#format# +#page (43)# +#kapitel ("5", "Gespeicherte", "Daten", "abfragen")# + + + +#abschnitt ("5.1", "ÖFFNEN", "Öffnen")# + +Als letzte Vorbereitung, bevor Sie mit der Adreßdatei spielen kön +nen, müssen Sie die Datei wie einen Karteikasten #on("i")#öffnen#off("i")#. Nach dem +Öffnen beziehen sich alle weiteren Funktionen auf die gerade ge +öffnete Datei. Aus diesem Grund darf auch immer nur eine einzige +Datei geöffnet sein - als hätte auf Ihrem Schreibtisch nur ein Kar +teikasten Platz. + Dazu wählen Sie jetzt wieder das erste Menü an. Dort finden +Sie die Funktion +#free (0.2)# +#beispiel# + O Öffnen +#text# +#free (0.2)# +Wählen Sie diese Funktion aus. Dann drücken Sie die Leertaste, um +die Funktion auszuführen. Als erstes erscheint im unteren Teil des +Bildschirms eine Frage: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Wollen Sie etwas aendern (eine Arbeitskopie anlegen) (j/n) ? +___________________________________________________________________________________________ +#text# + +Der Cursor bleibt hinter der Frage stehen. Sie kennen diesen Frage +zustand ja schon. + In diesem Fall wollen Sie an der Spieldatei nichts verändern, +Sie beantworten die Frage also mit einem 'n'. Als nächstes werden +Sie nach dem Namen gefragt (Beachten Sie auch hier wieder die +Statuszeile). + Tippen Sie nun 'Adressen' und beenden Sie die Eingabe mit +RETURN. EUDAS öffnet die Datei und kehrt zum Menü zurück. Alter +nativ können Sie die Datei auch in einer Auswahl ankreuzen, wenn +Sie ESC 'z' tippen. + +#a ("Fußzeile")# Nach der Ausführung dieser Funktion sollten Sie Ihre +Aufmerksamkeit auf die letzte Zeile des Bildschirms richten. Hier +finden Sie jetzt folgendes vor: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Akt.Datei: "Adressen" Manager: Datum: 22.07.87 +___________________________________________________________________________________________ +#text# + +Neben dem Datum und dem eingestellten Manager (dies kommt viel +später) sehen Sie hier, welche Datei Sie geöffnet haben und nun +bearbeiten können. Diese Fußzeile finden Sie auch in den ande +ren Menüs. Lediglich die mittlere Angabe ändert sich bei den ande +ren Menüs (eine Erläuterung dazu finden Sie in späteren Kapiteln). + +#a ("Anzeige")# Zum Anzeigen der Daten in der Adreßdatei müssen Sie das +zweite Menü 'Einzelsatz' anwählen (durch Drücken der Pfeiltaste +RECHTS). Am linken Rand erscheint das neue Menü mit den Anzei +gefunktionen. Der Rest des Bildschirms enthält das Formular für die +Adreßdatei mit den Daten des ersten Satzes. Abbildung 5-1 zeigt +das Bild, das sich dann ergibt. +#f2# +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: Satz 1 ................... Adressen ....... Zeile 1 + Positionieren : Name Wegner + W Weiter : Vorname Herbert + Z Zurück : PLZ 5000 + N Satz.Nr : Ort Köln + --------------: Strasse Krämergasse 12 + Suchbedingung : m/w m + S Setzen : ........................................................... + L Löschen : + M Markierung : + --------------: + Datensatz : + - Einfügen : + - Ändern : + - Tragen : + - Holen : + --------------: + F Feldauswahl : + --------------: + : + : + : + +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 5-1 Menü 'Einzelsatz' +#text# + +Das automatisch generierte Formular zeigt immer genau einen Satz. +Das Formular besteht aus drei Teilen: der Überschrift, dem Feldteil +und der Abschlußzeile. In der #on("i")#Überschrift#off("i")# steht der Name der Datei +("Adressen"), die Satznummer (1) und die Nummer der ersten ange +zeigten Zeile (immer 1, außer wenn die Datei mehr Felder hat, als +auf den Bildschirm passen). In manchen Fällen können auch noch +weitere Informationen dort auftauchen, wie wir später sehen wer +den. + Im #on("i")#Feldteil#off("i")# befindet sich der eigentliche Inhalt, und zwar sind +links markiert die Feldnamen zu sehen, während rechts die zugehö +rigen Inhalte des betreffenden Satzes stehen. Dieses Bild ähnelt +einer Karteikarte mit einem festen Format. + Die #on("i")#Abschlußzeile#off("i")# am Ende gibt an, daß für diesen Satz keine +weiteren Informationen mehr vorhanden sind. Wir werden aber spä +ter noch sehen, wie man anderenfalls die restlichen Informatio +nen sichtbar machen kann. + + +#abschnitt ("5.2", "BEWEGEN", "Bewegen")# + +Nun wollen Sie nicht immer nur einen Satz betrachten (das wäre ja +furchtbar langweilig). Daher müssen Sie die Möglichkeit haben, sich +in der Datei zu "bewegen". Dies geschieht mit Hilfe der beiden +Funktionen +#free (0.2)# +#beispiel# + W Weiter +#text# +#free (0.2)# +und +#free (0.2)# +#beispiel# + Z Zurück +#text# +#free (0.2)# +Sie haben die Wirkung, daß der Satz mit der nächsthöheren bzw. +nächstniedrigeren Satznummer angezeigt wird. Natürlich funktioniert +dies nur, wenn noch ein Satz vorhanden ist: am Anfang (Satz 1) +können Sie nicht zurückgehen. In diesem Fall ignoriert EUDAS Ihren +Befehl einfach. + Wenn Sie bis zum Ende der Datei gehen (keine Angst - diese +Datei enthält nur 10 Sätze), werden Sie feststellen, daß zum Schluß +ein ganz leerer Satz erscheint. Dieser Satz ist eine Art Endemarkie +rung; er informiert Sie, daß keine weiteren Sätze vorhanden sind. +Dieser Satz ist aber kein richtiger Satz, daher wird in der Über +schrift 'ENDE' angezeigt. (Wenn Ihnen diese Art Endemarkierung +merkwürdig erscheint: sie hat schon einen triftigen Grund, s.6.2). + Um einen Satz mit bekannter Satznummer gezielt anzuwählen, +können Sie die Funktion +#free (0.2)# +#beispiel# + N Satz.Nr +#text# +#free (0.2)# +verwenden. Sie müssen anschließend die Satznummer eingeben (Bitte +mit RETURN beenden). Ist der Satz vorhanden, erscheint dieser, +ansonsten stehen Sie am Ende der Datei. + +#a ("Aufruf über Buchstaben")# Vielleicht ist Ihnen inzwischen schon +aufgefallen, daß vor jeder Funktion in einem Menü ein Buchstabe +steht. Damit hat es folgendes auf sich: da das Positionieren des +Cursors zum Auswählen einer Funktion mehrere Tastendrücke erfor +dern kann, haben Sie die Möglichkeit, jede Funktion auch über +einen Buchstaben auszuführen. + Dies ist besonders dann sinnvoll, wenn Sie mit den eben be +sprochenen Funktionen schnell in der Datei "blättern" wollen. An +dererseits müssen Sie sich aber für eine schnelle Reaktion auch +einige der Tasten merken. Für die Praxis empfiehlt sich folgender +Kompromiß: die meistgebrauchten Funktionen über Buchstaben und +der Rest durch Positionieren im Menü. + + +#abschnitt ("5.3", "SUCHEN", "Suchen")# + +Stellen Sie sich vor, die Datei wäre größer und Sie müßten eine +bestimmte Adresse heraussuchen. Dazu würden Sie durch die ganze +Datei durchgehen, bis die gewünschte Adresse erscheint. Das wäre +natürlich bei vielen Adressen eine ungeheuer mühselige Arbeit, die +mit einem Karteikasten wahrscheinlich schneller zu erledigen wäre. + EUDAS bietet Ihnen jedoch die Möglichkeit, nach bestimmten +Sätzen zu suchen. Dazu müssen Sie angeben, wonach gesucht werden +soll. Als Beispiel wollen wir die Adresse von Frau Simmern su +chen. Bewegen Sie sich zunächst zurück bis auf den ersten Satz. +Dann wählen Sie die Funktion +#free (0.2)# +#beispiel# + Suchbedingung + S Setzen +#text# +#free (0.2)# +Auf dem Bildschirm verschwinden die Feldinhalte und der Cursor +steht hinter dem ersten Feldnamen. Dies bedeutet, daß Sie neben +die Feldnamen etwas schreiben können. Auch in der Statuszeile +erscheint statt der Anzeige der Menünamen ein Hinweis auf die +Eingabemöglichkeit (s. Abb. 5-2). Sie befinden sich jetzt in einem +Zustand, in dem Sie hinter die Feldnamen etwas schreiben können +(dem sogenannten #on("i")#Satzeditor#off("i")#). + Als Angabe, was gesucht werden soll, schreiben Sie jetzt in der +ersten Zeile neben 'Name' die Bedingung 'Simmern'. Sie haben jetzt +ein einfaches #on("i")#Suchmuster#off("i")# angegeben. Ein Suchmuster besteht aus +Bedingungen, die neben die Feldnamen geschrieben werden. Unser +einfaches Suchmuster lautet übersetzt: + + Wähle alle Sätze aus, bei denen 'Simmern' im Feld 'Name' + steht. + +Beenden Sie die Eingabe des Suchmusters mit ESC 'q'. Es erscheint +wieder das vorherige Bild, mit dem Unterschied, daß jetzt in der +Überschrift ein 'SUCH-' auftaucht. EUDAS steht immer noch auf dem +ersten Satz. + Die Anzeige 'SUCH' gibt an, daß ein Suchmuster eingestellt +wurde. Das Minuszeichen bedeutet, daß der aktuelle Satz die Such +bedingung jedoch #on("i")#nicht#off("i")# erfüllt. + +#bildschirm# +___________________________________________________________________________________________ + + SUCHMUSTER EINGEBEN: Abbruch: ESC h Beenden: ESC q Hilfe: ESC ? + --------------: Satz 1 .................... ............... Zeile 1 + Positionieren : Name Simmern + W Weiter : Vorname + Z Zurück : PLZ + N Satz.Nr : Ort + --------------: Strasse + Suchbedingung : m/w + * Setzen : ........................................................... + L Löschen : + M Markierung : + --------------: + Datensatz : + - Einfügen : + - Ändern : + - Tragen : + - Holen : + --------------: + F Feldauswahl : + --------------: + : + : +___________________________________________________________________________________________ + +#beispiel# +#center#Abb. 5-2 Eingabe eines Suchmusters +#text# + +#a ("Positionierung")# Das Suchen beginnt erst, wenn Sie sich in der Datei +bewegen. In diesem Fall erhalten die Funktionen 'Satz weiter' und +'Satz zurück' eine etwas geänderte Bedeutung. Sie gehen nämlich +nicht einfach zum nächsten bzw. vorigen Satz, sondern zum näch +sten bzw. vorigen #on("i")#ausgewählten#off("i")# Satz. + Als Indikator, daß Sie sich auf dem gesuchten Satz befinden, +dient die Anzeige 'SUCH+'. Probieren Sie dies jetzt aus, indem Sie +weitergehen. Als nächster Satz erscheint der gewünschte Satz 7. Die +nicht ausgewählten Sätze wurden also übersprungen. Das gleiche +passiert, wenn Sie noch weiter gehen. Da kein passender Satz mehr +vorhanden ist, erscheint der leere Endesatz. + +#limit (12.0)# + Denken Sie daran, daß das Einstellen der Suchbedingung + noch keine Suche bewirkt. Diese müssen Sie selbst + durch Positionieren mit 'Weiter' oder 'Zurück' auslösen. +#limit (13.5)# + +Sollten Sie sich nicht am Anfang der Datei befinden, wenn Sie eine +Suchbedingung einstellen, kann es sein, daß sich der gesuchte Satz +vor oder hinter der aktuellen Position befindet. In diesem Fall +müssen Sie entscheiden, ob Sie vorwärts oder rückwärts gehen. +Wenn Sie rückwärts gehen und der Satz ist nicht in diesem Ab +schnitt, erscheint der erste Satz mit der Anzeige 'SUCH-'. Gehen Sie +dann wieder vorwärts, finden Sie den Satz auf jeden Fall. + Die Funktion 'Satz.Nr' richtet sich natürlich nicht nach der +eingestellten Bedingung, da Sie ja eine bestimmte Satznummer wün +schen. Aus der 'SUCH'-Anzeige können Sie jedoch entnehmen, ob +die Suchbedingung auf diesen Satz zutrifft. + +#a ("Suchbedingung löschen")# Wollen Sie wieder alle Sätze sehen, müssen +Sie die Funktion +#free (0.2)# +#beispiel# + Suchbedingung + L Löschen +#text# +#free (0.2)# +auswählen. Die Anzeige 'SUCH' verschwindet wieder, um anzudeu +ten, daß keine Suchbedingung mehr eingestellt ist. + +#a ("Beispiel")# Um den Charakter einer Selektion nochmal deutlich zu +machen, sollen Sie jetzt eine Bedingung einstellen, die auf mehrere +Sätze zutrifft. Dies hätte uns auch eben passieren können, wenn es +mehrere Simmern gegeben hätte. Wir können zum Beispiel alle weib +lichen Personen auswählen. + Als erstes löschen Sie die alte Suchbedingung. Tun Sie dies +nicht, wird Ihnen beim nächsten Eingeben das alte Suchmuster zum +Ändern angeboten. Dies ist praktisch, wenn ein Suchmuster nicht +den erhofften Erfolg brachte und Sie es modifizieren wollen. + Danach wählen Sie erneut die Funktion 'Suchbedingung setzen'. +Nun bewegen Sie den Cursor mit der Pfeiltaste UNTEN neben den +Feldnamen 'm/w'. Dort tragen Sie die Bedingung 'w' ein. Verlassen +Sie die Eingabe mit ESC 'q'. + Wenn Sie sich jetzt in der Datei bewegen, sehen Sie, daß immer +nur weibliche Personen angezeigt werden - die männlichen werden +unterdrückt (in Umkehrung der Realität). + +#beispiel# + ! 1 ! ! 3 ! 4 ! ! 6 ! + +-----+-----+-----+-----+-----+-----+-----+ + !Name ! .. ! ! .. ! .. ! ! .. ! + ! ! ! ! ! ! ! ! + : : : : : + ! ! ! ! ! ! ! ! + !m/w ! w ! ! w ! w ! ! w ! + +-----+-----+ +-----+-----+ +-----+ + +#center#Abb. 5-3 Wirkung einer Selektion +#text# + + +#abschnitt ("5.4", "SUCHBEDINGUNGEN", "Suchbedingungen")# + +Im letzten Abschnitt haben Sie gesehen, wie das Einstellen einer +Suchbedingung funktioniert. In diesem Abschnitt sollen Sie weitere +Möglichkeiten zur Formulierung von Suchmustern kennenlernen. + Die erste Möglichkeit kennen Sie schon. Wenn neben einen +Feldnamen ein Text geschrieben wird, bedeutet dies, daß ausge +wählte Sätze im Inhalt dieses Feldes mit dem Text übereinstimmen +müssen. + +#a ("Kombination")# Nun kann es sein, daß mehrere Bedingungen gelten +müssen. Im ersten Beispiel des vorigen Abschnitts hätten wir zum +Beispiel auch noch den Vornamen 'Anna-Maria' angeben können, um +bei mehreren Simmern die richtige auszuwählen. Wird also in mehre +re Felder eine Bedingung geschrieben, müssen alle diese Bedingun +gen gleichzeitig zutreffen. + Würden Sie in unserem Beispiel noch als dritte Bedingung 'm' +für das Feld 'm/w' angeben, würde gar kein Satz mehr ausgewählt, +da Anna-Maria Simmern natürlich nicht männlich ist. Auch das +kann also passieren. + +#beispiel# + Name Simmern + Vorname Anna-Maria + .. + .. + m/w m + +#center#Abb. 5-4 Kombination von Bedingungen +#text# + +#a ("Stern")# Die Bedingungen, die wir bis jetzt kennengelernt haben, +müssen alle ganz exakt zutreffen. Häufig tritt aber der Fall auf, +daß der gesuchte Name nicht genau bekannt ist. In diesem Fall +kann der Name im Suchmuster auch teilweise eingegeben werden. +Der unbekannte Teil am Anfang oder am Ende wird einfach durch +einen Stern markiert. + Wenn Sie also als Bedingung #bsp ("'Sim*'")# für den Namen angeben, so +würde dies auf den Namen Simmern zutreffen, aber zum Beispiel +auch auf Simmerath oder Simon. Die Bedingung #bsp("'*mern'")# würde nicht +nur auf Simmern zutreffen, sondern auch auf Pommern. + Der Stern kann aber auch für einen leeren Text stehen. So +trifft #bsp("'Simmern*"')# auf Simmern zu, aber auch auf Doppelnamen. die +mit Simmern beginnen. Wissen Sie jetzt nicht, ob Simmern in dem +Doppelnamen vorne oder hinten erscheint, können Sie auch an bei +den Seiten einen Stern machen. Die Bedingung #bsp("'*Simmern*'")# trifft +nicht nur auf Simmern, sondern sowohl auf Deckerath-Simmern als +auch auf Simmern-Jakob zu. + Es gibt noch eine Reihe von weiteren Möglichkeiten, Bedingun +gen im Suchmuster zu formulieren. Auch komplexe Kombinationen +von Bedingungen sind möglich. Mit dem bisher Besprochenen sollten +Sie aber in vielen Fällen auskommen. Die übrigen Möglichkeiten +werden in Abschnitt 10.2 erklärt. Schauen Sie bei Bedarf dort nach. + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.6 b/app/eudas/4.4/doc/user-manual/eudas.hdb.6 new file mode 100644 index 0000000..fc752a1 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.6 @@ -0,0 +1,382 @@ +#type ("prop")##limit (14.0)# +#format# +#page (51)# +#kapitel ("6", "Daten", "eingeben und", "ändern")# + + + +#abschnitt ("6.1", "NEUE DATEI EINRICHTEN", "Neue Datei einrichten")# + +Nachdem Sie sich bis jetzt an einer existierenden Datei erprobt +haben, können Sie nun dazu übergehen, eine eigene neue Datei +einzurichten. Als Beispiel sollen Sie ein kleines Telefonregister +erstellen. + Dazu gehen Sie wieder in das Menü 'Öffnen' zurück und wäh +len erneut die Funktion +#free (0.2)# +#beispiel# + O Öffnen +#text# +#free (0.2)# +indem Sie mehrmals OBEN tippen, bis die Funktion markiert. Dann +tippen Sie die Lerrtaste zum Ausführen. Als Dateinamen geben Sie +'Telefonnummern' an. + Da die Datei 'Telefonnummern' noch nicht existiert, werden Sie +gefragt: +#f2# +#beispiel# + "Telefonnummern" neu einrichten ? (j/n) #on("i")#j#off("i")# +#text# +#f2# +Es kann ja sein, daß Sie sich vertippt haben und eine andere, +existierende Datei meinten. In unserem Fall wird die Datei aber +wirklich neu eingerichtet, daher bejahen Sie die Frage. + +#a ("Feldnamen eingeben")# Wenn Sie beim Öffnen eine Datei neu einrich +ten, müssen Sie zuerst die Feldnamen festlegen, zum Beispiel diese: + +#beispiel# + 'Name' + 'Vorname' + 'Strasse' + 'PLZ' + 'Ort' + 'Telefon' + 'Bemerkungen' +#text# + +Ihnen wird jetzt Gelegenheit gegeben, die Feldnamen untereinander +einzugeben. Zur Korrektur können Sie die gleichen Tasten verwen +den wie im Editor (beachten Sie dazu die Statuszeile am oberen +Bildschirmrand. + Geben Sie die Namen in dieser Reihenfolge ein. Tippen Sie nach +jedem Namen die RETURN-Taste, damit der nächste Name in eine +neue Zeile kommt. Beenden Sie die Eingabe mit ESC 'q'. + Die folgende Frage ermöglicht es Ihnen, noch weitere Eigen +schaften der Felder festzulegen. Dies ist jedoch im Normalfall nicht +nötig. Beantworten Sie also die Frage mit 'n'. Ihre Datei ist nun +eingerichtet. + Wie Sie sehen, besteht das Einrichten einer Datei eigentlich +nur aus der Eingabe der Feldnamen. Wenn Sie später noch Felder +anfügen wollen, ist dies ohne weiteres möglich. + + +#abschnitt ("6.2", "SÄTZE EINFÜGEN", "Sätze Einfügen")# + +Nachdem die Datei nun eingerichtet worden ist, sollen Sie zunächst +einige Sätze eingeben. Wenn Sie wieder das Menü 'Einzelsatz' an +wählen, sehen Sie nur den leeren Satz mit der Anzeige 'ENDE', der +das Dateiende markiert. Um neue Sätze aufzunehmen, gibt es die +Funktion +#free (0.2)# +#beispiel# + E Einfügen +#text# +#free (0.2)# +Wenn Sie diese Funktion aufrufen, geschieht etwas Ähnliches wie +beim Eingeben des Suchmusters. Der Cursor wandert wieder hinter +den ersten Feldnamen und in der Statuszeile erscheint die Auffor +derung +#f2# +#bildschirm# +___________________________________________________________________________________________ + + SATZ EINFUEGEN: Abbruch: ESC h Beenden: ESC q Hilfe: ESC ? +___________________________________________________________________________________________ +#text# + +Sie können nun die Feldinhalte der einzelnen Felder neben die +entsprechenden Feldnamen schreiben. Mit der RETURN-Taste schlie +ßen Sie eine Zeile ab und gelangen in die nächste. + Um eventuelle falsche Eingaben zu korrigieren, können Sie +ähnlich wie im Editor mit den Pfeiltasten herumfahren und falsche +Eingaben überschreiben. Die Taste RUBOUT löscht falsche Zeichen. +Sie beenden die Eingabe mit ESC 'q'. Anschließend ist der neue Satz +vorhanden. + +#beispiel# +#free (4.5)# + +#center#Abb. 6-1 Einfügen +#text# + +#a ("Wirkung")# Die Wirkungsweise der Funktion 'Einfügen' verdeutlicht +die Abb. 6-1. Dargestellt ist ein Ausschnitt aus einer Datei mit den +Sätzen 4 bis 7 und durch Buchstaben dargestellten, beliebigen In +halten. Satz 6 sei der aktuelle Satz. + Beim Einfügen wird nun vor dem aktuellen Satz eine Lücke für +den neuen Satz geschaffen, die zunächst noch leer ist und dann von +Ihnen ausgefüllt werden muß. Die Satznummern aller folgenden Sätze +erhöhen sich um 1. + Die Leerstelle bleibt nur dann erhalten, wenn Sie Daten für den +neuen Satz eingeben. Anderenfalls wird nach ESC 'q' wieder der alte +Zustand hergestellt. + Dieses Verfahren erklärt auch, warum das Ende der Datei ein +leerer Pseudosatz ist. Um nämlich am Ende der Datei einen neuen +Satz anzufügen, muß man vor dem Endesatz einen Satz einfügen. + Nachdem Sie also jetzt den ersten Satz eingegeben haben, +müssen Sie sich wieder zum Ende bewegen, damit der nächste Satz +hinter dem ersten steht. Für diesen häufig benötigten Vorgang gibt +es eine Abkürzung: Wenn Sie die Eingabe mit ESC 'w' (Weiter) statt +ESC 'q' beenden, geht EUDAS nach dem Einfügen des Satzes weiter +zum nächsten und fügt dort wieder einen Satz ein. + Auf diese Weise können Sie also schnell eine ganze Reihe von +Sätzen nacheinander eingeben. Nachdem Sie einen Satz eingegeben +haben, tippen Sie ESC 'w' und können gleich anschließend schon mit +der Eingabe des nächsten Satzes beginnen. Alle so eingegebenen +Sätze erscheinen nachher in der Reihenfolge der Eingabe. + +#a ("Satzeditor")# Bei der Eingabe eines neuen Satzes haben Sie nahezu +alle Möglichkeiten, die auch der EUMEL-Editor bietet. Der be +schreibbare Bereich ist jedoch kleiner. Er umfaßt das ganze Gebiet, +in dem sonst die Feldinhalte erscheinen. + Wie beim Editor können Sie den Cursor mit den Cursortasten +(Pfeiltasten) bewegen. Mit der Taste RUBOUT können Sie ein Zeichen +löschen. Die restlichen Zeichen der Zeile rücken dann nach. Mit +RUBIN dagegen schalten Sie in einen Einfügemodus um. Alle einge +gebenen Zeichen werden dann eingefügt - der Rest der Zeile rückt +entsprechend nach rechts. Nochmaliges Tippen von RUBIN schaltet +wieder in den alten Modus. Welcher Modus eingeschaltet ist, steht +in der Überschriftzeile. + Mit der Kombination ESC RUBOUT können Sie den Rest einer +Zeile ab der Cursorposition löschen. Steht der Cursor in der ersten +Spalte, wird dementsprechend die ganze Zeile gelöscht. Im Unter +schied zum EUMEL-Editor rücken die folgenden Zeilen jedoch nicht +herauf. + Entsprechend fügen Sie mit der Funktion ESC RUBIN eine neue +Zeile ein. Dies ist immer dann erforderlich, wenn ein Feldinhalt +nicht auf eine Zeile paßt. Der Teil der Zeile, der hinter dem Cursor +steht, wird bei ESC RUBIN in die neue Zeile mitgenommen. + Normalerweise tippen Sie ESC RUBIN, wenn Sie an das Ende +einer Zeile kommen. Wenn Sie aber weiterschreiben, wird die Zeile +einfach gerollt. Dies ist nicht weiter schlimm, aber Sie können den +ganzen Feldinhalt nicht auf einmal sehen. + In der normalen Anzeige wird ein überlanger Inhalt auf jeden +Fall auf mehrere Zeilen verteilt. + +#a ("Warnung")# Ein Hinweis für alle, die sich mit der Editorbedienung +schon auskennen: EUDAS benutzt den Editor als Unterprogramm. +Jedoch haben einige Editorfunktionen unliebsame Auswirkungen. +Besonders gefährlich sind hier HOP RUBOUT und HOP RUBIN. Diese +Funktion zerstören die Korrespondenz zwischen Feldnamen und +Feldinhalten, das heißt der Feldinhalt steht nicht mehr neben dem +Feldnamen. + Weiterhin können Sie das Editorbild rollen, ohne daß die Feld +namen mitrollen (zum Beispiel wenn Sie in der untersten Zeile +RETURN drücken). In diesem Fall ist die Korrespondenz auch nicht +erhalten, das heißt die Inhalte stehen falsch, sind aber eigentlich +richtig. + In solchen Fällen erscheint am oberen oder unteren Rand der +Hinweis #bsp("""Bitte ESC '1' druecken""")#. Wenn das Editorbild nur gerollt +wurde, verschwindet durch ESC '1' der Hinweis wieder und das Bild +ist in Ordnung. Wenn jedoch Zeilen gelöscht oder eingefügt wurden, +müssen Sie diese Änderungen von Hand wieder rückgängig machen, +bis der Hinweis verschwindet. Sie sollten also HOP RUBOUT und HOP +RUBIN im Satzeditor nicht verwenden. + Im Zweifelsfall, wenn Sie meinen, den Satz durcheinanderge +bracht zu haben, können Sie immer mit ESC 'h' abbrechen. Es steht +dann der vorherige Zustand für einen neuen Versuch zur Verfügung. + + +#abschnitt ("6.3", "DATEN ÄNDERN", "Daten ändern")# + +Wenn Sie nachträglich noch eingegebene Daten ändern wollen, kön +nen Sie die Funktion +#free (0.2)# +#beispiel# + A Ändern +#text# +#free (0.2)# +verwenden. Sie haben anschließend wie beim Einfügen Gelegenheit, +neue Daten einzugeben. Allerdings werden Ihnen die bisherigen +Daten gleich mit angeboten, so daß Sie nur die Änderungen ein +geben müssen. Alles andere kann unverändert bleiben. Auch diese +Funktion wird mit ESC 'q' verlassen. ESC 'w' funktioniert beim +Ändern ebenfalls (der nächste Satz wird zum Ändern angeboten). + Stellen Sie beim Ändern oder Einfügen fest, daß Sie irgendeinen +krassen Fehler gemacht haben, können Sie die Operation mit ESC 'h' +abbrechen. Beim Ändern bleibt dann der alte Zustand unverändert, +beim Einfügen wird kein Satz eingefügt. + +#a ("Löschen")# Für den Fall, daß Sie einen Satz wieder ganz aus der +Datei löschen wollen, hat EUDAS eine besondere Vorsichtsmaßnahme +vorgesehen. Damit der Satz nicht gleich unwiederbringlich verloren +geht, müssen Sie ihn zunächst in eine andere Datei #on("i")#tragen#off("i")#. Falls +das Löschen ein Irrtum war, können Sie den Satz von dort noch +wiederholen. In vielen Fällen besteht ohnehin die Anforderung, daß +auch die nicht mehr aktuellen Daten noch eine gewisse Zeit aufge +hoben werden müssen. + Zum Tragen gibt es die Funktion +#f2# +#beispiel# + Datensatz + T Tragen +#text# +#f2# +Sie werden nach einem Dateinamen gefragt. Geben Sie hier zum +Beispiel 'müll' an. Da diese Datei noch nicht existiert, werden Sie +gefragt, ob Sie sie neu einrichten wollen (falls Sie sich vielleicht +verschrieben haben). Danach wird der aktuelle Satz in die Datei +'müll' transportiert. Am Bildschirm erscheint der nächste Satz. Der +getragene Satz kommt an das Ende der Zieldatei. + Eine Bedingung beim Tragen ist, daß die Zieldatei immer die +gleichen Felder haben muß wie die aktuelle Datei. Sie können also +nicht aus verschieden strukturierten Dateien in die gleiche Datei +tragen. + Zum Zurückholen eines Satzes benutzen Sie die Funktion +#f2# +#beispiel# + Datensatz + H Holen +#text# +#f2# +Der letzte Satz der Datei, die Sie angeben, wird vor dem aktuellen +Satz eingefügt. Dadurch wird der Effekt des letzten Tragens wieder +aufgehoben. + Um die getragenen Sätze endgültig zu vernichten, müssen Sie +die Zieldatei als Ganzes löschen. Die dazu notwendige Funktion aus +dem Menü 'Dateien' haben Sie bereits in Abschnitt 4.4 kennenge +lernt. + + +#abschnitt ("6.4", "ARBEITSKOPIE SICHERN", "Arbeitskopie sichern")# + +Wenn Sie eine Datei zum Ändern öffnen oder sie gerade neu einge +richtet haben, wird von dieser Datei intern eine Arbeitskopie ange +legt, die dann geändert wird. Sie müssen diese Arbeitskopie nach +den Änderungen sichern, damit die Änderungen wirksam werden. + In unserem Beispiel ist die Datei "Telefonnummern" immer noch +leer. Die Änderungen sind momentan nur in der internen Kopie +vorhanden. Wenn Sie die Datei zum Beispiel auf eine Archivdiskette +schreiben wollten, würden Sie eine leere Datei auf der Diskette +haben. + Zum Sichern rufen Sie die Funktion +#free (0.2)# +#beispiel# + S Sichern +#text# +#free (0.2)# +im ersten Menü auf. Es erscheint dann folgende Frage: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Arbeitskopie "Telefonnummern" veraendert! Sichern (j/n) ? +___________________________________________________________________________________________ +#text# + +Beantworten Sie diese Frage mit 'j'. Als nächstes wird gefragt: +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Alte Version überschreiben (j/n) ? +___________________________________________________________________________________________ +#text# + +Beantworten Sie auch diese Frage mit 'j'. Die Arbeitskopie über +schreibt dann die (leere) Version vor dem Ändern. + Wenn Sie die Frage verneint hätten, könnten Sie anschließend +einen neuen Namen für die Arbeitskopie angeben. Dies wäre dann +sinnvoll, wenn Sie den Stand vor den Änderungen noch aufbewahren +wollen. In diesem Fall ist es jedoch nutzlos, die alte leere Datei +noch behalten zu wollen. + Abschließend wird gefragt, ob Sie die Arbeitskopien löschen +wollen. Wenn Sie noch weiter mit der Datei arbeiten wollen, vernei +nen Sie diese Frage. Die Datei bleibt dann geöffnet. Anderenfalls +müßten Sie die Datei neu öffnen, wenn Sie sie wieder ansehen wol +len. + +#a ("Arbeitskopien")# Es ist sehr wichtig, daß Sie sich die Funktionsweise +mit der Arbeitskopie immer vor Augen halten, damit Sie später bei +der Arbeit mit EUDAS nicht überrascht werden. + Eine Arbeitskopie wird immer dann angelegt, wenn Sie beim +Öffnen einer EUDAS-Datei angeben, daß Sie diese Datei ändern +wollen. In dem Beispiel haben Sie eine neue Datei eingerichtet. +EUDAS nimmt dann automatisch an, daß Sie ändern wollen. Öffnen +Sie eine existierende Datei, werden Sie gefragt +#f2# +#bildschirm# +___________________________________________________________________________________________ + + Wollen Sie etwas ändern (Arbeitskopie anlegen) (j/n) ? +___________________________________________________________________________________________ +#text# + +Wenn Sie diese Frage verneinen, wird keine Arbeitskopie angelegt; +alle Änderungsfunktionen werden jedoch gesperrt. Daran können Sie +auch erkennen, daß keine Arbeitskopie vorliegt. + Die Arbeitskopie, die EUDAS sich anlegt, ist anonym. Wenn Sie +sich also im Menü 'Dateien' eine Übersicht zeigen lassen, erscheint +nur das Original. Bevor Sie mit diesem Original etwas anstellen +(zum Beispiel auf Archiv schreiben), sollten Sie sich vergewissern, +daß Sie die Arbeitskopie gesichert haben, da das Original sonst +nicht auf dem neuesten Stand ist. + Um Sie in diesem Fall zu warnen, erscheint vor einer geöffneten +Datei in einer Dateiauswahl das Symbol #bsp ("<!>")#, zum Beispiel: + +#beispiel# + o <!> "Telefonnummern" + o "Mitglieder" +#text# + +Wenn Sie dieses Symbol sehen, sollten Sie die Datei lieber erst +sichern, bevor Sie etwas mit ihr anstellen. + +#a ("Beispiel")# Um die Arbeitsweise von EUDAS noch besser zu verstehen, +betrachten Sie das Beispiel in Abb. 6-2. Nehmen Sie an, Sie haben +drei EUDAS-Dateien 'Kalender', 'Namen' und 'Adressen' mit ihren +Anfangsinhalten K0, N0 und A0 (symbolisch). In dem Diagramm sind +die Vorgänge zu den Zeitpunkten 0 bis 10 mit ihren Auswirkungen +auf die Inhalte der Dateien und der Arbeitskopie dargestellt. + +#beispiel# +#free (5.5)# +#center#Abb. 6-2 Beispiel zur Arbeitskopie +#text# + +Zu den einzelnen Zeitpunkten passiere folgendes: + +0: Anfangszustand. Es wurde noch keine Datei geöffnet, also ist + keine Arbeitskopie vorhanden. Es könnte aber auch eine + beliebige Datei ohne Änderungserlaubnis geöffnet sein. +#free (0.2)# +1: Die Datei 'Adressen' wird geöffnet zum Ändern. Der momen + tane Zustand der Datei wird als Arbeitskopie übernommen. +#free (0.2)# +2: Es wird eine Änderung vorgenommen (zum Beispiel) ein Satz + eingefügt). Diese Änderung betrifft aber nur die Kopie - die + Datei 'Adressen' als Original bleibt unverändert. +#free (0.2)# +3: Eine weitere Änderung führt zum Inhalt A2 der Arbeitsko + pie. +#free (0.2)# +4: Aufruf von 'Sichern'. Die alte Version von 'Adressen' wird + überschrieben und durch den Inhalt A2 ersetzt. Die Frage + nach dem Löschen der Arbeitskopie wird verneint; daher bleibt + die Kopie auch erhalten. +#free (0.2)# +5: Die Kopie wird erneut verändert. +#free (0.2)# +6: Aufruf von 'Sichern'. Die Frage, ob die Kopie gesichert wer + den soll, wird verneint. Die Arbeitskopie soll jedoch gelöscht + werden. Als Ergebnis geht die Änderung A3 verloren (viel + leicht war diese Änderung ein Irrtum). Die Datei 'Adressen' + wird nicht verändert. Es ist keine Arbeitskopie mehr vor + handen. +#free (0.2)# +7: Die Datei 'Namen' wird zum Ändern geöffnet. +#free (0.2)# +8: Die Datei 'Kalender' wird zum Ändern geöffnet. Da an der + vorigen Arbeitskopie keine Änderungen vorgenommen wurden, + kann die Kopie einfach überschrieben werden. Anderenfalls + wäre an dieser Stelle die Möglichkeit zum Sichern angeboten + worden. +#free (0.2)# +9: Es wird eine Änderung durchgeführt. +#free (0.2)# +10: Die geänderte Arbeitskopie wird gesichert, das Original über + schrieben und die Arbeitskopie gelöscht (Normalfall). + + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.7 b/app/eudas/4.4/doc/user-manual/eudas.hdb.7 new file mode 100644 index 0000000..67f635d --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.7 @@ -0,0 +1,665 @@ +#type ("prop")##limit (14.0)# +#format# +#page (61)# +#kapitel ("7", "Ausdrucken", "der", "Daten")# + + + +#abschnitt ("7.1", "DRUCKMUSTER", "Druckmuster")# + +Nachdem Sie sich die Inhalte der EUDAS-Datei ausgiebig am Bild +schirm angesehen haben, möchten Sie die gespeicherten Daten sicher +auch in gedruckter Form auf Papier sehen. Sie können eine +EUDAS-Datei jedoch nicht ohne weiteres ausdrucken, da sie eine +andere Struktur als normale Textdateien hat. + Vor dem Drucken müssen also die Inhalte der EUDAS-Datei +zunächst in lesbarer Form in eine Textdatei geschrieben werden. +EUDAS kann diese Aufgabe jedoch ohne Ihre Hilfe nicht alleine be +wältigen. + Es taucht nämlich das Problem auf, daß die Dateiinhalte in +vielen verschiedenen Formen dargestellt werden können (Sie erin +nern sich sicher noch an das erste Kapitel). Vielleicht wollen Sie +bestimmte Überschriften haben oder die Daten müssen auf ein be +stimmtes Formular passen. + Um die Ausgabe nach Ihren Wünschen zu gestalten, müssen Sie +also dem Rechner genau angeben, an welcher Stelle welche Felder +gedruckt werden sollen usw. Dies geht am einfachsten, indem Sie +dem Rechner ein Muster vorsetzen, nach dem er dann die richtigen +Ausdrucke erstellen kann. Dieses Muster schreiben Sie in eine eige +ne Textdatei, die #on("i")#Druckmuster#off("i")# genannt wird. Aus den Daten der +EUDAS-Datei und der Form, die im Druckmuster angegeben ist, wird +dann eine weitere Textdatei erzeugt, die die Daten in der ge +wünschten Form enthält und die anschließend automatisch gedruckt +werden kann. + Durch ein Druckmuster erhalten Sie fast völlige Freiheit in der +Gestaltung Ihrer Ausdrucke. Zum Beispiel können aus einer einzigen +Adressendatei einfache Listen, Einladungskarten oder Rundbriefe +erzeugt werden. Für eine einfache Adressenliste entspricht das +Druckmuster einer Zeile der Liste, wobei angegeben wird, in welche +Spalten die Inhalte gedruckt werden. Zum Drucken von Einladungs +karten wird als Druckmuster eine Einladungskarte verwendet, in der +die Stellen markiert sind, an denen die Adresse erscheinen soll. Das +gleiche kann man mit einem Brief machen, der dann mit jeder +Adresse einmal ausgedruckt wird. + +#a ("Druckverfahren")# Man kann sich diesen Druckprozeß wie folgt vor +stellen: + +#beispiel# +#free (6.5)# + +#center#Abb. 7-1 Druckverfahren +#text# + +Vereinfacht gesagt (das genaue Verfahren wird später beschrieben) +wird für jeden Satz der EUDAS-Datei das Druckmuster einmal in die +Druckdatei übernommen. Dabei werden die Inhalte aus der EUDAS- +Datei in einer noch anzugebenden Weise an den gewünschten Stellen +eingefügt. + Im weiteren sollen Sie erfahren, wie ein Druckmuster genau +aussieht und wie daraus ein Ausdruck entsteht. + +#a ("Beispiel")# Im folgenden sollen Sie zur Demonstration die bereits in +Kapitel 3 und 4 beschriebene Beispieldatei verwenden. Nach Mög +lichkeit sollten Sie die angegebenen Beispiele mit dieser Datei +selbst am Rechner ausprobieren. + +Folgende Sätze befinden sich in der Datei: + +#beispiel# + Vorname Name, Strasse, PLZ Ort, m/w + ------------------------------------------------------- + Herbert Wegner, Krämergasse 12, 5000 Köln, m + Helga Sandmann, Willicher Weg 109, 5300 Bonn 1, w + Albert Katani, Lindenstr. 3, 5210 Troisdorf, m + Peter Ulmen, Mozartstraße 17, 5 Köln 60, m + Karin Regmann, Grengelweg 44, 5000 Köln 90, w + Hubert Arken, Talweg 12, 5200 Siegburg, m + Anna-Maria Simmern, Platanenweg 67, 5 Köln 3, w + Angelika Kaufmann-Drescher, Hauptstr. 123, 53 Bonn 2, w + Harald Fuhrmann, Glockengasse 44, 5000 Köln 1, m + Friedrich Seefeld, Kabelgasse, 5000 Köln-Ehrenfeld, m +#text# + +Wie Sie sehen, wurde die Reihenfolge der Felder gegenüber der Datei +teilweise verändert und Name und Vorname ohne Komma hinterein +andergeschrieben, während die anderen Feldinhalte durch Komma +getrennt sind. Diese Liste wurde unter Verwendung eines Druck +musters erzeugt. + Da dieses Druckmuster jedoch vorerst noch zu kompliziert ist, +sollen Sie erst einmal ein einfacheres Druckmuster erstellen und +versuchen, nur die Namen aus der Datei in Tabellenform auszuge +ben. + Das dafür nötige Druckmuster hat folgendes Aussehen: + +#beispiel# + % WIEDERHOLUNG + ! &Name ! &Vorname ! +#text# + +Das Druckmuster besteht nur aus zwei Zeilen, von der die zwei +te das eigentliche Muster darstellt. Die erste Zeile ist eine #on("i")# Anwei +sung#off("i")# an den Druckgenerator. 'WIEDERHOLUNG' gibt an, daß die +folgenden Zeilen für jeden Satz wiederholt werden sollen (warum +diese Angabe notwendig ist, werden Sie später einsehen). Das Pro +zentzeichen kennzeichnet eine Anweisung und muß unbedingt in der +ersten Spalte des Druckmusters stehen, also ganz am linken Rand. + In der zweiten Zeile ist zu sehen, daß das Zeichen '&' dazu +benutzt wird, die Stellen zu markieren, an denen nachher Feldin +halte eingesetzt werden sollen. Hinter dem '&'-Zeichen folgt der +Name des Feldes, das an dieser Stelle eingesetzt werden soll. Eine +solche Konstruktion wird #on("i")#Feldmuster#off("i")# genannt. Beachten Sie, daß +Feldnamen hier immer ohne Anführungsstriche geschrieben werden +müssen. Die Ausrufungszeichen bilden den eigentlichen Mustertext +und werden unverändert als Tabellenbegrenzung in die Ausgabe +übernommen. + Als Ergebnis des Druckprozesses sollte folgende Ausgabe auf +dem Drucker erscheinen: + +#beispiel# + ! Wegner ! Herbert ! + ! Sandmann ! Helga ! + ! Katani ! Albert ! + ! Ulmen ! Peter ! + ! Regmann ! Karin ! + ! Arken ! Hubert ! + ! Simmern ! Anna-Maria ! + ! Kaufmann-Drescher ! Angelika ! + ! Fuhrmann ! Harald ! + ! Seefeld ! Friedrich ! +#text# + +Sie können erkennen, daß die Feldmuster in der Ausgabe jeweils +durch den Inhalt des zugehörigen Feldes ersetzt worden sind. Der +übrige Text in der Musterzeile ist unverändert geblieben. Beachten +Sie, daß das '&' ein reserviertes Zeichen ist, das ein Feldmuster im +umgebenden Text kennzeichnet und daher (vorerst) nicht gedruckt +werden kann. + + +#abschnitt ("7.2", "AUFRUF", "Aufruf")# + +In diesem Abschnitt sollen Sie erfahren, wie Sie diese Ausgabe +selbst erzeugen können. Damit der Druckgenerator arbeiten kann, +müssen Sie die Datei 'Adressen' erst einmal öffnen. Anschließend +wählen Sie das Menü 'Drucken' an. + +#a ("Druckmuster erstellen")# Als nächstes müssen Sie das Druckmuster +erstellen. Hierfür gibt es die Funktion +#free (0.2)# +#beispiel# + Textdatei + E Editieren +#text# +#free (0.2)# +da das Druckmuster eine normale Textdatei ist. + Wählen Sie diese Funktion. Sie werden dann nach einem Namen +für das Druckmuster gefragt. Wir wollen das Druckmuster 'Namens +liste' nennen - Sie können aber auch einen beliebigen anderen +Namen wählen. Denken Sie daran, die Anführungsstriche nicht mit +einzugeben. + Es erscheint anschließend das gewohnte Editorbild mit einer +entsprechenden Statuszeile. Geben Sie die zwei Zeilen des Druck +musters ein und beenden Sie den Editor mit ESC 'q'. Damit ist das +Druckmuster fertig. + + Die hier beschriebene Funktion können Sie nicht nur zum Er +stellen, sondern auch zum Ändern und einfachen Ansehen eines +Druckmusters bzw. einer Textdatei allgemein verwenden. Es wird +Ihnen immer der jeweilige Inhalt präsentiert, den Sie dann nach +Belieben abändern können oder nicht. + +#bildschirm# +___________________________________________________________________________________________ + + EUDAS: Öffnen Einzelsatz Gesamtdatei Drucken Dateien Archiv + --------------: + Satzauswahl : + D Drucken : + --------------: + Druckausgabe : + R Richtung : + --------------: + Textdatei : + E Editieren : + A Ausdrucken : + N Nachbearb. : + --------------: + +___________________________________________________________________________________________ +#beispiel# +#center#Abb. 7-2 Menü "Drucken" +#text# + +#a ("Ausgaberichtung")# Bevor Sie jetzt weitermachen, sollten Sie über +prüfen, ob an Ihrem System ein Drucker angeschlossen ist. Der +Drucker sollte bei den folgenden Versuchen betriebsbereit sein. + Ist kein Drucker angeschlossen oder wollen Sie kein Papier +verschwenden, haben Sie die Möglichkeit, den Ausdruck als Text +datei zu erhalten. Dazu wählen Sie die Funktion +#free (0.2)# +#beispiel# + Ausgabe + R Richtung +#text# +#free (0.2)# +an. Beantworten Sie beide Fragen, die Ihnen gestellt werden, mit +'n'. Die Ausgaben stehen dann nachher in Dateien mit einem Namen +der Form +#free (0.2)# +#beispiel# + Namensliste.a$n +#text# +#free (0.2)# +die Sie sich mit der oben beschriebenen Funktion dann genau wie +ein Druckmuster anschauen können. Der Name besteht also aus dem +Namen des Druckmusters, dem ein #bsp("'.a$'")# angehängt wird. Die Nummer +'n' dient zur Unterscheidung bei mehreren aufeinanderfolgenden +Ausgaben. Um Verwirrung zu vermeiden, sollten Sie die Datei nach +dem Anschauen löschen (im Menü 'Dateien'). + +#a ("Druckaufruf")# Wenn Sie diese Hinweise beachtet haben, können Sie +den Druckvorgang mit der Auswahl +#free (0.2)# +#beispiel# + Satzauswahl + D Drucken +#text# +#free (0.2)# +starten. Sie werden hier nach dem Namen des Druckmusters gefragt, +das Sie verwenden wollen (Sie können ja durchaus eine ganze Reihe +von verschiedenen Druckmustern haben). + Sie können den Ablauf des Druckvorganges daran verfolgen, +daß jeweils die Nummer des Satzes ausgegeben wird, der gerade +bearbeitet wird. Probieren Sie eventuell auch kleine Abwandlungen +des Druckmusters aus, indem Sie die Tabellenspalten schmaler oder +breiter machen oder die Ausrufungszeichen durch ein anderes Zei +chen ersetzen (je nach Geschmack). + +#a ("Ausgabedatei")# Wollen Sie die erzeugte Ausgabe (die in der Datei +'Namensliste.a$1' steht) irgendwann tatsächlich ausdrucken, ver +wenden Sie die Funktion +#free (0.2)# +#beispiel# + A Ausdrucken +#text# +#free (0.2)# +Sie werden dann nach dem Namen der Textdatei gefragt. Beachten +Sie, daß Sie diese Funktion #on("i")#nicht#off("i")# zum Drucken von EUDAS-Dateien +verwenden können, da aus einer EUDAS-Datei erst eine Druckdatei +erzeugt werden muß. + Auch wenn Sie angegeben haben, daß die Ausgabe des Druck +prozesses direkt ausgedruckt werden soll, startet Ihr Drucker erst, +wenn EUDAS die ganze Datei durchgegangen ist und der Vorgang für +Sie beendet ist. Dies liegt am EUMEL-System, das nur vollständige +Druckaufträge entgegennimmt, damit sich mehrere Benutzer nicht in +die Quere kommen können. In einem Multi-User-System können Sie +weiterarbeiten, während der Drucker beschäftig ist. + +#a ("Fehler")# Bevor der eigentliche Druckprozeß gestartet wird, wird das +Druckmuster auf unsinnige oder unverständliche Konstruktionen +überprüft. Ist dem Druckgenerator etwas suspekt, gibt er eine Feh +lermeldung aus, in der die fragliche Situation von seiner Seite aus +beschrieben wird. Er kann natürlich nicht Ihren Fehler "verstehen". +Daher müssen Sie unter Umständen eine Fehlermeldung erst inter +pretieren, ehe Sie die wahre Ursache erkennen können. + Damit Sie einen aufgetretenen Fehler gleich korrigieren können, +werden Ihnen das Druckmuster und die Fehlermeldungen parallel auf +dem Bildschirm zum Ändern und Anschauen angeboten. Sie können +mit dem Editor das Druckmuster ändern und in den Fehlermeldungen +blättern. Diese Konfiguration wird Paralleleditor genannt. Mit ESC +'w' wechseln Sie zwischen den beiden Bildschirmhälften. + +#a ("Suchbedingung")# Wollen Sie nicht alle Namen ausdrucken, so können +Sie vorher ein Suchmuster einstellen, das nur auf die gewünschten +Namen zutrifft (wie im Kapitel 5 beschrieben). Der Druckgenerator +richtet sich immer nach dem aktuell eingestellten Suchmuster und +druckt nur die ausgewählten Sätze. Wenn Sie zum Beispiel die Na +men aller Frauen ausdrucken wollen, stellen Sie im Tastenmodus ein +Suchmuster ein (das sollten Sie können), das für das Feld 'm/w' die +Bedingung 'w' enthält. Danach können Sie den Druckgenerator auf +rufen. Vergessen Sie nicht, das Suchmuster anschließend wieder zu +löschen. + +#a ("Feldnamen abfragen")# Wenn Sie selber ein Druckmuster erstellen, +wird es häufiger vorkommen, daß Sie die genaue Schreibweise der +Feldnamen nicht im Kopf haben. Für diesen Zweck definiert EUDAS +im Editor eine spezielle Tastenkombination. + Wenn Sie dort ESC 'F' tippen (großes 'F'), erhalten Sie eine +Auswahl aller Felder der gerade geöffneten Datei. Sie können sich +die Namen einfach ansehen, aber auch direkt in den Text des +Druckmusters übernehmen. + Wenn Sie nämlich vor dem Verlassen der Auswahl mit ESC 'q' +ein Feld ankreuzen, wird anschließend der Name in Anführungs +strichen an die Position geschrieben, an der vor dem Aufruf der +Cursor stand. Auf diese Weise können Sie sich auch das Tippen +langer Feldnamen vereinfachen. + Beachten Sie, daß Sie im Normalfall im Druckmuster die Anfüh +rungsstriche wieder entfernen müssen. Die Anführungsstriche dienen +zur Abgrenzung, wie weit der Feldname geht. Falls der Name Leer +zeichen enthält, beachten Sie bitte den Absatz 'Abgrenzung der +Feldnamen' in Abschnitt 7.4. + + +#abschnitt ("7.3", "ABSCHNITTE", "Abschnitte")# + +Die Tabellen, die Sie bis jetzt erzeugen können, sehen optisch noch +nicht sehr gut aus. Es fehlt auf jeden Fall eine vernünftige Über +schrift. Um eine Überschrift zu erzeugen, können Sie im Druckmuster +einen #on("i")#Vorspann#off("i")# definieren, der ganz zu Anfang einmal gedruckt +wird. + Dieser Vorspann wird durch die Anweisung +#f2# +#beispiel# + % VORSPANN +#text# +#f2# +eingeleitet (bitte nicht vergessen, daß das '%'-Zeichen für eine +Anweisung in der ersten Spalte stehen muß). Die folgenden Zeilen +bis zur 'WIEDERHOLUNG'-Anweisung gehören zum Vorspann. Ein +Druckmuster für unsere Namensliste mit Überschrift könnte dann so +aussehen: + +#beispiel# + % VORSPANN + Alle Namen aus der EUDAS-Datei 'adressen' + ----------------------------------------- + % WIEDERHOLUNG + ! &Name ! &Vorname ! +#text# + +Der Druckgenerator erzeugt mit diesem Druckmuster die gewünschte +Liste mit Überschrift. Sie können als Vorspann natürlich auch einen +beliebigen anderen Text verwenden. + In einer analogen Weise können Sie die Liste noch durch eine +waagerechte Linie abschließen, indem Sie einen #on("i")#Nachspann#off("i")# definie +ren. Die dafür notwendige Anweisung heißt +#f2# +#beispiel# + % NACHSPANN +#text# +#f2# +Die Zeilen nach dieser Anweisung werden gedruckt, nachdem alle +Sätze bearbeitet worden sind. Das folgende Druckmuster erzeugt +schon eine sehr schöne Liste: + +#beispiel# + % VORSPANN + Alle Namen aus der EUDAS-Datei 'adressen' + ----------------------------------------- + % WIEDERHOLUNG + ! &Name ! &Vorname ! + % NACHSPANN + ----------------------------------------- +#text# + +nämlich: + +#beispiel# + Alle Namen aus der EUDAS-Datei 'adressen' + ----------------------------------------- + ! Wegner ! Herbert ! + ! Sandmann ! Helga ! + ! Katani ! Albert ! + ! Ulmen ! Peter ! + ! Regmann ! Karin ! + ! Arken ! Hubert ! + ! Simmern ! Anna-Maria ! + ! Kaufmann-Drescher ! Angelika ! + ! Fuhrmann ! Harald ! + ! Seefeld ! Friedrich ! + ----------------------------------------- +#text# + +Die drei Teile, aus denen ein Druckmuster bestehen kann (Vorspann, +Nachspann und Wiederholungsteil), werden #on("i")#Abschnitte#off("i")# genannt. Wie +Sie später noch sehen werden, haben Abschnitte eine Reihe von +gemeinsamen Eigenschaften. Ein Abschnitt wird durch eine eigene +Anweisung eingeleitet und endet, wenn ein anderer Abschnitt be +ginnt oder das Druckmuster zu Ende ist. Alle Abschnitte können +auch weggelassen werden, irgendein Abschnitt muß aber immer +vorhanden sein. So ist es zum Beispiel möglich, ein Druckmuster zu +bauen, das nur aus einem Nachspann besteht (Sie werden allerdings +jetzt noch nicht verstehen können, warum so etwas sinnvoll sein +kann). + Zum Abschluß dieses Kapitels hier noch einmal eine Übersicht +der bisher vorgestellten Anweisungen: + +#beispiel# + Anweisung ! Bedeutung + ---------------+---------------------------------- + % VORSPANN ! leitet Vorspann ein + % WIEDERHOLUNG ! leitet Wiederholungsteil ein + % NACHSPANN ! leitet Nachspann ein +#text# + + +#abschnitt ("7.4", "FELDMUSTER", "Feldmuster")# + +Mit den bis jetzt beschriebenen Möglichkeiten des Druckgenerators +können Sie schon sehr viel anfangen. Es fehlt aber noch die Mög +lichkeit, mehrere Feldinhalte direkt hintereinander zu schreiben, +egal wie lang diese Inhalte sind. Diese Fähigkeit wird zum Beispiel +für die anfangs vorgestellte Liste benötigt. + +#a ("Variable Position")# Die Feldmuster, die Sie bis jetzt kennen, begin +nen mit einem '&'-Zeichen und werden immer genau an der Stelle +gedruckt, an der sie stehen (feste Position). Sie können ein Feld +muster aber auch mit '%' beginnen lassen. In diesem Fall kann der +Inhalt verschoben werden (variable Position), je nachdem, ob vorhe +rige Inhalte kürzer oder länger sind. + '%' ist wie '&' ein reserviertes Zeichen, kann also nicht direkt +gedruckt werden. Da '&' und '%' Feldmuster einleiten, heißen sie +#on("i")#Musterzeichen#off("i")#. + Um Feldmuster variabler Position einmal auszuprobieren, soll +ten Sie unser bisheriges Druckmuster in der folgenden Weise um +schreiben: + +#beispiel# + % WIEDERHOLUNG + &Vorname %Name +#text# + +(Vorspann und Nachspann der Einfachheit halber mal weggelassen). +Als Ergebnis erhalten wir: + +#beispiel# + Herbert Wegner + Helga Sandmann + Albert Katani + Peter Ulmen + Karin Regmann + Hubert Arken + Anna-Maria Simmern + Angelika Kaufmann-Drescher + Harald Fuhrmann + Friedrich Seefeld +#text# + +Das Feldmuster '%Name' ist also entsprechend der Länge des Vor +namens nach links oder nach rechts gerutscht. Zu beachten ist, daß +ein Feldmuster mit '%' nicht in der ersten Spalte stehen darf, denn +dann würde die Zeile als Anweisung angesehen. Ein Feldmuster +variabler Position wäre ja auch in der ersten Spalte wenig sinnvoll. + +#a ("Feste Länge")# Außer den beiden bisher besprochenen einfachen +Arten (mit '&' oder '%') gibt es noch weitere Ausprägungen von +Feldmustern für besondere Fälle. Wird ein Feldmuster noch von +weiteren Musterzeichen gefolgt, dann wird dieses Feldmuster immer +in der reservierten Länge eingesetzt. Die reservierte Länge reicht +vom ersten bis zum letzten Musterzeichen. Durch die zusätzlichen +Musterzeichen wird also ein bestimmter Platz freigehalten. + Ersetzt man im obigen Druckmuster '&Vorname' durch +'&Vorname&&', wird der Effekt des folgenden '%'-Feldes wieder +aufgehoben, da jetzt für alle Vornamen die gleiche Länge verwendet +wird (Probieren Sie dies aus). + Bei einem solchen Feldmuster mit fester Länge wird der Inhalt +abgeschnitten, falls er diese Länge überschreitet; ist der Inhalt +kürzer, wird rechts mit Leerstellen aufgefüllt. Aber auch bei Feld +mustern mit variabler Länge (also ohne folgende Musterzeichen) +kann abgeschnitten werden, nämlich genau dann, wenn der Inhalt so +lang ist, daß ein folgendes Feld mit fester Position (mit '&' anfan +gend) überschrieben würde. Hätten wir also in unserem ersten +Druckmuster nicht genügend Platz für die Spalten vorgesehen, +wären einige Namen abgeschnitten worden (probieren Sie es nochmal +aus, falls es Ihnen nicht schon passiert ist). + In einem weiteren Fall werden Feldmuster variabler Länge +abgeschnitten, nämlich wenn die generierte Zeile die maximale +Zeilenlänge überschreitet. Die maximale Zeilenlänge richtet sich +nach dem Dateilimit, das für das Druckmuster eingestellt ist. Nor +malerweise ist dies 77, so daß Sie in Normalschrift die Zeilenbreite +auf einem DIN A4-Blatt nicht überschreiten. + Benutzen Sie jedoch breites Papier oder eine schmale Schrift, +sollten Sie während der Eingabe des Druckmusters ESC ESC tippen +und das Kommando +#f2# +#beispiel# + limit (135) +#text# +#f2# +eingeben. EUDAS nutzt dann die volle Zeilenbreite aus. + +#a ("Rechtsbündig")# Sie sind jetzt aber noch nicht zu Ende mit den +Feldmustervariationen. Eine letzte Möglichkeit besteht darin, den +Inhalt rechtsbündig in ein Feldmuster einzusetzen. Dies hat natür +lich nur Sinn bei fester Länge. Man erreicht dies dadurch, daß man +das Feldmuster mit mehreren Musterzeichen beginnen läßt. So ist +#f2# +#beispiel# + %%Vorname% +#text# +#f2# +die rechtsbündige Version von +#f2# +#beispiel# + %Vorname%% +#text# +#f2# +Beide Feldmuster sind gleich lang, beim ersten wird jedoch am lin +ken Rand aufgefüllt oder abgeschnitten, beim zweiten dagegen am +rechten Rand. + +#a ("Zusammenfassung")# Hier noch einmal eine Zusammenstellung +aller möglichen Feldmustertypen: + +#beispiel# + Typ ! Beispiel ! Position ! Länge ! bündig + ----+-----------+------------------------------ + 1 ! &Name ! fest ! variabel ! links + 2 ! %Name ! variabel ! variabel ! links + 3 ! &Name&&& ! fest ! fest ! links + 4 ! %Name%%% ! variabel ! fest ! links + 5 ! &&&Name& ! fest ! fest ! rechts + 6 ! %%%Name% ! variabel ! fest ! rechts +#text# + +Wir können zusammenfassen: +#free (0.2)# +#bsp("*")# Feldmuster dienen im Druckmuster dazu, Stellen zu markieren, an + denen Inhalte eingesetzt werden sollen. +#free (0.2)# +#bsp("*")# Feldmuster beginnen mit einem Musterzeichen ('&' oder '%'); + darauf folgt der Feldname. +#free (0.2)# +#bsp("*")# Durch '&' wird feste und durch '%' variable Position festgelegt. +#free (0.2)# +#bsp("*")# Durch zusätzliche Musterzeichen kann eine feste Länge angege + ben werden; mehrere Musterzeichen am Anfang führen zu rechts + bündigem Einsetzen. + +#a ("Abgrenzung der Feldnamen")# Als nächstes sollen Sie den Fall be +trachten, daß Sie einen Namen in der oft auftretenden Form +#f2# +#beispiel# + Name, Vorname +#text# +#f2# +schreiben wollen. Die Schwierigkeit liegt in dem Komma, das direkt +hinter dem Namen folgen soll. Sie könnten versuchen, diese Situa +tion im Druckmuster folgendermaßen darzustellen: + +#beispiel# + % WIEDERHOLUNG + &Name, %Vorname +#text# + +In diesem Fall erhalten Sie aber die Fehlermeldung + +#beispiel# + FEHLER in Zeile 2 bei >>Name,<< + diese Abkuerzung ist nicht definiert +#text# + +Wenn Sie sich nicht genau vorstellen können, wie der Druckgenera +tor ein Feldmuster liest, wird Ihnen dieser Fehler mysteriös er +scheinen, denn 'Name' ist doch als Feld definiert (was eine Abkür +zung ist, werden Sie in Kapitel 13 lernen). Den entscheidenden +Hinweis liefert jedoch das Komma. Offensichtlich hat der Druck +generator das Komma als Teil des Feldnamens angesehen. + Dies liegt daran, daß ja irgendwann der Feldname in einem +Feldmuster beendet sein muß. Normalerweise interpretiert der +Druckgenerator ein Leerzeichen oder Musterzeichen als Ende des +Namens, alle vorherigen Zeichen gehören mit zum Feldnamen. Wenn +nun aber nach dem Feldmuster kein Leerzeichen folgen soll (wie in +unserem Beispiel) oder der Feldname selbst Leerzeichen enthält +(dies ist ja erlaubt, könnte aber im Druckmuster nie erkannt wer +den), muß noch eine zusätzliche Angabe erfolgen. + In solchen Fällen kann der Feldname in spitze Klammern einge +schlossen werden. Der Druckgenerator sieht den Feldnamen dann bei +der ersten schließenden Klammer als beendet an, wobei die Klam +mern natürlich nicht zum Feldnamen gehören, aber auch nicht ge +druckt werden. + Das obige Beispiel müßte also richtig so formuliert werden: + +#beispiel# + % WIEDERHOLUNG + &<Name>, %Vorname +#text# + +Wenn Sie dieses Druckmuster ausprobieren, werden Sie sehen, daß +die Namen tatsächlich in der gewünschten Form erscheinen. + +#a ("Leerautomatik")# Es gibt noch eine trickreiche Automatik in EUDAS, +die in manchen Fällen ganz nützlich ist - und zwar in Fällen, in +denen Sie mehrere Felder als Aufzählung durch Leerzeichen ge +trennt drucken wollen. Nehmen wir an, unsere Adreßdatei hätte +noch ein Feld 'Titel', in das Sie bei Bedarf 'Dr.' oder 'Prof. Dr.' +eintragen. In der Adresse würden Sie dann angeben: + +#beispiel# + &Titel %Vorname %Name +#text# + +Wenn der Titel jedoch leer ist, würde ein störendes Leerzeichen vor +dem Namen bleiben. In einem solchen Fall entfernt EUDAS das Leer +zeichen automatisch. Vorbedingung für diese Automatik ist, daß es +sich um ein Feld variabler Länge handelt und vor dem Feld noch ein +Leerzeichen steht (außer in Spalte 1). + +#a ("Aufgabe")# Sie sollten jetzt die Möglichkeiten des Druckgenerators +soweit kennengelernt haben, daß Sie ein Druckmuster für die zu +Anfang des Kapitels erwähnte Liste aller Dateiinhalte erstellen +können. Versuchen Sie dies zunächst allein, ehe Sie die Lösung +nachschauen. + + +Hier nun die Lösung: + +#beispiel# + % VORSPANN + Vorname Name, Strasse, PLZ Ort, m/w + ------------------------------------------------------- + % WIEDERHOLUNG + &Vorname %<Name>, %<Strasse>, %PLZ %<Ort>, %m/w +#text# + +Beachten Sie die spitzen Klammern, die nötig sind, um das Kom +ma ohne Zwischenraum anzuschließen. + +#a ("Beispiel")# Als letztes Beispiel sollen Sie einen Fall betrachten, bei +dem pro Satz mehr als eine einzelne Listenzeile gedruckt werden +soll, und zwar sollen Sie einen Brief schreiben, in den der Druck +generator die Adressen verschiedener Leute einfügen soll. Die Er +stellung von Formbriefen ist eine sehr häufige Anwendung von +EUDAS. Mit den bisher beschriebenen Konstrukten kann man etwa +folgendes Druckmuster schreiben: + +#beispiel# + % WIEDERHOLUNG + &Vorname %Name + &Strasse + &PLZ %Ort + + Lieber &Vorname ! + + Ich lade Dich mit diesem Brief zu + meiner nächsten Party ein. + Bring gute Laune und was zu Essen mit. + + Viele Grüße + \#page\# +#text# + +Die letzte Zeile zeigt eine Möglichkeit, von der Sie wahrscheinlich +öfter Gebrauch machen werden, nämlich Druckersteuerungsanwei +sungen in das Druckmuster einzufügen. Die Anweisung '\#page\#' +wird an den Drucker weitergereicht und bewirkt, daß nach jedem +Brief eine neue Seite angefangen wird (Sie wollen sicher nicht +mehrere Briefe auf ein Blatt drucken). Sie können auch andere An +weisungen verwenden, z.B. neue Schrifttypen einstellen. Informieren +Sie sich gegebenenfalls, welche Anweisungen die Textkosmetik zur +Verfügung stellt. + +#a ("Ausblick")# Sie kennen jetzt bereits einen großen Teil der Möglich +keiten des Druckgenerators. Einige wünschenswerte Fähigkeiten +fehlen jedoch noch. So wäre es vorteilhaft, wenn abhängig vom +Inhalt des Feldes 'm/w' die Anrede 'Sehr geehrter Herr' oder 'Sehr +geehrte Frau' erzeugt werden könnte. Außerdem könnte das im +Rechner vorhandene Datum automatisch in den Brief übernommen +werden. Diese Möglichkeiten werden den Kapiteln 12 und 13 be +schrieben. + Sie sollten diese jedoch erst dann durchlesen, wenn Sie eine +gewisse Sicherheit im Umgang mit Druckmustern erlangt haben. +Zuvor sollten Sie die Inhalte dieses Kapitels beherrschen, damit Sie +EUDAS gut nutzen können. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.8 b/app/eudas/4.4/doc/user-manual/eudas.hdb.8 new file mode 100644 index 0000000..3799dce --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.8 @@ -0,0 +1,187 @@ +#type ("prop")##limit (14.0)# +#format# +#page (75)# +#kapitel ("8", "Was war", "und was", "noch kommt")# + + + +#abschnitt ("8.1", "RÜCKBLICK", "Rückblick")# + +So! Wenn Sie bis hierhin gut mitgearbeitet haben, haben Sie die +erste und wichtigste Etappe beim Erlernen von EUDAS schon ge +schafft. Bevor Sie kennenlernen, was für Möglichkeiten Ihnen EUDAS +sonst noch bietet, wollen wir die wichtigsten Dinge rekapitulieren, +die Sie gelernt haben sollten. + +#a ("EUDAS-Dateien")# Sie sollten wissen, wie EUDAS-Dateien aussehen, +und daß sie sich von normalen Textdateien unterscheiden. Diese +Unterscheidung sollten Sie immer beachten, denn es gibt Funktio +nen, die nur EUDAS-Dateien annehmen (zum Beispiel 'Öffnen'), +andere, die nur Textdateien annehmen (zum Beispiel 'Textdatei +erstellen') und solche, die mit beliebigen Arten von Dateien "ohne +Ansehen der Person" funktionieren (zum Beispiel 'Kopieren vom +Archiv'). + +#a("Bedienung")# Sie sollten wissen, wie man eine Funktion im Menü +aufruft; wie Sie EUDAS die notwendigen Informationen (zum Beispiel +Dateinamen) mitgeben und wie Sie in besonderen Situationen (Feh +ler, Abbruch) reagieren können. Zur problemlosen Bedienung sollten +Sie auch die jeweilige Statuszeile interpretieren können. + +#a("Dateiverwaltung")# Sie sollten wissen, wie Sie Dateien von Archiv +disketten holen und dort auch wieder abspeichern können. Dazu ist +die Dateiauswahl durch Ankreuzen sehr hilfreich. Sie sollten von +Anfang an darauf achten, daß Sie Ihre Dateien regelmäßig auf dem +Archiv sichern, damit Sie bei etwaigen Problemen mit Ihrem Rechner +die Daten nicht verlieren. + +#a("Öffnen")# Sie sollten wissen, daß Sie eine EUDAS-Datei vor dem +Bearbeiten erst öffnen müssen. Weiterhin sollten Sie mit der Ar +beitskopie umgehen können, die EUDAS bei Änderungen anlegt. +Denken Sie daran, Ihre Datei nach Änderungen zu sichern. Sie soll +ten auch neue EUDAS-Dateien mit eigener Struktur anlegen können. + +#a("Ansehen und Ändern")# Sie sollten wissen, wie Sie die Daten Ihrer +EUDAS-Dateien am Bildschirm abrufen können - entweder manuell +oder mit Hilfe eines Suchmusters. Sie sollten Änderungen und Ein +fügungen durchführen können. + +#a("Drucken")# Sie sollten wissen, wie Sie die Daten einer EUDAS-Datei +mit Hilfe eines Druckmusters ausdrucken können. Denken Sie daran, +daß dies ein zweistufiger Vorgang ist (Generierung der Druckdatei - +Ausgeben an Drucker), den Sie an verschiedenen Stellen beeinflus +sen können. + +Lesen Sie das entsprechende Kapitel erneut durch, wenn Sie sich bei +einem Punkt dieser Aufzählung nicht sicher sind. Wichtig ist auch, +daß Sie die bschriebenen Funktionen selbst am Rechner ausprobiert +haben. + Wenn Sie dies alles geduldig absolviert haben, sind Sie in der +Lage, EUDAS sinnvoll für Ihre eigenen Probleme einzusetzen. Sie +sollten jetzt ruhig versuchen, eigene Lösungen zu realisieren. Sicher +werden Sie dabei erkennen, daß Ihnen noch einige Möglichkeiten +fehlen. Die Chancen sind aber gut, daß EUDAS Ihnen diese Möglich +keiten bietet. + Im nächsten Abschnitt erhalten Sie einen Überblick darüber, +was EUDAS noch zur Verfügung stellt. Dort können Sie sich orien +tieren, welche Kapitel Sie lesen sollten, wenn Sie bestimmte Fragen +haben. + + +#abschnitt ("8.2", "AUSBLICK", "Ausblick")# + +Im zweiten Teil dieses Handbuchs erwarten Sie eine ganze Reihe +interessanter Themen. Dort werden Erweiterungen und Verallgemei +nerungen von Funktionen beschreiben, die Sie bereits kennen. Viele +Funktionen sind jedoch ganz neu und manchmal auch nicht ganz +einfach zu beherrschen. + +#a ("Kapitel 9")# Das neunte Kapitel befaßt sich mit der grundsätzlichen +Struktur der geöffneten Datei. Sie erfahren, daß Sie mehr als eine +Datei gleichzeitig öffnen und bearbeiten können. Zum einen können +Sie gleichartige Dateien verketten oder Dateien über Beziehungen +koppeln. Insbesondere das Koppeln ist eine wichtige Grundlage für +viele fortgeschrittene Anwendungen von EUDAS. + In diesem Kapitel wird auch beschrieben, wie Sie auf einem +Mehrplatzsystem von mehreren Plätzen aus auf die gleichen EUDAS- +Dateien zugreifen können. Die Fähigkeiten von EUDAS auf diesem +Gebiet erreichen nicht das Niveau von großen Datenbanksystemen, +sind jedoch einfach anzuwenden und in vielen Fällen nützlich. + +#a ("Kapitel 10")# Im zehnten Kapitel erfahren Sie, wie Sie den Bildschirm +übersichtlicher gestalten können, wenn Sie Dateien mit zahlreichen +Feldern benötigen. Sie können bestimmte Felder auswählen, aber +auch die Sätze einfach ausschnittweise ansehen. + Das Suchmuster besitzt noch viele Fähigkeiten, die im ersten +Teil nicht zur Sprache gekommen sind. Sie können mehrere Bedin +gungen auf verschiedene Weisen miteinander kombinieren. Auch +einige neue Vergleiche treten auf. Außerdem können Sie mehrere +Felder eines Satzes miteinander vergleichen. + Zum schnellen Überblick steht Ihnen eine Funktion bereit, die +jeweils einen Satz pro Bildschirmzeile anzeigt. In dieser Übersicht +können Sie blättern und auch Sätze markieren (ankreuzen), um Sie +später zu bearbeiten. + +#a ("Kapitel 11")# Das elfte Kapitel ist den Funktionen zur Bearbeitung +gewidmet. Dort erfahren Sie, wie Sie eine Datei sortieren können. +Außerdem können Sie eine Datei ausschnittweise kopieren, wobei Sie +noch eine Vielzahl von Manipulationsmöglichkeiten haben. + Auch das Tragen von mehreren Sätzen in einem Arbeitsgang ist +möglich. Dabei können Konsistenzbedingungen einer Datei überprüft +werden. + Als letztes erfahren Sie, wie man eine EUDAS-Datei automa +tisch nach einer beliebigen Vorschrift ändern kann. Hier, wie bei +den vorherigen Funktionen, werden Sie zum ersten Mal erkennen, +wieviel man mit der Programmiersprache ELAN innerhalb von EUDAS +ohne viel Aufwand machen kann. + +#a ("Kapitel 12")# Das nächste Kapitel zeigt Ihnen weitere Möglichkeiten +zum Drucken. Sie können die Druckausgabe vor dem Drucken noch +mit den Programmen der EUMEL-Textverarbeitung aufbereiten. Auch +innerhalb der EUMEL-Textverarbeitung können Sie EUDAS aufrufen, +um Daten aus einer EUDAS-Datei in den Text einzufügen. + EUDAS kann auch in mehreren Spalten drucken (zum Beispiel +für Etiketten). Schließlich wird noch beschrieben, wie Sie lange +Felder auf mehrere Zeilen aufteilen können und welche speziellen +Möglichkeiten Sie zur Erzeugung von Tabellen haben. + +#a ("Kapitel 13")# Ab hier beginnt die Beschreibung dessen, was die +Ausgabe des Druckgenerators so ungeheuer anpassungsfähig macht: +die Verwendung der Programmiersprache ELAN. + Mit einfachsten ELAN-Elementen können Sie komplizierte For +matierungswünsche erfüllen. Dazu können Sie den Inhalt von Feld +mustern durch vorherige Bearbeitung und durch die Abfrage von +Bedingungen manipulieren. Ganze Musterteile können in Abhängig +keit von Bedingungen variabel gestaltet werden. + Auch der Ablauf von Druckvorgängen kann von Bedingungen +abhängig gemacht werden. So lassen sich gesteuert Vorspann und +Nachspann innerhalb des Ausdrucks einfügen und Zwischenüber +schriften oder -summen bilden (Gruppenverarbeitung). + +#a ("Kapitel 14 und 15")# Für denjenigen, der noch nie mit ELAN zu tun +hatte, werden diese Möglichkeiten sicher nicht ganz einfach zu +verstehen sein. Obwohl die vorherigen Kapitel viele benutzbare +Beispiele enthalten, ist zur vollen Ausnutzung ein gewisses Ver +ständnis von ELAN notwendig. + Dies soll in den Kapitel 14 und 15 vermittelt werden, und zwar +in dem Umfang, in dem es in EUDAS nötig ist (Sie sollen hier nicht +zum ELAN-Programmierer ausgebildet werden). Für den ELAN- +Kenner bieten diese Kapitel sicher nichts Neues, aber sie enthalten +viele Beispiele und Beschreibungen der Funktionen, die für EUDAS +wichtig sind. + Dabei geht Kapitel 15 weiter auf die Sprachmittel für Zählvor +gänge, Auswertungen und statistische Anwendungen ein, während in +Kapitel 14 die grundlegenden Ausdrücke zur Formulierung von +Manipulationen besprochen werden. + +#a ("Kapitel 16")# Im letzten Kapitel geht es dann wieder harmloser zu. +Hier werden die Funktionen beschrieben, die unter EUDAS zur +allgemeinen Dateiverwaltung zur Verfügung stehen. Im Grunde sind +dies alles Funktionen, die vom EUMEL-System zur Verfügung ge +stellt werden. EUDAS integriert sie lediglich in ein Menüsystem, +damit Sie als Benutzer die Funktionen möglichst einfach aufrufen +können. + Aber auch dem erfahrenen EUMEL-Benutzer bieten die Funktio +nen einen zusätzlichen Komfort, da auch hier die praktische Aus +wahl durch Ankreuzen in allen Funktionen vertreten ist. Außerdem +wird die Anzahl von Tastendrücken zum Erreichen eines Ziels ver +ringert. Daher besteht auch für den "Profi" keine Notwendigkeit, +grundsätzlich mit einer Kommandoschnittstelle weiterzuarbeiten. + +#a ("Referenzhandbuch")# Im Referenzhandbuch sind alle hier besproche +nen Funktionen noch einmal in einer sehr kurzen, zusammenfassen +den und abstrakten Form aufgeführt. Dort sollen Sie nachschlagen, +wenn Sie eine ganz bestimmte Information suchen und sich mit +EUDAS bereits auskennen. + Sie können jedoch auch ohne das Referenzhandbuch auskommen, +denn alles, was Sie wissen müssen, steht auch hier im Benutzer +handbuch. + Das Referenzhandbuch enthält auch einen Teil, der sich spe +ziell an den ELAN-Programmierer wendet, der besondere Anwendun +gen mit EUDAS realisieren will. Allerdings sollten alle dort be +schriebenen Möglichkeiten mit Vorsicht betrachtet werden, da sie im +Normalfall nicht so abgesichert sind, wie die hier beschriebenen +Fähigkeiten. Auch sollten Sie mit den Einsatzmöglichkeiten von +ELAN, wie sie in den Kapitel 11 und 13 beschrieben sind, wirklich +alle praktischen Probleme erledigen können. + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.9 b/app/eudas/4.4/doc/user-manual/eudas.hdb.9 new file mode 100644 index 0000000..8294ca0 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.9 @@ -0,0 +1,534 @@ +#type ("prop")##limit (14.0)# +#format# +#page (83)# +#kapitel ("9", "Das", "virtuelle", "Dateikonzept")# + + + +#abschnitt ("9.1", "KONZEPT", "Konzept")# + +Bisher haben Sie zu einem Zeitpunkt immer nur eine EUDAS-Datei +bearbeiten können. Wenn Sie zu einer anderen Datei wechseln woll +ten, mußten Sie die eine Datei sichern und die andere Datei wieder +öffnen. Es gibt jedoch Fälle, in denen Beziehungen zwischen mehre +ren Dateien bestehen. Daher kann EUDAS auch mit mehreren Dateien +gleichzeitig umgehen. + Es hat jedoch Vorteile, wenn man nur mit einer Datei arbeitet. +Sie müssen dann nicht immer den Namen der gewünschten Datei +angeben, wenn Sie eine Funktion ausführen. Dies brauchen Sie nur +einmal beim Öffnen zu tun - danach ist eindeutig festgelegt, wel +che Datei gemeint ist. + EUDAS versucht diese Vorteile auch bei mehreren Dateien zu +erhalten. Die verschiedenen Dateien werden so kombiniert, daß eine +neue Datei entsteht. Sie arbeiten dann nur mit dieser Datei, die alle +Daten der Einzeldateien enthält. + Damit Sie aber nicht so lange warten müssen, geschieht dieser +Kombinationsvorgang erst beim Ansehen. Die kombinierte Datei ist +also nicht wirklich vorhanden, sondern ihre Einzelsätze werden nur +bei Bedarf erzeugt. Daher heißt diese Gesamtdatei auch #on("i")#virtuelle#off("i")# +(scheinbare) Datei. + Eine Kombination von Dateien ist auf zwei Arten möglich. Sie +können gleichartige Dateien hintereinander#on("i")#ketten#off("i")#, oder Sie können +Dateien über gemeinsame Felder #on("i")#koppeln#off("i")#. Beide Methoden können +auch kombiniert werden. + +#a ("Änderungen")# Die virtuelle Datei kann auch verändert werden. Die +Veränderungen werden dann in den entsprechenden Ursprungsda +teien vorgenommen. Es ist jedoch nicht immer eindeutig, wie diese +Änderungen aussehen sollen. Achten Sie daher auf die speziellen +Regeln, die bei solchen Änderungen gelten, damit Sie die Auswir +kungen einer Änderung abschätzen können. + Wenn Sie Veränderungen vorgenommen haben, müssen Sie die +Arbeitskopien anschließend wieder sichern. Denken Sie daran, daß +EUDAS immer auf unbenannten Kopien arbeitet, wenn Sie ändern +wollen. Beim Sichern von mehreren Dateien wird Ihnen zu jeder +Datei einzeln angezeigt, ob sie tatsächlich verändert wurde. Sie +können dann ebenfalls einzeln entscheiden, ob Sie die Datei sichern +wollen oder nicht. + + +#abschnitt ("9.2", "KETTEN", "Ketten")# + +Wenn Sie einmal EUDAS-Dateien mit mehreren tausend Sätzen er +stellen, werden Sie feststellen, daß deren Handhabung recht um +ständlich sein kann. Da die Datei sehr groß ist, dauern zum Beispiel +Kopiervorgänge aufs Archiv viel länger als bei kleinen Dateien. + Wenn Sie nun auch noch für jede kleine Änderung die Datei +vom Archiv holen und anschließend wieder zurückschreiben müssen, +werden Sie einen Weg suchen, diese Arbeit zu erleichtern. Die ein +fachste Möglichkeit wäre, einen schnelleren Rechner zu kaufen. Dies +ist gleichzeitig aber auch die teuerste. + +#beispiel# +#free (4.5)# + +#center#Abb. 9-1 Verkettung von A und B +#text# + +EUDAS ermöglicht es Ihnen nun, die große Datei in mehrere kleine +aufzuspalten. In der Regel gibt es bei solch großen Dateien ein +Kriterium, nach dem die Sätze in verschiedene Dateien verteilt +werden können. Jede einzelne Datei kann nun bequem geändert +werden. + Ein Problem entsteht jedoch, wenn alle Dateien zusammen ver +arbeitet werden müssen (zum Beispiel beim Drucken). Für einen +solchen Vorgang können Sie die kleineren Dateien logisch aneinan +derketten. + Dies bedeutet für Sie, daß alle kleinen Dateien wie eine große +Datei wirken. Wenn Sie beim Bewegen in der Datei das Ende einer +einzelnen Datei erreichen, kommen Sie automatisch an den Anfang +der nächsten Datei. + +#a ("Aufruf")# Damit dies funktioniert, müssen die Dateien natürlich +gleiche Feldstruktur haben. Außerdem ist die Zahl der verkettbaren +Dateien aus technischen Gründen auf 10 beschränkt. + Sie können die Dateien verketten, indem Sie die Funktion +#free (0.2)# +#beispiel# + K Ketten +#text# +#free (0.2)# +im Menü 'Öffnen' aufrufen. + +#a ("Änderungen")# In der virtuellen Datei ist sowohl Einfügen als auch +Ändern erlaubt. Beim Einfügen ist jedoch zu beachten, daß am Ende +einer Datei nicht angefügt werden kann. Dies liegt daran, daß Sie +entweder vor dem letzten Satz der einen Datei oder vor dem ersten +Satz der anderen Datei einfügen. Der Endesatz der einen Datei, der +normalerweise sichtbar wäre, wird übersprungen. + Am Ende der letzten Datei können Sie natürlich anfügen, da +deren Endemarkierung als Ende der ganzen Datei ja wieder sichtbar +ist. + + +#abschnitt ("9.3", "KOPPELN", "Koppeln")# + +Nachdem das Verketten von Dateien noch ganz einfach zu verstehen +war, kommt jetzt eine Funktion auf Sie zu, die kompliziertere Mög +lichkeiten in sich birgt: nämlich das Koppeln. + Es kommt häufiger vor, daß sich ein Feld einer Datei auf einen +bestimmten Satz in einer anderen Datei bezieht. So könnten zum +Beispiel die Ausleihen einer Bücherei in folgender Datei gespeichert +sein: + +#beispiel# + 'Name' + 'Vorname' + 'Datum' + 'Buch-Nr.' +#text# + +Wenn jetzt ein Ausleiher sein Rückgabedatum überschritten hat, +möchte die Bücherei dem Kunden ein Mahnschreiben schicken. Auf +diesem Schreiben soll aber nicht die Buch-Nr. erscheinen, sondern +Autor und Titel des Buches. + Diese Sekundärinformationen sind in einer anderen Datei ge +speichert, der Bestandskartei: + +#beispiel# + 'Buch-Nr.' + 'Autor' + 'Titel' + 'Verlag' +#text# + +Alle Dateistrukturen hier sind natürlich zwecks größerer Übersicht +lichkeit vereinfacht. Um jetzt dem Kunden das Mahnschreiben zu +schicken, müssen die Informationen in den beiden Dateien korreliert +werden. + +#a ("Aufruf")# Zuerst wird die Ausleihdatei normal geöffnet. Dazu wird +dann die Bestandsdatei mit Hilfe der Funktion +#free (0.2)# +#beispiel# + K Koppeln +#text# +#free (0.2)# +gekoppelt. Dies hat folgenden Effekt: + Die Sätze erscheinen normal so, wie sie in der Ausleihdatei +auftauchen, also für jede Ausleihe genau ein Satz. Dazu erscheint +aber jeweils die Beschreibung des ausgeliehenen Buches aus der +Bestandsdatei: die beiden Dateien wurden über das Feld "Buch-Nr." +gekoppelt. + Als Struktur ergibt sich für die kombinierte Datei: + +#beispiel# + 'Name' + 'Vorname' + 'Datum' + 'Buch-Nr.' + 'Titel' + 'Autor' + 'Verlag' +#text# + +Die Felder der Koppeldatei wurden also noch hinzugefügt. + +#a ("Koppelfelder")# Zwei Dinge sind in diesem Zusammenhang wichtig: +Damit der Koppelvorgang ohne allzuviele Vorgaben auskommen kann, +müssen Felder, über die gekoppelt wird, den gleichen Namen haben +- und zwar exakt Zeichen für Zeichen. Zum zweiten muß ein solches +#on("i")#Koppelfeld#off("i")# am Anfang der gekoppelten Datei (in unserem Fall der +Bestandsdatei) stehen. Dies ist aus technischen Gründen notwendig, +damit der Koppelvorgang in vernünftiger Geschwindigkeit ablaufen +kann. + +#beispiel# +#free (7.0)# + +#center#Abb. 9-2 Schema des Koppelvorgangs +#text# + +#a ("Mehrere Dateien")# Genau wie beim Ketten ist die Kombination der +Dateien nicht physikalisch, sondern nur scheinbar vollzogen worden. +Bis zum Limit der maximal geöffneten Dateien (10) können Sie auch +weitere Dateien dazukoppeln. Die Koppelfelder dieser Dateien kön +nen sich jedoch immer nur auf die erste Datei beziehen, also nicht +auf eine andere Koppeldatei. + Dies könnte man in unserem Beispiel ausnutzen. Die Bücherei +hat sicher auch eine Datei ihrer Mitglieder. Diese könnte etwa so +aussehen: + +#beispiel# + 'Name' + 'Vorname' + 'm/w' + 'Strasse' + 'PLZ' + 'Ort' +#text# + +Diese Datei können wir ebenfalls zur Ausleihdatei dazukoppeln. +Damit haben wir auch gleich die Quelle gewonnen, aus der wir die +Anschrift für das Mahnschreiben gewinnen können. + Die Kopplung geschieht in diesem Fall über zwei Felder, näm +lich 'Name' und 'Vorname'. Damit ein Mitglied eindeutig identifi +ziert wird, werden beide Namen gebraucht. Dies berücksichtigt auch +das Koppelverfahren. Wiederum müssen die Namen exakt mit Namen +der ersten Datei übereinstimmen. + Wenn mehrere Koppelfelder für eine Koppeldatei notwendig sind, +müssen Sie alle hintereinander stehen. Wäre die Struktur der Mit +gliederdatei etwa + +#beispiel# + 'Name' + 'Titel' + 'Vorname' + 'm/w' + 'Strasse' + 'PLZ' + 'Ort' +#text# + +würde nur über 'Name' gekoppelt, da 'Titel' in der ersten Datei +nicht vorkommt. Alle weiteren Felder können dann keine Koppelfel +der mehr werden. Durch Umstellen der Feldreihenfolge der Koppel +datei (durch Umkopieren) oder durch entsprechende Benennung von +Feldern können Sie immer den gewünschten Effekt erzielen. + +#beispiel# +#free (8.0)# + +#center#Abb. 9-3 Aufbau der virtuellen Datei +#text# + +#a ("Zusammenfassung")# An dieser Stelle wollen wir die Ergebnisse die +ses Abschnitts als Regel zusammenfassen: + +#limit (12.0)# + Die ersten Felder der Koppeldatei, die wörtlich an be + liebiger Stelle auch in der ersten Datei auftauchen, + werden Koppelfelder genannt. Zu einem Satz der ersten + Datei wird ein Satz der Koppeldatei gezeigt, der im In + halt der Koppelfelder übereinstimmt. +#limit (13.5)# + +Übersetzt in unser Beispiel heißt dies: 'Buch-Nr.' bzw. 'Name' und +'Vorname' sind Koppelfelder. Zu einer bestimmten Ausleihe erschei +nen die Daten des Buches mit der angegebenen Buch-Nr. bzw. die +Adresse des Mitgliedes mit den angegebenen Namen. + + +#abschnitt ("9.4", "AUSWIRKUNGEN DES KOPPELNS", "Auswirkungen des Koppelns")# + +Nachdem Sie nun das Grundprinzip des Koppelns kennen, sollen Sie +einige Auswirkungen dieses Verfahrens kennenlernen. + Ein Beispiel dazu finden Sie in Abb. 9-4. Dargestellt sind je +weils die Satznummern und einige Inhalte. Die zweite Zeile in der +Hauptdatei und die erste in der Koppeldatei stellen das Koppelfeld +dar. + +#beispiel# +#free (6.5)# + +#center#Abb. 9-4 Kombinationen +#text# + +#a ("Kombinationen")# Zuerst muß geklärt werden, was passiert, wenn es +keinen passenden Satz in der Koppeldatei gibt. Zum Beispiel könnte +eine Buchnummer eingegeben worden sein, die in der Bestandsdatei +nicht existiert. In diesem Fall zeigt EUDAS für die Felder der Kop +peldatei einfach einen leeren Inhalt an (siehe Satz 23 der Haupt +datei, es gibt keinen Satz mit 'L' in der Koppeldatei). + Wenn umgekehrt zu einem bestimmten Buch keine Ausleihe +existiert, macht das natürlich nichts - das Buch erscheint nur +dann, wenn Sie die Bestandsdatei alleine öffnen. + Weiterhin kann es passieren, daß es zwei passende Sätze in der +Koppeldatei gibt. Dies kommt dann vor, wenn zwei Mitglieder glei +chen Namen und gleichen Vornamen haben (was gar nicht so selten +ist). In diesem Fall zeigt EUDAS beide Kombinationen an (siehe +Satz 23 der Hauptdatei). Die Ausleihe erscheint also zweimal, je +weils mit einem anderen Mitglied. + Damit man diesen Fall ohne weiteres erkennen kann, führt +EUDAS bei Kopplungen zwei Nummern: zum einen die normale Satz +nummer und zum anderen eine Kombinationsnummer. In dem eben +besprochenen Fall würde die Satznummer gleichbleiben, die Kombi +nationsnummer aber hochgezählt werden. Am Bildschirm wird die +Kombinationsnummer durch Bindestrich getrennt hinter die Satz +nummer geschrieben, wenn Sie Dateien koppeln. + Das Durchgehen aller Kombinationen zu einem Satz der Haupt +datei passiert aber nur dann, wenn Sie sich mit der Funktion 'Satz +weiter' in der Datei bewegen. Wenn Sie rückwärts gehen oder auf +einen bestimmten Satz positionieren, wird immer nur die erste Kom +bination angezeigt (Dies hat zum Teil technische Gründe). Beim +Zurückgehen von Satz 23-1 in dem Beispiel würde also auf Satz +22-1 positioniert und die Kombination 22-2 übersprungen. + +#a ("Änderungen")# Auch wenn Sie Dateien gekoppelt haben, können Sie +immer noch Sätze ändern und einfügen (wenn Sie dies beim Öffnen +erlaubt haben). Die Auswirkungen der Veränderungen sind jedoch +nicht mehr ganz so einfach wie bei geketteten Dateien, wo sich die +Änderungen ja einfach auf den aktuellen Satz bezogen. + Als Grundregel gilt, daß Änderungen möglichst wenig Auswir +kungen auf die Koppeldateien haben sollen. Das führt dazu, daß +beim Einfügen eines neuen Satzes oder beim Entfernen eines Satzes +durch Tragen keine Aktion in der Koppeldatei durchgeführt wird. +Dies ist auch nicht nötig, denn wenn zum Beispiel ein neuer (zu +nächst leerer) Satz eingefügt wird, existiert sowieso noch kein +passender Satz in der Koppeldatei und die entsprechenden Felder +bleiben leer. Hingegen darf beim Entfernen eines Satzes der Satz in +der Koppeldatei nicht entfernt werden, da er ja noch zu einem an +deren Satz gehören könnte. + Änderungen an den Koppelfeldern können nun zu drei verschie +denen Reaktionen führen: + +1. Es wird kein Satz der Koppeldatei geändert, sondern nur ein + neuer passender Satz gesucht. Dies geschieht immer dann, wenn + außer den Koppelfeldern nur leere Inhalte für die Felder der + Koppeldatei angegeben sind. Nach dem Ändern oder Einfügen + werden dann die Inhalte des neuen Koppelsatzes angezeigt. + + Beispiel: Bei einer Ausleihe geben Sie Name und Vorname des + Ausleihers an, nicht aber seine Adresse. Wenn Sie den Satzedi + tor beim Einfügen mit ESC 'q' verlassen, wird die zugehörige + Adresse angezeigt (falls der entsprechende Name in der Kop + peldatei vorhanden ist). + +2. Es wird ein neuer Satz in der Koppeldatei angefügt. Dies ge + schieht immer dann, wenn die Koppelfelder verändert wurden + und die anderen Felder der Koppeldatei nicht leer sind. Da + durch soll verhindert werden, daß die Koppelfelder in einem + Satz verändert werden, der vielleicht noch zu einem anderen + Satz paßt. + + Beispiel: Sie geben bei einer Ausleihe auch die Adresse mit + an. Wenn eine Person mit gleichem Namen und Vornamen bereits + existiert, wird die dort gespeicherte Adresse nicht überschrie + ben. Stattdessen wird die zweite Adresse auch in die Koppel + datei eingetragen. Beim nächsten Ansehen bekommen Sie dann + zwei Adressen angezeigt. So wird verhindert, daß Sie ungewollt + die erste Adresse vernichten. + +3. Der Satz in der Koppeldatei wird verändert. Dies geschieht nur + dann, wenn die Koppelfelder unverändert geblieben sind, der + Rest sich aber geändert hat. + + Beispiel: Sie ändern eine Ausleihe mit der zugehörigen + Adresse. Sie geben nur eine neue Straße an und lassen Name + und Vorname unverändert. Der Satz in der Koppeldatei enthält + anschließend die neue Straße. + +Da Koppeldateien keine Sortierung besitzen müssen, werden neue +Sätze der Koppeldatei immer am Ende angefügt. Dies ist zu beach +ten, wenn die Koppeldatei auch allein verwendet werden soll. Ge +gebenenfalls müssen Sie die Koppeldatei dann erst sortieren. + + +#abschnitt ("9.5", "UMSCHALTEN AUF KOPPELDATEI", "Umschalten auf Koppeldatei")# + +Häufig kommt es vor, daß Sie beim Einfügen eines neuen Satzes mit +gekoppelten Dateien die Verbindung mit einem existierenden Satz +der Koppeldatei erreichen wollen, aber den notwendigen Inhalt der +Koppelfelder nicht auswendig wissen. + So wollen Sie beim Eingeben einer Ausleihe Name und Vorname +des Entleihers nicht immer wieder abtippen. Dabei ist auch die +Gefahr von Eingabefehlern sehr groß. Stattdessen wollen Sie lieber +erst den Entleiher in der Mitgliederdatei suchen und dessen Namen +dann automatisch in den Entleihsatz übernehmen. + Hierfür bietet Ihnen EUDAS eine Unterstützung an. + +#a ("Ausführung")# Während Sie sich in der virtuellen Datei befinden, +können Sie auf eine bestimmte Koppeldatei umschalten, die Sie dann +wie eine Einzeldatei bearbeiten können. Beim Zurückschalten haben +Sie dann die Möglichkeit, die Koppelfelder des gefundenen Satzes zu +übernehmen. + Das Umschalten bewirken Sie durch die Tastenkombination ESC +'K' (großes K) nur im Menü 'Einzelsatz' sowie im Satzeditor beim +Einfügen und Ändern. An anderen Stellen hat dieser Befehl keine +Wirkung. Bei mehreren Koppeldateien werden Ihnen die Dateien der +Reihenfolge nach angeboten. Durch Verneinung aller Fragen können +Sie die Funktion ohne Wirkung beenden. + Haben Sie nun umgeschaltet, wird Ihnen die Koppeldatei dar +geboten, als hätten Sie sie allein geöffnet. Sie können die Datei +auch beliebig ändern (wenn Sie dies beim Öffnen angegeben haben). +Nur die Anzeige #bsp ("<KOPPEL>")# in der Bildüberschrift zeigt an, daß Sie +sich in einer Koppeldatei befinden. Sie können auch Funktionen in +anderen Menüs aufrufen. + Das Zurückschalten geschieht im Menü 'Einzelsatz' mit der +gleichen Tastenkombination. Alle Einstellungen der virtuellen Datei +von vorher bis auf die Feldauswahl bleiben erhalten. + Wenn Sie nicht im Menü, sondern im Satzeditor (also beim +Ändern oder Einfügen) umschalten, werden Sie zunächst wieder aus +dem Satzeditor rausgeworfen. Sie können dann in der Koppeldatei +den gewünschten Satz aufsuchen (oder neu eintragen). Beim Zurück +schalten werden Sie gefragt, ob Sie die Koppelfelder übernehmen +wollen oder nicht. Danach kehren Sie automatisch wieder in den +Satzeditor zurück, wobei jetzt die Koppelfelder gegebenenfalls aus +gefüllt oder überschrieben sind. + Durch erneutes Umschalten können Sie den Vorgang auch für +weitere Koppeldateien wiederholen. + Die Position, die Sie beim Umschalten in der Koppeldatei einge +nommen haben, wird bis zum nächsten Umschalten gespeichert. Sie +kommen dann zunächst wieder auf den gleichen Satz. So können Sie +die gleichen Koppelfelder wie beim letzten Mal übernehmen, indem +Sie einfach zweimal ESC 'K' tippen. + +#a ("Beispiel")# Der typische Vorgang beim Entleihen würde dann wie folgt +aussehen. Zunächst öffnen Sie die Entleihdatei mit Änderungser +laubnis; dann koppeln Sie die Mitgliederdatei und die Bestandsdatei +dazu. + Für eine neue Ausleihe rufen Sie zunächst die Funktion 'Ein +fügen' auf. Dann tippen Sie ESC 'K' und schalten auf die Mitglie +derdatei um. Dort suchen Sie das Mitglied und schalten wieder zu +rück. Existierte das Mitglied noch nicht, können Sie es gleich ein +tragen. Beim Zurückschalten übernehmen Sie den Namen des Mit +glieds. + Dann tragen Sie die Nummer des Buches ein (die müssen Sie nur +dann suchen, wenn Sie nicht auf dem Buch steht). Das Entleihdatum +erhalten Sie mit Hilfe der Tastenkombination ESC 'D' (wird im näch +sten Kapitel beschrieben). + Wollen Sie mehrere Ausleihen für ein Mitglied eintragen, so +tippen Sie beim nächsten Einfügen einfach zweimal ESC 'K', ohne +dazwischen eine Positionierung vorzunehmen. + + +#abschnitt ("9.6", "MEHRFACHBENUTZUNG", "Mehrfachbenutzung")# + +EUDAS ermöglicht es mehreren Benutzern an einem Rechner, mit den +gleichen Dateien zu arbeiten. Dies ist eigentlich nichts Besonderes, +denn das EUMEL-System ist ja bereits von Haus aus dazu geeignet. +Es müssen jedoch einige Schutzvorkehrungen getroffen werden, +damit dadurch keine Probleme entstehen. + Als Grundvoraussetzung für die Mehrfachbenutzung müssen +EUDAS-Dateien in einer unabhängigen #on("i")#Managertask#off("i")# gespeichert +sein. Eine Managertask kann man sich durch das Kommando 'global +manager' einrichten. In dieser Task sollte dann nicht mehr gearbei +tet werden. + Stattdessen kann sich der Benutzer Dateien aus dieser Mana +gertask kopieren und auch wieder dorthin zurückschreiben. Wie Sie +dies im EUDAS-Menü bewerkstelligen können, wird im Kapitel 16 +beschrieben. Es sei nochmal betont, daß dies eine Methode ist, die +Sie für beliebige Dateien verwenden können. + Im Kapitel 16 ist weiterhin auch beschrieben, wie Sie solche +Dateien mit #on("i")#Passworten#off("i")# schützen können, so daß sie nicht jeder +benutzen kann. Schauen Sie bei Bedarf dort nach. + +#beispiel# +#free (7.7)# + +#center#Abb. 9-5 Mehrfachbenutzung +#text# + +#a ("Konflikte")# Wir wollen uns jedoch jetzt um ein Problem kümmern, das +bei dieser Art von Mehrfachbenutzung auftritt. Nehmen wir an, +unsere Bücherei habe zwei Plätze, an denen Entleihen durchgeführt +werden können. Beide Plätze sollen mit der gleichen Entleihdatei +arbeiten (wie Sie gleich noch sehen werden und aus anderen Grün +den würde man EUDAS für eine solche Bücherei nicht einsetzen - +wir wollen hier nur das Prinzip illustrieren). + Der Ablauf wäre dann folgendermaßen. Jeder Platz kopiert sich +für eine Entleihe die gemeinsame Datei aus der Managertask, öffnet +sie, trägt die Entleihe ein und sichert die Datei wieder. Dann wird +die Datei in die Managertask zurückgeschrieben, wo sie die alte +Entleihdatei ersetzt. + Abgesehen von dem viel zu hohen manuellen Aufwand kann der +Fall eintreten, daß beide gleichzeitig eine Entleihe bearbeiten. +Nehmen wir an, beide benutzen die Entleihdatei mit dem symboli +schen Inhalt A. Auf Platz 1 kommt noch die Entleihe B, auf Platz 2 +die Entleihe C dazu. Platz 1 will anschließend den Inhalt AB zu +rückschreiben, Platz 2 den Inhalt AC. + Je nach der zeitlichen Reihenfolge wird nur eine der beiden +Versionen übrigbleiben, da derjenige, der später zurücksichert, die +vorherige Version überschreibt. Richtig sollte die endgültige Version +ABC herauskommen. Unser Beispiel führt jedoch auf jeden Fall zu +einer fehlerhaften Datei. + Grund dafür ist, daß beim Zurückschreiben der ganzen Datei ein +Platz gesperrt werden muß, während der andere Platz eine Datei +zum Ändern angefordert hat. Man könnte auch dazu übergehen, nur +einzelne Sätze zu übertragen; diese Methode wird jedoch von EUDAS +wegen des hohen Aufwandes nicht unterstützt (daher würde man +EUDAS eben auch nicht für eine Mehrplatz-Bücherei nehmen). + In vielen Fällen reicht das Sperren ganzer Dateien jedoch aus, +besonders, wenn nicht ganz so häufig an einzelnen Sätzen geändert +wird. EUDAS bietet dafür neben der notwendigen Sperre auch noch +eine automatische Versendung der Dateien an. + +#a ("Manager")# Es bietet sich an, dieses Kopieren der Dateien beim Öff +nen (auch Koppeln und Ketten) und Sichern automatisch durchzu +führen. Als Voraussetzung dafür müssen Sie EUDAS angeben, mit +welcher Managertask Sie arbeiten wollen. Dazu dient die Funktion +#free (0.2)# +#beispiel# + M Manager +#text# +#free (0.2)# +im Menü 'Öffnen'. Sie werden dann nach dem Namen der Task ge +fragt. Geben Sie keinen Namen an, wird der Managermodus wieder +ausgeschaltet. Welche Task als Manager eingestellt ist, sehen Sie in +der untersten Bildschirmzeile. + In der Task, die Sie angeben, muß EUDAS insertiert sein (oder +in einem Vater), da sonst die Sperre nicht funktioniert. + Wenn Sie nun einen solchen Manager angegeben haben, können +Sie beim Öffnen Dateinamen aus dieser Task angeben. Auch bei ESC +'z' werden Ihnen alle Namen aus dem Manager mit angeboten. Wenn +Sie einen solchen Namen angeben, der nicht aus Ihrer eigenen Task +stammt, wird die Datei vor dem Öffnen automatisch kopiert. Wenn +Sie angegeben haben, daß Sie die Datei verändern wollen, wird in +der Managertask eine entsprechende Sperre gesetzt. + Wenn Sie die Datei nach Änderungen dann sichern, wird die +geänderte Kopie zurückgeschrieben. Die Sperre wird jedoch erst +dann aufgehoben, wenn Sie die Arbeitskopien endgültig löschen. + Möchte nun ein anderer Benutzer diese Datei öffnen, während +Sie sie ändern, kann er dies nur, wenn er sie nicht ändern will. +Natürlich wird die Datei dann auch nicht wieder zurückgeschickt. +Will er sie ändern, erhält er eine Fehlermeldung und kann den +Versuch später wiederholen. + +#a ("Vorsichtsmaßregeln")# Bedenken Sie, daß der Schutz nur wirksam sein +kann, wenn Sie diesen Vorgang nicht unter Umgehung der Menü +steuerung ausführen. Würden Sie sich zum Beispiel eine Datei vom +Manager holen (s. Kapitel 16), ohne daß Sie ein Änderungsvorhaben +anmelden können, können Sie diese Datei ja trotzdem ändern und +wieder zurückschicken. In diesem Fall hat EUDAS keine Kontrolle +mehr über die Datei. + Aus dem gleichen Grund sollten Sie sich die Managertask auch +nicht an Ihren Bildschirm holen, denn auch dann könnten Sie ohne +Kontrolle Änderungen durchführen (zudem kann der Manager wäh +rend dieser Zeit nicht auf andere Benutzer reagieren). + Nur wenn Sie eine neue Datei im Manager anlegen, müssen Sie +dies von Hand tun. Dazu erstellen Sie die Datei ganz normal und +schreiben Sie mit der in Kapitel 16 beschriebenen Funktion zum +Manager. Sie sollten jedoch darauf achten, daß dort nicht schon +eine Datei gleichen Namens liegt (EUDAS fragt ja dann, ob über +schrieben werden soll). + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.inhalt b/app/eudas/4.4/doc/user-manual/eudas.hdb.inhalt new file mode 100644 index 0000000..edd8709 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.inhalt @@ -0,0 +1,172 @@ +#type ("prop")##limit (14.0)# +#format# +#kapitel (" ", " Inhalt", "", " ")# + + + +#type ("12")# + Vorwort . . . . . . . . . . . . . . . . . . . i + Inhalt . . . . . . . . . . . . . . . . . . . . iii + + +#type ("prop")# +#abschnitt ("I.", "DIE ERSTEN SCHRITTE", "Die ersten Schritte")# + +#type ("prop")# +#on("b")#1 Was kann EUDAS ?#off("b")# +#free (0.2)# +#type ("12")# +1.1 Textverarbeitung und Datenverwaltung . . . . . 3 +1.2 EUDAS als Karteikasten . . . . . . . . . . . . 5 +1.3 Drucken . . . . . . . . . . . . . . . . . . . 7 +1.4 Grenzen . . . . . . . . . . . . . . . . . . . 9 + +#type ("prop")# +#on("b")#2 Installation#off("b")# +#free (0.2)# +#type ("12")# +2.1 Lieferumfang . . . . . . . . . . . . . . . . . 11 +2.2 Single-User . . . . . . . . . . . . . . . . . 12 +2.3 Multi-User . . . . . . . . . . . . . . . . . . 13 + +#type ("prop")# +#on("b")#3 Ein Beispiel zum Ausprobieren#off("b")# +#free (0.2)# +#type ("12")# +3.1 Start . . . . . . . . . . . . . . . . . . . . 15 +3.2 Daten eintragen . . . . . . . . . . . . . . . 16 +3.3 Daten abfragen . . . . . . . . . . . . . . . . 21 +3.4 Drucken . . . . . . . . . . . . . . . . . . . 22 +3.5 Ergebnis . . . . . . . . . . . . . . . . . . . 24 + + +#type ("prop")# +#abschnitt ("II.", "EINFÜHRUNG IN DIE BENUTZUNG", "Einführung in die Benutzung")# + +#type ("prop")# +#on("b")#4 Umgang mit Dateien und Menüs#off("b")# +#free (0.2)# +#type ("12")# +4.1 EUDAS-Dateien . . . . . . . . . . . . . . . . 27 +4.2 EUDAS-Menüs . . . . . . . . . . . . . . . . . 29 +4.3 Archivmenü . . . . . . . . . . . . . . . . . . 32 +4.4 Dateiverwaltung . . . . . . . . . . . . . . . 37 +4.5 Bedienungsregeln . . . . . . . . . . . . . . . 39 + +#type ("prop")# +#on("b")#5 Gespeicherte Daten abfragen#off("b")# +#free (0.2)# +#type ("12")# +5.1 Öffnen . . . . . . . . . . . . . . . . . . . . 43 +5.2 Bewegen . . . . . . . . . . . . . . . . . . . 45 +5.3 Suchen . . . . . . . . . . . . . . . . . . . . 46 +5.4 Suchbedingungen . . . . . . . . . . . . . . . 49 + +#type ("prop")# +#on("b")#6 Daten eingeben und ändern#off("b")# +#free (0.2)# +#type ("12")# +6.1 Neue Datei einrichten . . . . . . . . . . . . 51 +6.2 Sätze einfügen . . . . . . . . . . . . . . . . 52 +6.3 Daten ändern . . . . . . . . . . . . . . . . . 55 +6.4 Arbeitskopie sichern . . . . . . . . . . . . . 56 + +#type ("prop")# +#on("b")#7 Ausdrucken der Daten#off("b")# +#free (0.2)# +#type ("12")# +7.1 Druckmuster . . . . . . . . . . . . . . . . . 61 +7.2 Aufruf . . . . . . . . . . . . . . . . . . . . 64 +7.3 Abschnitte . . . . . . . . . . . . . . . . . . 67 +7.4 Feldmuster . . . . . . . . . . . . . . . . . . 69 + +#type ("prop")# +#on("b")#8 Was war und was noch kommt#off("b")# +#free (0.2)# +#type ("12")# +8.1 Rückblick . . . . . . . . . . . . . . . . . . 75 +8.2 Ausblick . . . . . . . . . . . . . . . . . . . 76 + + +#type ("prop")# +#abschnitt ("III.", "WEITERE MÖGLICHKEITEN", "Weitere Möglichkeiten")# + +#type ("prop")# +#on("b")#9 Das virtuelle Dateikonzept#off("b")# +#free (0.2)# +#type ("12")# +9.1 Konzept . . . . . . . . . . . . . . . . . . . 83 +9.2 Ketten . . . . . . . . . . . . . . . . . . . . 84 +9.3 Koppeln . . . . . . . . . . . . . . . . . . . 85 +9.4 Auswirkungen des Koppelns . . . . . . . . . . 89 +9.5 Umschalten auf Koppeldatei . . . . . . . . . . 92 +9.6 Mehrfachbenutzung . . . . . . . . . . . . . . 93 + +#type ("prop")# +#on("b")#10 Datenabfrage am Bildschirm#off("b")# +#free (0.2)# +#type ("12")# +10.1 Feldauswahl . . . . . . . . . . . . . . . . . 97 +10.2 Satzeditor . . . . . . . . . . . . . . . . . . 98 +10.3 Suchmuster . . . . . . . . . . . . . . . . . . 99 +10.4 Markieren . . . . . . . . . . . . . . . . . . 104 +10.5 Übersicht . . . . . . . . . . . . . . . . . . 105 + +#type ("prop")# +#on("b")#11 Funktionen zur Bearbeitung#off("b")# +#free (0.2)# +#type ("12")# +11.1 Sortieren . . . . . . . . . . . . . . . . . . 109 +11.2 Kopieren . . . . . . . . . . . . . . . . . . . 112 +11.3 Tragen . . . . . . . . . . . . . . . . . . . . 118 +11.4 Automatische Änderungen . . . . . . . . . . . 121 + +#type ("prop")# +#on("b")#12 Weitere Möglichkeiten zum Drucken#off("b")# +#free (0.2)# +#type ("12")# +12.1 Anschluß an die Textverarbeitung . . . . . . . 123 +12.2 Spaltendruck . . . . . . . . . . . . . . . . . 126 +12.3 Modi . . . . . . . . . . . . . . . . . . . . . 128 + +#type ("prop")# +#on("b")#13 Programmierung von Druckmustern#off("b")# +#free (0.2)# +#type ("12")# +13.1 Abkürzungen . . . . . . . . . . . . . . . . . 133 +13.2 Bedingte Musterteile . . . . . . . . . . . . . 141 +13.3 Übersetzung . . . . . . . . . . . . . . . . . 142 +13.4 Gruppen . . . . . . . . . . . . . . . . . . . 144 + +#type ("prop")# +#on("b")#14 Ausdrücke in ELAN#off("b")# +#free (0.2)# +#type ("12")# +14.1 Was sind Ausdrücke ? . . . . . . . . . . . . . 151 +14.2 Datentypen . . . . . . . . . . . . . . . . . . 152 +14.3 TEXT-Funktionen . . . . . . . . . . . . . . . 156 +14.4 Rechenfunktionen . . . . . . . . . . . . . . . 160 +14.5 Abfragen . . . . . . . . . . . . . . . . . . . 161 + +#type ("prop")# +#on("b")#15 Anweisungen in ELAN#off("b")# +#free (0.2)# +#type ("12")# +15.1 Variablen und Zuweisungen . . . . . . . . . . 165 +15.2 Weitere Konstruktionen . . . . . . . . . . . . 168 + +#type ("prop")# +#on("b")#16 Dateiverwaltung mit EUDAS#off("b")# +#free (0.2)# +#type ("12")# +16.1 Dateien im System . . . . . . . . . . . . . . 171 +16.2 Dateien auf dem Archiv . . . . . . . . . . . . 174 + + +#type ("prop")# +#abschnitt ("IV.", "ANHANG", "Anhang")# + +#type ("12")# + Register . . . . . . . . . . . . . . . . . . . 181 + + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.macros b/app/eudas/4.4/doc/user-manual/eudas.hdb.macros new file mode 100644 index 0000000..2def44f --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.macros @@ -0,0 +1,66 @@ +#*format# +#limit (13.5)##start (3.5,2.5)##pagelength (21.0)##block# +#:firsthead (false)# +#linefeed (1.07)# +#*macro end# +#*text# +#type ("prop10")# +#linefeed (1.07)# +#*macro end# +#*beispiel# +#type ("12")# +#linefeed (0.97)# +#*macro end# +#*bildschirm# +#type ("17")# +#linefeed(0.83)# +#*macro end# +#*proc# +#type ("12")# +#*macro end# +#*endproc# +#free (0.1)# +#type ("prop10")# +#linefeed (1.0)# +#*macro end# +#*abschnitt ($1,$2,$3)# +#headodd# +#on("b")#$1#right#$3 %#off("b")# +#free (1.0)# +#end# +#on("b")##ib(9)#$1#ie(9," $3")# $2#off("b")# +#*macro end# +#*char($1)# +$1 +#*macro end# +#*kapitel ($1,$2,$3,$4)# +#free (1.3)# +#"nlq"# +#type("roman.24")# +#on("b")##center#$1#off("b")# +#free (0.2)# +#type ("roman.18")# +#on("b")##center#$2 #off("b")# +#on("b")##center# $3#off("b")# +#on("b")##center#$4#off("b")# +#type ("prop10")# +#free (0.6)# +#headeven# +#on("b")#% $2 $3 $4#off("b")# +#free (1.0)# +#end# +#headodd# +#right##on("b")#%#off("b")# +#free (1.0)# +#end# +#*macro end# +#*f2# +#free (0.2)# +#*macro end# +#*a ($1)# +#on("b")#$1.#off("b")# +#*macro end# +#*bsp ($1)# +#type("12")#$1#type("prop")# +#*macro end# + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.titel b/app/eudas/4.4/doc/user-manual/eudas.hdb.titel new file mode 100644 index 0000000..022235c --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.titel @@ -0,0 +1,73 @@ +#type ("prop")##limit (14.0)# +#format# +#free (6.0)# +#type ("roman.18")# +#on("b")#EUDAS#off("b")# +#free (1.0)# +#type ("roman.14")# +#on("b")#Anwender-#off("b")# +#on("b")#Datenverwaltungssystem#off("b")# +#free (2.0)# +#type ("10")# +#on ("b")#VERSION 4#off("b")# +#free(1.0)# +#on("u")# #off("u")# +#free (0.5)# +#on("b")#BENUTZERHANDBUCH#off("b")# +#type ("prop")##block# +#page# +#free (12.0)# +Ausgabe Juli 1987 + +Dieses Handbuch und das zugehörige Programm sind urheberrechtlich +geschützt. Die dadurch begründeten Rechte, insbesondere der Ver +vielfältigung in irgendeiner Form, bleiben dem Autor vorbehalten. + +Es kann keine Garantie dafür übernommen werden, daß das Pro +gramm für eine bestimmte Anwendung geeignet ist. Die Verantwor +tung dafür liegt beim Kunden. + +Das Handbuch wurde mit größter Sorgfalt erstellt. Für die Korrekt +heit und Vollständigkeit der Angaben wird aber keine Gewähr über +nommen. Das Handbuch kann jederzeit ohne Ankündigung geändert +werden. + +(c) Copyright 1987 Thomas Berlage + Software-Systeme + Im alten Keller 3 +#free (0.1)# + D-5205 Sankt Augustin 1 +#page# +#type ("roman.24")# +#free (7.0)# +#center##on("b")#I.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#DIE#off("b")# +#center##on("b")#ERSTEN#off ("b")# +#center##on("b")#SCHRITTE#off("b")# +#page# +#type ("roman.24")# +#free (7.0)# +#center##on("b")#II.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#EINFÜHRUNG#off("b")# +#center##on("b")#IN DIE#off ("b")# +#center##on("b")#BENUTZUNG#off("b")# +#page# +#free (7.0)# +#type ("roman.24")# +#center##on("b")#III.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#WEITERE#off("b")# +#center##on("b")#MÖGLICHKEITEN#off("b")# +#page# +#free (7.0)# +#type ("roman.24")# +#center##on("b")#IV.#off("b")# +#free (1.0)# +#type ("roman.18")# +#center##on("b")#ANHANG#off("b")# + diff --git a/app/eudas/4.4/doc/user-manual/eudas.hdb.vorwort b/app/eudas/4.4/doc/user-manual/eudas.hdb.vorwort new file mode 100644 index 0000000..2b372b4 --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/eudas.hdb.vorwort @@ -0,0 +1,59 @@ +#type ("prop")##limit (14.0)# +#format# +#kapitel (" ", " Vorwort", "", " ")# + + + +Lieber EUDAS-Benutzer ! + +Dieses Handbuch soll Sie bei Ihrer Arbeit mit EUDAS begleiten. Ob +wohl EUDAS nicht schwierig zu bedienen ist, gibt es doch eine Reihe +von Dingen zu lernen, ehe Sie ein EUDAS-Spezialist geworden sind. + Um Ihnen diesen Weg möglichst einfach zu machen, ist die +EUDAS-Dokumentation in zwei Handbücher aufgeteilt. Dies ist das +#on("b")#Benutzerhandbuch#off("b")#, das Ihnen eine gut lesbare Einführung in alle +Fähigkeiten von EUDAS bieten soll. Außerdem gibt es noch das +#on("b")#Referenzhandbuch#off("b")#, das Ihnen zum Nachschlagen und als Hilfe beim +Programmieren dienen soll. + + Bis Sie EUDAS gut beherrschen, sollten Sie sich also mit dem +Benutzerhandbuch beschäftigen. Das Benutzerhandbuch ist nochmal +in drei Teile aufgeteilt, um Ihnen das Lernen zu erleichtern. In +jedem Teil werden die vorher behandelten Dinge zyklisch wieder +aufgenommen und auf höherem Niveau erweitert. + Der allererste Teil des Handbuchs umfaßt nur drei Kapitel und +soll Ihnen über den ersten Tag mit EUDAS hinweghelfen. Dort finden +Sie eine Übersicht, was Sie mit EUDAS anfangen können, wie Sie das +Programm auf Ihrem Rechner installieren und ein kurzes Beispiel +zum Ausprobieren. + Im zweiten Teil lernen Sie dann die Grundkonzepte von EUDAS +anhand von zahlreichen Beispielen kennen. Sie sollten die Beispiele +am Rechner ausprobieren und ihre Bedeutung verstehen. Nach dem +Durcharbeiten dieses Teils (was höchstens wenige Tage in Anspruch +nimmt) sind Sie dann in der Lage, EUDAS für eigene Zwecke anzu +wenden. + Wenn Ihre Ansprüche dann wachsen, sollten Sie sich mit dem +dritten Teil befassen. Hier erhalten Sie Einblick in weitergehende +Möglichkeiten von EUDAS. Die einzelnen Kapitel sind relativ unab +hängig voneinander, so daß Sie nur die für Sie interessanten +genauer durchlesen müssen. + In Kapitel 8 finden Sie als Orientierung nicht nur eine Wieder +holung dessen, was Sie im zweiten Teil gelernt haben sollten, son +dern auch eine Übersicht, welche weiteren Möglichkeiten im dritten +Teil noch beschrieben werden. + + Im Referenzhandbuch finden Sie später, wenn Sie einige Erfah +rung gesammelt haben, eine genaue Beschreibung der Wirkungsweise +aller Funktionen. Um diese zu verstehen, sollten Sie jedoch bereits +eine grobe Ahnung der Wirkungsweise haben. + Als zweites finden Sie im Referenzhandbuch Informationen für +Programmierer, die EUDAS-Funktionen in eigenen Programmen ver +wenden wollen. Dies sollte jedoch in den meisten Fällen nicht not +wendig sein, so daß dieser Teil für Spezialisten reserviert bleibt. + + Trotz größter Bemühungen kann das Handbuch natürlich nicht +frei von Unklarheiten und Fehlern sein. Anregungen und Kritik sind +daher dringend erwünscht, um diese Dokumentation zu verbessern. + +Und nun viel Spaß bei Ihrer Arbeit mit EUDAS ! + diff --git a/app/eudas/4.4/doc/user-manual/register b/app/eudas/4.4/doc/user-manual/register new file mode 100644 index 0000000..59e47df --- /dev/null +++ b/app/eudas/4.4/doc/user-manual/register @@ -0,0 +1,482 @@ +#type ("prop")##limit (6.5)# +#format# +#page (181)# +#kapitel (" ", "Register ", "", " ")# + + + +#columns (2, 0.5)# +#limit (6.5)# +#bsp("%")# 63, 69, 148 +#bsp("%%")# 141 +#bsp("&")# 63, 69, 103, 148 +#bsp("<!>")# 57 +#bsp("--")# 103 +#bsp("..")# 102 +#bsp(".a$")# 65 +#bsp("'+'")# 107 +#bsp("'-'")# 107 + +Abbruch 35 +Abkürzungen 133 +Abkürzungsteil 134, 140 +Absatzmarken 125, 129 +Abschlußzeile 45 +Abschneiden 71 +Abschnitt 67, 69, 134 +Alternative 99 + -, globale 100 + -, lokale 99 +AND 162 +Ändern 55 +Änderungen 83, 85, 90, 95 + -, automatisch 121 +Änderungsmuster 121, 166 +Anführungsstrich 27, 34 +Ankreuzen 36, 40 +Anrede 138 +Anweisung 63 + -, Textkosmetik 74 +Anzeige 44 + -, rollen 97 +Arbeitsbereich 16 +Arbeitskopie 56, 84, 173 + -, Beispiel 58 + -, löschen 57 +Arbeitstask 16 +Archiv 32 + -, anmelden 34 + -diskette 36 + -, lesen 34 + -, löschen 176 + -manager 175, 177 + -menü 33, 174 + -name 34, 36 + -, schreiben 36 + -übersicht 175 +Arithmetik 161 +Attribut 4, 29 +Aufräumen 173 +Ausdrucken 66 +Ausdrücke 116, 151 + -, Zusammensetzung 152 +Ausgabedatei 66 +Ausgaberichtung 65 +Auswahlzustand 36, 40 +Automatische Änderungen 121 + +Bedienungsregeln 39 +begin 16 +Benutzerhandbuch i +Berechnungen 8 +Bewegen 45 +Bildschirmaufbau 45 +Bitte warten 34, 40 +blättern 46 +BOOL 154, 162 + +Carriage Return 15 +CAT 167 +CONST 155 +CR 15 +Cursor 35, 46 + -tasten 54 + +date 137 +Datei 27 + -arten 27 + -, aufräumen 173 + -auswahl 36 + -größe, Begrenzung 124 + -, kopieren 172 + -limit 71 + -, löschen 38, 172 + -namen 172 + -, Platzbedarf 173 + -, reorganisieren 174 + -sperre 95 + -, umbenennen 172 + -verwaltung 37 + -, virtuelle 83 +Dateien, Archiv 174 + - (Menü) 38, 171 + -, System 171 +DATEIENDE 106 +Daten, ändern 55 + -, anzeigen 44 + -, sichern 33 + -typen 152 + -typen, umwandeln 154 + -verwaltung 3 +Datum 44, 99, 133, 137 +DATUM 112 +DECR 167 +Denotation 154 +Dezimalkomma 111, 161 +Dezimalpunkt 148 +DIN 112 +Diskette 28, 32 + -, formatieren 176 + -, initialisieren 176 +Diskettenlaufwerk 175 +Doppeleinträge 121 +DOS 178 +Druckausgabe, Bearbeitung 125 +Drucken 7, 61 + -, Ablauf 66 + -, Aufruf 64, 66 + - (Menü) 22, 65 + -, Übersicht 175 +Druckersteuerungsanweisungen + 74, 124 +Druckmuster 13, 23, 61, 166 + -, Fehler 134 + -, Übersetzung 134, 142 + -, Zeilenlänge 71 +Druckrichtung 123 +Druckverfahren 62 + +Editieren 64 +Editor 34, 41, 52, 125 +eindeutige felder 121 +Einfügen 18, 52 +Eingabe, Daten 52 + -, Suchmuster 46 +Eingabeüberprüfung 112 +Eingabezustand 35, 40 +Eingangsmenü 17 +Einzelsatz (Menü) 18, 44, 92, 97 +ELAN-Anweisungen 141 +ELAN-Ausdrücke 116, 151 +ELAN-Compiler 134 +ELIF 168 +ELSE 139 +ENDE 45 +Endesatz 45, 48, 53, 85 +ENTER 15 +ESC '1' 107 +ESC '?' 31, 39, 40 +ESC '9' 107 +ESC 'D' 99 +ESC ESC 41, 111 +ESC 'F' 67 +ESC 'g' 99 +ESC 'h' 35, 39, 40, 55, 107 +ESC 'K' 92 +ESC OBEN 97 +ESC 'p' 99 +ESC 'P' 118 +ESC 'q' 32ff.,40 , 47, 65, 107 +ESC RUBIN 54 +ESC RUBOUT 54 +ESC UNTEN 97 +ESC 'w' 32, 40, 53 +ESC 'z' 32, 36, 40, 95 +Etiketten 126 +eudas 30, 125 +EUDAS-Archivdiskette 11, 29 +EUDAS-Datei 27, 61, 171 + -, drucken 61 + -, einrichten 17, 51 + -, Grenzen 29 + -, kopieren 113 + -, Mehrfachbenutzung 93 + -, Struktur 28 +EUDAS, Aufruf 30 + -, Installation 11 + -, Start 15 + -, Verlassen 24, 32 +EUMEL-Netz 175 +EUMEL-Textverarbeitung 5 +EUMEL-Zeichencode 110 + +f 117, 134, 156 +FALSE 154 +Fehler, Druckmuster 66 + -, quittieren 36 + -zustand 35, 40 +Feld 29 +Feldauswahl 97, 106 +Felder, anfügen 111, 114 +Feldinhalt 29, 156, 160 +feldmaske 120 +Feldmuster 63, 69 +Feldmustertypen 71 +Feldnamen 29, 67 + -, abfragen 67 + -, Abgrenzung 72 + -, ändern 112 + -, eingeben 51 + -, Länge 133 +Feldreihenfolge 113 +Feldstruktur 111 +Feldteil 45 +Feldtypen 110, 154 + -, ändern 111 +Feldvergleich 103 +Formatieren 177 +Formbrief 74 +Formular 8, 44 +Fragezustand 38, 40 +Funktionen 152 + -, ausführen 31, 46 + -, auswählen 30 + -, gesperrt 31 +Fußzeile 44 + +Gib Kommando 41, 11 +global manager 93 +GRUPPE 145 +Gruppen 144 + -definition 145 + -, mehrere 145 + -wechsel 145 +gruppenwechsel 145 + +halt 39, 110 +Hardwarefehler 33 +Hauptdatei 87ff. +Hilfe 31 +Hilfezustand 31, 40 +Hilfstexte 13, 31 +Hintergrunddiskette 12 +Hintergrundengpaß 124 +Holen 56 +HOP OBEN 40, 98, 106 +HOP RETURN 106 +HOP RUBIN 54 +HOP RUBOUT 54 +HOP UNTEN 40, 98, 106 +HOP 'x' 98 + +IF 117 +IF-Abfragen 161, 168 +IF-Anweisungen 138 +INCR 167 +Init 176 +Initialisierungsteil 124, 143 +Installation 11 +int 140 +INT 153 + +K 113 +Karteikarten 5 +KB 173 +Ketten 13, 83, 85, 95 +Kilobyte 173 +Klammern 163 + -, spitze 72 +Kombination 89 +Kombinationsnummer 90 +Kopieren, logisch 172 + -, EUDAS-Datei 112 + - (vom Archiv) 34, 176 +Kopieranweisung 113 +Kopiermuster 113, 115, 166 + -, Übersetzung 116 +KOPPEL 92 +Koppeldatei, Markierung 105 + -, Position 93 + -, umschalten 92 +Koppelfeld 86, 89 + -, übernehmen 92 +Koppeln 13, 83, 85, 95 + -, mehrere Dateien 87 +Koppelvorgang, Schema 87 +Korrekturversion 14 + +Länge, feste 70, 137 + -, variable 70 +Leerautomatik 73 +Leertaste 17, 31 +length 158 +lfd nr 137, 157 +limit 71, 125 +lineform 125, 129 +LINKS 31, 35 +linksbündig 71 +Linksschieben 128 +list (archive) 34 +Löschen 55 + - (auf Archiv) 176 + - (Datei) 172 + +Manager 93, 95 +Managertask 175 +MARK 104 +Markieren 104 + -, in Übersicht 107 +Markierung 104 + -, löschen 105 +maxdruckzeilen 124 +MEHR 129 +Mehrfachbenutzung 93 +Menü 30 +Menüzustand 31, 40 +min 155 +Modi 128 +Multi-User 12 +Multi-User-System 16 +Musterbrief 139 +Musterteil 135 +Musterzeichen 70 + +Nachbearbeitung 125 +Nachspann 68, 144 +NACHSPANN 68 +Negation 103 +Netz 175 +Numerieren 137 + +'o' 40, 98 +OBEN 30, 106 +ODER 100 +Öffnen 17, 21, 43, 51, 57, 83, 95 + - (Menü) 30 +Operatoren 152, 155 + -, Priorität 163 +OR 163 + +pageform 125 +Paralleleditor 67, 142 +Parameter 152 +Paßwort 94, 177 +Pfeiltasten 54 +Platzbedarf, Datei 173 +pos 159 +Position, feste 69 + -, variable 69 +Positionierung 48 +Proportionalschrift 129 +Prüfbedingungen 118 +pruefe 120 +PUBLIC 13 + +REAL 153 +real 155 +RECHTS 31, 55 +rechtsbündig 71, 137 +Referenzhandbuch i, 79 +Refinement 134, 140, 163 +Reorganisieren 174 +Reservieren 178 +RET 15 +RETURN 15 +Richtung, Druckausgabe 65, 123 +Rollen 97, 106 +RUBIN 35, 54 +RUBOUT 35, 54 +Runden 160 + +Satz 29 + -, anwählen 46 + -editor 41, 47, 53, 92, 98 + -, einfügen 52 + -, holen 56 + -, löschen 55 + -, tragen 55 +Satz.Nr 46, 48 +Satznummer 45, 90 +Satzauswahl, kopieren 114 +Schreiben (auf Archiv) 36, 176 +Schreibmarke 35 +Schrifttypen 125 +Selektion 48 +Sichern 20, 56, 84, 95 +Single-User 12 +Single-User-System 16 +Sortieren 109 + -, Optimierung 110 + -, Zieldatei 115 +Sortierreihenfolge 109 +Spaltenbreite 126 +Spaltendruck 126 +Speicherplatz 14, 38, 176 + -, Datei 173 +Sperren von Dateien 95 +Standard-Kopiermuster 115 +Stationsnummer 175 +Statistik 169 +Statuszeile 31, 39 +Stern 50, 101 +SUB 158, 163 +subtext 158 +SUCH 47 +Suchbedingung f. Drucken 67 +Suchbedingung, Kombination 49 +Suchbedingung löschen 48 +Suchbedingung setzen 46 +Suchen 21, 46 + -, Optimierung 104 +Suchmuster 47, 99 + -, Eingabe 47 +SV-Taste 16, 39 +System 32 + +Tabellenmodus 128 +Tagesdatum 99 +Task, Manager 93 +Tasks 13 +Teildatei 114 +Teiltexte 158 +TEXT 112, 153 +text 140 +Textdatei 28, 61, 171 + -, ändern 65 + -, ansehen 65 + -, ausdrucken 66 + -, editieren 64 +Texte, verketten 156 +Text-Funktionen 156 +Textkonstanten 139 +Text, konstanter 117 +Text, Länge 158 +Textverarbeitung 3, 123 +THEN 139 +Tragen 55, 118 +TRUE 154 + +Uhrzeit 133 +Umbruch 129 +Umlaute 143 +Umschalten auf Koppeldatei 92 +UND 100ff. +UNTEN 30, 106 +Überschrift 45, 68 +Übersicht (Archiv) 34, 175 + - (Dateien) 37, 171 + - (Sätze) 105 + +V 122 +VAR 165 +Variablen 165 + -, Initialisierung 143, 167 + -, Lebensdauer 166 + -, Typ 165 +Verändern 121 +Vergleiche 102, 162 +virtuelle Datei 83 +Vorspann 68, 144 +VORSPANN 68 + +Weiter 45, 48, 90 +wert 148, 160 +wertemenge 119 +WIEDERHOLUNG 63, 126 + +'x' 36, 40 + +ZAHL 110 +zahltext 148, 160 +Zeichen, reservierte 64, 69, 103 +Zeigen 40 +Zeile einfügen 54 +Zeilenfortsetzung 129 +Zeilenlänge 71 +Zielarchiv 175 +Zieldatei, Struktur 113 +Zurück 45, 48, 90 +Zustand 31, 40 +Zuweisung 166 + + |