Initial import

13 files changed, 2478 insertions, 0 deletions

diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Inhaltsverzeichnis b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Inhaltsverzeichnis
new file mode 100644
index 0000000..9507802
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Inhaltsverzeichnis
@@ -0,0 +1,50 @@
+#limit (11.5)##pagelength (16.5)##pageblock# 
+#start (1.8,0.0)# 
+Inhaltsverzeichnis 
+ 
+ 
+1     Was kann gs-MP BAP                             3 
+ 
+2     Allgemeines zum Simulationsprogramm            6 
+2.1   Entstehung                                     6 
+2.2   Beschreibung des Programmkerns                 7 
+      - ein Simulationslauf                            
+2.3   Das Teilprogramm 'Materialprüfung'             9 
+2.4   Das Teilprogramm 'Bildschirmarbeitsplatz'     10 
+2.5   Hinweise zum Einsatz des Programmsystems      12 
+2.6   Erfahrungen mit dem Programmsystem            13 
+2.7   Hinweise auf Arbeitsmaterial                  14 
+ 
+3     Installation von gs-MP BAP                    16 
+3.1   Voraussetzungen                               16 
+3.2   Lieferumfang                                  16 
+3.3   Installation                                  17 
+3.4   Organisation des Task - Systems               19 
+3.5   Direktstart des Systems                       20 
+ 
+4     Eine kleine Beispielsitzung                   22 
+4.1   Aufruf von 'Bildschirmarbeitsplatz' (BAP)     22 
+4.2   Einstellung von Simulationsparametern         23 
+4.3   Ein Simulationslauf                           26 
+4.4   Die Simulationsauswertung/das Protokoll       28 
+4.5   Hinweise zur Protokollauswertung              36 
+4.5.1 Der Bewertungsfaktor                          36 
+4.5 2 Fehlerzeichenhäufigkeit in den Werkstücken    38 
+4.5 3 Fehlerhafte Auswertungen                      38 
+ 
+5     Beschreibung der Menufunktionen               40 
+5.1   Kurzhinweise zur Bedienung der Menus          40 
+5.2   Menufunktionen z. Oberbegriff 'Simulation'    44 
+5.3   Menufunktionen z. Oberbegriff 'Parameter'     48 
+5.4   Menufunktionen z. Oberbegriff 'Konfiguration' 56 
+5.5   Menufunktionen z. Oberbegriff 'Dateien'       58 
+5.6   Menufunktionen z. Oberbegriff 'Archiv'        60 
+ 
+6     Hinweise für den Systembetreuer               61 
+
+
+
+
+
+
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 1 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 1
new file mode 100644
index 0000000..e418764
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 1
@@ -0,0 +1,119 @@
+#type ("12.lq")##limit (11.0)##pagelength (16.5)##block# 
+#start (2.0,0.0)# 
+#page (3)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#1 
+ 
+#center#Was 
+#center#kann 
+#center#gs-MP BAP 
+ 
+ 
+   #on("b")#gs-MP BAP#off("b")# ist ein Programm, mit dem die Arbeit
+an einem Bildschirmarbeitsplatz unter ganz unter­
+schiedlichen Aspekten simuliert werden kann. Vom
+Benutzer wird dabei verlangt, eine Art "Kontrolltä­
+tigkeit am Bildschirm" auszuüben. Während dieser
+Arbeit werden Daten über den Arbeitsverlauf erfaßt,
+die (später) ausgewertet werden können. 
+   #on("b")#gs-MP BAP#off("b")# ist so gestaltet, daß es für ganz un­
+terschiedliche Zwecke eingesetzt werden kann. Es
+ist möglich, sämtliche Simulationsparameter den
+eigenen Wünschen und der jeweiligen Situation an­
+zupassen. Daneben besteht die Möglichkeit, die Si­
+mulationsprotokolle offensichtlich oder "heimlich"
+zu erfassen. 
+   #on("b")#gs-MP BAP#off("b")# kann dazu benutzt werden, um Anwendern
+lediglich die Belastungen eines Bildschirmarbeits­
+platzes an einem Beispiel darzulegen; es ist aber
+genauso möglich, ihm eindrucksvoll aufzuzeigen, wie
+eine Kontrolle am Bildschirmarbeitsplatz - ohne
+sein Wissen - erfolgen kann. Auf der Basis dieser
+Erfahrungen lassen sich dann ganz neue Fragestel­
+lungen thematisieren (Möglichkeiten/Befugnis der/
+zur Kontrolle am (Bildschirm-) Arbeitsplatz; Daten­
+schutz; Betriebsvereinbarungen zu Computerarbeits­
+plätzen und vieles mehr). 
+   Durch die Möglichkeit, die Simulationsparameter
+vielfältig zu variieren, können verschiedenste Un­
+tersuchungen mit dem Programm durchgeführt werden:
+Angefangen von Untersuchungen zur Konzentrations­
+fähigkeit bei unterschiedlichen Umgebungsbedingun­
+gen (z.B. Lichtverhältnisse, Musik am Arbeitsplatz,
+etc.), über Untersuchungen zum optimalen Arbeits­
+phasen - Pausen - Rhythmus (z.B. zur Fragestellung,
+ob lange Arbeitsphasen mit langen Pausen günstiger
+sind als kurze Arbeitsphasen mit immer wieder ein­
+gestreuten kleineren Pausen oder umgekehrt - wenn
+die Gesamtzeit konstant ist), bis hin zu Untersu­
+chungen zur Ergonomie von Computerarbeitsplätzen
+(z.B. hinsichtlich der Tastaturbelegung, Nützlich­
+keit eines eigenen Cursorblockes, etc.). 
+   Anhand der aufgezeigten Möglichkeiten wird
+sicher deutlich, daß der Einsatz des Programms
+nicht auf den Informatikunterricht beschränkt ist.
+Ebensogut ist, bei entsprechender Fragestellung,
+ein Einsatz im gesellschafts- / sozialwissenschaft­
+lichen Unterricht, im Biologieunterricht, in den
+kaufmännischen Lernbereichen oder im Technikunter­
+richt denkbar. Das Programm ist auch für die Aufar­
+beitung verschiedener Fragestellungen bei der Vor-
+und Nachbereitung von Betriebspraktika geeignet. 
+   Um all diese Möglichkeiten auch den Ausbildern
+offenzuhalten, die keinerlei Vorerfahrungen mit
+Computern haben, aber dieses Programm einsetzen
+möchten, ist die Simulationsumgebung so komforta­
+bel, daß jeder Benutzer innerhalb weniger Minuten
+das gesamte Programmsystem überblicken und bedienen
+kann. 
+ 
+-  Durch die Einbettung in die komfortable Benut­
+   zerschnittstelle #on("b")#gs-DIALOG#off("b")#, sind nur noch wenige
+   Betriebssystemkommandos zur Bedienung des Sy­
+   stems notwendig. 
+ 
+-  Der Benutzer kann jederzeit Informationen über
+   die Bedienung des Menusystems und die Wirkung
+   der einzelnen Menufunktionen anfordern, die ihm
+   daraufhin in den aktuellen Bildschirm eingeblen­
+   det werden. 
+ 
+-  Dem Benutzer wird ständig angezeigt, welche Mög­
+   lichkeiten der Bedienung bestehen, welche Tasten
+   wirksam sind und welche Wirkung deren Betätigung
+   hat. Menufunktionen, deren Wirkungen zu bestimm­
+   ten Zeitpunkten sinnlos oder fehlerhaft wären,
+   werden "inaktiviert", d.h. sind dem Benutzer gar
+   nicht erst zugänglich. 
+ 
+-  Die Auswertung der Simulationsprotokolle erfolgt
+   vom Menu aus durch einfaches Ankreuzen der ge­
+   wünschten Protokolldateien. Es besteht sowohl
+   die Möglichkeit, die Auswertungen auf dem Bild­
+   schirm anzeigen als auch über den Drucker ausge­
+   ben zu lassen. 
+ 
+-  Die Festlegung der Simulationsparameter ist kin­
+   derleicht. Die aktuell eingestellten Werte kön­
+   nen jederzeit eingesehen werden. Zur Einstellung
+   werden umfangreiche Informationen und Hilfen
+   ausgegeben. Eine Fehlbedienung ist ausgeschlos­
+   sen. 
+ 
+-  In das System ist eine komfortable Archivbehand­
+   lung integriert, so daß auch für den Computer­
+   laien die Konservierung der Simulationsergebnis­
+   se auf einfachste Weise möglich ist. 
+ 
+-  Bei auftretenden Fehlern erhält der Benutzer
+   konkrete, verständliche Fehlermeldungen, die
+   zumeist mit einem Zusatz versehen sind, wie die
+   "Situation bereinigt werden kann". 
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 2 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 2
new file mode 100644
index 0000000..b063ea3
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 2
@@ -0,0 +1,302 @@
+#limit (11.0)##pagelength (16.5)##block# 
+#start (2.0,0.0)# 
+#page (6)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#2 
+ 
+#center#Allgemeines 
+#center#zum 
+#center#Simulationsprogramm 
+ 
+ 
+2.1  Entstehung 
+ 
+  Das Simulationsprogramm #on("b")#gs-MP BAP#off("b")# basiert auf
+einer Idee von Hartmut Spenn und Mene Wolf, die
+eine Unterrichtsreihe mit dem Titel "Der gläserne
+Arbeiter" im Rahmen der Materialien zur Lehrerfort­
+bildung in Nordrhein Westfalen (Neue Technologien,
+informations- und kommunikationstechnologische In­
+halte im Wahlpflichtunterricht der Klassen 9/10)
+beschrieben und dazu ein Grundprogramm für den C64
+in COMAL geschrieben haben. 
+   Dieses Grundprogramm diente einmal als Ausgangs­
+punkt für #on("b")#gs-MP BAP#off("b")#. Allerdings wuchsen die An­
+sprüche an das System immer mehr, so daß eine Reihe
+weiterer Funktionen hinzugefügt wurden. Ein wesent­
+liches Ziel war es, ein Simulationsprogramm zur
+Verfügung zu stellen, daß umfangreiche Variations­
+möglichkeiten - ohne jegliche Programmierkenntnisse
+- bietet; ein Programm, das selbst von einem völli­
+gen Computerlaien innerhalb weniger Minuten über­
+blickt und sicher bedient werden kann. 
+ 
+   Erst als die komfortable Benutzerschnittstelle
+#on("b")#gs-DIALOG#off("b")# zur Verfügung stand, konnte dieses Ziel
+erreicht werden. Heute präsentiert sich Ihnen ein
+Programmsystem, in dem Sie jede Programmfunktion
+von einem Menu aus wählen können. Durch Informa­
+tionstexte, die Sie jederzeit abrufen können, und
+durch die Bedienungshinweise werden Sie sicher
+durch das Programmsystem geführt. Sie haben komfor­
+table Möglichkeiten, die Simulationsparameter zu
+variieren. Das Programmsystem ist gegen Fehlbedie­
+nungen mehrfach abgesichert. 
+ 
+ 
+2.2  Beschreibung des Programmkerns 
+      - ein Simulationslauf 
+ 
+   Mit #on("b")#gs-MP BAP#off("b")# kann die Arbeit an einem Bild­
+schirmarbeitsplatz simuliert werden. Der Benutzer
+übt am Bildschirm eine Art "Kontrolltätigkeit" aus.
+Die Interpretation dieser Tätigkeit ist offen: So
+kann man sich vorstellen, daß "Werkstücke" auf dem
+Bildschirm angezeigt werden, die auf Fehler hin
+untersucht werden sollen; dabei muß jeder gefundene
+Fehler markiert werden. Der Benutzer kann sich auch
+vorstellen, er sei bei einer Tageszeitung beschäf­
+tigt und habe die aus der Redaktion eingehenden
+Artikel auf Tippfehler hin zu untersuchen - natür­
+lich müssen die Tippfehler "verbessert" werden.
+Andere Interpretationen sind denkbar. 
+   Das Grundprinzip des Simulationslaufes ist recht
+einfach - ein typischer Bildschirm könnte so ausse­
+hen: 
+#free (9.5)# 
+   Im oberen Bereich des Bildschirms werden alle
+Daten angezeigt, die der Benutzer während des Simu­
+lationslaufes benötigt. Links oben sind alle Tasten
+angegeben, die für die Handhabung des Programms
+notwendig sind. Rechts oben wird der Benutzer über
+die Simulationszeiten und das festgelegte 'Fehler­
+zeichen' informiert. 
+   Im unteren Bereich des Bildschirms wird ein
+rechteckiger Block ausgegeben, der sich aus ver­
+schiedenen Zeichen (z.B. Buchstaben, Ziffern, Son­
+derzeichen) zusammensetzt. Der Benutzer hat jetzt
+die Aufgabe, die Blöcke daraufhin zu untersuchen,
+ob in ihnen das angegebene Fehlerzeichen auftaucht. 
+   Entdeckt er solche Zeichen im Block auf dem
+Bildschirm, so ist es seine Aufgabe, den Cursor
+(Lichtfleck) auf dem Bildschirm mit Hilfe festge­
+legter Tasten an die entsprechende Position zu
+steuern und eine 'Ausbesserung' (Kennzeichnung/
+Korrektur) vorzunehmen. Ist der Benutzer der Mei­
+nung, alle Fehlerzeichen bearbeitet zu haben, so
+kann er den nächsten Block (das nächste Werkstück/
+den nächsten Artikel) durch Tippen einer festgeleg­
+ten Taste anfordern. 
+   Die Arbeit ist dabei streng in 'Arbeitsphasen'
+und 'Pausen' eingeteilt - der Rhythmus wird aber
+vom Programm und nicht vom Benutzer bestimmt. Wäh­
+rend des Simulationslaufes werden alle wesentlichen
+Kenndaten protokolliert. Diese können später ausge­
+wertet werden. 
+   In unserem konkreten Beispiel hat der Benutzer
+nach dem Fehlerzeichen 'F' zu suchen. Er hat insge­
+samt 34 Minuten zu arbeiten; dabei ist seine Ar­
+beitszeit eingeteilt in 3 Arbeitsphasen zu je 10
+Minuten mit zwei dazwischenliegenden Pausen von je
+2 Minuten. 
+   Zur Bedienung des Systems kann er die (Cursor-)
+Pfeiltasten <rechts>, <links>, <hoch> und <runter>
+benutzen; damit kann er den Lichtfleck innerhalb
+des Zeichen-Blocks bewegen. Zur Ausbesserung dient
+die <HOP>-Taste. Mit der <ESC>-Taste kann er je­
+weils die neuen Werkstücke (Artikel) zur Bearbei­
+tung anfordern. 
+ 
+ 
+2.3  Das Teilprogramm 'Materialprüfung' (MP) 
+ 
+   Gemeinsamer Bestandteil beider Programmteile ist
+der sogenannte "Simulationslauf" - ein eben ge­
+schilderter Arbeitsprozeß am Bildschirm. Diesem
+Simulationslauf gehen im Teilprogramm 'Materialprü­
+fung' (MP) jedoch noch umfangreiche Informationen
+voraus, die dem Benutzer die anschließend zu ver­
+richtende Tätigkeit detailliert erläutern. Gleich
+nach Aufruf des Programmteils wird der Benutzer
+noch nach einer "Identifikation" gefragt und aufge­
+fordert, z.B. den Vor- und Nachnamen einzugeben.
+Die hier eingegebene Kennung ist auch Bestandteil
+des Namens des Protokolls, das über den dann fol­
+genden Simulationslauf angelegt wird. 
+   Am Ende des Simulationslaufes wird dem Benutzer,
+sofern das System entsprechend konfiguriert ist,
+eine 'Kurzauswertung' seiner Arbeit auf dem Bild­
+schirm präsentiert. Zusätzlich wird - ohne daß der
+Benutzer es merkt - das angelegte Protokoll in die
+Vatertask geschickt und in der eigenen Task ge­
+löscht. 
+ 
+ 
+2.4  Das Teilprogramm 'Bildschirmarbeitsplatz'
+     (BAP) 
+ 
+   Nach Aufruf des Teilprogramms erscheint auf dem
+Bildschirm ein Menu, von dem aus eine Vielzahl von
+Funktionen gewählt werden kann. Natürlich ist es
+auch von hier aus möglich, einen oben beschriebenen
+Simulationslauf zu starten. Im Gegensatz zum Pro­
+grammteil 'Materialprüfung' wird hier aber auf die
+umfangreichen Informationen zur Handhabung des
+Systems verzichtet und zum Abschluß auch keine Pro­
+tokolldatei zur Vatertask geschickt - die Proto­
+kolldatei verbleibt in der eigenen Task. 
+   Daneben können vom Menu aus auch Protokolldatei­
+en ausgewertet werden. Sie können dabei noch ent­
+scheiden, ob Sie die Auswertungen auf dem Bild­
+schirm angezeigt oder aber auf dem angeschlossenen
+Drucker ausgegeben haben möchten. 
+   Weiterhin können Sie sämtliche Simulationspara­
+meter vom Menu aus Ihren Wünschen gemäß einstellen.
+So ist es möglich, die Breite und Höhe des Werk­
+stücks zu variieren und zu entscheiden, ob die
+Werkstücke "normal" oder "invers" dargestellt wer­
+den sollen. Sie können das 'Fehlerzeichen' festle­
+gen und überhaupt die Zeichen bestimmen, aus denen
+die Werkstücke aufgebaut werden. Daneben haben Sie
+noch die Möglichkeit, zu bestimmen, welche Tasten
+auf der Tastatur welche Funktion beim Simulations­
+lauf haben sollen. 
+   Sie legen von hier aus auch fest, in wie viele
+Arbeitsphasen die Arbeitszeit unterteilt wird und
+wie lange eine einzelne Arbeitsphase und die zwi­
+schen den Arbeitsphasen liegende Pause dauern sol­
+len. Auch hinsichtlich der Bewertung können Sie
+Festlegungen treffen - nach dem von Ihnen hier ein­
+gestellten Wertungsschlüssel werden nämlich die
+Protokolldateien ausgewertet. 
+   Ihnen obliegt es auch, zu bestimmen, ob mit je­
+der Protokollauswertung die umfangreichen Erläute­
+rungen ausgegeben werden sollen und ob der Benutzer
+am Ende eines Simulationslaufes eine 'Kurzauswer­
+tung' über seine Arbeit auf dem Bildschirm erhalten
+soll oder nicht. 
+   Zusätzlich werden Ihnen noch eine Reihe von Mög­
+lichkeiten zur Datei- und Archivbehandlung angebo­
+ten. So können Sie komfortabel Dateien löschen,
+kopieren, umbenennen, etc., Dateien auf Diskette
+konservieren oder gespeicherte Dateien von dort
+holen und vieles mehr. 
+ 
+ 
+2.5  Hinweise zum Einsatz des Programmsystems 
+ 
+   Aus den Beschreibungen in 2.3 und 2.4 ist Ihnen
+sicher schon die unterschiedliche Absicht, die hin­
+ter den beiden Programmteilen steckt, klar gewor­
+den. Die beiden Programmteile richten sich nämlich
+auch an ganz unterschiedliche Nutzergruppen. 
+   Das Teilprogramm 'Materialprüfung' (MP) ist vor­
+nehmlich für den 'unerfahrenen'/'unbefangenen' Be­
+nutzer gedacht. Ihm werden nämlich umfangreiche
+Informationen ausgegeben. Mit diesem Programmteil
+ist eben auch die "heimliche" Erfassung der Simula­
+tionsdaten möglich. Dieser Teil des Programms wird
+sicherlich dann Anwendung finden, wenn die Fragen
+um die Möglichkeiten und Gefahren der Kontrolle am
+(Bildschirm-) Arbeitsplatz im Vordergrund der Be­
+trachtungen stehen. 
+   Das Teilprogramm 'Bildschirmarbeitsplatz' (BAP)
+hat zumindest zwei ganz unterschiedliche Einsatz­
+aspekte: 
+ 
+   Einerseits dient es dem Lehrer/Ausbilder dazu,
+die gewünschten Simulationsparameter für das Teil­
+programm 'Materialprüfung' einzustellen. Die aktu­
+elle Einstellung, die mit dem Teilprogramm 'Bild­
+schirmarbeitsplatz' getroffen wurde, ist in der
+jeweilgen Task gültig, in der die Einstellung vor­
+genommen wurde. Die Einstellung wird aber auch von
+allen Sohntasks übernommen, die sich nach der je­
+weiligen Einstellung neu anmelden. Darüber hinaus
+dient dieses Teilprogramm dem Lehrer/Ausbilder
+dazu, die (ihm zugestellten) Simulationsprotokolle
+auszuwerten. 
+   Andererseits hat das Teilprogramm 'Bildschirm­
+arbeitsplatz' auch einen "eigenen Charakter":
+Gerade bei den schon oben angesprochenen Untersu­
+chungen (zur Konzentrationsfähigkeit in Abhängikeit
+von verschiedenen Faktoren, zur Bedeutung der Ar­
+beitsphasen-Pausen-Rhythmen, zur 'Ergonomie am Ar­
+beitsplatz', etc.) bietet sich hier ein schneller,
+komfortabler Wechsel zwischen Parametereinstellung
+und Simulationsläufen - ohne unnötigen Zeitverlust;
+erst recht, wenn mehrere Simulationsläufe aufeinan­
+der folgen. 
+ 
+ 
+2.6  Erfahrungen mit dem Programmsystem 
+ 
+   Das Programmsystem wurde bereits in verschiede­
+nen Klassen/ Kursen ab der Jahrgangsstufe 8 einge­
+setzt, und zwar in verschiedenen Fachbereichen und
+Schulformen. Die Akzeptanz ist sehr hoch; die Hand­
+habung des Programmsystems bereitete selbst Kolle­
+gen, die noch nie zuvor an einem Computer gesessen
+hatten, keinerlei Schwierigkeiten. Von der Hand­
+habung des Programms her ist deshalb sicher auch
+keine Alteruntergrenze hinsichtlich der "Eignung"
+anzugeben. 
+   Jedoch scheint eine Bearbeitung mit den oben
+angegebenen Zielsetzungen erst auf dem Erfahrungs­
+horizont der Jahrgangsstufe 8 sinnvoll zu sein.
+Eine Bearbeitung der Fragestellungen in der von
+Hartmut Spenn und Mene Wolf (siehe Kapitel 2.7)
+vorgeschlagenen Tiefe scheint allerdings erst am
+Ende der Jahrgangsstufe 9 bzw. in der Jahrgangsstu­
+fe 10 erreichbar. 
+   Besonders interessant scheint der Einsatz bei
+der Vor- bzw. Nachbereitung von Betriebspraktika zu
+sein. Durch die unmittelbare Berührung mit den
+"neuen Technologien am Arbeitsplatz" ist das Inter­
+esse an der Bearbeitung entsprechender Fragestel­
+lungen sehr hoch und eine Sensibilisierung für die
+angesprochenen Problematiken zu erreichen. 
+   Die angegebenen Fragestellungen im Zusammenhang
+mit diesem Programmsystem können auch Thema einer
+Projektwoche/von Projekttagen sein. Besonders be­
+währt hat sich hier die Zusammenarbeit mit Kollegen
+aus dem gesellschafts-/sozialwissenschaftlichen
+Bereich. Ein Unterrichtsgang, z.B. in einen Super­
+markt mit modernen Scannerkassen, bei einer Tages­
+zeitung (Kleinanzeigenaufnahme am Freitag-Vormit­
+tag) o.ä., bei dem die "im Hintergrund (möglicher­
+weise) ablaufenden Prozesse" bewußt gemacht werden,
+kann das Vorhaben noch abrunden. 
+   Zum Einsatz in der Sekundarstufe II liegen erst
+wenige Erfahrungen vor. Mit Sicherheit bietet das
+Programm einen "anderen", interessanten Einstieg in
+den Informatikunterricht der Jahrgangsstufe 11 und
+kann auch bei der Aufarbeitung entsprechender Fra­
+gestellungen zu späteren Zeitpunkten herangezogen
+werden. Erfahrungen aus anderen Fachbereichen lie­
+gen (noch) nicht vor. 
+ 
+ 
+2.7  Hinweise auf Arbeitsmaterial 
+ 
+   Ausdrücklich sei an dieser Stelle auf die Ausar­
+beitung von Hartmut Spenn und Mene Wolf hingewie­
+sen: 
+ 
+Spenn, Hartmut; Wolf, Mene; Der gläserne Arbeiter,
+        Elektronische Leistungs- und Verhaltenskon­
+        trolle am Arbeitsplatz 
+   in:  Landesinstitut für Schule und Weiterbildung
+        (Hrsg.), Materialien zur Lehrerfortbildung
+        in Nordrhein-Westfalen, Heft 4, Neue Tech­
+        nologien - Informations- und Kommunuika­
+        tionstechnologische Inhalte im Wahlpflicht­
+        unterricht der Klassen 9/10, Soest, 1986. 
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 3 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 3
new file mode 100644
index 0000000..f589a93
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 3
@@ -0,0 +1,237 @@
+#limit (11.0)##pagelength (16.5)##block##pageblock# 
+#start (2.0,0.0)# 
+#page (16)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#3 
+ 
+#center#Installation 
+#center#von 
+#center#gs-MP BAP 
+ 
+ 
+   Bevor Sie #on("b")#gs-MP BAP#off("b")# auf Ihrem Computer benutzen
+können, müssen Sie das Programm zunächst installie­
+ren. Wenn #on("b")#gs-MP BAP#off("b")# auf Ihrem System schon zur Ver­
+fügung steht, können Sie dieses Kapitel ruhig über­
+springen. 
+ 
+ 
+3.1  Voraussetzungen 
+ 
+   Um #on("b")#gs-MP BAP#off("b")# auf Ihrem Computer betreiben zu
+können, muß das EUMEL-Betriebssystem installiert
+sein. #on("b")#gs-MP BAP#off("b")# setzt die Multi-User-Version voraus
+und ist lauffähig ab Version 1.7.5. #on("b")#gs-MP BAP#off("b")# setzt
+weiterhin voraus, daß auf Ihrem Computer bereits
+das Programm #on("b")#gs-DIALOG#off("b")# installiert ist. 
+ 
+ 
+3.2  Lieferumfang 
+ 
+   #on("b")#gs-MP BAP#off("b")# wird auf einer Diskette geliefert, die
+alle notwendigen Programme enthält (die Installa­
+tion von #on("b")#gs-DIALOG#off("b")# wird dabei vorausgesetzt!). 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 Dis­
+kette ein und geben das Kommando: 
+ 
+   archive("gs-MP BAP");list(archive); 
+   release(archive) <RETURN> 
+ 
+   Anschließend erscheint eine Übersicht der auf
+dem Archiv vorhandenen Programme. Folgende Program­
+me sollten sich in der Übersicht befinden: 
+ 
+         "gs-MP BAP 1" 
+         "gs-MP BAP 2" 
+         "gs-MENUKARTE:MP-BAP" 
+         "gs-MP BAP/gen" 
+ 
+   Eventuell können noch weitere Namen auf der Dis­
+kette vorhanden sein. Wenn Sie den Inhalt der Dis­
+kette kontrolliert haben und diese Programme auf
+der Diskette vorhanden sind, können Sie #on("b")#gs-MP BAP#off("b")#
+installieren. 
+   Sollten Sie statt der Übersicht eine Fehlermel­
+dung erhalten, überprüfen Sie bitte, ob die Disket­
+te das richtige Format besitzt oder ob Ihr Disket­
+tenlaufwerk Probleme macht. Sollten dagegen Pro­
+gramme fehlen, so reklamieren Sie die Diskette. 
+ 
+ 
+3.3  Installation 
+ 
+   #on("b")#gs-MP BAP#off("b")# muß in einer Task installiert werden,
+in der bereits das Programm #on("b")#gs-DIALOG#off("b")# zur Verfügung
+steht. Alle Söhne und Enkel der neuen Task können
+anschließend auf die Programme (Materialprüfung /
+Bildschirmarbeitsplatz) zugreifen. Richten Sie also
+eine Task als Sohn der Task ein, in der auf Ihrem
+Computer bereits #on("b")#gs-DIALOG#off("b")# installiert ist. Wir
+nehmen hier an, daß #on("b")#gs-DIALOG#off("b")# in der Task 'MENU'
+installiert ist und die neue Task den Namen 'MP
+BAP' erhalten soll. (Sie können für die Task auch
+einen beliebigen anderen Namen wählen): 
+ 
+#on("b")# 
+          <SV>           (Supervisor - Taste) 
+#off("b")# 
+ 
+  -->     gib supervisor kommando: 
+#on("b")# 
+          begin ("MP BAP","MENU") <RETURN> 
+#off("b")# 
+ 
+  -->     gib kommando: 
+ 
+   (Arbeiten mehrere Personen mit dem Computer,
+dann ist es sinnvoll, diese Task vor unbefugtem
+Zugriff durch ein Passwort zu schützen. Wie das
+gemacht wird, können Sie in Ihrem EUMEL-Benutzer­
+handbuch erfahren.) 
+ 
+   Legen Sie dann die Archivdiskette ein, auf der
+sich #on("b")#gs-MP BAP#off("b")# befindet, und geben Sie das folgende
+Kommando: 
+ 
+#on("b")# 
+          archive("gs-MP BAP") <RETURN> 
+ 
+          fetch("gs-MP BAP/gen",archive) <RETURN> 
+ 
+          run <RETURN> 
+#off("b")# 
+ 
+   Sie haben damit das Generatorprogramm gestartet.
+Beantworten Sie die Frage, ob Sie das Archiv ange­
+meldet und die Diskette eingelegt haben, mit 'ja'
+durch Tippen der Taste <j>. 
+   Daraufhin wird die Installation automatisch
+durchgeführt. Lassen Sie während des gesamten Vor­
+gangs die Archivdiskette eingelegt. Sie erhalten
+einen Hinweis, wenn die Diskette entnommen werden
+kann! Die Generierung ist beendet, wenn der EUMEL-
+Eingangsbildschirm erscheint. Die Task, in der die
+Generierung stattfindet, wird automatisch zur Mana­
+gertask, das heißt, daß Söhne von ihr eingerichtet
+werden können. 
+   Richten Sie sich gleich eine Sohntask (z.B mit
+dem Namen 'mp bap') ein, dann können Sie das System
+sofort ausprobieren. Gehen Sie dazu folgendermaßen
+vor: 
+ 
+#on("b")# 
+          <SV>           (Supervisor - Taste) 
+#off("b")# 
+ 
+  -->     gib supervisor kommando: 
+#on("b")# 
+          begin ("mp bap","MP BAP") <RETURN> 
+#off("b")# 
+ 
+  -->     gib kommando: 
+ 
+Mit dem Kommando 
+ 
+#center##on("b")#mp <RETURN>  bzw. bap <RETURN>#off("b")# 
+ 
+können Sie nun das Programm 
+ 
+#center#'Materialprüfung'  bzw.  'Bildschirmarbeitsplatz' 
+ 
+aufrufen. 
+ 
+ 
+3.4  Organisation des Task - Systems 
+ 
+   Wollen Sie unter anderem das Teilprogramm 'Ma­
+terialprüfung' (MP) nutzen, so sollten Sie beden­
+ken, daß die dabei entstehenden Simulationsproto­
+kolle in die Vatertask geschickt werden. Die Vater­
+task sollte sich daher ständig im Wartezustand be­
+finden, um die Protokolle auch aufnehmen zu können.
+So kann es sinnvoll sein, eine 'Zwischentask' ein­
+zurichten, damit auch andere ungestört mit dem Si­
+mulationsprogramm arbeiten können. Gehen Sie dazu
+etwa folgendermaßen vor: 
+  In der Task 'mp bap', in der Sie bisher gearbei­
+tet haben, geben Sie bei 'gib kommando:' den Be­
+fehl: 
+ 
+   #on("b")#global manager <RETURN>#off("b")# 
+ 
+   Sie gestatten dadurch, daß Söhne dieser Task
+eingerichtet werden können. Auf dem Bildschirm er­
+scheint der EUMEL-Eingangsbildschirm. 
+   Alle Anwender (Schüler) melden sich dann als
+Sohn der Task 'mp bap' an: 
+ 
+   #on("b")#begin ("Anwender1", "mp bap") <RETURN>#off("b")# 
+   #on("b")#begin ("Anwender2", "mp bap") <RETURN>#off("b")# 
+   #on("b")#begin ("Anwender3", "mp bap") <RETURN>#off("b")# 
+   ... 
+ 
+   Die Simulationsprotokolle finden Sie dann an­
+schließend in der Task 'mp bap'. 
+ 
+ 
+3.5  Direktstart des Systems 
+     (Steht erst ab gs-DIALOG Version 1.1 zur Ver­
+     fügung) 
+ 
+   In den Kapitel 3.3/3.4 haben wir Ihnen gezeigt,
+wie sie Sohntasks einrichten und hier durch das
+Kommando 'mp' bzw. 'bap' das System aufrufen kön­
+nen. Wenn Sie immer nur mit einer Modellvariante
+arbeiten oder vor dem Benutzer die 'gib komman­
+do:'-Ebene verbergen wollen, können Sie das System
+auch so einrichten, daß sich sofort nach Einrichten
+des Arbeitsbereichs das Menusystem meldet. Für den
+Anfänger kann das die Arbeit durchaus erleichtern. 
+  Gehen Sie dazu in die Task, unterhalb der die
+Sohntasks eingerichtet werden sollen: 
+ 
+#on("b")# 
+          <SV>           (Supervisor - Taste) 
+ 
+#off("b")# 
+  -->     gib supervisor kommando: 
+#on("b")# 
+          continue ("mp bap") <RETURN> 
+#off("b")# 
+ 
+  -->     gib kommando: 
+#on("b")# 
+          direktstart ("mp", TRUE) <RETURN> 
+#off("b")# 
+ 
+   Durch das Kommando haben Sie festgelegt, daß
+sich alle Sohntasks direkt mit dem Programm 'Mate­
+rialprüfung' melden. Möchten Sie lieber mit 'Bild­
+schirmarbeitsplatz' arbeiten, ist nur 'mp' durch
+'bap' zu ersetzen. In diesem Falle meldet sich das
+System gleich mit dem BAP-Menu. 
+   Durch den zweiten Parameter 'TRUE' legen Sie
+fest, daß in den Sohntasks nach Verlassen des Menus
+die jeweilige Task automatisch gelöscht wird. Statt
+'TRUE' können Sie hier auch den Wert 'FALSE' ein­
+tragen. Dann wird nach Verlassen des Menus ange­
+fragt, ob die Task gelöscht werden soll. Wird die
+Frage bejaht, wird gelöscht - sonst wird die Task
+abgekoppelt (break) und kann durch 'continue' wie­
+der angekoppelt werden. 
+   Anmerkung: In der Task, in der Sie das Kommando
+'direktbefehl' gegeben haben, sollte nicht das Kom­
+mando 'monitor' gegeben werden, da Sie durch dieses
+Kommando auch diese Task zu einer Task machen, die
+sich direkt mit dem Menu meldet und ggf. bei Ver­
+lassen des Menus automatisch gelöscht wird! 
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 4 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 4
new file mode 100644
index 0000000..6236d91
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 4
@@ -0,0 +1,638 @@
+#limit (11.0)##pagelength (16.5)##block##pageblock# 
+#start (2.0,0.0)# 
+#page (22)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#4 
+ 
+#center#Eine 
+#center#kleine 
+#center#Beispielsitzung 
+ 
+ 
+4.1  Aufruf von 'Bildschirmarbeitsplatz' (BAP) 
+ 
+   Wenn Sie, wie in Kapitel 3 beschrieben, eine
+Sohntask der Task eingerichtet haben, in der #on("b")#gs-MP
+BAP#off("b")# installiert ist, und dort bei 'gib kommando:'
+den Befehl: 
+ 
+  #on("b")#bap <RETURN>#off("b")# 
+ 
+geben, erscheint - nach dem #on("b")#gs-DIALOG#off("b")#-Eingangsbild­
+schirm - das folgende Menu: 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
++-------------------------------+----------------------------------------- 
+|  s Simulation ausführen       | 
+|  ---------------------------  | 
+|  a Auswertung auf Bildschirm  | 
+|  d Drucken von Auswertungen   | 
++-------------------------------+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+4.2  Einstellung von Simulationsparametern 
+ 
+   Bevor Sie eine Neueinstellung von Simulations­
+parametern vornehmen, sollten Sie sich einen Über­
+blick über die zur Zeit eingestellten Werte ver­
+schaffen. Zwar wäre es möglich, gleich einen Simu­
+lationslauf zu starten, doch müßten Sie dann gleich
+34 Minuten arbeiten - denn standardmäßig ist das
+Simulationssystem auf 3 Arbeitsphasen von je 10
+Minuten Dauer und zwei dazwischenliegende Pausen
+von je 2 Minuten eingestellt. 
+   Wenn Sie sich die Einstellung anzeigen lassen
+wollen, müssen Sie das Pull-Down-Menu wechseln.
+Gehen Sie als durch Tippen der Pfeiltaste <rechts>
+zum Oberbegriff 'Parameter'. Dadurch wird das fol­
+gende Pull-Down-Menu aufgeschlagen: 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
+-------+---------------------------+-------------------------------------- 
+       |  e Einstellung anzeigen   | 
+       |  s Standardwerte          | 
+       |  -----------------------  | 
+       |  b Breite des Werkstücks  | 
+       |  h Höhe des Werkstücks    | 
+       |  i Invers-/Normal         | 
+       |  z Zeichensatz            | 
+       |  f Fehlerzeichen          | 
+       |  t Tastenbelegung         | 
+       |  -----------------------  | 
+       |  a Anzahl Arbeitsphasen   | 
+       |  d Dauer Arbeitsphase     | 
+       |  p Pausendauer            | 
+       |  -----------------------  | 
+       |  w Wertungsschlüssel      | 
+       +---------------------------+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+Nach Tippen der Taste <e> (für 'Einstellung anzei­
+gen') erscheint der folgende Bildschirm: 
+ 
+#on("b")# 
++-----------------------------------++-----------------------------------+ 
+|                                   ||         Wertungsschlüssel         | 
+| Breite       :  15 Zeichen        || Bewertungs-                       | 
+| Höhe         :  12 Zeichen        ||   faktor                          | 
+| Darstellung  :  normal            ||                                   | 
+| Zeichensatz  :  A...Z (26 Zeichen)||1.0|                             + | 
+| Fehlerzeichen:  F                 ||   |                          +    | 
+|                                   ||   |                       +       | 
+| Nach rechts  : <rechts>           ||   |                    +          | 
+| Nach links   : <links>            ||   |                 +             | 
+| Nach oben    : <hoch>             ||0.5|              +                | 
+| Nach unten   : <runter>           ||   |           +                   | 
+| Ausbesserung : <HOP>              ||   |        +                      | 
+| Nächstes     : <ESC>              ||   |     +                         | 
+|                                   ||   |  +                            | 
+| Anzahl der Arbeitsphasen:   3     ||0.0+--|--|--|--|--|--|--|--|--|--| | 
+| Dauer einer Arbeitsphase:  10 min ||  0.0            0.5            1.0| 
+| Dauer einer Pause       :   2 min ||                                   | 
+|                                   ||                  Ausbesserungsrate| 
+| Simulationsgesamtdauer  :  34 min ||                                   | 
++-----------------------------------++-----------------------------------+ 
+-------------------------------------------------------------------------- 
+Zum Weitermachen irgendeine Taste tippen! 
+#off("b")# 
+ 
+   Oben links wird das "Aussehen" der Werkstücke
+auf dem Bildschirm beschrieben. Nach diesen Angaben
+sind die Werkstücke 15 Zeichen breit und 12 Zeichen
+hoch. Sie werden auf dem Bildschirm normal (nicht
+invers) dargestellt. Die Werkstücke werden aus den
+Großbuchstaben 'A ... Z' zusammengesetzt, wobei 'F'
+das Fehlerzeichen ist, nach dem gesucht werden
+soll. 
+   Der Cursor kann mit den Pfeiltasten (<rechts>,
+<links>, <hoch> und <runter>) innerhalb des Werk­
+stücks bewegt werden. Steht der Cursor auf einem
+Fehlerzeichen, so verschwindet es, wenn die <HOP>-
+Taste getippt wird. Nach Tippen der <ESC>-Taste
+erscheint das nächste Werkstück auf dem Bildschirm. 
+   Darunter sind die Informationen angegeben, die
+uns eigentlich interessieren: Die Anzahl/Zeiten für
+Arbeitsphasen und Pausen. Sie sollen die Simula­
+tionszeiten jetzt so verändern, daß die Gesamtsimu­
+lationszeit 3 Minuten beträgt. Wählen Sie dazu zu­
+erst die Menufunktion 'Anzahl Arbeitsphasen' durch
+Tippen der Taste <a>. Dann erscheint auf dem Bild­
+schirm folgendes Bild: 
+ 
+#on("b")# 
++-------------------------++-------------------------------------------+ 
+|       Informationen     ||     Anzahl Arbeitsphasen festlegen:       | 
+|                         ||                                           | 
+| Kleinster     Wert:   2 || Anzahl Arbeitsphasen neu festlegen (j/n)? | 
+| Größter       Wert:  20 ||                                           | 
+|                         ||                                           | 
+| Eingestellter Wert:   3 ||                                           | 
++-------------------------++-------------------------------------------+ 
+ 
+ 
+ 
+               +-------------------------------------+ 
+               |         Simulationszeiten:          | 
+               |                                     | 
+               | Anzahl der Arbeitsphasen:   3       | 
+               | Dauer einer Arbeitsphase:  10 min   | 
+               | Dauer einer Pause       :   2 min   | 
+               |                                     | 
+               | Simulationsgesamtdauer  :  34 min   | 
+               +-------------------------------------+ 
+ 
+ 
+   Wenn Sie die im Fenster oben rechts gestellte
+Frage bejahen (Taste <j> tippen), ändert sich der
+Fensterinhalt: 
+ 
+#on("b")# 
++-------------------------++---------------------------------------------+ 
+|       Informationen     ||      Anzahl Arbeitsphasen festlegen:        | 
+|                         ||                                             | 
+| Kleinster     Wert:   2 ||Mit den Pfeilen <hoch>  und <runter> den Wert| 
+| Größter       Wert:  20 ||einstellen. Eingabe mit <RETURN> abschließen.| 
+|                         ||                                             | 
+| Eingestellter Wert:   3 ||Bitte die Anzahl der Arbeitsphasen:   3      | 
++-------------------------++---------------------------------------------+ 
+ 
+   Bestimmt ist Ihnen schon klar, was zu tun ist:
+Mit der Pfeiltaste <runter> stellen Sie den
+kleinstmöglichen Wert (2) ein - anschließend tippen
+Sie die <RETURN>-Taste. Schauen Sie auf das Fenster
+ganz unten - jetzt hätten Sie nur noch 24 Minuten
+zu arbeiten. Bevor Sie die anderen Parameter ein­
+stellen, bestätigen Sie bitte, daß Sie mit der An­
+zahl der Arbeitsphasen einverstanden sind. 
+   Gehen Sie jetzt ebenso vor, um die 'Dauer (ei­
+ner) Arbeitsphase' und die 'Pausendauer' einzustel­
+len - eine Beschreibung dazu ist sicher überflüs­
+sig. 
+   Rechts im Fenster ist noch der 'Wertungsschlüs­
+sel' angegeben - seine Bedeutung erläutern wir aber
+erst in Zusammenhang mit der Auswertung der Simula­
+tionsprotokolle. 
+ 
+ 
+4.3  Ein Simulationslauf 
+ 
+   So, jetzt können Sie zum Ausprobieren einen kur­
+zen Simulationslauf starten. Gehen Sie dazu zurück
+zum Pull-Down-Menu ganz links und wählen Sie hier
+die Menufunktion 'Simulation ausführen'. Zunächst
+werden Sie nach einer "Identifikation" gefragt.
+Geben Sie z.B. Ihren Namen ein und tippen Sie an­
+schließend die <RETURN>-Taste. Auf dem Bildschirm
+erscheinen oben alle Informationen, die Sie während
+der Simulation benötigen; darunter erscheint der
+Hinweis, daß mit dem nächsten Tastendruck die erste
+Arbeitsphase beginnt. Wenn das erste Werkstück auf
+dem Bildschirm erscheint, sieht das z.B. so aus: 
+ 
+#on("b")# 
++-------------------------------+ +-------------------------------------+ 
+| Nach rechts  : <rechts>       | | Anzahl der Arbeitsphasen:    3      | 
+| Nach links   : <links>        | | Dauer einer Arbeitsphase:   10 min  | 
+| Nach oben    : <hoch>         | | Dauer einer Pause       :    2 min  | 
+| Nach unten   : <runter>       | | Simulationsgesamtdauer  :   34 min  | 
+| Ausbesserung : <HOP>          | |                                     | 
+| Nächstes     : <ESC>          | | Fehlerzeichen           :    F      | 
++-------------------------------+ +-------------------------------------+ 
+ 
+                            GFMKLPDRFGTZQAL 
+                            RTWOJLMNVWQHTRS 
+                            PZBFVDDSWWAFGBD 
+                            EWWQAKGHHJINMPA 
+                            WSSDEKLJNHHGTFD 
+                            GGTEWLVCXFFRPTR 
+                            TREKGLMNTREFGTW 
+                            TRWFGLMBVCCDSAQ 
+                            HGFRWZTCXYAASWW 
+                            MNNBHGTREWQKJLO 
+                            CCXSDRFGHKLPOZR 
+                            RWPPKHJUUZTFDSE 
+ 
+ 
+   Nun dürfen Sie einmal zeigen, was Sie können.
+Bitte achten Sie darauf, daß Sie in jeder Arbeits­
+phase mindestens ein Werkstück bearbeiten - sonst
+könnte es später zu Fehlern bei der Auswertung kom­
+men. Sie sollen sich ja auch nicht ausruhen, son­
+dern arbeiten! 
+   Pausen werden Ihnen auf dem Bildschirm ange­
+zeigt. Auch wenn Sie weiterarbeiten wollen - um die
+Pausen kommen Sie nicht herum! Am Ende einer Pause
+wird ein Hinweis auf das Pausenende ausgegeben. 
+   Nach der letzten Arbeitsphase erhalten Sie eine
+Kurzauswertung des aktuellen Simualtionslaufes auf
+den Bildschirm (wenn Ihnen das nicht gefällt, kön­
+nen Sie das später auch abschalten). Zur Erläute­
+rung der angegebenen Daten in der 'Kurzauswertung'
+sehen Sie bitte das folgende Kapitel. 
+ 
+ 
+4.4  Die Simulationsauswertung/das Simulations­
+     protokoll 
+ 
+   Wenn Sie wollen, können Sie das Protokoll, das
+über Ihre Arbeit angefertigt wurde, gleich auswer­
+ten lassen. Wählen Sie dazu die Menufunktion 'Aus­
+wertung auf Bildschirm' (im gleichen Pull-Down-
+Menu). Ihnen werden jetzt alle Protokolle, die sich
+in Ihrer Task befinden, zur Auswahl angeboten.
+Wahrscheinlich ist es zur Zeit nur eine Protokoll­
+datei. 
+   Jetzt sehen Sie auch, warum von Ihnen vor Simu­
+lationsbeginn eine "Identifikation" erbeten wurde.
+Sie ist Bestandteil des Protokollnamens - danach
+können Sie nämlich die Protokolle zuordnen. Verwen­
+den Sie mehrfach die gleiche Identifikation, so
+werden die Protokolle in der Reihenfolge ihrer An­
+lage durchnumeriert. 
+   Wenn Sie den/die Dateinamen angekreuzt haben
+(z.B. mit <RETURN>) und die Auswahl durch <ESC><q>
+verlassen, werden die angekreuzten Protokolldateien
+ausgewertet und anschließend auf dem Bildschirm
+angezeigt. 
+   Das Protokoll ist jeweils nach folgendem Schema
+aufgebaut: Zunächst werden Datum und Uhrzeit des
+Simulationslaufs ausgegeben; anschließend alle
+Kenndaten der Simulation, so daß daraus die gesamte
+Konfiguration des Simulationssystems rekonstruier­
+bar ist. Es folgt die "Gesamtauswertung" des Simu­
+lationslaufes, die identisch ist mit der auf dem
+Bildschirm angezeigten 'Kurzauswertung'. Die Ge­
+samtauswertung erfolgt nach den gleichen Grundsät­
+zen wie die sich anschließenden Auswertungen der
+einzelnen Werkstücke (es werden hier nur die ggf.
+angefallenen Pausenüberschreitung(en) mit in die
+Beurteilung einbezogen). 
+   Das Protokoll ist durch die angehängten Bemer­
+kungen nahezu selbsterklärend. Damit Sie sich einen
+Eindruck verschaffen können, haben wir auf den
+nächsten Seiten ein ausgewertetes Protokoll abge­
+druckt. Bitte studieren Sie es eingehend - insbe­
+sondere die Anmerkungen am Ende des Protokolls: 
+ 
+ 
+ 
+ 
+ 
+ 
+#on("b")# 
+                        gs-Protokoll: TEST - Auswertung 
+                        =============================== 
+Datum :  03.09.87                            Uhrzeit (zu Beginn):  10:21 
+ 
+                      Kenndaten der Werkstückbearbeitung: 
+                      =================================== 
+Nach rechts  : <rechts>               Anzahl der Arbeitsphasen:    3 
+Nach links   : <links>                Dauer einer Arbeitsphase:   10 min 
+Nach oben    : <hoch>                 Dauer einer Pause       :    2 min 
+Nach unten   : <runter>               Simulationsgesamtdauer  :   34 min 
+Ausbesserung : <HOP> 
+Nächstes     : <ESC>                  Fehlerzeichen           :    F 
+ 
+Werkstückbreite              :   15 Zeichen 
+Werkstückhöhe                :   12 Zeichen 
+Anzahl Zeichen pro Werkstück :  180 Zeichen 
+Umfang des Zeichensatzes     :  A ... Z ( 26 Zeichen) 
+ 
+                              Beispielwerkstück: 
+                              ------------------ 
+                                QQSEUZSTABQBZWI 
+                                UKZVNYPHCPLQMGH 
+                                NDJZPCMOOPQQICL 
+                                ARELRDKUOOZWOIE 
+                                NASIPRLRQUKJHGN 
+                                YJJVKIGWCJOLRTL 
+                                FXSZBOBIBKQPYXN 
+                                JJFKFMEVALZNDPU 
+                                VTWWIHKWRMPMHZP 
+                                CSSFZBOSACLARKQ 
+                                WAAIMHJELLFKIWA 
+                                XLNHUCZRVXOXHRL 
+ 
+ 
+ 
+                       G e s a m t a u s w e r t u n g: 
+                       ================================ 
+Anzahl der vollständig bearbeiteten Werkstücke :        51 
+Anzahl der Zeichen pro Werkstück               :       180 
+Anzahl der insgesamt untersuchten Zeichen      :      9180 
+ 
+Anzahl der Bedienfehler                        :         3 
+ 
+Anzahl der vorgegebenen Fehler                 :       363 
+Anzahl der Fehlerkorrekturen                   :       304 
+Arbeitszeit     (incl. Pausenüberschreitungen) :    1792.5  sec 
+Anzahl bearbeiteter Zeichen pro Sekunde        :       5.1 
+ 
+Ausbesserungsrate                              :       0.8 
+Bewertungsfaktor                               :       0.8 
+ 
+Gesamtbewertung (incl. Pausenüberschreitungen) :       4.3 
+================================================  ======== 
+Arbeitszeit     (ohne  Pausenüberschreitungen) :    1788.5  sec 
+Anzahl bearbeiteter Zeichen pro Sekunde        :       5.1 
+Gesamtbewertung (ohne  Pausenüberschreitungen) :       4.3 
+================================================  ======== 
+ 
+ 
+                       Einzelauswertung der Werkstücke: 
+                       ================================ 
+ 
+Werk-  | Anzahl | Vorge- | Anzahl | Benö- | Zei-  | Aus-  |Bewer- | Bewer- 
+stück- |   Be-  | gebene |  Kor-  | tigte | chen  | bes-  |tungs- | tungs- 
+nummer | dien-  |  Feh-  |  rek-  | Zeit  |  pro  |  se-  |faktor |  zahl 
+       |  feh-  |  ler-  | turen  | [sec] |  Se-  | rungs-|       | 
+       |  ler   |  zahl  |        |       | kunde |  rate |       | 
+-------------------------------------------------------------------------- 
+       |        |        |        |       |       |       |       | 
+    1  |    0   |     5  |     3  |  45.6 |   3.9 |   0.6 |   0.6 |   2.4 
+    2  |    0   |    10  |     6  |  33.5 |   5.4 |   0.6 |   0.6 |   3.2 
+    3  |    0   |     5  |     4  |  35.7 |   5.0 |   0.8 |   0.8 |   4.0 
+    4  |    0   |     3  |     3  |  33.9 |   5.3 |   1.0 |   1.0 |   5.3 
+    5  |    0   |    10  |     7  |  38.0 |   4.7 |   0.7 |   0.7 |   3.3 
+    6  |    0   |     5  |     4  |  37.2 |   4.8 |   0.8 |   0.8 |   3.9 
+    7  |    0   |     9  |     8  |  36.9 |   4.9 |   0.9 |   0.9 |   4.3 
+    8  |    0   |     5  |     4  |  31.7 |   5.7 |   0.8 |   0.8 |   4.5 
+    9  |    0   |     4  |     3  |  27.3 |   6.6 |   0.8 |   0.8 |   4.9 
+   10  |    0   |     6  |     6  |  33.3 |   5.4 |   1.0 |   1.0 |   5.4 
+   11  |    0   |     3  |     3  |  25.0 |   7.2 |   1.0 |   1.0 |   7.2 
+   12  |    0   |     6  |     3  |  28.6 |   6.3 |   0.5 |   0.5 |   3.1 
+   13  |    0   |    11  |    10  |  37.9 |   4.7 |   0.9 |   0.9 |   4.3 
+   14  |    0   |     4  |     4  |  38.3 |   4.7 |   1.0 |   1.0 |   4.7 
+   15  |    0   |    11  |     8  |  39.3 |   4.6 |   0.7 |   0.7 |   3.3 
+   16  |    0   |     5  |     4  |  28.4 |   6.3 |   0.8 |   0.8 |   5.1 
+   17  |    0   |     4  |     4  |  36.4 |   4.9 |   1.0 |   1.0 |   4.9 
+   18  |    0   |    15  |    14  |  44.9 |   4.0 |   0.9 |   0.9 |   3.7 
+ 
+ PAUSE     --->    Überzogen um     2.2  sec 
+ 
+   19  |    0   |     3  |     3  |  38.9 |   4.6 |   1.0 |   1.0 |   4.6 
+   20  |    0   |    11  |    10  |  40.2 |   4.5 |   0.9 |   0.9 |   4.1 
+   21  |    0   |     8  |     7  |  34.7 |   5.2 |   0.9 |   0.9 |   4.5 
+   22  |    0   |     7  |     5  |  30.3 |   5.9 |   0.7 |   0.7 |   4.2 
+   23  |    0   |     4  |     4  |  33.9 |   5.3 |   1.0 |   1.0 |   5.3 
+   24  |    0   |     7  |     7  |  39.5 |   4.6 |   1.0 |   1.0 |   4.6 
+   25  |    0   |     6  |     4  |  28.1 |   6.4 |   0.7 |   0.7 |   4.3 
+   26  |    0   |    11  |    10  |  34.8 |   5.2 |   0.9 |   0.9 |   4.7 
+   27  |    0   |    11  |     9  |  34.2 |   5.3 |   0.8 |   0.8 |   4.3 
+   28  |    0   |    10  |     8  |  35.0 |   5.1 |   0.8 |   0.8 |   4.1 
+   29  |    0   |     9  |     8  |  36.4 |   4.9 |   0.9 |   0.9 |   4.4 
+   30  |    0   |     8  |     7  |  34.8 |   5.2 |   0.9 |   0.9 |   4.5 
+   31  |    0   |    10  |     8  |  36.2 |   5.0 |   0.8 |   0.8 |   4.0 
+   32  |    0   |    10  |    10  |  44.0 |   4.1 |   1.0 |   1.0 |   4.1 
+   33  |    0   |     8  |     8  |  44.4 |   4.1 |   1.0 |   1.0 |   4.1 
+   34  |    0   |     4  |     3  |  35.6 |   5.1 |   0.8 |   0.8 |   3.8 
+ 
+ PAUSE     --->    Überzogen um     1.8  sec 
+ 
+   35  |    0   |     8  |     8  |  42.7 |   4.2 |   1.0 |   1.0 |   4.2 
+   36  |    1   |     8  |     8  |  45.3 |   4.0 |   1.0 |   1.0 |   4.0 
+   37  |    0   |     5  |     5  |  34.3 |   5.2 |   1.0 |   1.0 |   5.2 
+   38  |    0   |     5  |     4  |  27.9 |   6.5 |   0.8 |   0.8 |   5.2 
+   39  |    0   |    10  |     8  |  39.5 |   4.6 |   0.8 |   0.8 |   3.6 
+   40  |    1   |     7  |     6  |  35.5 |   5.1 |   0.9 |   0.9 |   4.3 
+   41  |    0   |     3  |     3  |  29.5 |   6.1 |   1.0 |   1.0 |   6.1 
+   42  |    0   |     5  |     5  |  30.2 |   6.0 |   1.0 |   1.0 |   6.0 
+   43  |    0   |     6  |     3  |  28.0 |   6.4 |   0.5 |   0.5 |   3.2 
+   44  |    0   |     5  |     4  |  30.2 |   6.0 |   0.8 |   0.8 |   4.8 
+   45  |    0   |     5  |     4  |  33.1 |   5.4 |   0.8 |   0.8 |   4.4 
+   46  |    0   |     8  |     7  |  33.7 |   5.3 |   0.9 |   0.9 |   4.7 
+   47  |    0   |     9  |     7  |  32.2 |   5.6 |   0.8 |   0.8 |   4.3 
+   48  |    0   |     9  |     8  |  37.5 |   4.8 |   0.9 |   0.9 |   4.3 
+   49  |    0   |     4  |     4  |  32.0 |   5.6 |   1.0 |   1.0 |   5.6 
+   50  |    0   |     9  |     7  |  34.8 |   5.2 |   0.8 |   0.8 |   4.0 
+   51  |    1   |     9  |     4  |  29.2 |   6.2 |   0.4 |   0.4 |   2.7 
+       |        |        |        |       |       |       |       | 
+========================================================================== 
+ 
+(  52  |    0   |     7  |     7  |  35.9 |   5.0 |   1.0 |   1.0 |   5.0) 
+ 
+                                 Anmerkungen: 
+                                 ============= 
+ 
+  -  Das zuletzt bearbeitete Werkstück  (in der obigen Tabelle unterhalb 
+     der letzten Trennlinie in Klammern angegeben) wurde nicht vollstän- 
+     dig innerhalb der zur Verfügung stehenden Zeit bearbeitet. 
+     Aus diesem Grunde wird es bei der Auswertung (Gesamtwertung)  nicht 
+     berücksichtigt! 
+ 
+  -  Bei der Auflistung der Daten der einzelnen Werkstücke sind auch die 
+     Pausen eingetragen,  so daß sich die einzelnen Arbeitsphasen erken- 
+     nen und miteinander vergleichen lassen.  Die dabei notierten Zeiten 
+     geben  die Pausenüberschreitungen an.  Diese Zeiten bleiben bei der 
+     Betrachtung der einzelnen Werkstücke unberücksichtigt, fließen aber 
+     in die Gesamtauswertung ein! 
+ 
+  -  Die Anzahl der  Bedienfehler  ist ein Maß für die Sicherheit im Um- 
+     gang mit dem System.  Bei den weiteren  Auswertungen bleibt die Be- 
+     dienfehlerzahl allerdings unberücksichtigt! 
+ 
+  -  Die 'Vorgegebene Fehlerzahl', die 'Anzahl Korrekturen' und die 'Be- 
+     nötigte Zeit [sec]'  wurden bei der Bearbeitung des  Werkstücks er- 
+     faßt. Auf diesen Daten beruhen die folgenden Auswertungen! 
+ 
+  -  Da die Werkstücke ganz unterschiedliche Größen haben können, eignet 
+     sich die 'Benötigte Zeit [sec]',  die für die Bearbeitung eines je- 
+     den Werkstücks ermittelt wird, als Maß für die "Arbeitsgeschwindig- 
+     keit" nicht!  Stattdessen wird ermittelt, wie viele Zeichen pro Se- 
+     kunde "bearbeitet" wurden: 
+ 
+                             Anzahl Zeichen pro Werkstück 
+     Zeichen pro Sekunde  =  ---------------------------- 
+                                 Benötigte Zeit [sec] 
+ 
+     Die 'Anzahl Zeichen pro Werkstück' kann aus der Werkstückbreite und 
+     Werkstückhöhe ermittelt werden: 
+ 
+     Anzahl Zeichen pro Werkstück = Werkstückbreite * Werkstückhöhe 
+ 
+  -  Aus der (zufällig)  'Vorgegebenen Fehlerzahl'  und der 'Anzahl Kor- 
+     rekturen' wird die 'Ausbesserungsrate' ermittelt: 
+ 
+                             Anzahl Korrekturen 
+     Ausbesserungsrate  =  ---------------------- 
+                           Vorgegebene Fehlerzahl 
+ 
+     Die Ausbesserungsrate gibt an,  welcher Anteil der vorhandenen Feh- 
+     ler ausgebessert wurde. Sie ist ein Maß für die Güte der verrichte- 
+     ten Arbeit. 
+ 
+  -  Der 'Bewertungsfaktor' ist abhängig von der 'Ausbesserungsrate'. Er 
+     läßt sich aus dem folgenden Diagramm entnehmen: 
+ 
+              Bewertungs- 
+                faktor 
+ 
+             1.0|                             + 
+                |                          + 
+                |                       + 
+                |                    + 
+                |                 + 
+             0.5|              + 
+                |           + 
+                |        + 
+                |     + 
+                |  + 
+             0.0+--|--|--|--|--|--|--|--|--|--| 
+               0.0            0.5            1.0 
+                               Ausbesserungsrate 
+ 
+ 
+     In diesem  Diagramm ist festgelegt,  wie die  einzelnen  'Ausbesse- 
+     rungsraten' bewertet werden. 
+ 
+  -  Am Ende wird die 'Bewertungszahl' folgendermaßen ermittelt: 
+ 
+     Bewertungszahl = Zeichen pro Sekunde * Bewertungsfaktor 
+ 
+     Da der 'Bewertungsfaktor' nur Werte zwischen 0 und 1 annehmen kann, 
+     ist die  'Bewertungszahl'  ein Wert zwischen 0 und der 'Zeichen pro 
+     Sekunde'. Die "Arbeitsleistung" war um so größer, je höher die 'Be- 
+     wertungszahl ist. 
+ 
+Eine weitere Kommentierung des Protokolls dürfte
+sich wohl erübrigen, wenn Sie die Anmerkungen in­
+tensiv studiert haben. 
+ 
+ 
+4.5  Hinweise zur Protokollauswertung 
+ 
+4.5.1  Der Bewertungsfaktor 
+ 
+   Sie haben sich sicher über den sogenannten 'Be­
+wertungsfaktor' gewundert, der an verschiedenen
+Stellen genannt wird - aber bisher unberücksichtigt
+blieb. In den bisher aufgezeigten Situationen war
+der Bewertungsfaktor identisch mit der 'Ausbesse­
+rungsrate'. Warum dieser Faktor gesondert einge­
+führt wurde, möchten wir an einem kleinen Beispiel
+erläutern: 
+   Wenn Ihnen der Auswertalgorithmus vor dem Simu­
+lationslauf bekannt gewesen wäre und Sie die Ab­
+sicht gehabt hätten, eine möglichst hohe Bewer­
+tungszahl zu erzielen, wäre folgende "Arbeitsstra­
+tegie" erfolgversprechend gewesen: 
+   Sobald ein Werkstück auf dem Bildschirm er­
+scheint, bewegen Sie den Cursor schnellstens zum
+ersten Fehlerzeichen, das Sie entdecken können und
+löschen es mit der Ausbesserungstaste. Sollten zu­
+fällig noch weiterer Fehlerzeichen in unmittelbarer
+Nähe zu sehen sein, so können Sie sie ja auch "aus­
+merzen" - aber dann schnell das nächste Werkstück
+anfordern usw. 
+   Machen wir uns klar, was das bedeutet: Da sie
+das Werkstück in sehr kurzer Zeit bearbeitet haben,
+wird der eigentlich entscheidende Faktor hinsicht­
+lich der Auswertung "enorm in die Höhe getrieben"
+(die Anzahl der Zeichen pro Sekunde). Da Sie bei
+dieser Strategie zumeist nur 2 - 4 Sekunden zur
+Bearbeitung eines Werkstücks brauchen, erhalten Sie
+- auf das obige Beispielprotokoll bezogen - Werte
+zwischen 90.0 und 45.0 (bearbeitete Zeichen pro
+Sekunde). 
+   Im Schnitt treten pro Werkstück etwa 7 Fehler­
+zeichen auf (sehen Sie dazu auch unter 'Aufbau der
+Werkstücke'), von denen Sie dann eines korrigiert
+haben. Sie kommen also auf eine durchschnittliche
+Ausbesserungsrate von 0.14. Wäre - wie im obigen
+Beispielprotokoll - der Bewertungsfaktor mit der
+Ausbesserungsrate identisch, so erhielten Sie Be­
+wertungszahlen zwischen 12.9 und 6.4. Ein deut­
+licher Unterschied zur "Leistung" die im Protokoll
+dokumentiert ist - oder? 
+   Das aber ist nicht Sinn der dem Benutzer ge­
+stellten Aufgabe! Es würde auch nicht einer sinn­
+vollen 'Kontrolltätigkeit' entsprechen, wenn derart
+viele Fehler unentdeckt blieben. Um hier "regulie­
+rend" einschreiten zu können, ist der 'Bewertungs­
+faktor' eingeführt worden. So können Sie festlegen,
+daß Werkstücke, in denen weniger als 80% der Fehler
+entdeckt wurden, bei der Auswertung unberücksich­
+tigt bleiben. Sie brauchen dazu nur den Bewertungs­
+schlüssel entsprechend einzustellen. ("Ziehen Sie
+dazu bei der Einstellung des Bewertungsschlüssels
+die ersten 8 Kreuzchen auf die Grundlinie"). 
+   Anders ausgedrückt: Durch die Manipulation des
+Bewertungsschlüssels können Sie die Anforderungen,
+die an die Werkstückbearbeitung gestellt werden,
+festlegen. Hierdurch entscheiden Sie über die Wer­
+tigkeit von Schnelligkeit und Genauigkeit. 
+   Übrigens wird der zur Simulationszeit einge­
+stellte Wertungsschlüssel mit im Protokoll notiert.
+Eine Auswertung des Protokolls mit verschiedenen
+Wertungsschlüsseln ist so nicht möglich - und auch
+nicht sinnvoll. Denn sonst könnte es ja vorkommen,
+daß der Anwender ein ganz anderes Ergebnis in der
+Kurzauswertung auf dem Bildschirm gezeigt bekommt
+als er nachher im Protokoll nachlesen kann. Wenn
+Sie also mit einem veränderten Wertungsschlüssel
+arbeiten wollen, müssen Sie ihn #on("u")#vor dem Simula­
+tionslauf#off("u")# eingestellt haben! 
+ 
+ 
+4.5.2  Fehlerzeichenhäufigkeit in den Werkstücken 
+ 
+   Die Häufigkeit des Auftretens der Fehlerzeichen
+in den einzelnen Werkstücken kann deutlich schwan­
+ken. Die Werkstücke werden nämlich mit Hilfe des
+Zufallszahlengenerators aufgebaut. Je nach Anzahl
+der verschiedenen Zeichen, die in einem Werkstück
+auftreten können, ändert sich auch der Anteil der
+auftretenden Fehlerzeichen. 
+   In unserem bisher betrachteten Beispiel können
+26 verschiedene Buchstaben im Werkstück auftreten.
+Ein Werkstück besteht aus 180 Zeichen. In 1/26 al­
+ler Fälle müßte also das Fehlerzeichen auftreten,
+d.h. also etwa 7 Fehlerzeichen pro Werkstück - al­
+lerdings auf eine große Anzahl von produzierten
+Werkstücken bezogen. Da die Werkstücke zufällig
+zusammengesetzt werden, gilt dieser Wert natürlich
+nicht für das einzelne Werkstück! 
+ 
+ 
+4.5.3  Fehlerhafte Auswertungen 
+ 
+   In zwei Situationen kann es zu Fehlern bei der
+Auswertung von Protokollen kommen: 
+ 
+   Wurde der Simulationslauf mit der <SV>-Taste
+rigoros abgebrochen, so ist ggf. eine sinnvolle
+Auswertung des Protokolls nicht möglich, da nur
+unvollständige Daten vorhanden sind. 
+ 
+   In der letzten Arbeitsphase eines Simulations­
+laufes muß zumindest ein Werkstück angefordert wor­
+den sein. Dehnt ein Anwender die letzte Pause so
+lange aus, daß das Pausenende über das Ende der
+letzten Arbeitsphase hinausreicht, so erscheinen im
+Protokoll keine Werte für die einzelnen Werkstücke
+- in der Gesamtauswertung sind (fast) alle Werte
+auf '0' gesetzt. 
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 5 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 5
new file mode 100644
index 0000000..d08e4a7
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 5
@@ -0,0 +1,699 @@
+#limit (11.0)##pagelength (16.5)##block##pageblock# 
+#start (2.0,0.0)# 
+#page (40)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#5 
+ 
+#center#Beschreibung 
+#center#der 
+#center#Menufunktionen 
+ 
+#center#(Programmteil 'Bildschirmarbeitsplatz' (BAP)) 
+ 
+ 
+5.1  Kurzhinweise zur Bedienung des Menus 
+ 
+   Die Bedienung des Menus ist sehr einfach. Eine
+ausführliche Beschreibung dazu finden Sie in den
+Unterlagen zum Programmsystem #on("b")#gs-DIALOG#off("b")#. An dieser
+Stelle sollen nur die wesentlichen Bedienungsvor­
+gänge beschrieben werden. 
+ 
+-  Mit der Tastenfolge <ESC><?> können Sie sich
+   Informationen zur Bedienung des Menusystems in
+   das Menu einblenden lassen. 
+ 
+-  Mit den Pfeiltasten <rechts> und <links> können
+   Sie zwischen den "Oberbegriffen" in der Kopfzei­
+   le wählen. Der aktuelle Oberbegriff ist jeweils
+   invers dargestellt. Das ausgeklappte 'Pull-
+   Down-Menu' bezieht sich auf diesen invers darge­
+   stellten Oberbegriff. 
+ 
+-  Mit den Pfeiltasten <hoch> und <runter> können
+   Sie zwischen den Menufunktionen wählen, die
+   Ihnen im aktuellen Pull-Down-Menu zur Auswahl
+   angeboten werden. Die aktuell angewählte Menu­
+   funktion wird jeweils invers dargestellt. Die
+   Trennlinien, die in einigen Pull-Down-Menus
+   sichtbar sind, dienen nur der optischen Unter­
+   gliederung; sie können nicht angewählt werden
+   und werden deshalb automatisch übersprungen. Die
+   einzelnen Menupunkte sind "zyklisch miteinander
+   verknüpft", das heißt, man gelangt vom untersten
+   Menupunkt wieder zum obersten und umgekehrt.
+   Menupunkte, vor denen ein Minuszeichen steht
+   ('-'), sind (zur Zeit) nicht aktivierbar; auch
+   sie können nicht angewählt werden und werden
+   einfach übersprungen. 
+ 
+-  Durch Tippen der Fragezeichentaste (<?>) können
+   Sie sich jeweils zur aktuellen Menufunktion (in­
+   vers im Pull-Down-Menu) Informationen in das
+   Menu einblenden lassen. 
+ 
+-  Um eine Menufunktion ausführen zu lassen, bewe­
+   gen Sie sich mit den Pfeiltasten auf die ge­
+   wünschte Menufunktion im aktuellen Pull-Down-
+   Menu und tippen dann die <RETURN>-Taste. Steht
+   vor dem gewünschten Menupunkt ein einzelner
+   Buchstabe oder eine Ziffer, so kann durch Tippen
+   der entsprechenden Taste diese Menufunktion da­
+   durch direkt aufgerufen werden. Sobald eine Me­
+   nufunktion aufgerufen worden ist, erscheint da­
+   vor ein Stern ('*'). Daraus können Sie entneh­
+   men, daß das System bereits den Auftrag aus­
+   führt. 
+ 
+-  An verschiedenen Stellen werden Fragen an Sie
+   gerichtet, die Sie mit 'ja' oder 'nein' beant­
+   worten müssen. Tippen Sie dazu entsprechend der
+   Entscheidung die Taste <j> (für 'ja') bzw. <n>
+   (für 'nein'). 
+ 
+-  Werden Ihnen vom Menu aus Dateinamen zur Auswahl
+   angeboten, so können Sie den auf dem Bildschirm
+   sichtbaren Pfeil vor den gewünschten Namen posi­
+   tionieren. Mit den Tasten <x> oder <RETURN> kön­
+   nen Sie den Namen ankreuzen. Ist die Auswahl
+   mehrerer Dateinamen möglich, so können Sie den
+   Vorgang wiederholen. Mit den Tasten <o> oder
+   <RUBOUT> können Sie auch ein Kreuz vor einem
+   Namen wieder löschen. Daneben gibt es noch eini­
+   ge Tastenfunktionen, die für die Bedienung recht
+   hilfreich sein können. Tippen Sie während der
+   Auswahl die Fragezeichentaste (<?>), so werden
+   Ihnen alle Bedienungsmöglichkeiten auf dem Bild­
+   schirm angezeigt. Eine Auswahl, in der mehrere
+   Dateien angekreuzt werden dürfen, wird durch die
+   Tastenfolge <ESC><q> verlassen. Anschließend
+   wird die eingestellte Operation mit den ange­
+   kreuzten Dateien ausgeführt. Sind Sie versehent­
+   lich in eine solche Auswahl gelangt, so können
+   Sie den Vorgang durch die Tastenkombination
+   <ESC><h> abbrechen. 
+ 
+-  An einigen Stellen werden Sie aufgefordert, eine
+   Eingabe zu machen (z.B. einen Dateinamen einzu­
+   geben). Wird Ihnen hier ein Vorschlag gemacht,
+   den Sie akzeptieren, so brauchen Sie zur Bestä­
+   tigung nur die <RETURN>-Taste zu tippen. Ge­
+   fällt Ihnen der Vorschlag nicht oder wird Ihnen
+   kein Vorschlag gemacht, so machen Sie bitte die
+   gewünschte Eingabe. Zum Schreiben stehen Ihnen
+   alle aus dem Editor bekannten Funktionen zur
+   Verfügung. Mit der Taste <RUBOUT> können Sie
+   Buchstaben löschen, mit <RUBIN> einfügen. Die
+   Eingabe wird durch Tippen der <RETURN>-Taste
+   abgeschlossen. Ist der von Ihnen gewünschte Name
+   schon in Ihrer Task vorhanden und steht in der
+   Fußzeile der Hinweis 'Zeigen: <ESC><z>', dann
+   können Sie sich auch alle vorhandenen Namen zur
+   Auswahl anbieten lassen und durch Ankreuzen den
+   beabsichtigten Namen auswählen. 
+ 
+-  Ihnen können auch mehrere Alternativen angeboten
+   werden, zwischen denen Sie wählen müssen. In der
+   untersten Zeile eines solchen Kastens, in denen
+   Ihnen die Alternativen auf dem Bildschirm einge­
+   blendet werden, sind die Möglichkeiten aufge­
+   führt, die darüber beschrieben sind. Mit den
+   Pfeiltasten können sie die Markierung auf die
+   gewünschte Alternative positionieren und dann
+   durch die <RETURN>-Taste zur Ausführung bringen.
+   (Manchmal ist das auch durch Tippen der den Al­
+   ternativen vorangestellten Buchstaben oder Zif­
+   fern möglich). 
+ 
+-  Durch die Tastenfolge <ESC><q> kann das Menu
+   insgesamt verlassen werden. Damit das nicht ver­
+   sehentlich geschieht, wird jeweils die Frage
+   gestellt, ob Sie das Menu tatsächlich verlassen
+   wollen. Diese Frage beantworten Sie bitte je
+   nach Wunsch mit 'ja' oder 'nein' durch Tippen
+   der Tasten <j> bzw. <n>. 
+ 
+#page#    
+5.2  Menufunktionen zum Oberbegriff  'Simulation' 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
++-------------------------------+----------------------------------------- 
+|  s Simulation ausführen       | 
+|  ---------------------------  | 
+|  a Auswertung auf Bildschirm  | 
+|  d Drucken von Auswertungen   | 
++-------------------------------+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+#on("u")##on("b")#s Simulation ausführen#off("b")##off("u")# 
+        Mit dieser Menufunktion starten Sie einen
+     Simulationslauf. Bevor Sie aber mit der Arbeit
+     am Bildschirmarbeitsplatz beginnen können,
+     wird eine "Identifikation" (Vor- und Nachname)
+     von Ihnen verlangt. Das Protokoll, das bei der
+     Simulation entsteht, erhält dann die hier ein­
+     gegebene Kennung. Geben Sie für mehrere Proto­
+     kolle den gleichen Namen an, so werden die
+     Protokolle in der Reihenfolge ihrer Anlage
+     durchnumeriert. 
+        Nach Eingabe der Kennung werden oben auf
+     dem Bildschirm die zur Zeit eingestellten Si­
+     mulationsdaten angezeigt - alle Daten, die Sie
+     zur Bedienung während der Simulation benöti­
+     gen. Die eigentliche Simulation beginnt erst
+     mit dem nächsten Tastendruck; dazu erfolgt ein
+     Hinweis auf dem Bildschirm. 
+        Nach Abschluß der Simulation wird Ihnen
+     gegebenenfalls (sehen Sie dazu auch die Menu­
+     funktion 'k Kurzauswertung' unter dem Oberbe­
+     griff 'Konfiguration') eine Kurzauswertung auf
+     dem Bildschirm ausgegeben. Anschließend gelan­
+     gen Sie zurück in das Menu. 
+        Diese Menufunktion hat eine ähnliche Wir­
+     kung wie der Aufruf des Programms 'Material­
+     prüfung' (MP). Im Gegensatz zum Aufruf des
+     Programms 'Materialprüfung' (MP - mit dem Be­
+     fehl: mp <RETURN>) werden hier allerdings kei­
+     ne ausführlichen Informationen vor dem eigent­
+     lichen Simulationslauf ausgegeben, sondern es
+     wird nur nach einer Identifikation (Vorname
+     und Nachname) gefragt. Nach Abschluß der Si­
+     mulation verbleibt das Protokoll in der Task -
+     es wird nicht, wie im Programmteil 'Material­
+     prüfung', in die Vatertask geschickt. 
+ 
+#on("u")##on("b")#a Auswertung auf Bildschirm#off("b")##off("u")# 
+        Alle Simulationsprotokolle, die sich in
+     Ihrer Task befinden, werden Ihnen zur Auswahl
+     angeboten. Wenn Sie den/die gewünschten Proto­
+     kollnamen angekreuzt und die Auswahl mit der
+     Tastenfolge <ESC><q> verlassen haben, werden
+     die Protokolle nacheinander in der Ankreuzrei­
+     henfolge ausgewertet und die Auswertungen auf
+     dem Bildschirm angezeigt. 
+        Die gesamte Auswertung kann zwar nicht auf
+     einmal auf dem Bildschirm angezeigt werden -
+     Sie können aber das Fenster mit <HOP><hoch>
+     und <HOP><runter> rollen und so in die gesamte
+     Datei Einsicht nehmen. Gegebenenfalls (sehen
+     Sie dazu auch die Menufunktion 'u Umfang der
+     Auswertung' unter dem Oberbegriff 'Konfigura­
+     tion') werden an das Ende der eigentlichen
+     Ergebnisse noch Erläuterungen zum Protokoll
+     ausgegeben. (Zur Protokollauswertung selbst
+     sehen Sie bitte Kapitel 4.4). Da die Auswer­
+     tung jeweils in eine Datei geschrieben wird,
+     können Sie sie mit der Tastenkombination
+     <ESC><q> verlassen. 
+ 
+     Fehlerfälle:  - Sehen Sie dazu bitte Kapitel
+                     4.5.3 
+ 
+#on("u")##on("b")#d Drucken von Auswertungen#off("b")##off("u")# 
+        Alle Simulationsprotokolle, die sich in
+     Ihrer Task befinden, werden Ihnen zur Auswahl
+     angeboten. Wenn Sie den/die gewünschten Proto­
+     kollnamen angekreuzt und die Auswahl mit der
+     Tastenfolge <ESC><q> verlassen haben, werden
+     die Protokolle nacheinander in der Ankreuzrei­
+     henfolge ausgewertet und die Auswertdateien
+     zum Drucker geschickt. 
+        #on("b")#ACHTUNG!#off("b")# Zum Ausdruck von Simulationsproto­
+     kollen muß unbedingt diese Menufunktion ge­
+     wählt werden! Zwar können normale Textdateien
+     auch mit dem Menupunkt 'Drucken' unter dem
+     Oberbegriff 'Dateien' ausgedruckt werden - das
+     gilt aber nicht für die bei den Simulationen
+     erzeugten Protokolldateien, die Sie am Präfix
+     'gs-Protokoll:' erkennen können. 
+        Der Ausdruck der Protokollauswertungen er­
+     folgt normalerweise im Standardschrifttyp Ih­
+     res Druckers. Es besteht allerdings die Mög­
+     lichkeit, einen anderen Schrifttyp für den
+     Ausdruck der Protokolldateien einzustellen.
+     Sehen Sie dazu bitte im Kapitel 6 'Hinweise
+     für den Systembetreuer'. 
+ 
+#page#             
+5.3  Menufunktionen zum Oberbegriff  'Parameter' 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
+-------+---------------------------+-------------------------------------- 
+       |  e Einstellung anzeigen   | 
+       |  s Standardwerte          | 
+       |  -----------------------  | 
+       |  b Breite des Werkstücks  | 
+       |  h Höhe   des Werkstücks  | 
+       |  i Invers-/Normal         | 
+       |  z Zeichensatz            | 
+       |  f Fehlerzeichen          | 
+       |  t Tastenbelegung         | 
+       |  -----------------------  | 
+       |  a Anzahl Arbeitsphasen   | 
+       |  d Dauer Arbeitsphase     | 
+       |  p Pausendauer            | 
+       |  -----------------------  | 
+       |  w Wertungsschlüssel      | 
+       +---------------------------+ 
+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+#on("u")##on("b")#e Einstellung anzeigen#off("b")##off("u")# 
+        Auf dem Bildschirm erscheinen zwei Fenster.
+     Im Fenster links werden alle Werte angezeigt,
+     die die Parameter zur Zeit annehmen. Oben kön­
+     nen Sie ablesen, welches Aussehen ein Werk­
+     stück nach der augenblicklichen Einstellung
+     auf dem Bildschirm hätte. Darunter ist angege­
+     ben, welche Tasten bei der Bearbeitung der
+     Werkstücke während des Simulationslauf benutzt
+     werden können. Unten ist noch aufgeführt, wie
+     viele Arbeitsphasen vorgesehen sind und wie
+     lange die Arbeitsphasen, Pausen und die Ge­
+     samtsimulation dauern. 
+        Im Fenster rechts wird ein Diagramm ausge­
+     geben. Hier ist der Bewertungsfaktors in Ab­
+     hängigkeit von der Ausbesserungsrate darge­
+     stellt. Hinsichtlich der Bedeutung des Bewer­
+     tungsfaktors sehen Sie bitte in Kapitel 4.5.1. 
+        Die Anzeige kann durch Tippen einer belie­
+     bigen Taste verlassen werden. 
+ 
+#on("u")##on("b")#s Standardwerte#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie mit ei­
+     nem Tastendruck die sogenannten "Standardwer­
+     te" einstellen - die Werte, die die Parameter
+     haben, wenn das System "frisch installiert"
+     ist. 
+        Zur Sicherheit zeigt das System die aktuel­
+     len Werte an und erfragt, ob Sie die Standard­
+     werte tatsächlich einstellen wollen. Bejahen
+     Sie diese Frage, so werden alle aktuellen Wer­
+     te durch die Standardwerte überschrieben und
+     auf dem Bildschirm angezeigt. Von dieser Ein­
+     stellung ist auch der Wertungsschlüssel be­
+     troffen - der aber nicht angezeigt wird. Die
+     Einstellung wird derart vorgenommen, daß Be­
+     wertungsfaktor und Ausbesserungsrate identisch
+     sind. 
+ 
+#on("u")##on("b")#b Breite des Werkstücks#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie die An­
+     zahl der Zeichen je Werkstückzeile festlegen.
+     Im Fenster links oben werden der kleinstmög­
+     liche Wert (1), der größtmögliche Wert (70)
+     und der aktuell eingestellte Wert angezeigt.
+     Unten erscheint zur Kontrolle ein Werkstück,
+     das den aktuellen Parameterwerten entspricht. 
+        Im Fenster rechts oben wird an Sie die Fra­
+     ge gerichtet, ob Sie tatsächlich eine Verände­
+     rung vornehmen möchten. Haben Sie versehent­
+     lich diesen Menupunkt gewählt, verneinen Sie
+     einfach diese Frage (Taste <n>) und gelangen
+     so - unter Beibehaltung des z.Z. eingestellten
+     Wertes - zurück in das Menu. 
+        Bejahen Sie die Frage, so erhalten Sie die
+     Möglichkeit, den bisher eingestellten Wert mit
+     der Pfeiltaste <hoch> zu erhöhen, mit der
+     Pfeiltaste <runter> zu erniedrigen - aller­
+     dings nur innerhalb der angezeigten Grenzen.
+     Wenn Sie die gewünschte Einstellung vorgenom­
+     men und die Eingabe durch <RETURN> abgeschlos­
+     sen haben, erscheint ein Werkstück in der neu
+     eingestellten Breite unten auf dem Bildschirm.
+     Bejahen Sie die Frage, ob Sie mit der Werk­
+     stückbreite einverstanden sind, dann gelangen
+     Sie ins Menu zurück; ansonsten können Sie die
+     Werkstückbreite nach gleichem Verfahren erneut
+     einstellen. 
+ 
+#on("u")##on("b")#h Höhe des Werkstücks#off("b")##off("u")# 
+        Die Einstellung der Werkstückhöhe (Anzahl
+     Zeichen pro Werkstückspalte) erfolgt analog
+     zur Einstellung der Werkstückbreite - sehen
+     Sie bitte dort. 
+ 
+#on("u")##on("b")#i Invers-/Normal#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie festle­
+     gen, ob das zu bearbeitende Werkstück 'normal'
+     oder 'invers' dargestellt wird. Diese Darstel­
+     lung ist aber immer in Abhängigkeit von der
+     Grundeinstellung Ihres Bildschirms zu sehen.
+     Wenn Ihr Bildschirm normalerweise helle Zei­
+     chen auf dunklem Grund darstellt, so bedeutet
+     'normal' eben diese Einstellung; 'invers' be­
+     deutet dann, daß die Zeichen des Werkstücks
+     dunkel auf hellem Grund dargestellt werden -
+     bei anderer Bildschirmgrundeinstellung eben
+     umgekehrt. 
+        Unten auf dem Bildschirm wird Ihnen zur
+     Kontrolle ein Werkstück in aktueller Darstel­
+     lung gezeigt. Im Fenster oben rechts erscheint
+     die Frage, ob Sie eine Veränderung der augen­
+     blicklichen Einstellung wünschen. Je nachdem,
+     ob Sie die Frage bejahen oder verneinen, wird
+     eine Veränderung vorgenommen oder nicht. 
+ 
+#on("u")##on("b")#z Zeichensatz#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie das Feh­
+     lerzeichen festlegen und bestimmen, aus wel­
+     chen Zeichen die Werkstücke zusammengesetzt
+     werden sollen. Bejahen Sie die Frage nach der
+     Neufestlegung des Zeichensatzes, so werden
+     Ihnen im Fenster links alle möglichen Zeichen
+     angezeigt. Die Zeichen werden hier in der Rei­
+     henfolge ihres internen Codes ausgegeben. Sie
+     können nun - indem Sie einfach die entspre­
+     chende Taste tippen - eines der angegebenen
+     Zeichen als 'Fehlerzeichen' bestimmen. Es wird
+     daraufhin invers dargestellt. 
+        Anschließend können Sie die Zeichen bestim­
+     men, die sonst noch im Werkstück vorkommen
+     sollen. Allerdings sind Sie bei dieser Wahl
+     nicht so frei wie bei der Wahl des Fehlerzei­
+     chens. Es muß sich um einen zusammenhängenden
+     Bereich von Zeichen handeln, die um das Feh­
+     lerzeichen gruppiert sind - 'zusammenhängend'
+     bezieht sich dabei auf die Reihenfolge der
+     Zeichen im Fenster links. 
+        Die Festlegung selbst erfolgt in zwei Etap­
+     pen. Zuerst können Sie den Bereich der Zeichen
+     bestimmen, die in der Reihenfolge vor dem Feh­
+     lerzeichen stehen. Mit der Pfeiltaste <hoch>
+     markieren Sie den Bereich, der vor dem Fehler­
+     zeichen liegt; mit der Pfeiltaste <runter>
+     können Sie ggf. die Markierung wieder rückgän­
+     gig machen. Wenn Sie so den gewünschten Be­
+     reich markiert haben, tippen Sie die
+     <RETURN>-Taste. 
+        Anschließend bestimmen Sie den Bereich hin­
+     ter dem Fehlerzeichen auf vergleichbare Weise
+     und schließen auch hier die Einstellung mit
+     der <RETURN>-Taste ab. Daraufhin wird Ihnen
+     der eingestellte Zeichensatz mit markiertem
+     Fehlerzeichen noch einmal zur Kontrolle im
+     Fenster links ausgegeben. Sind Sie mit der
+     Einstellung einverstanden, so bejahen Sie die
+     an Sie gerichtete Frage und gelangen ins Menu
+     zurück; ansonsten können Sie nach gleichem
+     Verfahren die Einstellung korrigieren. 
+ 
+#on("u")##on("b")#f Fehlerzeichen#off("b")##off("u")# 
+        Diese Menufunktion ist dann sinnvoll zu
+     wählen, wenn Sie den eingestellten Zeichensatz
+     beibehalten und nur das Fehlerzeichen verän­
+     dern wollen. Wenn Sie die Frage bejaht haben,
+     eine Veränderung vornehmen zu wollen, haben
+     Sie die Möglichkeit, durch Verschiebung der
+     Markierung im Fenster links (durch die Tasten
+     <hoch> und <runter>) das neue Fehlerzeichen
+     einzustellen. Die Einstellung wird durch
+     <RETURN> abgeschlossen. Sind Sie mit dem ein­
+     gestellten Fehlerzeichen einverstanden, gelan­
+     gen Sie zurück ins Menu; ansonsten können Sie
+     Ihre Einstellung korrigieren. 
+ 
+#on("u")##on("b")#t Tastenbelegung#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie die Ta­
+     sten bestimmen, die bei einem Simulationslauf
+     zur Bedienung des Systems benutzt werden kön­
+     nen. Ihnen wird im Fenster links oben die ak­
+     tuelle Einstellung angezeigt. Haben Sie sich
+     entschlossen, eine Neueinstellung vorzunehmen,
+     werden nacheinander die entsprechenden Tasten
+     erfragt. Sie brauchen dabei jeweils nur die
+     Taste zu tippen, die Sie für die entsprechende
+     Funktion vorgesehen haben. 
+        Sie können die Tasten nahezu frei wählen.
+     Es ist allerdings nicht erlaubt, die <SV>-
+     Taste zu wählen. Ebensowenig wird die Einstel­
+     lung akzeptiert, wenn Sie Mehrfachbelegungen
+     vornehmen, d.h, eine Taste für mehrere Funk­
+     tionen vorschlagen. Achten Sie deshalb immer
+     auf den Kommentar zur Einstellung im Fenster
+     unten links. Ist die Neueinstellung fehler­
+     haft, so erfolgt ein Hinweis darauf - in einem
+     solchen Falle bleibt die alte Tastenbelegung
+     erhalten. 
+ 
+#on("u")##on("b")#a Anzahl Arbeitsphasen#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie festle­
+     gen, in wie viele Arbeitsphasen ein Simula­
+     tionslauf jeweils eingeteilt werden soll. Im
+     Fenster links oben werden der kleinstmögliche
+     Wert (2), der größtmögliche Wert (20) und der
+     aktuell eingestellte Wert angezeigt. Im Fen­
+     ster unten wird die aktuelle Simulationsdauer
+     angezeigt. 
+        Im Fenster rechts oben wird an Sie die Fra­
+     ge gerichtet, ob Sie tatsächlich eine Verände­
+     rung vornehmen möchten. Bejahen Sie die Frage,
+     so erhalten Sie die Möglichkeit, den bisher
+     eingestellten Wert mit der Pfeiltaste <hoch>
+     zu erhöhen, mit der Pfeiltaste <runter> zu
+     erniedrigen - allerdings nur innerhalb der
+     angezeigten Grenzen. 
+        Wenn Sie die gewünschte Einstellung vorge­
+     nommen und die Eingabe durch <RETURN> abge­
+     schlossen haben, erscheinen die neuen Simula­
+     tionszeiten im Fenster unten. Bejahen Sie die
+     Frage, ob Sie mit der Arbeitsphasenanzahl ein­
+     verstanden sind, dann gelangen Sie ins Menu
+     zurück; ansonsten können Sie nach gleichem
+     Verfahren die getroffene Einstellung korrigie­
+     ren. 
+ 
+#on("u")##on("b")#d Dauer Arbeitsphase#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie festle­
+     gen, wie lange eine Arbeitsphase dauern soll.
+     Es kann ein Wert zwischen 1 min und 60 min
+     eingestellt werden. Das Einstellverfahren ver­
+     läuft analog zur Festlegung der Anzahl der
+     Arbeitsphasen - sehen Sie bitte dort. 
+ 
+#on("u")##on("b")#p Pausendauer#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie festle­
+     gen, wie lange die Pause zwischen je zwei Ar­
+     beitsphasen dauern soll. Es kann ein Wert zwi­
+     schen 1 min und 30 min eingestellt werden. Das
+     Einstellverfahren verläuft analog zur Festle­
+     gung der Anzahl der Arbeitsphasen - sehen Sie
+     bitte dort. 
+ 
+#on("u")##on("b")#w Wertungsschlüssel#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie den Wer­
+     tungsschlüssel festlegen. Zur genauen Erläu­
+     terung der Bedeutung des Bewertungsfaktors
+     sehen Sie bitte Kapitel 4.5.1. 
+        Im Fenster links wird der aktuell einge­
+     stellte Wertungsschlüssel angezeigt. Stellen
+     Sie sich die ins Koordinatensystem eingetrage­
+     nen Kreuzchen durch einen Streckenzug verbun­
+     den vor. Entscheiden Sie sich für eine Neu­
+     festlegung, dann können Sie mit den Pfeil­
+     tasten <hoch> und <runter> nacheinander die
+     einzelnen Kreuzchen im Koordinatensystem nach
+     oben bzw. nach unten verschieben. 
+        Haben Sie ein Kreuzchen an die gewünschte
+     Stelle positioniert, so tippen Sie als Kenn­
+     zeichen dafür die <RETURN>-Taste. So gelangen
+     Sie zum nächsten Kreuzchen bzw. nach dem letz­
+     ten Kreuzchen zurück in das Fenster oben
+     rechts. Wenn Sie mit dem eingestellten Wer­
+     tungsschlüssel einverstanden sind, gelangen
+     Sie zurück ins Menu; ansonsten können Sie die
+     vorgenommene Einstellung korrigieren. 
+ 
+#page# 
+5.4  Menufunktionen zum Oberbegriff  'Konfigu­
+     ration' 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
+--------------------+---------------------------+------------------------- 
+                    |  u Umfang der Auswertung  | 
+                    |  k Kurzauswertung         | 
+                    +---------------------------+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+#on("u")##on("b")#u Umfang der Auswertung#off("b")##off("u")# 
+        Mit dieser Menufunktion können Sie festle­
+     gen, ob am Ende einer Protokollauswertung die
+     sogenannten 'Anmerkungen', die die Zusammen­
+     hänge im Protokoll erläutern, jeweils mit aus­
+     gegeben werden sollen oder nicht. Die hier
+     getroffene Festlegung gilt sowohl für die Aus­
+     wertung auf dem Bildschirm als auch für den
+     Ausdruck über einen angeschlossenen Drucker. 
+        Zum Verständnis der Auswertungen sind die
+     Anmerkungen sehr hilfreich. Hat man aber meh­
+     rere Simulationsläufe absolviert, bei denen
+     der Wertungsschlüssel identisch ist, so wäre
+     es überflüssig, jeweils die Anmerkungen mit
+     ausgeben zu lassen. 
+        Die aktuelle Einstellung (mit/ohne Anmer­
+     kungen) wird im Fenster links oben angezeigt.
+     Im Fenster rechts oben wird die Frage ge­
+     stellt, ob Sie eine Veränderung der Einstel­
+     lung wünschen. Nur wenn Sie diese Frage beja­
+     hen, wird die Einstellung verändert; ansonsten
+     gelangen Sie unter Beibehaltung der alten Ein­
+     stellung ins Menu zurück. 
+ 
+#on("u")##on("b")#k Kurzsauswertung#off("b")##off("u")# 
+        Standardmäßig wird am Ende eines Simula­
+     tionslaufes eine Kurzauswertung auf dem Bild­
+     schirm ausgegeben. Wenn Sie diese überflüssig
+     finden oder wenn Sie es aus didaktischen Grün­
+     den vorziehen, auf eine solche Kurzauswertung
+     zu verzichten, können Sie diese Kurzauswertung
+     durch diese Menufunktion ab- bzw. wieder ein­
+     schalten. 
+        Die hier getroffene Einstellung ist auch
+     gültig für anschließend eingerichtete Sohn­
+     tasks - und zwar sowohl für das Teilprogramm
+     'Bildschirmarbeitsplatz' als auch für das
+     Teilprogramm 'Materialprüfung'. 
+        Die aktuelle Einstellung (mit/ohne Kurzaus­
+     wertung) wird im Fenster links oben angezeigt.
+     Im Fenster rechts oben wird die Frage ge­
+     stellt, ob Sie eine Veränderung der Einstel­
+     lung wünschen. Nur wenn Sie diese Frage beja­
+     hen, wird die Einstellung verändert; ansonsten
+     gelangen Sie unter Beibehaltung der alten Ein­
+     stellung ins Menu zurück 
+ 
+#page# 
+5.5  Menufunktionen zum Oberbegriff  'Dateien' 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
+------------------------------------+-------------------+----------------- 
+                                    |  v Verzeichnis    | 
+                                    |  ---------------  | 
+                                    |  l Löschen        | 
+                                    |  d Drucken        | 
+                                    |  ---------------  | 
+                                    |  k Kopieren       | 
+                                    |  u Umbenennen     | 
+                                    |  ---------------  | 
+                                    |  s Speicherplatz  | 
+                                    |  a Aufräumen      | 
+                                    +-------------------+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+   Die einzelnen Menufunktionen zu diesem Oberbe­
+griff sind detailliert im Handbuch zum Programm
+#on("b")#gs-DIALOG#off("b")# beschrieben und können dort nachgeschla­
+gen werden. An dieser Stelle seien nur einige Be­
+sonderheiten genannt, die hinsichtlich des Pro­
+grammsystems #on("b")#gs-MP BAP#off("b")# zutreffen: 
+   Protokolldateien, die während eines Simulations­
+laufs angelegt werden, können Sie am Präfix 'gs-
+Protokoll:' erkennen. Diese Protokolldateien können
+#on("u")#nicht#off("u")# mit der in diesem Pull-Down-Menu angegebenen
+Menufunktion 'd Drucken' über den Drucker ausge­
+druckt werden. Die Simulationsdaten sind in den
+Protokolldateien nämlich in einem gesonderten For­
+mat aufgezeichnet, das vom Drucker nicht ausgewer­
+tet werden kann. 
+   Für die Auswertung und den anschließenden Aus­
+druck dieser Protokolldateien ist die Menufunktion
+'d Drucken von Auswertungen' unter dem Oberbegriff
+'Simulation' bereitgestellt! 
+   Sie können den Protokolldateien mit der Menu­
+funktion 'u Umbenennen' einen neuen Namen geben.
+Achten Sie aber #on("u")#unbedingt(!)#off("u")# darauf, daß das Präfix
+'gs-Protokoll:' bei der Umbenennung erhalten bleibt
+- sonst wird die Datei nicht mehr als Protokollda­
+tei vom Auswertsystem erkannt! 
+   Die eben angesprochenen Protokolldateien können
+auch nicht mit der Menufunktion 'a Aufräumen' bear­
+beitet werden, da hier nur "normale" Textdateien
+akzeptiert werden - im übrigen sind die Protokoll­
+dateien immer optimal organisiert. 
+ 
+#page# 
+5.6  Menufunktionen zum Oberbegriff  'Archiv' 
+ 
+#on("b")# 
+BAP:  Simulation  Parameter  Konfiguration  Dateien  Archiv 
+------------------------------------------+-------------------------+----- 
+                                          |  r Reservieren          | 
+                                          |  n Neue Diskette        | 
+                                          |  ---------------------  | 
+                                          |  s Schreiben            | 
+                                          |  c Checken              | 
+                                          |  k Kombination          | 
+                                          |  h Holen/Lesen          | 
+                                          |  l Löschen              | 
+                                          |  ---------------------  | 
+                                          |  v Verzeichnis          | 
+                                          |  d Drucken              | 
+                                          |  ---------------------  | 
+                                          |  i Initialisieren       | 
+                                          |  z Zieltask einstellen  | 
+  +---------------------+                 +-------------------------+ 
+  | Dateiaustausch mit: | 
+  |  Archiv             | 
+  | Archivname:         | 
+  |  gs-MP BAP          | 
+  +---------------------+ 
+-------------------------------------------------------------------------- 
+Info:<ESC><?>/<?>  Wahl:<Pfeile>  Ausführen:<RETURN>  Verlassen:<ESC><q> 
+#off("b")# 
+ 
+   Die einzelnen Menufunktionen zu diesem Oberbe­
+griff sind detailliert im Handbuch zum Programm
+#on("b")#gs-DIALOG#off("b")# beschrieben und können dort nachgeschla­
+gen werden. 
+ 
+
diff --git a/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 6 b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 6
new file mode 100644
index 0000000..7d485d7
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/A5 - Doku: gs-MP BAP - Kapitel 6
@@ -0,0 +1,53 @@
+#limit (11.0)##pagelength (16.5)##block##pageblock# 
+#start (2.0,0.0)# 
+#page (61)# 
+#headodd# 
+#center#gs-MP BAP#right#% 
+ 
+#end# 
+#headeven# 
+%#center#gs-MP BAP 
+ 
+#end# 
+#center#6
+ 
+#center#Hinweise 
+#center#für den 
+#center#Systembetreuer 
+ 
+ 
+   Für den Ausdruck von Protokollauswertungen ist
+der Standardschrifttyp des Druckers voreingestellt.
+Sie haben aber die Möglichkeit, einen anderen
+Schrifttyp für den Protokollausdruck einzustellen.
+Dafür sind die beiden folgenden Prozeduren vorbe­
+reitet: 
+ 
+PROC druckereinstellung fuer protokolldatei 
+     (TEXT CONST schrifttyp, REAL CONST linker 
+      rand, oberer rand, schreibfeldbreite, 
+      schreibfeldlaenge) 
+ 
+     Geben Sie einen in Ihrer Installation vorhan­
+     denen Schrifttyp an. Beachten Sie bei der
+     Festlegung der anderen Maße (wie gewohnt in
+     cm), daß auf dem Schreibfeld 80 Druckpositio­
+     nen nebeneinander Platz haben müssen! 
+ 
+ 
+PROC std druckereinstellung fuer protokolldatei 
+ 
+     Sie können mit diesem Befehl wieder die Ein­
+     stellung vornehmen, die sonst standardmäßig
+     von #on("b")#gs-MP BAP#off("b")# vorgegeben wird: 
+ 
+     schrifttyp         :    ""  (Standard- 
+                                  schrifttyp) 
+     linker rand        :   0.0  (cm) 
+     oberer rand        :   0.0  (cm) 
+     schreibfeldbreite  :  21.0  (cm) 
+     schreibfeldlaenge  :  29.5  (cm) 
+ 
+ 
+ 
+
diff --git a/app/gs.mp-bap/1.1/doc/gs-MP BAP handbuch.impressum b/app/gs.mp-bap/1.1/doc/gs-MP BAP handbuch.impressum
new file mode 100644
index 0000000..91c6ce0
--- /dev/null
+++ b/app/gs.mp-bap/1.1/doc/gs-MP BAP handbuch.impressum
@@ -0,0 +1,104 @@
+____________________________________________________________________________ 
+ 
+ 
+#on("b")##on ("u")# 
+#center#Betriebssystem E U M E L 
+#off ("u")# 
+ 
+ 
+#center#gs-MP BAP 
+ 
+ 
+ 
+ 
+#off("b")# 
+#center#Lizenzfreie Software der 
+#on ("b")# 
+ 
+#center#Gesellschaft für Mathematik und Datenverarbeitung mbH, 
+#center#5205 Sankt Augustin 
+ 
+ 
+#off("b")# 
+#center#Die Nutzung der Software ist nur im Schul- und Hochschulbereich für 
+#center#nichtkommerzielle Zwecke gestattet. 
+ 
+#center#Gewährleistung und Haftung werden ausgeschlossen 
+ 
+ 
+____________________________________________________________________________ 
+#page# 
+ 
+#free (4.0)##on("b")# 
+#center#gs-MP BAP
+ 
+ 
+#center#Benutzerhandbuch 
+ 
+ 
+#center#Version 1.0 
+ 
+ 
+#off("b")##center#copyright 
+#center#Eva Latta-Weber 
+#center#Software- und Hardware-Systeme, 1988 
+#center#ERGOS GmbH, 1990 
+#page# 
+#block# 
+#center#____________________________________________________________________________ 
+ 
+ 
+Copyright:  ERGOS GmbH   März 1990 
+ 
+                     Alle Rechte vorbehalten. Insbesondere ist die Überführung in
+                     maschinenlesbare Form sowie das Speichern in Informations­
+                     systemen, auch auszugsweise, nur mit schriftlicher Einwilligung
+                     der ERGOS GmbH gestattet. 
+ 
+ 
+#center#____________________________________________________________________________ 
+ 
+Es kann keine Gewähr übernommen werden, daß das Programm für eine
+bestimmte Anwendung geeignet ist. Die Verantwortung dafür liegt beim
+Anwender. 
+ 
+Das Handbuch wurde mit größter Sorgfalt erstellt. Für die Korrektheit und
+Vollständigkeit der Angaben kann keine Gewähr übernommen werden. Das
+Handbuch kann jederzeit ohne Ankündigung geändert werden. 
+ 
+Texterstellung   :  Dieser Text wurde mit der ERGOS-L3 Textverarbeitung
+                   erstellt und aufbereitet und auf einem Kyocera Laser­
+                   drucker gedruckt. 
+ 
+ 
+ 
+ 
+#center#___________________________________________________________________________ 
+ 
+ 
+ 
+Ergonomic Office Software GmbH 
+ 
+Bergstr. 7              Telefon: (02241) 63075 
+5200 Siegburg           Teletex: 2627-2241413=ERGOS 
+                        Telefax: (02241) 63078 
+ 
+ 
+#center#____________________________________________________________________________ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/gs.mp-bap/1.1/source-disk b/app/gs.mp-bap/1.1/source-disk
new file mode 100644
index 0000000..1732e99
--- /dev/null
+++ b/app/gs.mp-bap/1.1/source-disk
@@ -0,0 +1 @@
+informatikpaket/07_gs.mp-bap.img
diff --git a/app/gs.mp-bap/1.1/src/ls-MENUKARTE:MP-BAP b/app/gs.mp-bap/1.1/src/ls-MENUKARTE:MP-BAP
new file mode 100644
index 0000000..564b07c
--- /dev/null
+++ b/app/gs.mp-bap/1.1/src/ls-MENUKARTE:MP-BAP
diff --git a/app/gs.mp-bap/1.1/src/ls-MP BAP 1 b/app/gs.mp-bap/1.1/src/ls-MP BAP 1
new file mode 100644
index 0000000..be7e3d2
--- /dev/null
+++ b/app/gs.mp-bap/1.1/src/ls-MP BAP 1
@@ -0,0 +1,119 @@
+PACKET ls mp bap 1  DEFINES                (*******************************) 
+                                           (*                             *) 
+       stdvoreinstellung der parameter,    (*         ls-MP BAP 1         *) 
+       werkstueckdefinition,               (*         Version 1.1         *) 
+       tastendefinition,                   (*                             *) 
+       phasendefinition,                   (*   (c) 1987, 1988            *) 
+       bewertungsschluessel,               (*       by Eva Latta-Weber    *) 
+       werkstueckaufhaenger,               (*          Bielefeld          *) 
+       tastenbezeichnung,                  (*                             *) 
+       piepse,                             (*******************************) 
+                                            
+       mp bap einstellung anzeigen,         
+       mp bap standardwerte,                
+       mp bap breite des werkstuecks, 
+       mp bap hoehe  des werkstuecks, 
+       mp bap invers normal, 
+       mp bap zeichensatz, 
+       mp bap fehlerzeichen, 
+       mp bap tastenbelegung, 
+       mp bap anzahl arbeitsphasen, 
+       mp bap dauer einer arbeitsphase, 
+       mp bap pausendauer, 
+       mp bap wertungsschluessel: 
+ 
+LET maxspalten         =            70,{}    maxzeilen          =            14,{}    kleinster wert     =             1,{}    oben unten return  = ""3""10""13"",{}    punkt              =           "+",{}    punkt und zurueck  =        "+"8"",{}    piep               =         ""7"",{}    blank              =           " ";{}INT  VAR aktuelle werkstueckbreite,{}         aktuelle werkstueckhoehe,{}         kleinster aktueller zeichencode,{}         groesster aktueller zeichencode,{}         aktuelle anzahl der arbeitsphasen,{}
+         aktuelle arbeitsphasendauer in minuten,{}         aktuelle pausendauer in minuten;{}TEXT VAR aktuelles fehlerzeichen,{}         nach rechts,{}         nach links,{}         nach oben,{}         nach unten,{}         ausbesserung,{}         naechstes;{}BOOL VAR inversdarstellung;{}ROW 11 REAL VAR bewertung;{}WINDOW VAR w1, w2, w3, w4;{}PROC stdvoreinstellung der parameter:{}  aktuelle werkstueckbreite               :=     15;{}  aktuelle werkstueckhoehe                :=     12;{}  kleinster aktueller zeichencode         :=     65;{}
+  groesster aktueller zeichencode         :=     90;{}  aktuelle anzahl der arbeitsphasen       :=      3;{}  aktuelle arbeitsphasendauer in minuten  :=     10;{}  aktuelle pausendauer in minuten         :=      2;{}  aktuelles fehlerzeichen                 :=    "F";{}  nach rechts                             :=  ""2"";{}  nach links                              :=  ""8"";{}  nach oben                               :=  ""3"";{}  nach unten                              := ""10"";{}  ausbesserung                            :=  ""1"";{}
+  naechstes                               := ""27"";{}  inversdarstellung                       :=  FALSE;{}  bewertung := ROW 11 REAL : (0.0, 0.1, 0.2, 0.3, 0.4, 0.5,{}                                   0.6, 0.7, 0.8, 0.9, 1.0){}END PROC stdvoreinstellung der parameter;{}PROC werkstueckdefinition (INT VAR breite, hoehe, kleinster, groesster,{}                           TEXT VAR fzeichen, BOOL VAR invers):{}  breite        := aktuelle werkstueckbreite;{}  hoehe         := aktuelle werkstueckhoehe;{}
+  kleinster     := kleinster aktueller zeichencode;{}  groesster     := groesster aktueller zeichencode;{}  fzeichen      := aktuelles fehlerzeichen;{}  invers        := inversdarstellung{}END PROC werkstueckdefinition;{}PROC tastendefinition (TEXT VAR rechts, links, hoch, runter, aus, nach):{}  rechts        := nach rechts;{}  links         := nach links;{}  hoch          := nach oben;{}  runter        := nach unten;{}  aus           := ausbesserung;{}  nach          := naechstes{}END PROC tastendefinition;{}
+PROC phasendefinition (INT VAR aphasenzahl, aphasendauer, pausendauer):{}  aphasenzahl   := aktuelle anzahl der arbeitsphasen;{}  aphasendauer  := aktuelle arbeitsphasendauer in minuten;{}  pausendauer   := aktuelle pausendauer in minuten{}END PROC phasendefinition;{}PROC bewertungsschluessel (ROW 11 REAL VAR schluessel):{}  INT VAR zeiger;{}  FOR zeiger FROM 1 UPTO 11 REP{}    schluessel [zeiger] := bewertung [zeiger]{}  PER{}END PROC bewertungsschluessel;{}PROC mp bap einstellung anzeigen:{}  aktuellen parameterzustand anzeigen;{}
+  regenerate menuscreen{}END PROC mp bap einstellung anzeigen;{}PROC mp bap standardwerte:{}  standardwerte einstellen;{}  regenerate menuscreen{}END PROC mp bap standardwerte;{}PROC mp bap breite des werkstuecks:{}  breite des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap breite des werkstuecks;{}PROC mp bap hoehe des werkstuecks:{}  hoehe des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap hoehe des werkstuecks;{}PROC mp bap invers normal:{}  werkstueckdarstellung einstellen;{}
+  regenerate menuscreen{}END PROC mp bap invers normal;{}PROC mp bap zeichensatz:{}  zeichensatz einstellen;{}  regenerate menuscreen{}END PROC mp bap zeichensatz;{}PROC mp bap fehlerzeichen:{}  fehlerzeichen veraendern;{}  regenerate menuscreen{}END PROC mp bap fehlerzeichen;{}PROC mp bap tastenbelegung:{}  tastaturbelegung einstellen;{}  regenerate menuscreen{}END PROC mp bap tastenbelegung;{}PROC mp bap anzahl arbeitsphasen:{}  anzahl der arbeitsphasen festlegen;{}  regenerate menuscreen{}END PROC mp bap anzahl arbeitsphasen;{}
+PROC mp bap dauer einer arbeitsphase:{}  dauer einer arbeitsphase festlegen;{}  regenerate menuscreen{}END PROC mp bap dauer einer arbeitsphase;{}PROC mp bap pausendauer:{}  pausendauer festlegen;{}  regenerate menuscreen{}END PROC mp bap pausendauer;{}PROC mp bap wertungsschluessel:{}  wertungsschluessel veraendern;{}  regenerate menuscreen{}END PROC mp bap wertungsschluessel;{}PROC aktuellen parameterzustand anzeigen:{}  zeige die fenster;{}  fuelle die fenster mit inhalt;{}  gib hinweis aus.{}
+  zeige die fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41,  2, 38, 20);{}    w3 := window ( 1,  1, 79, 24);{}    page; show (w1); show (w2).{}  fuelle die fenster mit inhalt:{}    zeige inhalt fenster 1;{}    zeige inhalt fenster 2.{}  zeige inhalt fenster 1:{}    zeige eingestellte parameter an (w1).{}  zeige inhalt fenster 2:{}    gib bewertungsschluessel aus (w2).{}  gib hinweis aus:{}    out footnote (w3, anwendungstext (2)); pause.{}END PROC aktuellen parameterzustand anzeigen;{}
+PROC zeige eingestellte parameter an (WINDOW VAR w):{}  zeige ueberschrift;{}  zeige werkstueckdefinition;{}  zeige tastenbelegung;{}  zeige simulationszeiten.{}  zeige ueberschrift:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 1)))).{}  zeige werkstueckdefinition:{}    cursor (w, 2,  3); out (w, anwendungstext ( 6));{}                       out (w, text (aktuelle werkstueckbreite, 3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  4); out (w, anwendungstext ( 7));{}
+                       out (w, text (aktuelle werkstueckhoehe,  3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  5); out (w, anwendungstext ( 8));{}                        IF inversdarstellung{}                           THEN out (w, anwendungstext (29)){}                           ELSE out (w, anwendungstext (30)){}                        FI;{}    cursor (w, 2,  6); out (w, anwendungstext ( 9));{}                       out (w, zeichensatz);{}    cursor (w, 2,  7); out (w, anwendungstext (10));{}
+                       out (blank + aktuelles fehlerzeichen).{}  zeige tastenbelegung:{}    cursor (w, 2,  9); out (w, anwendungstext (11));{}                       out (w, tastenbezeichnung (nach rechts));{}    cursor (w, 2, 10); out (w, anwendungstext (12));{}                       out (w, tastenbezeichnung (nach links));{}    cursor (w, 2, 11); out (w, anwendungstext (13));{}                       out (w, tastenbezeichnung (nach oben));{}    cursor (w, 2, 12); out (w, anwendungstext (14));{}                       out (w, tastenbezeichnung (nach unten));{}
+    cursor (w, 2, 13); out (w, anwendungstext (15));{}                       out (w, tastenbezeichnung (ausbesserung));{}    cursor (w, 2, 14); out (w, anwendungstext (16));{}                       out (w, tastenbezeichnung (naechstes)).{}  zeige simulationszeiten:{}    cursor (w, 2, 16); out (w, anwendungstext (17));{}                       out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}    cursor (w, 2, 17); out (w, anwendungstext (18));{}                       out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}
+                       out (w, anwendungstext (51));{}    cursor (w, 2, 18); out (w, anwendungstext (19));{}                       out (w, text (aktuelle pausendauer in minuten, 4));{}                       out (w, anwendungstext (51));{}    cursor (w, 2, 20); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  zeichensatz:{}    blank + code (kleinster aktueller zeichencode) + "..." +{}            code (groesster aktueller zeichencode) + " ("  +{}            text (groesster aktueller zeichencode{}
+                   - kleinster aktueller zeichencode + 1, 2) +{}            anwendungstext (28) + ")".{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC zeige eingestellte parameter an;{}PROC gib bewertungsschluessel aus (WINDOW VAR w):{}  zeichne koordinatenkreuz;{}
+  trage messwerte ein.{}  zeichne koordinatenkreuz:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 4))));{}    cursor (w, 2,  3); out (w, anwendungstext (20));{}    cursor (w, 2,  4); out (w, anwendungstext (21));{}    cursor (w, 2,  6); out (w, anwendungstext (23));{}    cursor (w, 2,  7); out (w, anwendungstext (22));{}    cursor (w, 2,  8); out (w, anwendungstext (22));{}    cursor (w, 2,  9); out (w, anwendungstext (22));{}    cursor (w, 2, 10); out (w, anwendungstext (22));{}
+    cursor (w, 2, 11); out (w, anwendungstext (24));{}    cursor (w, 2, 12); out (w, anwendungstext (22));{}    cursor (w, 2, 13); out (w, anwendungstext (22));{}    cursor (w, 2, 14); out (w, anwendungstext (22));{}    cursor (w, 2, 15); out (w, anwendungstext (22));{}    cursor (w, 2, 16); out (w, anwendungstext (25));{}    cursor (w, 2, 17); out (w, anwendungstext (26));{}    cursor (w, 2, 19); out (w, anwendungstext (27)).{}  trage messwerte ein:{}    INT CONST abszisse :: 16, ordinate :: 2;{}
+    INT VAR nr;{}    FOR nr FROM 1 UPTO 11 REP{}      zeichne einen punkt{}    PER.{}  zeichne einen punkt:{}    cursor (w, ordinate + 3 * nr, abszisse - nachkommastelle); out (punkt).{}  nachkommastelle:{}    int(bewertung [nr] * 10.0).{}END PROC gib bewertungsschluessel aus;{}PROC standardwerte einstellen:{}  zeige fenster;{}  zeige eingestellte parameter an (w1);{}  gib information aus;{}  hole bestaetigung ein.{}  zeige fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41, 10, 37, 12);{}
+    w3 := window (41,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib information aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (67));{}    cursor (w2, 2, 4); out (w2, anwendungstext (68));{}    cursor (w2, 2, 7); out (w2, anwendungstext (69));{}    cursor (w2, 2, 9); out (w2, anwendungstext (70));{}    cursor (w2, 2,10); out (w2, anwendungstext (71));{}    cursor (w2, 2,11); out (w2, anwendungstext (72));{}
+    cursor (w2, 2,12); out (w2, anwendungstext (73)).{}  hole bestaetigung ein:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (66))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (66)){}       THEN stdvoreinstellung der parameter;{}            gib positive rueckmeldung{}    FI.{}  gib positive rueckmeldung:{}    page (w1);{}    zeige eingestellte parameter an (w1);{}    cleop  (w3, 2, 3); out (anwendungstext (221));{}    cursor (w3, 2, 5); out (anwendungstext (  3));{}
+    pause.{}END PROC standardwerte einstellen;{}PROC breite des werkstuecks einstellen:{}  zeige die fenster;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige die fenster:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxspalten,     3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle werkstueckbreite, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (57))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (216)){}
+       THEN LEAVE breite des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (60));{}    aktuelle werkstueckbreite := ermittelter wert (1, maxspalten,{}                                                aktuelle werkstueckbreite).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}
+    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (62)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC breite des werkstuecks einstellen;{}PROC hoehe des werkstuecks einstellen:{}  fenster zeigen;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
+  fenster zeigen:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxzeilen,      3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}
+                       out (w1, text (aktuelle werkstueckhoehe, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (63))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (217)){}       THEN LEAVE hoehe des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (64));{}    aktuelle werkstueckhoehe := ermittelter wert (1, maxzeilen,{}
+                                                  aktuelle werkstueckhoehe).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (65)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC hoehe des werkstuecks einstellen;{}PROC werkstueckdarstellung einstellen:{}  fenster zeigen;{}
+  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  REP{}    bestaetigung einholen;{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3){}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (32,  2, 46,  6);{}    w3 := window ( 2,  9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (74));{}
+                       out (w1, anwendungstext (76));{}    cursor (w1, 2, 4); out (w1, anwendungstext (74));{}                       out (w1, anwendungstext (77));{}    cursor (w1, 2, 6); out (w1, anwendungstext (75));{}                       IF inversdarstellung{}                          THEN out (w1, anwendungstext (77)){}                          ELSE out (w1, anwendungstext (76)){}                       FI.{}  bestaetigung einholen:{}    page (w2);{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (89))));{}
+    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (78)){}       THEN veraendere darstellungsart{}       ELSE LEAVE werkstueckdarstellung einstellen{}    FI.{}  veraendere darstellungsart:{}    IF inversdarstellung{}       THEN inversdarstellung := FALSE{}       ELSE inversdarstellung := TRUE{}    FI.{}  benutzer ist einverstanden:{}    cleop (w2, 1, 3);{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (99)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC werkstueckdarstellung einstellen;{}
+PROC zeichensatz einstellen:{}  zeige fenster;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    erfrage das neue fehlerzeichen;{}    ermittle das kleinste zeichen;{}    ermittle das groesste zeichen;{}    page (w1);{}    gib eingestellten zeichensatz an{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}
+  gib eingestellten zeichensatz an:{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (80));{}    cursor (w2, 2, 4); out (w2, anwendungstext (81));{}
+    cursor (w2, 2, 5); out (w2, anwendungstext (82));{}    cursor (w2, 2, 6); out (w2, anwendungstext (83));{}    cursor (w2, 2, 8); out (w2, anwendungstext (84));{}    cursor (w2, 2, 9); out (w2, anwendungstext (85));{}    cursor (w2, 2,10); out (w2, anwendungstext (86));{}    cursor (w2, 2,12); out (w2, anwendungstext (87));{}    cursor (w2, 2,13); out (w2, anwendungstext (88)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}
+    IF no (w3, anwendungstext (91)){}       THEN LEAVE zeichensatz einstellen{}    FI.{}  erfrage das neue fehlerzeichen:{}    gib vollstaendigen zeichensatz aus;{}    gib fehlerzeicheninformationen aus;{}    REP{}      lasse fehlerzeichen eingeben{}    UNTIL fehlerzeichen ist ok PER.{}  gib vollstaendigen zeichensatz aus:{}    page (w1); page (w2); page (w3);{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (92))));{}    gib zeichenkette aus (w1, 33, 126, 0).{}  gib fehlerzeicheninformationen aus:{}
+    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3);  out (w2, anwendungstext (95));{}    cursor (w2, 2, 4);  out (w2, anwendungstext (96));{}    cursor (w2, 2, 6);  out (w2, anwendungstext (97)).{}  lasse fehlerzeichen eingeben:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (100))));{}    cursor (w3, 2, 3);{}    out (w3, anwendungstext (101));{}    cursor on; inchar (aktuelles fehlerzeichen); cursor off;{}    IF fehlerzeichen ist ok{}
+       THEN out (w3, aktuelles fehlerzeichen);{}            markiere das fehlerzeichen im ersten fenster;{}       ELSE lege beschwerde ein{}    FI.{}  fehlerzeichen ist ok:{}        code (aktuelles fehlerzeichen) >=  33{}    AND code (aktuelles fehlerzeichen) <= 126.{}  markiere das fehlerzeichen im ersten fenster:{}    positioniere cursor in zeichenkette (w1, 33, code (aktuelles fehlerzeichen));{}    out (w1, invers (aktuelles fehlerzeichen)).{}  lege beschwerde ein:{}    piepse;{}    cursor (w2, 2, 8); out (w2, anwendungstext (102));{}
+    cursor (w2, 2,10); out (w2, anwendungstext (103));{}    cursor (w2, 2,11); out (w2, anwendungstext (104));{}    cursor (w2, 2,12); out (w2, anwendungstext (105));{}    cursor (w2, 2,13); out (w2, anwendungstext (106));{}    cursor (w2, 2,14); out (w2, anwendungstext (107)).{}  ermittle das kleinste zeichen:{}    page (w2); page (w3);{}    gib kleinste zeichencode informationen aus;{}    lasse den vorbereich festlegen.{}  ermittle das groesste zeichen:{}    lasse den nachbereich festlegen.{}  gib kleinste zeichencode informationen aus:{}
+    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (111));{}    cursor (w2, 2, 4); out (w2, anwendungstext (112));{}    cursor (w2, 2, 5); out (w2, anwendungstext (113));{}    cursor (w2, 2, 6); out (w2, anwendungstext (114));{}    cursor (w2, 2, 8); out (w2, anwendungstext (115));{}    cursor (w2, 2, 9); out (w2, anwendungstext (116));{}    cursor (w2, 2,10); out (w2, anwendungstext (117));{}    cursor (w2, 2,11); out (w2, anwendungstext (118));{}
+    cursor (w2, 2,13); out (w2, anwendungstext (119));{}    cursor (w2, 2,14); out (w2, anwendungstext (120)).{}  lasse den vorbereich festlegen:{}    INT VAR s, z; page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (123));{}    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    kleinster aktueller zeichencode := code (aktuelles fehlerzeichen);{}
+    groesster aktueller zeichencode := code (aktuelles fehlerzeichen);{}    kleinster aktueller zeichencode := eingabe mit intervallanzeige ( w1, 33,{}                                       code (aktuelles fehlerzeichen),{}                                       kleinster aktueller zeichencode, s, z);{}    cursor off.{}  lasse den nachbereich festlegen:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (124));{}
+    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    groesster aktueller zeichencode := eingabe mit intervallanzeige ( w1,{}                                       code (aktuelles fehlerzeichen), 126,{}                                       groesster aktueller zeichencode, s, z);{}    cursor off.{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (126)){}
+       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC zeichensatz einstellen;{}PROC fehlerzeichen veraendern:{}  fenster zeigen;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    lasse fehlerzeichen einstellen{}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}  gib eingestellten zeichensatz an:{}
+    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (131));{}    cursor (w2, 2, 4); out (w2, anwendungstext (132));{}    cursor (w2, 2, 5); out (w2, anwendungstext (133));{}
+    cursor (w2, 2, 7); out (w2, anwendungstext (134));{}    cursor (w2, 2, 8); out (w2, anwendungstext (135));{}    cursor (w2, 2, 9); out (w2, anwendungstext (136)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF no (w3, anwendungstext (137)){}       THEN LEAVE fehlerzeichen veraendern{}    FI.{}  lasse fehlerzeichen einstellen:{}    INT VAR s, z, fehlercode :: code (aktuelles fehlerzeichen);{}    page (w3); cursor (w3, 1, 1);{}
+    out (w3, center (w3, invers (anwendungstext (138))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (139));{}    cursor (w3, 2, 4); out (w3, anwendungstext (140));{}    cursor (w3, 2, 5); out (w3, anwendungstext (141));{}    get cursor (s, z); cursor on;{}    fehlercode := eingabe mit elementanzeige (w1,{}                                              kleinster aktueller zeichencode,{}                                              groesster aktueller zeichencode,{}                                              fehlercode, s, z);{}
+    cursor off;{}    aktuelles fehlerzeichen := code (fehlercode).{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (142)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC fehlerzeichen veraendern;{}PROC tastaturbelegung einstellen:{}  ROW 6 TEXT VAR tastenname, taste;{}  fenster zeigen;{}  REP{}    tastaturneubelegung vornehmen{}  UNTIL benutzer ist einverstanden PER.{}
+  fenster zeigen:{}    w1 := window ( 2,  2, 28, 10);{}    w2 := window ( 2, 14, 28, 10);{}    w3 := window (32, 10, 46, 14);{}    w4 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3); show (w4).{}  tastaturneubelegung vornehmen:{}    alte tastenbelegung einlesen;{}    tastenbelegung anzeigen;{}    bedienhinweise ausgeben;{}    veraenderung erfragen;{}    neue tastenbelegung erfragen;{}    hinweis zur bewertung und stand ausgeben.{}  alte tastenbelegung einlesen:{}    INT VAR z1;{}
+    FOR z1 FROM 1 UPTO 6 REP{}      tastenname [z1] := anwendungstext (z1 + 10){}    PER;{}    taste [1] := nach rechts;{}    taste [2] := nach links;{}    taste [3] := nach oben;{}    taste [4] := nach unten;{}    taste [5] := ausbesserung;{}    taste [6] := naechstes;{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (151)))).{}  tastenbelegung anzeigen:{}    INT VAR cspa, czei;{}    cursor (w1, 2, 3); out (w1, tastenname [1]);{}                       out (w1, tastenbezeichnung (taste [1]));{}
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 4); out (w1, tastenname [2]);{}                       out (w1, tastenbezeichnung (taste [2]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 5); out (w1, tastenname [3]);{}                       out (w1, tastenbezeichnung (taste [3]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 6); out (w1, tastenname [4]);{}
+                       out (w1, tastenbezeichnung (taste [4]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 8); out (w1, tastenname [5]);{}                       out (w1, tastenbezeichnung (taste [5]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2,10); out (w1, tastenname [6]);{}                       out (w1, tastenbezeichnung (taste [6]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei).{}
+  bedienhinweise ausgeben:{}    cursor (w2, 1, 1); out (center (w2, invers (anwendungstext (152))));{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (52))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (153));{}    cursor (w3, 2, 4); out (w3, anwendungstext (154));{}    cursor (w3, 2, 6); out (w3, anwendungstext (155));{}    cursor (w3, 2, 7); out (w3, anwendungstext (156));{}    cursor (w3, 2, 8); out (w3, anwendungstext (157));{}    cursor (w3, 2, 9); out (w3, anwendungstext (158));{}
+    cursor (w3, 2,11); out (w3, anwendungstext (159));{}    cursor (w3, 2,12); out (w3, anwendungstext (160));{}    cursor (w3, 2,13); out (w3, anwendungstext (161));{}    cursor (w3, 2,14); out (w3, anwendungstext (162)).{}  veraenderung erfragen:{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3);{}    IF no (w4, anwendungstext (164)){}       THEN LEAVE tastaturbelegung einstellen{}    FI.{}  neue tastenbelegung erfragen:{}    INT VAR z2; page (w4);{}
+    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3); out (w4, anwendungstext (165));{}    FOR z2 FROM 1 UPTO 6 REP{}      gib tastenhinweis;{}      hole tastatureingabe;{}      tastenbelegung anzeigen{}    PER.{}  gib tastenhinweis:{}    cleol (w4, 2, 5); out (w4, tastenname [z2]).{}  hole tastatureingabe:{}    INT VAR s, z; get cursor (w4, s, z);{}    cursor on; inchar (taste [z2]); cursor off;{}    cursor (w4, s, z); out (w4, tastenbezeichnung (taste [z2])).{}
+  hinweis zur bewertung und stand ausgeben:{}    IF neue tastenbelegung ist ok{}       THEN akzeptiere{}       ELSE akzeptiere nicht{}    FI.{}  neue tastenbelegung ist ok:{}    INT VAR zeiger; TEXT VAR tastenkette :: "";{}    FOR zeiger FROM 1 UPTO 6 REP{}      IF pos (tastenkette, taste [zeiger]) > 0{}         THEN LEAVE neue tastenbelegung ist ok WITH FALSE{}         ELSE tastenkette CAT taste [zeiger]{}      FI{}    PER;{}    TRUE.{}  akzeptiere:{}    cursor (w2, 3, 4);{}    out (w2, anwendungstext (166));{}
+    cursor (w2, 7, 6);{}    out (w2, anwendungstext (167)).{}  akzeptiere nicht:{}    cursor (w2, 3, 3); out (w2, anwendungstext (168));{}    cursor (w2, 3, 4); out (w2, anwendungstext (169));{}    cursor (w2, 3, 6); out (w2, anwendungstext (170));{}    cursor (w2, 3, 7); out (w2, anwendungstext (171));{}    cursor (w2, 3, 9); out (w2, anwendungstext (172));{}    cursor (w2, 5,10); out (w2, anwendungstext (173)).{}  benutzer ist einverstanden:{}    page (w4);{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}
+    IF neue tastenbelegung ist ok{}       THEN gib hinweis auf abspeicherung{}       ELSE frage nach neueingabe{}    FI.{}  gib hinweis auf abspeicherung:{}    cursor (w4, 3, 3); out (w4, anwendungstext (174));{}    neue tastenbelegung festschreiben;{}    cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}    cursor on; pause; cursor off;{}    TRUE.{}  neue tastenbelegung festschreiben:{}    nach rechts   := taste [1];{}    nach links    := taste [2];{}    nach oben     := taste [3];{}    nach unten    := taste [4];{}
+    ausbesserung  := taste [5];{}    naechstes     := taste [6].{}  frage nach neueingabe:{}    cursor (w4, 2, 3);{}    IF yes (w4, anwendungstext (175)){}       THEN cleop (w2, 1, 3); FALSE{}       ELSE alte tastenbelegung einlesen;{}            tastenbelegung anzeigen;{}            cleop  (w4, 2, 3); out (w4, anwendungstext (176));{}            cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}            cursor on; pause; cursor off;{}            TRUE{}    FI.{}END PROC tastaturbelegung einstellen;{}
+PROC simulationszeiten anzeigen (WINDOW VAR w):{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (181))));{}  cursor (w, 2, 3); out (w, anwendungstext (17));{}                    out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}  cursor (w, 2, 4); out (w, anwendungstext (18));{}                    out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}                    out (w, anwendungstext (51));{}  cursor (w, 2, 5); out (w, anwendungstext (19));{}                    out (w, text (aktuelle pausendauer in minuten, 4));{}
+                    out (w, anwendungstext (51));{}  cursor (w, 2, 7); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC simulationszeiten anzeigen;{}PROC anzahl der arbeitsphasen festlegen:{}
+  INT CONST minwert :: 2, maxwert :: 20;{}  zeige fenster;{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle anzahl der arbeitsphasen, 2)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (182))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (218)){}
+       THEN LEAVE anzahl der arbeitsphasen festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (183));{}    aktuelle anzahl der arbeitsphasen := ermittelter wert (minwert, maxwert,{}                                         aktuelle anzahl der arbeitsphasen).{}  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}
+    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (184)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC anzahl der arbeitsphasen festlegen;{}PROC dauer einer arbeitsphase festlegen:{}  INT CONST minwert :: 1, maxwert :: 60;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}
+    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle arbeitsphasendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (187))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (219)){}       THEN LEAVE dauer einer arbeitsphase festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}
+    cursor (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (188));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle arbeitsphasendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                  aktuelle arbeitsphasendauer in minuten).{}  benutzer ist einverstanden:{}
+    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (189)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC dauer einer arbeitsphase festlegen;{}PROC pausendauer festlegen:{}  INT CONST minwert :: 1, maxwert :: 30;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
+  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}
+                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle pausendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (191))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (220)){}       THEN LEAVE pausendauer festlegen{}    FI.{}
+  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (192));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle pausendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                          aktuelle pausendauer in minuten).{}
+  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (193)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC pausendauer festlegen;{}PROC wertungsschluessel veraendern:{}  INT CONST abszisse :: 16, ordinate :: 2;{}  zeige fenster;{}  gib bewertungsschluessel aus (w1);{}  gib informationen aus;{}  stelle frage nach veraenderung;{}  REP{}    neueinstellung{}  UNTIL benutzer ist einverstanden PER.{}
+  zeige fenster:{}    w1 := window ( 2,  2, 38, 22);{}    w2 := window (42, 10, 37, 14);{}    w3 := window (42,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib informationen aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (195));{}    cursor (w2, 2, 4); out (w2, anwendungstext (196));{}    cursor (w2, 2, 6); out (w2, anwendungstext (197));{}    cursor (w2, 2, 7); out (w2, anwendungstext (198));{}    cursor (w2, 2, 8); out (w2, anwendungstext (199));{}
+    cursor (w2, 2,11); out (w2, anwendungstext (200));{}    cursor (w2, 2,12); out (w2, anwendungstext (201));{}    cursor (w2, 2,13); out (w2, anwendungstext (202)).{}  stelle frage nach veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (205))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (206)){}       THEN LEAVE wertungsschluessel veraendern{}       ELSE gib hinweis auf linkes fenster{}    FI.{}  gib hinweis auf linkes fenster:{}    cleop  (w3, 2, 3); out (w3, anwendungstext (211));{}
+    cursor (w3, 2, 4); out (w3, anwendungstext (212));{}    cursor (w3, 2, 5); out (w3, anwendungstext (213)).{}  neueinstellung:{}    INT VAR zeiger;{}    cursor an;{}    FOR zeiger FROM 1 UPTO 11 REP{}      gehe auf aktuelle punktposition;{}      lasse verschieben{}    PER;{}    cursor aus.{}  gehe auf aktuelle punktposition:{}    cursor (w1, ordinate + 3 * zeiger, abszisse - nachkommastelle).{}  nachkommastelle:{}    int (bewertung [zeiger] * 10.0).{}  lasse verschieben:{}    TEXT VAR eingabezeichen; INT VAR position;{}
+    REP{}      inchar (eingabezeichen);{}      position := pos (oben unten return, eingabezeichen);{}      fuehre angemessene reaktion aus{}    UNTIL position = 3 PER.{}  fuehre angemessene reaktion aus:{}    SELECT position OF{}      CASE 1: steige auf{}      CASE 2: steige ab{}      CASE 3: (* tue nichts *){}      OTHERWISE piepse{}    END SELECT.{}  steige auf:{}    IF bewertung [zeiger] < 1.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] INCR 0.1;{}            schreibe neuen punkt{}
+       ELSE piepse{}    FI.{}  steige ab:{}    IF bewertung [zeiger] > 0.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] DECR 0.1;{}            schreibe neuen punkt{}       ELSE piepse{}    FI.{}  loesche alten punkt:{}    INT VAR tabspalte, tabzeile;{}    gehe auf aktuelle punktposition;{}    get cursor (w1, tabspalte, tabzeile);{}    IF tabspalte = ordinate + 3 OR tabzeile = abszisse{}       THEN out (w1, "|"){}       ELSE out (w1, blank){}    FI.{}  schreibe neuen punkt:{}    gehe auf aktuelle punktposition;{}
+    out (w1, punkt und zurueck).{}  benutzer ist einverstanden:{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (207)){}       THEN TRUE{}       ELSE gib hinweis auf linkes fenster;{}            FALSE{}    FI.{}END PROC wertungsschluessel veraendern;{}PROC cleol (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cursor (w, cursorspalte, cursorzeile);{}  IF remaining lines (w) > 1{}     THEN out (w, (areaxsize (w) - cursorspalte + 1) * blank){}     ELSE out (w, (areaxsize (w) - cursorspalte) * blank){}
+  FI;{}  cursor (w, cursorspalte, cursorzeile){}END PROC cleol;{}PROC cleop (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cleol (w, cursorspalte, cursorzeile);{}  INT VAR i;{}  FOR i FROM 1 UPTO remaining lines (w) REP{}    cleol (w, 1, cursorzeile + i){}  PER;{}  cursor  (w, cursorspalte, cursorzeile){}END PROC cleop;{}PROC cursor an:{}  INT VAR spalte, zeile;{}  get cursor (spalte, zeile); cursor on; cursor (spalte, zeile){}END PROC cursor an;{}PROC cursor aus:{}  INT VAR spalte, zeile;{}
+  get cursor (spalte, zeile); cursor off; cursor (spalte, zeile){}END PROC cursor aus;{}INT PROC eingabe mit intervallanzeige (WINDOW VAR w, INT CONST minwert,{}                                       maxwert, anfangswert, cursorspalte,{}                                       cursorzeile):{}  BOOL VAR ist aufsteigend :: minwert = anfangswert;{}  INT  VAR aktueller wert  :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
+      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            IF ist aufsteigend{}               THEN loesche alte markierung{}               ELSE markiere neues zeichen{}            FI{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}
+    IF aktueller wert < maxwert{}       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            IF ist aufsteigend{}               THEN markiere neues zeichen{}               ELSE loesche alte markierung{}            FI{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, 33, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, 33, aktueller wert);{}
+    out (w, invers (code (aktueller wert)));{}    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit intervallanzeige;{}INT PROC eingabe mit elementanzeige (WINDOW VAR w, INT CONST minwert,{}                                     maxwert, anfangswert,{}                                     cursorspalte, cursorzeile):{}  INT VAR aktueller wert :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
+      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maxwert{}
+       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, minwert, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, minwert, aktueller wert);{}    out (w, invers (code (aktueller wert)));{}
+    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit elementanzeige;{}PROC werkstueck zeigen (WINDOW VAR w):{}  INT VAR zaehler, spalte, zeile;{}  page (w);{}  werkstueckaufhaenger (spalte, zeile);{}  schreibe werkstueck zeilenweise.{}  schreibe werkstueck zeilenweise:{}    FOR zaehler FROM 1 UPTO aktuelle werkstueckhoehe REP{}      positioniere den cursor;{}      bastle eine zeile;{}      gib eine zeile aus{}    PER.{}  positioniere den cursor:{}    cursor (w, spalte,  zeile + zaehler - 1).{}
+  bastle eine zeile:{}    TEXT VAR zeileninhalt := "";{}    INT VAR z;{}    FOR z FROM 1 UPTO aktuelle werkstueckbreite REP{}      zeileninhalt CAT code (random (kleinster aktueller zeichencode,{}                                     groesster aktueller zeichencode)){}    PER.{}  gib eine zeile aus:{}    IF inversdarstellung{}       THEN out (w, invers (zeileninhalt)){}       ELSE out (w, zeileninhalt){}    FI.{}END PROC werkstueck zeigen;{}PROC werkstueckaufhaenger (INT VAR spalte, zeile):{}  spalte := ((maxspalten - aktuelle werkstueckbreite) DIV 2) + 3;{}
+  zeile  := ((maxzeilen  - aktuelle werkstueckhoehe ) DIV 2) + 2;{}  IF inversdarstellung THEN spalte DECR 1 FI{}END PROC werkstueckaufhaenger;{}PROC gib zeichenkette aus (WINDOW VAR w,{}                           INT CONST kleinster, groesster, markiertes):{}  INT VAR zaehler;{}  FOR zaehler FROM kleinster UPTO groesster REP{}    positioniere cursor in zeichenkette (w, kleinster, zaehler);{}    IF zaehler = markiertes{}       THEN out (w, invers (code (zaehler))){}       ELSE out (w, code (zaehler)){}
+    FI{}  PER{}END PROC gib zeichenkette aus;{}PROC positioniere cursor in zeichenkette (WINDOW VAR w,{}                                          INT CONST mincode, position):{}  cursor (w, 4 + ((position - mincode) DIV 19) * 5,{}             3 + ((position - mincode) MOD 19)){}END PROC positioniere cursor in zeichenkette;{}TEXT PROC tastenbezeichnung (TEXT CONST zeichen):{}  IF code (zeichen) >= 33 AND code (zeichen) <= 126{}     THEN "<" + zeichen + ">"{}     ELSE umgesetzter code{}  FI.{}  umgesetzter code:{}
+    SELECT code (zeichen) OF{}      CASE   1: anwendungstext (31){}      CASE   2: anwendungstext (32){}      CASE   3: anwendungstext (33){}      CASE   8: anwendungstext (34){}      CASE   9: anwendungstext (35){}      CASE  10: anwendungstext (36){}      CASE  11: anwendungstext (37){}      CASE  12: anwendungstext (38){}      CASE  13: anwendungstext (39){}      CASE  16: anwendungstext (40){}      CASE  27: anwendungstext (41){}      CASE  32: anwendungstext (42){}      CASE 214: anwendungstext (43){}
+      CASE 215: anwendungstext (44){}      CASE 216: anwendungstext (45){}      CASE 217: anwendungstext (46){}      CASE 218: anwendungstext (47){}      CASE 219: anwendungstext (48){}      CASE 251: anwendungstext (49){}      OTHERWISE anwendungstext (50){}  END SELECT{}END PROC tastenbezeichnung;{}INT PROC ermittelter wert (INT CONST minimum, maximum, startwert):{}  INT VAR aktueller wert, eingelesener wert;{}  cursor an;{}  aktueller wert := startwert;{}  REP{}    gib dreistellig aus und positioniere zurueck (aktueller wert, FALSE);{}
+    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}      CASE 1: erhoehe aktuellen wert wenn moeglich{}      CASE 2: erniedrige aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  cursor aus;{}  aktueller wert.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maximum{}       THEN aktueller wert INCR 1{}       ELSE piepse{}    FI.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minimum{}
+       THEN aktueller wert DECR 1{}       ELSE piepse{}    FI.{}END PROC ermittelter wert;{}PROC gib dreistellig aus und positioniere zurueck (INT CONST wert,{}                                                   BOOL CONST mit wertwandel):{}  INT VAR spalte, zeile; get cursor (spalte, zeile);{}  IF mit wertwandel{}     THEN out ("'" + code (wert) + "'"){}     ELSE out (text (wert, 3)){}  FI;{}  cursor (spalte, zeile);{}END PROC gib dreistellig aus und positioniere zurueck;{}PROC hole position aus vorgabe (TEXT CONST vorgabe, INT VAR position):{}
+  TEXT VAR eingabezeichen; INT VAR spa, zei;{}  REP{}    get cursor (spa, zei); inchar (eingabezeichen); cursor (spa, zei);{}    position := pos (vorgabe, eingabezeichen);{}    IF position = 0 THEN piepse; cursor (spa, zei) FI{}  UNTIL position > 0 PER{}END PROC hole position aus vorgabe;{}PROC piepse:{}  INT VAR spa, zei; get cursor (spa, zei); out (piep); cursor (spa, zei){}END PROC piepse;{}END PACKET ls mp bap 1;{}stdvoreinstellung der parameter{}
+
diff --git a/app/gs.mp-bap/1.1/src/ls-MP BAP 2 b/app/gs.mp-bap/1.1/src/ls-MP BAP 2
new file mode 100644
index 0000000..0cd66ff
--- /dev/null
+++ b/app/gs.mp-bap/1.1/src/ls-MP BAP 2
@@ -0,0 +1,126 @@
+PACKET ls mp bap 2  DEFINES                (*******************************) 
+                                           (*                             *) 
+  materialpruefung, mp,                    (*         ls-MP BAP 2         *) 
+  bildschirmarbeitsplatz, bap,             (*         Version 1.1         *) 
+                                           (*                             *) 
+  mp bap simulation ausfuehren,            (*   (c) 1987, 1988            *) 
+  mp bap auswertung auf bildschirm,        (*       by Eva Latta-Weber    *) 
+  mp bap drucken von auswertungen,         (*          Bielefeld          *) 
+                                           (*                             *) 
+  mp bap protokollumfang festlegen,        (*******************************) 
+  mp bap kurzauswertung, 
+ 
+  druckereinstellung fuer protokolldatei, 
+  stddruckereinstellung fuer protokolldatei: 
+ 
+ 
+ 
+LET maxeintraege             =                    800, 
+    protokolldateipraefix    =       "ls-Protokoll: ", 
+    menukarte                =  "ls-MENUKARTE:MP-BAP", 
+    menubezeichnung          =                  "BAP", 
+    auswertdateipostfix      =        " - Auswertung", 
+    protokolldateityp        =                   1955, 
+    maxspalten               =                     70, 
+    maxzeilen                =                     14,{}    blank                    =                    " ",{}    trenn                    =                    "|",{}    werkstueckendekennung    =                      1,{}    pausenendekennung        =                      2,{}    simulationsendekennung   =                      3,{}    markierung ein           =                 ""15"",{}    markierung aus           =                " "14"",{}    stdschrifttyp            =                     "",{}
+    stdxstart                =                    0.0,{}    stdystart                =                    0.0,{}    stdfeldbreite            =                   21.0,{}    stdfeldlaenge            =                   29.5;{}LET  KONTROLLTABELLE = STRUCT (INT  letzter eintrag,{}                                    breite, hoehe,{}                                    kleinster code, groesster code,{}                                    anzahl aphasen, aphasendauer,{}                                    pausendauer,{}
+                               TEXT datum, uhrzeit, fehlerzeichen,{}                                    nach rechts, nach links,{}                                    nach oben, nach unten,{}                                    ausbesserung, naechstes,{}                               BOOL inversdarstellung,{}                               ROW  11 REAL bewertung,{}                               ROW maxeintraege KONTROLLE tabelle),{}     KONTROLLE       = STRUCT (INT  eintragskennung,{}                                    produktionsfehler,{}
+                                    anzahl korrekturen,{}                                    anzahl bedienfehler,{}                               REAL anfang, ende, differenz),{}     WERKSTUECK      = ROW maxspalten ROW maxzeilen INT;{}INT  VAR breite, hoehe, kleinster code, groesster code,{}         anzahl aphasen, aphasendauer, pausendauer,{}         eckspalte, eckzeile, x, y, xsize, ysize;{}TEXT VAR fehlerzeichen, nach rechts, nach links, nach oben, nach unten,{}         ausbesserung, naechstes, datum, uhrzeit;{}
+TEXT VAR protokollschrifttyp :: stdschrifttyp;{}REAL VAR xstart              :: stdxstart,{}         ystart              :: stdystart,{}         schreibfeldbreite   :: stdfeldbreite,{}         schreibfeldlaenge   :: stdfeldlaenge;{}ROW 11 REAL VAR bewertung;{}BOOL VAR inversdarstellung,{}         kontrolldatei zur vatertask ::  TRUE,{}         mit kurzprotokoll           ::  TRUE,{}         mit anmerkungen             ::  TRUE,{}         auswertung geht zum drucker :: FALSE;{}WERKSTUECK VAR werkstueck;{}
+PROC bildschirmarbeitsplatz:{}  kontrolldatei zur vatertask := FALSE;{}  install menu (menukarte);{}  handle menu  (menubezeichnung);{}END PROC bildschirmarbeitsplatz;{}PROC bap:{}  bildschirmarbeitsplatz{}END PROC bap;{}PROC materialpruefung:{}  TEXT VAR benutzerkennung :: "", protokollname, alter dateiname :: std;{}  install menu (menukarte, FALSE);{}  kontrolldatei zur vatertask := TRUE;{}  ermittle eingestellte parameter;{}  bereite den bildschirm vor;{}  ermittle die benutzerkennung;{}  gib benutzerhinweise aus;{}
+  arbeitsplatzsimulation ausfuehren (benutzerkennung, protokollname);{}  forget (protokollname, quiet);{}  last param (alter dateiname).{}  bereite den bildschirm vor:{}    WINDOW VAR w :: window ( 2, 10, 77, 14);{}    page;{}    show (w);{}    out (w, center (w, anwendungstext (400))).{}  ermittle die benutzerkennung:{}    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{}    IF benutzerkennung = ""{}       THEN cursor on; page;{}            LEAVE materialpruefung{}    FI.{}
+  gib benutzerhinweise aus:{}    boxinfo (w, anwendungstext (402));{}    boxinfo (w, anwendungstext (403));{}    boxinfo (w, anwendungstext (404));{}    gib bedieninformationen aus (2);{}    boxinfo (w, anwendungstext (405));{}    boxinfo (w, anwendungstext (406));{}    boxinfo (w, anwendungstext (407));{}    boxinfo (w, anwendungstext (408)).{}END PROC materialpruefung;{}PROC mp:{}  materialpruefung{}END PROC mp;{}PROC mp bap simulation ausfuehren:{}  TEXT VAR benutzerkennung :: "", dateiname;{}
+  kontrolldatei zur vatertask := FALSE;{}  ermittle eingestellte parameter;{}  bereite den bildschirm vor;{}  ermittle die benutzerkennung;{}  arbeitsplatzsimulation ausfuehren (benutzerkennung, dateiname);{}  regenerate menuscreen.{}  bereite den bildschirm vor:{}    WINDOW VAR w :: window (2,2,77,22);{}    page;{}    out (w, center (w, anwendungstext (399))).{}  ermittle die benutzerkennung:{}    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{}    IF benutzerkennung = ""{}
+       THEN regenerate menuscreen;{}            LEAVE mp bap simulation ausfuehren{}    FI.{}END PROC mp bap simulation ausfuehren;{}PROC mp bap auswertung auf bildschirm:{}  auswertung geht zum drucker := FALSE;{}  lasse protokolldateien auswaehlen;{}  werte protokolldateien aus;{}  regenerate menuscreen.{}  lasse protokolldateien auswaehlen:{}    THESAURUS VAR verfuegbare;{}    verfuegbare := infix namen (ALL myself, protokolldateipraefix,{}                                            protokolldateityp);{}
+    IF NOT not empty (verfuegbare){}       THEN noch kein protokoll{}       ELSE biete auswahl an{}    FI.{}  noch kein protokoll:{}    regenerate menuscreen;{}    menuinfo (anwendungstext (424));{}    LEAVE mp bap auswertung auf bildschirm.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, anwendungstext (421),{}                             anwendungstext (422), FALSE).{}  werte protokolldateien aus:{}    INT VAR k;{}    steige ggf bei leerem thesaurus aus;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}
+      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              gib hinweis auf auswertung;{}              simulationsauswertung (name (verfuegbare, k), TRUE);{}              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{}              fehlerbehandlung{}      FI{}    PER.{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN regenerate menuscreen;{}            menuinfo (anwendungstext (423));{}            LEAVE mp bap auswertung auf bildschirm{}
+    FI.{}  gib hinweis auf auswertung:{}    page;{}    WINDOW VAR fenster :: window ( 2, 2, 77, 22);{}    show (fenster);{}    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));{}    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (274))).{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen;{}            menuinfo (invers (errormessage));{}            clear error; enable stop;{}            LEAVE mp bap auswertung auf bildschirm{}    FI.{}
+END PROC mp bap auswertung auf bildschirm;{}PROC mp bap drucken von auswertungen:{}  auswertung geht zum drucker := TRUE;{}  lasse protokolldateien auswaehlen;{}  werte protokolldateien aus;{}  regenerate menuscreen.{}  lasse protokolldateien auswaehlen:{}    THESAURUS VAR verfuegbare;{}    verfuegbare := infix namen (ALL myself, protokolldateipraefix,{}                                            protokolldateityp);{}    IF NOT not empty (verfuegbare){}       THEN noch kein protokoll{}       ELSE biete auswahl an{}
+    FI.{}  noch kein protokoll:{}    regenerate menuscreen;{}    menuinfo (anwendungstext (424));{}    LEAVE mp bap drucken von auswertungen.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, anwendungstext (425),{}                             anwendungstext (422), FALSE).{}  werte protokolldateien aus:{}    INT VAR k;{}    steige ggf bei leerem thesaurus aus;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              gib hinweis auf auswertung;{}
+              simulationsauswertung (name (verfuegbare, k), FALSE);{}              print (name (verfuegbare, k) + auswertdateipostfix);{}              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{}              fehlerbehandlung{}      FI{}    PER.{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN regenerate menuscreen;{}            menuinfo (anwendungstext (423));{}            LEAVE mp bap drucken von auswertungen{}    FI.{}  gib hinweis auf auswertung:{}
+    page;{}    WINDOW VAR fenster :: window ( 2, 2, 77, 22);{}    show (fenster);{}    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));{}    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (270))).{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen;{}            menuinfo (invers (errormessage));{}            clear error; enable stop;{}            LEAVE mp bap drucken von auswertungen{}    FI.{}END PROC mp bap drucken von auswertungen;{}
+PROC mp bap protokollumfang festlegen:{}  page;{}  zeige aktuellen protokollumfang an;{}  gib erlaeuterungen zum protokollumfang;{}  frage nach umfangsaenderung;{}  regenerate menuscreen{}END PROC mp bap protokollumfang festlegen;{}PROC mp bap kurzauswertung:{}  page;{}  zeige aktuelle kurzauswertungseinstellung an;{}  gib erlaeuterungen zur kurzauswertung;{}  frage nach kurzauswertungsaenderung;{}  regenerate menuscreen{}END PROC mp bap kurzauswertung;{}PROC druckereinstellung fuer protokolldatei (TEXT CONST schrifttyp,{}
+                                             REAL CONST linker rand,{}                                                        oberer rand,{}                                                        feldbreite,{}                                                        feldlaenge):{}  protokollschrifttyp := schrifttyp;{}  xstart              := linker rand;{}  ystart              := oberer rand;{}  schreibfeldbreite   := feldbreite;{}  schreibfeldlaenge   := feldlaenge;{}END PROC druckereinstellung fuer protokolldatei;{}
+PROC stddruckereinstellung fuer protokolldatei:{}  protokollschrifttyp := stdschrifttyp;{}  xstart              := stdxstart;{}  ystart              := stdystart;{}  schreibfeldbreite   := stdfeldbreite;{}  schreibfeldlaenge   := stdfeldlaenge{}END PROC stddruckereinstellung fuer protokolldatei;{}                 (********************************){}PROC arbeitsplatzsimulation ausfuehren (TEXT CONST kennung,{}                                        TEXT VAR   dateiname):{}  ermittle eingestellte parameter;{}
+  lege datei mit kennung an (kennung, dateiname);{}  cursor on;{}  fuehre simulation durch (dateiname);{}  schicke ggf protokolldatei zur vatertask;{}  gib ggf kurzprotokoll aus.{}  schicke ggf protokolldatei zur vatertask:{}    IF kontrolldatei zur vatertask{}       THEN command dialogue (FALSE);{}            save (dateiname);{}            command dialogue (TRUE){}    FI.{}  gib ggf kurzprotokoll aus:{}    IF mit kurzprotokoll{}       THEN kurzauswertung auf bildschirm (dateiname){}       ELSE page; put (anwendungstext (271)){}
+    FI.{}END PROC arbeitsplatzsimulation ausfuehren;{}PROC ermittle eingestellte parameter:{}  werkstueckdefinition (breite, hoehe, kleinster code, groesster code,{}                        fehlerzeichen, inversdarstellung);{}  tastendefinition     (nach rechts, nach links, nach oben, nach unten,{}                        ausbesserung, naechstes);{}  phasendefinition     (anzahl aphasen, aphasendauer, pausendauer);{}  bewertungsschluessel (bewertung);{}END PROC ermittle eingestellte parameter;{}PROC lege datei mit kennung an (TEXT CONST kennung, TEXT VAR datname):{}
+  BOUND KONTROLLTABELLE VAR tab;{}  TEXT VAR interner name :: protokolldateipraefix;{}  interner name CAT kennung;{}  lege neue datei an;{}  type (old (datname), protokolldateityp).{}  lege neue datei an:{}    INT VAR i :: 0; TEXT VAR bezeichnung;{}    REP{}      i INCR 1;{}      bezeichnung := interner name + " /" + text (i){}    UNTIL NOT exists (bezeichnung) PER;{}    tab := new (bezeichnung);{}    initialisiere tabelle;{}    datname := bezeichnung.{}  initialisiere tabelle:{}    tab.letzter eintrag := 0.{}
+END PROC lege datei mit kennung an;{}PROC fuehre simulation durch (TEXT CONST dateiname):{}  BOUND KONTROLLTABELLE VAR tab :: old (dateiname);{}  TEXT CONST moegliche eingabezeichen :: nach rechts  + nach links +{}                                         nach oben    + nach unten +{}                                         ausbesserung + naechstes;{}  treffe vorbereitungen;{}  trage grunddaten in tabelle;{}  simuliere.{}  treffe vorbereitungen:{}     initialisierungen;{}     WINDOW VAR fenster :: window (  1,  9, 79, 16);{}
+     page;{}     gib bedieninformationen aus (2);{}     werkstueckaufhaenger (eckspalte, eckzeile);{}     weise auf arbeitsbeginn hin;{}     beginn der arbeitsphase      :=               clock (1);{}     beginn der bearbeitung       := beginn der arbeitsphase;{}     arbeitsphasenlaenge          := real (aphasendauer * 60).{}  initialisierungen:{}    INT  VAR eintragzaehler        :: 0,{}             arbeitsphasenzaehler  :: 1,{}             werkstueckzaehler     :: 0,{}             bedienfehlerzaehler   :: 0,{}
+             korrekturzaehler      :: 0,{}             produktionsfehler,{}             cursorspalte relativ,{}             cursorzeile  relativ;{}    REAL VAR beginn der arbeitsphase,{}             beginn der bearbeitung,{}             arbeitsphasenlaenge,{}             arbeitsphasenueberziehung,{}             pausenueberziehung.{}  weise auf arbeitsbeginn hin:{}    page (fenster);{}    boxinfo (fenster, anwendungstext (252), 5, maxint);{}    clear buffer.{}  trage grunddaten in tabelle:{}    tab.datum               := date;{}
+    tab.uhrzeit             := time of day;{}    tab.breite              := breite;{}    tab.hoehe               := hoehe;{}    tab.kleinster code      := kleinster code;{}    tab.groesster code      := groesster code;{}    tab.anzahl aphasen      := anzahl aphasen;{}    tab.aphasendauer        := aphasendauer;{}    tab.pausendauer         := pausendauer;{}    tab.fehlerzeichen       := fehlerzeichen;{}    tab.nach rechts         := nach rechts;{}    tab.nach links          := nach links;{}    tab.nach oben           := nach oben;{}
+    tab.nach unten          := nach unten;{}    tab.ausbesserung        := ausbesserung;{}    tab.naechstes           := naechstes;{}    tab.inversdarstellung   := inversdarstellung;{}    tab.bewertung           := bewertung;{}    eintragzaehler          := 1.{}  simuliere:{}    REP{}      gib holehinweis;{}      hole werkstueck  (werkstueck, produktionsfehler);{}      zeige werkstueck (werkstueck, fenster);{}      lasse werkstueck bearbeiten{}    UNTIL simulationsende erreicht PER.{}  gib holehinweis:{}
+    page (fenster);{}    cursor (fenster, 2, 3); out (fenster, anwendungstext (253)).{}  lasse werkstueck bearbeiten:{}    initialisiere den relativcursor;{}    setze cursor;{}    clear buffer;{}    bearbeite das werkstueck.{}  initialisiere den relativcursor:{}    cursorspalte relativ := 1;{}    cursorzeile relativ  := 1.{}  setze cursor:{}    IF inversdarstellung{}       THEN cursor (fenster, eckspalte + cursorspalte relativ,{}                             eckzeile  + cursorzeile  relativ - 1);{}
+       ELSE cursor (fenster, eckspalte + cursorspalte relativ - 1,{}                             eckzeile  + cursorzeile  relativ - 1);{}    FI.{}  bearbeite das werkstueck:{}    BOOL VAR werkstueck voll bearbeitet :: FALSE;{}    REP{}      hole eingabe und werte aus{}    UNTIL werkstueck voll bearbeitet PER.{}  hole eingabe und werte aus:{}    TEXT VAR eingabezeichen := incharety (100);{}    SELECT eingabezeichenposition OF{}      CASE 1: wenn moeglich nach rechts{}      CASE 2: wenn moeglich nach links{}
+      CASE 3: wenn moeglich nach oben{}      CASE 4: wenn moeglich nach unten{}      CASE 5: wenn moeglich ausbessern{}      CASE 6: beende werkstueckbearbeitung{}      OTHERWISE entscheide ob gepiepst wird{}    END SELECT.{}  eingabezeichenposition:{}    pos (moegliche eingabezeichen, eingabezeichen).{}  wenn moeglich nach rechts:{}    IF cursorspalte relativ < breite{}       THEN cursorspalte relativ INCR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach links:{}
+    IF cursorspalte relativ > 1{}       THEN cursorspalte relativ DECR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach oben:{}    IF cursorzeile relativ > 1{}       THEN cursorzeile relativ DECR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach unten:{}    IF cursorzeile relativ < hoehe{}       THEN cursorzeile relativ INCR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}
+  wenn moeglich ausbessern:{}    IF werkstueck [cursorspalte relativ][cursorzeile relativ] = code (fehlerzeichen){}       THEN werkstueck [cursorspalte relativ][cursorzeile relativ] := code (blank);{}            korrekturzaehler INCR 1;{}            get cursor (fenster, x, y);{}            out (fenster, blank);{}            cursor (fenster, x, y);{}       ELSE registriere bedienfehler{}    FI.{}  registriere bedienfehler:{}    piepse; bedienfehlerzaehler INCR 1.{}  entscheide ob gepiepst wird:{}    IF eingabezeichen <> "" THEN piepse FI.{}
+  beende werkstueckbearbeitung:{}    IF   simulationsende erreicht{}         THEN trage simulationsende in tabelle ein{}    ELIF arbeitsphasenende erreicht{}         THEN trage werkstueckdaten in tabelle ein;{}              ermittle ueberziehung der arbeitsphase;{}              lege eine pause ein{}    ELSE trage werkstueckdaten in tabelle ein{}    FI;{}    werkstueck voll bearbeitet := TRUE.{}  lege eine pause ein:{}    nimm pausendaten;{}    weise auf pausenanfang hin;{}    pausiere;{}    weise auf pausenende hin;{}
+    registriere pausenueberziehung.{}  nimm pausendaten:{}    REAL VAR pausenanfang :: clock (1),{}             pausenende   :: pausenanfang + real (pausendauer * 60);.{}  weise auf pausenanfang hin:{}    page (fenster);{}    boxnotice (fenster, anwendungstext (255), 5, x, y, xsize, ysize).{}  pausiere:{}    REP{}      pause (int ((pausenende - clock (1)) * 10.0)){}    UNTIL clock (1) >= pausenende PER.{}  weise auf pausenende hin:{}    page (fenster);{}    pausenanfang := clock (1);{}    piepse;{}
+    clear buffer;{}    boxinfo (fenster, anwendungstext (256), 5, maxint);{}    pausenende   := clock (1).{}  registriere pausenueberziehung:{}    pausenueberziehung := pausenende - pausenanfang;{}    trage pausenueberziehung in tabelle ein.{}  trage werkstueckdaten in tabelle ein:{}    REAL VAR bearbeitungsende :: clock (1);{}    tab.tabelle [eintragzaehler].eintragskennung    := werkstueckendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{}
+    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{}    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;{}    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;{}    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;{}    erhoehe eintragzaehler;{}    beginn der bearbeitung := clock (1);{}    werkstueckzaehler INCR 1;{}    bedienfehlerzaehler := 0;{}    korrekturzaehler    := 0.{}  trage pausenueberziehung in tabelle ein:{}
+    tab.tabelle [eintragzaehler].eintragskennung    := pausenendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := 0;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := 0;{}    tab.tabelle [eintragzaehler].anzahl bedienfehler:= 0;{}    tab.tabelle [eintragzaehler].anfang             := pausenanfang;{}    tab.tabelle [eintragzaehler].ende               := pausenende;{}    tab.tabelle [eintragzaehler].differenz          := pausenueberziehung;{}    erhoehe eintragzaehler;{}    arbeitsphasenzaehler    INCR 1;{}
+    beginn der bearbeitung  := clock (1);{}    beginn der arbeitsphase := clock (1);{}    bearbeitungslaenge bestimmen.{}  trage simulationsende in tabelle ein:{}    bearbeitungsende := clock (1);{}    tab.tabelle [eintragzaehler].eintragskennung    := simulationsendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{}    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{}
+    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;{}    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;{}    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;{}    tab.letzter eintrag                             := eintragzaehler.{}  bearbeitungszeit:{}    bearbeitungsende - beginn der bearbeitung.{}  erhoehe eintragzaehler:{}    IF eintragzaehler < maxeintraege{}       THEN eintragzaehler INCR 1{}       ELSE trage simulationsende in tabelle ein;{}
+            errorstop (anwendungstext (254)){}    FI.{}  ermittle ueberziehung der arbeitsphase:{}    arbeitsphasenueberziehung := clock (1) - beginn der arbeitsphase{}                                           - arbeitsphasenlaenge.{}  bearbeitungslaenge bestimmen:{}    arbeitsphasenlaenge := real (aphasendauer * 60){}                                - arbeitsphasenueberziehung{}                                - pausenueberziehung.{}  arbeitsphasenende erreicht:{}    clock (1) - beginn der arbeitsphase >= arbeitsphasenlaenge.{}
+  simulationsende erreicht:{}    arbeitsphasenzaehler = anzahl aphasen AND arbeitsphasenende erreicht.{}END PROC fuehre simulation durch;{}PROC gib bedieninformationen aus (INT CONST zeile):{}  WINDOW VAR f1 :: window ( 2, zeile, 35, 6),{}             f2 :: window (40, zeile, 39, 6);{}  show (f1); show (f2);{}  cursor (f1, 2, 1); out (f1, anwendungstext (11));{}                     out (f1, tastenbezeichnung ( nach rechts));{}  cursor (f1, 2, 2); out (f1, anwendungstext (12));{}                     out (f1, tastenbezeichnung ( nach links));{}
+  cursor (f1, 2, 3); out (f1, anwendungstext (13));{}                     out (f1, tastenbezeichnung ( nach oben));{}  cursor (f1, 2, 4); out (f1, anwendungstext (14));{}                     out (f1, tastenbezeichnung ( nach unten));{}  cursor (f1, 2, 5); out (f1, anwendungstext (15));{}                     out (f1, tastenbezeichnung ( ausbesserung));{}  cursor (f1, 2, 6); out (f1, anwendungstext (16));{}                     out (f1, tastenbezeichnung ( naechstes));{}  cursor (f2, 2, 1); out (f2, anwendungstext (17));{}
+                     out (f2, text (anzahl aphasen, 4));{}  cursor (f2, 2, 2); out (f2, anwendungstext (18));{}                     out (f2, text (aphasendauer,   4));{}                     out (f2, anwendungstext (51));{}  cursor (f2, 2, 3); out (f2, anwendungstext (19));{}                     out (f2, text (pausendauer,    4));{}                     out (f2, anwendungstext (51));{}  cursor (f2, 2, 4); out (f2, anwendungstext ( 5));{}                     out (f2, text (gesamtzeit,      4));{}                     out (f2, anwendungstext (51));{}
+  cursor (f2, 2, 6); out (f2, anwendungstext (251));{}                     out (f2, 3 * blank);{}                     out (f2, fehlerzeichen).{}END PROC gib bedieninformationen aus;{}INT PROC gesamtzeit:{}  anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer{}END PROC gesamtzeit;{}PROC hole werkstueck (WERKSTUECK VAR w, INT VAR anzahl fehler):{}  INT VAR spaltenzaehler, zeilenzaehler;{}  anzahl fehler := 0;{}  FOR zeilenzaehler FROM 1 UPTO hoehe REP{}    ermittle eine zeile{}  PER.{}
+  ermittle eine zeile:{}    FOR spaltenzaehler FROM 1 UPTO breite REP{}      ermittle eine position;{}      ggf fehler registrieren{}    PER.{}  ermittle eine position:{}    w [spaltenzaehler][zeilenzaehler] := zufallscode.{}  zufallscode:{}    random (kleinster code, groesster code).{}  ggf fehler registrieren:{}    IF w [spaltenzaehler][zeilenzaehler] = code (fehlerzeichen){}       THEN anzahl fehler INCR 1{}    FI.{}END PROC hole werkstueck;{}PROC zeige werkstueck (WERKSTUECK CONST w, WINDOW VAR f):{}
+  INT VAR spaltenzaehler, zeilenzaehler;{}  page (f);{}  FOR zeilenzaehler FROM 1 UPTO hoehe REP{}    zeige eine zeile{}  PER.{}  zeige eine zeile:{}    cursor (f, eckspalte, eckzeile + zeilenzaehler - 1);{}    ggf invers einschalten;{}    FOR spaltenzaehler FROM 1 UPTO breite REP{}      out (f, code (w [spaltenzaehler][zeilenzaehler])){}    PER;{}    ggf invers ausschalten.{}  ggf invers einschalten:{}    IF inversdarstellung THEN out (f, markierung ein) FI.{}  ggf invers ausschalten:{}    IF inversdarstellung THEN out (f, markierung aus) FI.{}
+END PROC zeige werkstueck;{}PROC kurzauswertung auf bildschirm (TEXT CONST dateiname):{}  WINDOW VAR fenster :: window (  2, 10, 77, 13);{}  show (fenster);{}  clear buffer;{}  notiere ueberschrift;{}  notiere ergebnis.{}  notiere ueberschrift:{}    cursor (fenster, 1, 1);{}    out (fenster, center (fenster, anwendungstext (275)));{}    cursor (fenster, 1, 2);{}    out (fenster, center (fenster, anwendungstext (276))).{}  notiere ergebnis:{}    BOUND KONTROLLTABELLE CONST k := old (dateiname);{}    ermittle die simulationsdaten;{}
+    notiere gesamtzahl werkstuecke;{}    notiere zeichengesamtzahl;{}    notiere bedienfehler;{}    notiere benoetigte zeit;{}    notiere gesamtausbesserungsrate;{}    notiere gesamtbewertungsfaktor;{}    notiere gesamtbewertungszahl mit pausenueberziehung;{}    cursor (1, 24); out (anwendungstext (2));{}    pause.{}  ermittle die simulationsdaten:{}    INT  VAR z, anzahl zeichen pro werkstueck,{}             anzahl werkstuecke        ::   0,{}             anzahl bedienfehler       ::   0,{}             anzahl produktionsfehler  ::   0,{}
+             anzahl korrekturen        ::   0;{}    REAL VAR gesamtzahl zeichen, anteil korrekturen,{}             gesamtzeit                :: 0.0,{}             pausenueberzug            :: 0.0;{}    FOR z FROM 1 UPTO k.letzter eintrag REP{}      IF   k.tabelle [z].eintragskennung = werkstueckendekennung{}           THEN anzahl werkstuecke       INCR 1;{}                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;{}                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{}
+                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;{}                gesamtzeit               INCR k.tabelle [z].differenz;{}      ELIF k.tabelle [z].eintragskennung = pausenendekennung{}           THEN pausenueberzug           INCR k.tabelle [z].differenz;{}      FI{}    PER;{}    anzahl zeichen pro werkstueck := k.breite * k.hoehe;{}    gesamtzahl zeichen            :=   real (anzahl werkstuecke){}                                     * real (anzahl zeichen pro werkstueck);{}
+    IF anzahl produktionsfehler = 0{}       THEN anteil korrekturen    := 1.0{}       ELSE anteil korrekturen    :=   real (anzahl korrekturen){}                                     / real (anzahl produktionsfehler){}    FI.{}  notiere gesamtzahl werkstuecke:{}    cursor (fenster, 12, 4); out (fenster, anwendungstext (277));{}                             out (fenster, text (anzahl werkstuecke, 8)).{}  notiere zeichengesamtzahl:{}    cursor (fenster, 12, 5); out (fenster, anwendungstext (278));{}                             out (fenster, zahl aus zeichenkette).{}
+  zahl aus zeichenkette:{}    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{}  notiere bedienfehler:{}    cursor (fenster, 12, 6); out (fenster, anwendungstext (279));{}                             out (fenster, text (anzahl bedienfehler, 8)).{}  notiere benoetigte zeit:{}    cursor (fenster, 12, 7); out (fenster, anwendungstext (280));{}                             out (fenster, text (gesamtzeit,         8, 2)).{}  notiere gesamtausbesserungsrate:{}    cursor (fenster, 12, 9); out (fenster, anwendungstext (281));{}
+                             out (fenster, text (anteil korrekturen, 8, 2)).{}  notiere gesamtbewertungsfaktor:{}    cursor (fenster, 12,10); out (fenster, anwendungstext (282));{}                             out (fenster, text (bewertungsfaktor, 8, 2)).{}  bewertungsfaktor:{}    bewertungsmasszahl (anteil korrekturen).{}  notiere gesamtbewertungszahl mit pausenueberziehung:{}    cursor (fenster, 12, 12); out (fenster, (anwendungstext (283)));{}                              out (fenster, text (gesamtwertung,   8, 2));{}
+    cursor (fenster, 12, 13); out (fenster, (anwendungstext (284)));{}                              out (fenster, 8 * "=").{}  gesamtwertung:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}                               * bewertungsfaktor{}    FI.{}END PROC kurzauswertung auf bildschirm;{}PROC simulationsauswertung (TEXT CONST dateiname, BOOL CONST mit zeigen):{}  TEXT CONST auswertdatei :: dateiname + auswertdateipostfix;{}  ermittle die kenndaten aus der protokolldatei (dateiname);{}
+  notiere ueberschrift 1               (auswertdatei);{}  notiere die kenndaten der simulation (auswertdatei);{}  notiere die werkstueckkenndaten      (auswertdatei);{}  notiere ein beispielwerkstueck       (auswertdatei);{}  notiere ueberschrift 2               (auswertdatei);{}  notiere gesamtergebnisse             (auswertdatei, dateiname);{}  notiere ueberschrift 3               (auswertdatei);{}  notiere tabellenkopf                 (auswertdatei);{}  notiere einzelne werkstueckdaten     (auswertdatei, dateiname);{}
+  notiere ggf die anmerkungen;{}  zeige ggf auswertung auf bildschirm.{}  notiere ggf die anmerkungen:{}    IF mit anmerkungen{}       THEN notiere anmerkungen        (auswertdatei);{}    FI.{}  zeige ggf auswertung auf bildschirm:{}    IF mit zeigen{}       THEN cursor on; show (auswertdatei); cursor off{}    FI.{}END PROC simulationsauswertung;{}PROC ermittle die kenndaten aus der protokolldatei (TEXT CONST dateiname):{}  BOUND KONTROLLTABELLE CONST k := old (dateiname);{}  breite                    := k.breite;{}
+  hoehe                     := k.hoehe;{}  kleinster code            := k.kleinster code;{}  groesster code            := k.groesster code;{}  fehlerzeichen             := k.fehlerzeichen;{}  inversdarstellung         := k.inversdarstellung;{}  nach rechts               := k.nach rechts;{}  nach links                := k.nach links;{}  nach oben                 := k.nach oben;{}  nach unten                := k.nach unten;{}  ausbesserung              := k.ausbesserung;{}  naechstes                 := k.naechstes;{}
+  anzahl aphasen            := k.anzahl aphasen;{}  aphasendauer              := k.aphasendauer;{}  pausendauer               := k.pausendauer;{}  datum                     := k.datum;{}  uhrzeit                   := k.uhrzeit;{}  bewertung                 := k.bewertung;{}END PROC ermittle die kenndaten aus der protokolldatei;{}PROC notiere ueberschrift 1 (TEXT CONST auswertdatei):{}  IF exists (auswertdatei){}     THEN forget (auswertdatei, quiet){}  FI;{}  FILE VAR f :: sequential file (output, auswertdatei);{}
+  IF auswertung geht zum drucker{}     THEN schreibe druckeranweisungen{}  FI;{}  putline (f, center (auswertdatei));{}  putline (f, center (length (auswertdatei) * "="));{}  put (f, anwendungstext (272)); put (f, datum); put (f, 26 * blank);{}  put (f, anwendungstext (273)); putline (f, uhrzeit);{}  line (f);{}  putline (f, center (anwendungstext (291)));{}  putline (f, center (length (anwendungstext (291)) * "=")).{}  schreibe druckeranweisungen:{}    write (f, "#type (""");{}    write (f, protokollschrifttyp);{}
+    write (f, """)##limit (");{}    write (f, text (schreibfeldbreite));{}    write (f, ")##pagelength (");{}    write (f, text (schreibfeldlaenge));{}    write (f, ")##start (");{}    write (f, text (xstart));{}    write (f, ",");{}    write (f, text (ystart));{}    write (f, ")#"); line (f).{}END PROC notiere ueberschrift 1;{}PROC notiere ueberschrift 2 (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  putline (f, center (anwendungstext (285)));{}  putline (f, center (length (anwendungstext (285)) * "=")){}
+END PROC notiere ueberschrift 2;{}PROC notiere ueberschrift 3 (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  line (f, 2);{}  putline (f, center (anwendungstext (311)));{}  putline (f, center (length (anwendungstext (311)) * "="));{}  line (f){}END PROC notiere ueberschrift 3;{}PROC notiere die kenndaten der simulation (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  ROW 6 TEXT VAR ausgabe;{}  bestuecke ausgabezeilen;{}  schreibe ausgabezeilen.{}
+  bestuecke ausgabezeilen:{}    ausgabe [1] :=   anwendungstext (11){}                   + gleichlang (tastenbezeichnung (nach rechts ), 23){}                   + anwendungstext (17){}                   + text (anzahl aphasen,   4);{}    ausgabe [2] :=   anwendungstext (12){}                   + gleichlang (tastenbezeichnung (nach links  ), 23){}                   + anwendungstext (18){}                   + text (aphasendauer,     4) + anwendungstext (51);{}    ausgabe [3] :=   anwendungstext (13){}
+                   + gleichlang (tastenbezeichnung (nach oben   ), 23){}                   + anwendungstext (19){}                   + text (pausendauer,      4) + anwendungstext (51);{}    ausgabe [4] :=   anwendungstext (14){}                   + gleichlang (tastenbezeichnung (nach unten  ), 23){}                   + anwendungstext ( 5){}                   + text (simulationsdauer, 4) + anwendungstext (51);{}    ausgabe [5] :=   anwendungstext (15){}                   + gleichlang (tastenbezeichnung (ausbesserung), 23);{}
+    ausgabe [6] :=   anwendungstext (16){}                   + gleichlang (tastenbezeichnung (naechstes   ), 23){}                   + anwendungstext (251){}                   + (3 * blank) + fehlerzeichen.{}  simulationsdauer:{}    anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer.{}  schreibe ausgabezeilen:{}    INT VAR i;{}    FOR i FROM 1 UPTO 6 REP{}      putline (f, ausgabe [i]){}    PER;{}    line (f).{}END PROC notiere die kenndaten der simulation;{}PROC notiere die werkstueckkenndaten (TEXT CONST auswertdatei):{}
+  FILE VAR f :: sequential file (output, auswertdatei);{}  ROW 4 TEXT VAR ausgabe;{}  bestuecke ausgabezeilen;{}  schreibe ausgabezeilen.{}  bestuecke ausgabezeilen:{}    ausgabe [1] :=  anwendungstext (292) + text (breite,        4) +{}                    anwendungstext (296);{}    ausgabe [2] :=  anwendungstext (293) + text (hoehe,          4) +{}                    anwendungstext (296);{}    ausgabe [3] :=  anwendungstext (294) + text (breite * hoehe, 4) +{}                    anwendungstext (296);{}
+    ausgabe [4] :=  anwendungstext (295) + zeichenumfang.{}  zeichenumfang:{}    " " + code (kleinster code) + " ... " + code (groesster code) +{}    " (" + text (groesster code - kleinster code + 1, 3) +{}    anwendungstext (296) + ")".{}  schreibe ausgabezeilen:{}    INT VAR i;{}    FOR i FROM 1 UPTO 4 REP putline (f, ausgabe [i]) PER;{}    line (f).{}END PROC notiere die werkstueckkenndaten;{}PROC notiere ein beispielwerkstueck (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}
+  WERKSTUECK VAR beispiel;{}  INT VAR beispielfehler;{}  hole werkstueck (beispiel, beispielfehler);{}  notiere ueberschrift;{}  notiere werkstueckzeilen;{}  notiere werkstueckleerzeilen.{}  notiere ueberschrift:{}    putline (f, center (anwendungstext (297)));{}    putline (f, center (length (anwendungstext (297)) * "-")).{}  notiere werkstueckzeilen:{}    INT VAR bs, bz;{}    FOR bz FROM 1 UPTO hoehe REP{}      notiere eine zeile{}    PER.{}  notiere eine zeile:{}    TEXT VAR beispielzeile :: "";{}
+    konstruiere beispielzeile;{}    gib beispielzeile aus.{}  konstruiere beispielzeile:{}    beispielzeile CAT (((80 - breite) DIV 2) * blank);{}    FOR bs FROM 1 UPTO breite REP{}      beispielzeile CAT code (beispiel [bs][bz]){}    PER.{}  gib beispielzeile aus:{}    putline (f, beispielzeile).{}  notiere werkstueckleerzeilen:{}    line (f, maxzeilen - hoehe + 1).{}END PROC notiere ein beispielwerkstueck;{}PROC notiere gesamtergebnisse (TEXT CONST auswertdatei, protokolldatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}
+  BOUND KONTROLLTABELLE CONST k :: old (protokolldatei);{}  ermittle die simulationsdaten;{}    notiere gesamtzahl werkstuecke;{}    notiere anzahl zeichen pro werkstueck;{}    notiere zeichengesamtzahl;{}    notiere bedienfehler;{}    notiere produktionsfehlerzahl;{}    notiere fehlerkorrekturen;{}    notiere gesamtzeit mit pausenueberziehung;{}    notiere zeichenzahl pro sekunde mit;{}    notiere gesamtausbesserungsrate;{}    notiere gesamtbewertungsfaktor  mit;{}    notiere gesamtbewertungszahl    mit;{}
+    notiere gesamtzeit ohne pausenueberziehung;{}    notiere zeichenzahl pro sekunde ohne;{}    notiere gesamtbewertungszahl    ohne.{}  ermittle die simulationsdaten:{}    INT  VAR z, anzahl zeichen pro werkstueck,{}             anzahl werkstuecke        ::   0,{}             anzahl bedienfehler       ::   0,{}             anzahl produktionsfehler  ::   0,{}             anzahl korrekturen        ::   0;{}    REAL VAR gesamtzahl zeichen, anteil korrekturen,{}             gesamtzeit                :: 0.0,{}
+             pausenueberzug            :: 0.0;{}    FOR z FROM 1 UPTO k.letzter eintrag REP{}      IF   k.tabelle [z].eintragskennung = werkstueckendekennung{}           THEN anzahl werkstuecke       INCR 1;{}                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;{}                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{}                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;{}                gesamtzeit               INCR k.tabelle [z].differenz;{}
+      ELIF k.tabelle [z].eintragskennung = pausenendekennung{}           THEN pausenueberzug           INCR k.tabelle [z].differenz;{}      FI{}    PER;{}    anzahl zeichen pro werkstueck := k.breite * k.hoehe;{}    gesamtzahl zeichen            :=   real (anzahl werkstuecke){}                                     * real (anzahl zeichen pro werkstueck);{}    IF anzahl produktionsfehler = 0{}       THEN anteil korrekturen    := 1.0{}       ELSE anteil korrekturen    :=   real (anzahl korrekturen){}
+                                     / real (anzahl produktionsfehler){}    FI.{}  notiere gesamtzahl werkstuecke:{}    put (f, anwendungstext (277)); putline (f, text (anzahl werkstuecke, 8)).{}  notiere anzahl zeichen pro werkstueck:{}    put (f, anwendungstext (286)); putline (f, text (breite * hoehe,     8)).{}  notiere zeichengesamtzahl:{}    put (f, anwendungstext (278)); putline (f, zahl aus zeichenkette);{}    line (f).{}  zahl aus zeichenkette:{}    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{}
+  notiere produktionsfehlerzahl:{}    put (f, anwendungstext (287)); putline (f, text (anzahl produktionsfehler, 8)).{}  notiere fehlerkorrekturen:{}    put (f, anwendungstext (288)); putline (f, text (anzahl korrekturen, 8)).{}  notiere bedienfehler:{}    put (f, anwendungstext (279)); putline (f, text (anzahl bedienfehler,8));{}    line (f).{}  notiere gesamtzeit mit pausenueberziehung:{}    put (f, anwendungstext (301)); put (f, text (gesamtzeit mit, 8, 1));{}    putline (f, anwendungstext (300)).{}
+  gesamtzeit mit:{}    gesamtzeit + pausenueberzug.{}  notiere zeichenzahl pro sekunde mit:{}    put (f, anwendungstext (302));{}    putline (f, text (zeichenpro sec mit, 8, 1));{}    line (f).{}  zeichen pro sec mit:{}    IF gesamtzeit + pausenueberzug > 0.0{}       THEN gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}       ELSE 0.0{}    FI.{}  notiere gesamtausbesserungsrate:{}    put (f, anwendungstext (281)); putline (f, text (anteil korrekturen, 8, 1)).{}  notiere gesamtbewertungsfaktor mit:{}
+    put (f, anwendungstext (282)); putline (f, text (bewertungsfaktor, 8, 1));{}    line (f).{}  bewertungsfaktor:{}    bewertungsmasszahl (anteil korrekturen).{}  notiere gesamtbewertungszahl mit:{}    put (f, (anwendungstext (283))); putline (f, text (gesamtwertung mit,   8, 1));{}    put (f, (anwendungstext (284))); putline (f, 8 * "=").{}  gesamtwertung mit:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}                               * bewertungsfaktor{}
+    FI.{}  notiere gesamtzeit ohne pausenueberziehung:{}    put (f, anwendungstext (303)); put (f, text (gesamtzeit, 8, 1));{}    putline (f, anwendungstext (300)).{}  notiere zeichenzahl pro sekunde ohne:{}    put (f, anwendungstext (302));{}    putline (f, text (zeichenpro sec ohne, 8, 1)).{}  zeichen pro sec ohne:{}    IF gesamtzeit > 0.0{}       THEN gesamtzahl zeichen / gesamtzeit{}       ELSE 0.0{}    FI.{}  notiere gesamtbewertungszahl ohne:{}    put (f, (anwendungstext (304))); putline (f, text (gesamtwertung ohne,   8, 1));{}
+    put (f, (anwendungstext (284))); putline (f, 8 * "=").{}  gesamtwertung ohne:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / gesamtzeit * bewertungsfaktor{}    FI.{}END PROC notiere gesamtergebnisse;{}PROC notiere tabellenkopf (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  putline (f, anwendungstext (312));{}  putline (f, anwendungstext (313));{}  putline (f, anwendungstext (314));{}  putline (f, anwendungstext (315));{}  putline (f, anwendungstext (316));{}
+  putline (f, anwendungstext (317));{}  putline (f, anwendungstext (318));{}END PROC notiere tabellenkopf;{}PROC notiere einzelne werkstueckdaten (TEXT CONST auswertdatei, dateiname):{}  BOUND KONTROLLTABELLE CONST k :: old (dateiname);{}  FILE VAR f :: sequential file (output, auswertdatei);{}  INT  VAR zeiger, werkstuecknummer :: 0;{}  TEXT VAR ausgabezeile :: "";{}  FOR zeiger FROM 1 UPTO k.letzter eintrag REP{}   notiere bearbeitungszeile{}  PER.{}  notiere bearbeitungszeile:{}    IF   k.tabelle [zeiger].eintragskennung = werkstueckendekennung{}
+         THEN werkstuecknummer INCR 1;{}              schreibe werkstueckzeile{}    ELIF k.tabelle [zeiger].eintragskennung = pausenendekennung{}         THEN schreibe pausenzeile{}    ELIF k.tabelle [zeiger].eintragskennung = simulationsendekennung{}         THEN werkstuecknummer INCR 1;{}              schreibe abschluss{}    ELSE putline (f, 75 * "?"){}    FI.{}  schreibe werkstueckzeile:{}    konstruiere ausgabezeile;{}    putline (f, ausgabezeile).{}  konstruiere ausgabezeile:{}    ausgabezeile := "";{}
+    ausgabezeile CAT text (werkstuecknummer, 5);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].anzahl bedienfehler, 5);{}    ausgabezeile CAT 3 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].produktionsfehler,   6);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].anzahl korrekturen,  6);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}
+    ausgabezeile CAT text (k.tabelle [zeiger].differenz,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (zeichen pro zeiteinheit,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (einzelausbesserungsrate,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (bewertungsmasszahl (einzelausbesserungsrate), 6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}
+    ausgabezeile CAT text (endbewertungszahl, 6, 1);{}    ausgabezeile CAT blank.{}  zeichen pro zeiteinheit:{}    real (breite * hoehe) / k.tabelle [zeiger].differenz.{}  einzelausbesserungsrate:{}    IF k.tabelle [zeiger].produktionsfehler = 0{}       THEN 0.0{}       ELSE   real (k.tabelle [zeiger].anzahl korrekturen){}            / real (k.tabelle [zeiger].produktionsfehler ){}    FI.{}  endbewertungszahl:{}    real (breite * hoehe) / k.tabelle [zeiger].differenz{}                          * bewertungsmasszahl (einzelausbesserungsrate).{}
+  schreibe pausenzeile:{}    line (f);{}    put     (f, anwendungstext (320));{}    put     (f, text (k.tabelle [zeiger].differenz, 6, 1));{}    putline (f, anwendungstext (300));{}    line (f).{}  schreibe abschluss:{}    putline (f, anwendungstext (318));{}    putline (f, anwendungstext (319));{}    line (f);{}    konstruiere ausgabezeile;{}    ausgabezeile := "(" +{}                    subtext (ausgabezeile, 2, length (ausgabezeile) - 1) +{}                    ")";{}    putline (f, ausgabezeile).{}
+END PROC notiere einzelne werkstueckdaten;{}PROC notiere anmerkungen (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  line (f);{}  schreibe kopf;{}  schreibe hinweis auf letztes werkstueck;{}  schreibe hinweis auf bedienfehler;{}  erlaeutere bewertungsschluessel;{}  stelle bewertungsschluessel graphisch dar;{}  schreibe rest.{}  schreibe kopf:{}    putline (f, center (anwendungstext (325)));{}    putline (f, center (length (anwendungstext (325)) * "="));{}    line (f).{}
+  schreibe hinweis auf letztes werkstueck:{}    INT VAR i;{}    FOR i FROM 326 UPTO 337 REP{}      putline (f, anwendungstext (i)){}    PER;{}    line (f).{}  schreibe hinweis auf bedienfehler:{}    FOR i FROM 339 UPTO 341 REP{}      putline (f, anwendungstext (i)){}    PER;{}    line (f).{}  erlaeutere bewertungsschluessel:{}    FOR i FROM 343 UPTO 372 REP{}      putline (f, anwendungstext (i)){}    PER.{}  stelle bewertungsschluessel graphisch dar:{}    putline (f, anwendungstext (374));{}    putline (f, anwendungstext (375));{}
+    ermittle die startposition;{}    zeichne diagramm;{}    trage werte ein.{}  ermittle die startposition:{}    modify (f);{}    INT VAR zeilenpos :: lines (f) + 2, spaltenpos :: 18.{}  zeichne diagramm:{}    cursor (f, spaltenpos, zeilenpos     , anwendungstext (20));{}    cursor (f, spaltenpos, zeilenpos +  1, anwendungstext (21));{}    cursor (f, spaltenpos, zeilenpos +  3, anwendungstext (23));{}    cursor (f, spaltenpos, zeilenpos +  4, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  5, anwendungstext (22));{}
+    cursor (f, spaltenpos, zeilenpos +  6, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  7, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  8, anwendungstext (24));{}    cursor (f, spaltenpos, zeilenpos +  9, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 10, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 11, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 12, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 13, anwendungstext (25));{}
+    cursor (f, spaltenpos, zeilenpos + 14, anwendungstext (26));{}    cursor (f, spaltenpos, zeilenpos + 15, anwendungstext (27)).{}  trage werte ein:{}    zeilenpos INCR 13;{}    INT VAR bwzeiger;{}    FOR bwzeiger FROM 1 UPTO 11 REP{}      cursor (f, spaltenpos + 3 * bwzeiger, zeilenpos - konkreter wert, "+"){}    PER.{}  konkreter wert:{}    int (bewertung [bwzeiger] * 10.0).{}  schreibe rest:{}    output (f);{}    line (f, 2);{}    FOR i FROM 377 UPTO 387 REP{}      putline (f, anwendungstext (i)){}
+    PER;{}    haenge an jede zeile ein blank an.{}  haenge an jede zeile ein blank an:{}    TEXT VAR inhalt;{}    INT  VAR zeilenzeiger;{}    modify (f);{}    FOR zeilenzeiger FROM 1 UPTO lines (f) REP{}      to line (f, zeilenzeiger);{}      read record (f, inhalt);{}      inhalt CAT blank;{}      write record (f, inhalt){}    PER;{}    to line (f,1).{}END PROC notiere anmerkungen;{}PROC cursor (FILE VAR f, INT CONST spa, zei, TEXT CONST text):{}  positioniere an zeile;{}  positioniere an spalte;{}
+  gib text an position aus.{}  positioniere an zeile:{}    IF zeile noch nicht vorhanden{}       THEN schaffe zeile und gehe dorthin{}       ELSE to line (f,zei){}    FI.{}  zeile noch nicht vorhanden:{}    zei > lines (f).{}  schaffe zeile und gehe dorthin:{}    INT VAR zaehler 1;{}    IF lines (f) = 0{}       THEN to line (f,lines (f));{}            insert record (f);{}    FI;{}    FOR zaehler 1 FROM lines (f)  UPTO zei REP{}      to line (f,lines (f));{}      down (f);insert record (f){}    PER;{}
+    to line(f,zei).{}  positioniere an spalte:{}    TEXT VAR alter satz :: "", neuer satz :: "", restsatz ::"";{}    INT VAR satzlaenge;{}    read record (f,alter satz);{}    satzlaenge := length (alter satz);{}    IF satzlaenge = 0{}       THEN neuer satz CAT (spa -1) * " "{}    ELIF satzlaenge >= spa{}       THEN neuer satz := subtext(alter satz,1,spa-1);{}            restsatz   := subtext(alter satz, spa + length (text));{}       ELSE neuer satz := alter satz;{}            neuer satz CAT (spa - satzlaenge - 1) * " "{}
+    FI.{}  gib text an position aus:{}   neuer satz CAT text;{}   IF restsatz <> ""{}      THEN neuer satz CAT restsatz{}   FI;{}   write record(f,neuer satz).{} END PROC cursor;{}TEXT PROC gleichlang (TEXT CONST text, INT CONST laenge):{}  TEXT VAR intern :: compress (text);{}  INT  VAR anzahl :: laenge - length (intern);{}  IF anzahl < 0{}     THEN subtext (intern, 1, laenge){}     ELSE intern + (anzahl * blank){}  FI{}END PROC gleichlang;{}REAL PROC bewertungsmasszahl (REAL CONST wert):{}  REAL VAR interner wert := round (wert, 1);{}
+  IF interner wert > wert{}     THEN interner wert DECR 0.1{}  FI;{}  interpoliere.{}  interpoliere:{}    REAL VAR unterer wert, oberer wert;{}    unterer wert := interner wert;{}    IF unterer wert = 1.0{}       THEN oberer wert := 1.0{}       ELSE oberer  wert := unterer wert + 0.1{}    FI;{}    unterer wert := bewertung (int (unterer wert * 10.0) + 1);{}    oberer  wert := bewertung (int (oberer  wert * 10.0) + 1);{}    unterer wert + (oberer wert - unterer wert) * faktor.{}  faktor:{}    frac (wert * 10.0).{}
+END PROC bewertungsmasszahl;{}PROC zeige aktuellen protokollumfang an:{}  WINDOW VAR w :: window (2, 2, 34,  5);{}  show (w);{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{}  IF mit anmerkungen{}     THEN cursor (w, 2, 4); out (w, anwendungstext (432)){}     ELSE cursor (w, 2, 4); out (w, anwendungstext (433));{}  FI.{}END PROC zeige aktuellen protokollumfang an;{}PROC gib erlaeuterungen zum protokollumfang:{}  WINDOW VAR f :: window ( 2, 9, 77, 15);{}  show (f);{}  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (434))));{}
+  cursor (f, 5, 3); out (f, anwendungstext (435));{}  cursor (f, 5, 4); out (f, anwendungstext (436));{}  cursor (f, 5, 5); out (f, anwendungstext (437));{}  cursor (f, 5, 6); out (f, anwendungstext (438));{}  cursor (f, 5, 8); out (f, anwendungstext (439));{}  cursor (f, 5, 9); out (f, anwendungstext (440));{}  cursor (f, 5,10); out (f, anwendungstext (441));{}  cursor (f, 5,11); out (f, anwendungstext (442));{}  cursor (f, 5,13); out (f, anwendungstext (443));{}  cursor (f, 5,14); out (f, anwendungstext (444));{}
+END PROC gib erlaeuterungen zum protokollumfang;{}PROC frage nach umfangsaenderung:{}  WINDOW VAR fenster :: window (38, 2, 41, 5);{}  show (fenster);{}  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (451))));{}  cursor (fenster, 4, 3); out (fenster, anwendungstext (452));{}  cursor (fenster, 4, 4);{}  IF yes (fenster, anwendungstext (453)){}     THEN  mit anmerkungen := NOT mit anmerkungen{}  FI.{}END PROC frage nach umfangsaenderung;{}PROC zeige aktuelle kurzauswertungseinstellung an:{}
+  WINDOW VAR w :: window ( 2, 2, 34,  5);{}  show (w);{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{}  IF mit kurzprotokoll{}     THEN cursor (w, 7, 4); out (w, anwendungstext (461));{}     ELSE cursor (w, 7, 4); out (w, anwendungstext (462));{}  FI.{}END PROC zeige aktuelle kurzauswertungseinstellung an;{}PROC gib erlaeuterungen zur kurzauswertung:{}  WINDOW VAR f :: window ( 2, 9, 77, 15);{}  show (f);{}  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (463))));{}
+  cursor (f, 5, 3); out (f, anwendungstext (464));{}  cursor (f, 5, 4); out (f, anwendungstext (465));{}  cursor (f, 5, 5); out (f, anwendungstext (466));{}  cursor (f, 5, 6); out (f, anwendungstext (467));{}  cursor (f, 5, 8); out (f, anwendungstext (468));{}  cursor (f, 5, 9); out (f, anwendungstext (469));{}  cursor (f, 5,10); out (f, anwendungstext (470));{}  cursor (f, 5,11); out (f, anwendungstext (471));{}  cursor (f, 5,13); out (f, anwendungstext (472));{}  cursor (f, 5,14); out (f, anwendungstext (473));{}
+END PROC gib erlaeuterungen zur kurzauswertung;{}PROC frage nach kurzauswertungsaenderung:{}  WINDOW VAR fenster :: window (38, 2, 41, 5);{}  show (fenster);{}  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (481))));{}  cursor (fenster, 5, 3); out (fenster, anwendungstext (482));{}  cursor (fenster, 5, 4);{}  IF yes (fenster, anwendungstext (483)){}     THEN  mit kurzprotokoll := NOT mit kurzprotokoll{}  FI.{}END PROC frage nach kurzauswertungsaenderung;{}END PACKET ls mp bap 2;{}
+
diff --git a/app/gs.mp-bap/1.1/src/ls-MP BAP-gen b/app/gs.mp-bap/1.1/src/ls-MP BAP-gen
new file mode 100644
index 0000000..26a84c3
--- /dev/null
+++ b/app/gs.mp-bap/1.1/src/ls-MP BAP-gen
@@ -0,0 +1,30 @@
+                                             (*****************************) 
+                                             (*                           *) 
+                                             (*         ls-MP BAP         *) 
+                                             (*     GENERATORPROGRAMM     *) 
+                                             (*                           *) 
+                                             (* (c) 1987  (01.09.87)      *) 
+                                             (*     by Eva Latta          *) 
+                                             (*        Bielefeld          *) 
+                                             (*****************************) 
+LET mm taskname   = "ls-MENUKARTEN", 
+    eigener name  = "ls-MP BAP/gen", 
+    datei1        = "ls-MP BAP 1", 
+    datei2        = "ls-MP BAP 2", 
+    menukarte     = "ls-MENUKARTE:MP-BAP"; 
+ 
+PROC stelle existenz des mm sicher: 
+  cursor (1, 5); out (""4""); 
+  IF NOT exists (task (mm taskname)) 
+     THEN errorstop ("Unbedingt erst den 'MENUKARTEN MANAGER' generieren!"); 
+  FI 
+END PROC stelle existenz des mm sicher; 
+ 
+PROC vom archiv (TEXT CONST datei): 
+  cursor (1,5); out (""4""); 
+  out ("  """); out (datei); putline (""" wird geholt.");{}  fetch (datei, archive){}END PROC vom archiv;{}PROC hole (TEXT CONST datei):{}  IF NOT exists (datei) THEN vom archiv (datei) FI{}END PROC hole;{}PROC in (TEXT CONST datei):{}  hole (datei);{}  cursor (1, 5); out (""4"");{}  out ("  """); out (datei); out (""" wird übersetzt: ");{}  insert (datei);{}  forget (datei, quiet);{}END PROC in;{}PROC schicke (TEXT CONST datei):{}  cursor (1, 5); out (""4"");{}  out ("  """); out(datei);{}  out (""" wird zum MENUKARTEN-MANAGER geschickt!");{}
+  command dialogue (FALSE);{}  save (datei, task (mm taskname));{}  command dialogue (TRUE);{}  forget (datei, quiet){}END PROC schicke;{}INT VAR size, used;{}BOOL VAR einzeln;{}storage (size, used);{}einzeln := size - used < 500;{}forget (eigener name, quiet);{}wirf kopfzeile aus;{}stelle existenz des mm sicher;{}hole die dateien;{}insertiere die dateien;{}mache global manager aus der task.{}wirf kopfzeile aus:{}  page;{}  putline ("                  "15"ls-MP BAP  -  Automatische Generierung "14"").{}
+hole die dateien:{}  IF     NOT exists (datei 1){}     COR NOT exists (datei 2){}     COR NOT exists (menukarte){}     THEN hole dateien vom archiv; LEAVE hole die dateien{}  FI.{}hole dateien vom archiv:{}  cursor (1,3); out (""4"");{}  IF yes ("Ist das Archiv angemeldet und die Diskette eingelegt"){}     THEN lese ein{}     ELSE line (2);{}          errorstop ("Ohne die Diskette kann ich das System nicht generieren!"){}  FI.{}lese ein:{}  cursor (1, 3); out (""4"");{}  out ("                   "15"Bitte die Diskette eingelegt lassen! "14"");{}
+  IF NOT einzeln{}     THEN  hole (datei 1);{}           hole (datei 2);{}           hole (menukarte);{}           cursor (1, 3); out(""4"");{}           out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");{}           release (archive){}  FI.{}insertiere die dateien:{}  check off;{}  cursor (1, 3); out(""4"");{}  out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");{}  in (datei 1);{}  in (datei 2);{}  schicke (menukarte);{}  IF einzeln THEN release (archive) FI;{}
+  check on.{}mache global manager aus der task:{}  global manager.{}
+