Graphischer Editor für JavaKara

Graphischer Editor für JavaKara
Studienarbeit im Fach Informatik
vorgelegt von
Johannes Handl
geb. 16.11.79 in Mannheim
angefertigt am
Institut für Informatik
Lehrstuhl für Informatik 2
Programmiersysteme
Friedrich-Alexander-Universität Erlangen–Nürnberg
(Prof. Dr. M. Philippsen)
Betreuer: Franz X. Forman, Prof. Dr. M. Philippsen
Beginn der Arbeit: 02.11.04
Abgabe der Arbeit: 02.08.05
Ich versichere, dass ich die Arbeit ohne fremde Hilfe und ohne Benutzung anderer als
der angegebenen Quellen angefertigt habe und dass die Arbeit in gleicher oder ähnlicher
Form noch keiner anderen Prüfungsbehörde vorgelegen hat und von dieser als Teil einer
Prüfungsleistung angenommen wurde. Alle Ausführungen, die wörtlich oder sinngemäß
übernommen wurden, sind als solche gekennzeichnet.
Der Universität Erlangen-Nürnberg, vertreten durch die Informatik 2 (Programmiersysteme), wird für Zwecke der Forschung und Lehre ein einfaches, kostenloses, zeitlich
und örtlich unbeschränktes Nutzungsrecht an den Arbeitsergebnissen der Studienarbeit
einschließlich etwaiger Schutzrechte und Urheberrechte eingeräumt.
Erlangen, den 02.08.05
Johannes Handl
Studienarbeit
Thema: Graphischer Editor für JavaKara
Hintergrund: Mit dem G8 wird in Bayern das Pflichtfach Informatik eingeführt. Der
Lehrplan der 6. und 7. Jahrgangsstufe steht unter der Leitidee Einführung in die
objektorientierte Modellierung. Die Schülerinnen und Schüler lernen dieses Konzept in
der Darstellung von Informationen mittels Standardsoftware kennen. Am Ende der 7.
Klasse erhalten sie mit einem einfachen Programmiersystem einen ersten Einblick in die
Beschreibung von Abläufen durch Algorithmen. In der 9. Klasse sollen umfangreichere
Algorithmen entwickelt und im folgenden Jahr die Konzepte der Objektorientierung
anhand einer geeigneten Sprache vertieft werden. Als Sprache bietet sich hier Java an,
die die Schüler altersgemäß schon ab der 7. Jahrgangsstufe erlernen können:
In der 7. Jahrgangsstufe kann man mit dem Marienkäfer Kara, der in der ETH-Zürich
entwickelt wurde, spielerisch in die grundlegenden Programmierkonzepte einführen. Kara
wird in Java programmiert. Eine Klasse JavaKaraProgramm, die geeignete Methoden zur Fortbewegung des Käfers und Sensoren für die Wahrnehmung der Umwelt
enthält, wird vom System zur Verfügung gestellt. Mithilfe der Grundstrukturen Sequenz, Auswahl und Wiederholung bzw. der erwähnten Methoden lassen sich Aufgaben
mit anspruchsvollem Schwierigkeitsgrad schon in dieser Altersgruppe lösen. Mit dem
Einsatz der Programmiersprache Java sehen die Schülerinnen und Schüler, dass sich
die Konzepte der objektorientierten Modellierung (Objekte, Attribut, Attributwert und
Methoden, sowie die Punktnotation), die sie bei der Standardsoftware kennen gelernt
haben, auch praktisch anwenden lassen. In der Schule sollte JavaKara mit einem komfortablen Editor ausgestattet sein.
Aufgabenstellung: Im Rahmen der Arbeit soll eine graphische Programmierumgebung
erstellt werden, mit der man per ’Drag and Drop’ einfache Programme mit den Bausteinen
Sequenz, Wiederholung und Auswahl entwerfen kann.
Die Programmieroberfläche soll weiter den objektorientierten Entwurf von Algorithmen mit Java unterstützen. In der Lernumbgebung Kara lassen sich die Objekte ‘Kara’
und ’Welt’ einsetzten. Die Oberfläche soll eine Sicht auf deren Methoden und Attribute
mit den Attributwerten gewähren und deren Verwendung im Programm erleichtern.
Ziel ist es, ein Hilfsmittel zu haben, dass den Blick stärker auf den Entwurf des
Algorithmus als auf die Syntaxregeln der Sprache lenkt, sowie die Schreibarbeit und
Fehlerhäufigkeit im Unterricht minimiert.
Betreuung: Franz X. Forman, Prof. Dr. M. Philippsen
Bearbeiter: Johannes Handl
Abstract
In dieser Arbeit wird die Implementierung eines graphischen Editors vorgestellt, der
für den Einsatz im Schulunterricht in Verbindung mit einem Programmiersystem wie
JavaKara gedacht ist. Der Code wird mittels Nassi Shneiderman Diagrammen visualisiert, wobei die Eingabe vorwiegend mit Hilfe der Maus (Drag & Drop) und Copy
& Paste erfolgt. Als Zielcode werden die Programmiersprachen Loop/While und Java
unterstützt.
i
ii
Contents
1
Einführung
1
2
Installation
3
2.1
2.2
2.3
3
Nassi Shneiderman Diagramme
3.1
3.2
3.3
3.4
4
5.2
5.3
7
Copy und Paste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Drag und Drop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Autocompletion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Fehlervermeidung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Arbeiten im Java-Mode
5.1
5
Die Sequenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Fallunterscheidung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Abweisende Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Nicht abweisende Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Verwendete Konzepte der graphischen Programmierung
4.1
4.2
4.3
4.4
5
Installationsvoraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Installations (Zip-Datei) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
9
Java1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.1.1 Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.1.2 Die Mode-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
5.1.3 Das Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Java2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.2.1 Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.2.2 Die Mode-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12
5.2.3 Das Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Java3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3.1 Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
iii
Contents
5.4
6
Loop / While
6.1
6.2
7
9
9.3
9.4
iv
25
Anpassen der Template-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Anpassen oder Erstellen einer neuen Toolbar-Datei . . . . . . . . . . . . . . . . . . . . . . 29
Die Konfigurationsdateien
9.1
9.2
23
Der Toolbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Eintrag für ein Objekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
Eintrag für eine Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Eintrag für ein Attribut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Erweitern von JavaKara
8.1
8.2
17
Spezifikation Loop / While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.1.1 Datentyp Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.1.2 Variablenbezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.1.3 Macroaufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.1.4 Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.1.5 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.1.6 Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.1.7 Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Der Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Toolbar und Punktnotation
7.1
7.2
7.3
7.4
8
5.3.2 Die Mode-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
5.3.3 Das Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Java 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
5.4.1 Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.4.2 Die Mode-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
5.4.3 Das Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
31
Allgemeine Konfiguration des Editors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31
Graphik Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
9.2.1 Einfacher Konfigurationseintrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
9.2.2 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
9.2.3 Angabe von RGB-Farbwerten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
9.2.4 Übersicht über die konfigurierbaren graphischen Objekte . . . . . . . . . . . 33
9.2.5 Übersicht über die konfigurierbaren Features . . . . . . . . . . . . . . . . . . . . . . . 34
Die Modes-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Die Mode-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Contents
9.5
9.6
9.4.1 Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.4.2 Menü . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Konfiguration des Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.5.1 Übersicht über die Flags bei Toolbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.5.2 Übersicht über die Datentypen bei Toolbar . . . . . . . . . . . . . . . . . . . . . . . . 38
Code-Generierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10 Appendix A
10.1
10.2
10.3
10.4
10.5
10.6
Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Nsd Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
11 Appendix B
11.1
11.2
11.3
11.4
39
41
Toolbar Konfigurationsdatei (keine Punktnotation) . . . . . . . . . . . . . . . . . . . . . . 41
Toolbar Konfigurationsdatei (Punktnotation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Mode Konfigurationsdatei Java (5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Graphik Konfigurationsdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
v
Contents
vi
List of Figures
3.1
3.2
3.3
3.4
Sequenz (SVG-Export) . . . . . . . . . .
Fallunterscheidung (SVG-Export) . . . .
Abweisende Schleife (SVG-Export) . . .
Nicht abweisende Schleife (SVG-Export)
5.1
5.2
5.3
5.4
Das
Das
Das
Das
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
6
6
6
Programm Circle von Java1 (SVG-Export) . . . . . . .
Programm PassTree von Java2 (SVG-Export) . . . . . .
Nassi Shneiderman Diagramm von Java4 (SVG-Export)
Nassi Shneiderman Diagramm von Java4 (SVG-Export)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
11
13
15
6.1
6.2
6.3
Das Loop-Programm (SVG-Export) . . . . . . . . . . . . . . . . . . . . .
Das Loop-Programm (Loop-Export) . . . . . . . . . . . . . . . . . . . .
Der Java-Export des Loop-Programms . . . . . . . . . . . . . . . . . . .
20
20
21
7.1
7.2
7.3
Eintrag in der ToolBar Konfigurationsdatei für ein Objekt . . . . . . . .
Eintrag in der ToolBar Konfigurationsdatei für eine Methode . . . . . . .
Eintrag in der ToolBar Konfigurationsdatei für ein Attribut . . . . . . .
23
24
24
8.1
8.2
8.3
8.4
JavaKara Template . . . . . . . . . .
Die neue Basisklasse für Programme
Die neue Basisklasse für JavaKara .
Die neue JavaKara Klasse . . . . . .
26
26
27
27
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
vii
List of Figures
viii
1 Einführung
Seit einigen Jahren wird Informatik in größerem Umfang an Gymnasien und Realschulen
unterrichtet. Für diesen Unterricht werden neue Materialien benötigt, die dem Schüler
einen einfacheren und, wenn möglich, einen auch auf andere Weise attraktiveren Zugang
zu der Materie erlauben.
Anders als an der Universität, wo ein Student der Informatik die Täler und Durststrecken des praktischen Programmierens eher alleine durchwandert, findet im Schulunterricht das Programmieren auch im Klassenverband statt.
Der begrenzte Zeitrahmen, der einem durch die Schulstunden gesteckt ist, macht eine
stärkere Unterstützung des beginnenden Programmierers bei seinen ersten Schritten erforderlich. Für nicht triviale Programmieraufgaben fehlt oft einfach die Zeit. Unerwartet große Probleme beim Verstehen des Algorithmus einiger weniger Schüler oder
zahlreiche nichts sagende Fehlermeldungen können jedes auch nur zu gut durchdachte
Stundenkonzept ins Wanken bringen.
Um auch größere Projekte im Unterricht bearbeiten zu können, ist daher sowohl eine
höhere Effizienz bei der Programmierung (begrenzter Zeitrahmen), als auch das schnelle
Auffinden oder gar Vermeiden von Fehlern sowie eine anschauliche Visualisierung des
Ablaufs des Algorithmus wünschenswert.
In der Praxis spielen Themen wie Effizienzgewinn und Fehlerminimierung ebenfalls
ein große Rolle (Softwareproblem). Aktuelle IDEs wie Visual Studio, Eclipse oder
SharpDevelop verfügen über zahlreichen graphischen Features, welche einem das Programmieren und insbesondere das Auffinden und Vermeiden von Fehlern erleichtern.
Einfache graphische Oberflächen werden häufig nur noch per Drag and Drop erstellt und
aus UML-Diagrammen lassen sich vollständige Klassen generieren, was meist weitaus
schneller gelingt, als das Schreiben des Codes per Hand. Auch für den Schulunterricht
ist ein System hilfreich, welches den Schüler so weit wie möglich - auch visuell - unterstützt. Dabei hätte die Verwendung eines solchen Systems den zusätzlichen Vorteil,
dass der Schüler das Arbeiten mit einer visuellen Programierumgebung en passant erlernt. Dies erscheint umso wichtiger, als visuelle Programmierung in näherer Zukunft
eine größere Rolle spielen wird.
Für das verständliche Präsentieren von Algorithmen bietet sich der Einsatz von kleinen
graphischen Programmierwelten an. Es ist oft einfacher einen Sortieralgorithmus mit
Hilfe eines Kartenspieles zu erlernen (jeder Kartenspieler kann schon einen Algorithmus!) als mit Hilfe von irgendwelchen Buchstaben oder Zahlen. Eine Vielzahl von
bekannten Problemen lässt sich gut visualisieren und/oder auf einfache Probleme in
einer Modellwelt reduzieren.
1
1 Einführung
Das System Kara [1] ist eine kleine graphische Programmierwelt, welche die Programmierung seines Protagonisten, des Marienkäfers Kara, mit Hilfe von Automaten,
Turing-Maschienen, Lego-Mindstorms oder Java erlaubt. (Der Marienkäfer Kara lebt
in einer friedlichen Welt voller Kleeblätter, Bäumen und Pilzen und hat Sensoren, mit
denen er solche in seiner Umgebung erkennen kann. Zusätzlich kann er Kleeblätter
aufheben und hinlegen und Pilze verschieben.)
Die vorliegende Arbeit erweitert das System Kara um die Möglichkeit, Kara mittels
Nassi Shneiderman Diagrammen zu programmieren, wobei die Programmierung weitestgehend graphisch in einem externen Editor erfolgt. Der Code in den Diagrammen kann
dabei wahlweise in Loop, While oder Java verfasst werden.
Das Einfügen des Codes erfolgt dabei vorwiegend mittels Drag & Drop und Copy &
Paste, die Eingabe per Tastatur wird jedoch gleichfalls unterstützt.
Mit dem Editor erstellte Dateien können in einem internen Format (.nsd-Dateien)
gespeichert und wieder eingelesen werden Auch kann man diese in eines der Exportformate konvertieren. Im Moment kann man NSD-Dateien als Loop/While, Java oder SVG
abspeichern.
Menüs, Tastaturkürzel und der Toolbar des Editors sowie die Darstellung der Eingabefenster und NSD-Diagramme lassen sich mittels Konfigurationsdateien konfigurieren.
Zwischen diesen einzelnen Konfigurationen, sogenannten Modes, kann man zur Laufzeit
umschalten.
Die Code-Generierung läßt sich in hohem Grade ohne eigene Programmierung anpassen. Diese Konfigurierbarkeit des Editors ermöglicht den Einsatz des Editors auch für
ähnliche Programmierwelten oder die Erweiterung einer solchen. So kann der Marienkäfer
Kara um weitere Methoden oder Attribute erweitert werden, ohne dass man an der
Oberfläche des Editors und im generierten Code einen Unterschied zwischen den ursprünglichen Methoden und den neu hinzugefügten erkennt.
2
2 Installation
2.1 Installationsvoraussetzungen
Das System ist vollständig in Java geschrieben und sollte daher unter jedem Betriebsystem laufen, sofern auf diesem die folgenden Programme installiert sind:
• JRE 5.0 (Java Runtime Environment)
• JSDK 5.0 (Java Software Development Kit)
2.2 Installations (Zip-Datei)
Die Zip-Datei enthält die folgenden eigenständigen Programme:
• antlr.jar (Version 2.7.5)
• allkara.jar
Bei allkara handelt es sich um das ursprüngliche jar-File, wobei jedoch einige zusätzliche
Class-Files eingefügt wurden. In der Zip-Datei befinden sich die folgenden BAT-Dateien
für die Arbeit unter Windows.
• compilensd.bat: Kompiliert den Code
• startkara.bat: Startet Kara (ursprüngliche Startdatei für allkara.jar)
• startnsd.bat: Startet den Editor
2.3 Installation
Falls der Pfad richtig konfiguriert ist, reicht es aus, die Zip-Datei an einer beliebigen
Stelle zu entpacken. Es ist jedoch wichtig, darauf zu achten, dass es sich bei dem
ausgeführten Java wirklich um Java 5.0 handelt. Sollten bei Aufruf der Java-Klassen
Versionsprobleme auftreten, so kann man die Java-Dateien mittels Aufruf der Datei
compilensd.bat neu kompilieren.
3
2 Installation
4
3 Nassi Shneiderman Diagramme
Nassi Shneiderman Diagramme, benannt nach ihren Schöpfern Dr. Ike Nassi und Dr.
Ben Shneiderman, dienen dem Entwurf und der Visualisierung von Algorithmen. (Eine
andere Bezeichnung für Nassi Schneiderman Diagramm ist Struktogramm). Die Idee
hinter Nassi Shneiderman Diagrammen ist, dass sich jedes Problem in kleinere Teilprobleme zerlegen läßt, bis es irgendwann nur noch aus Grundstrukturen wie Sequenzen,
Fallunterscheidungen oder Schleifen besteht, die sich gut visualisieren lassen.
Die im Editor implementierten Grundstrukturen und ihre Darstellung werden im folgenden kurz beleuchtet.
3.1 Die Sequenz
Die Sequenz ist ein Abfolge von Befehlen. Oft werden die einzelnen Befehle auch durch
vertikale Striche getrennt (so auch im Editor bei der Erstellung).
Figure 3.1: Sequenz (SVG-Export)
5
3 Nassi Shneiderman Diagramme
3.2 Fallunterscheidung
Die Fallunterscheidung entspricht einem normalen If-Statement, wie man es aus Java
oder anderen Programmiersprachen kennt. Allerdings gibt es keinen ’else if’-Block und
der ’then’ und der ’else’-Block sind obligatorisch.
Figure 3.2: Fallunterscheidung (SVG-Export)
3.3 Abweisende Schleife
Bei einer abweisenden Schleife wird der enthaltene Block nur dann durchlaufen, wenn
die Bedingung zu true evaluiert. Die abweisende Schleife ist analog zur While-Schleife
in Java.
Figure 3.3: Abweisende Schleife (SVG-Export)
3.4 Nicht abweisende Schleife
Diese Schleife wird mindestens einmal durchlaufen, danach verhält sie sich wie die WhileSchleife. Sie entspricht der Do-Schleife in Java.
Figure 3.4: Nicht abweisende Schleife (SVG-Export)
6
4 Verwendete Konzepte der
graphischen Programmierung
Bei der Eingabe der Nassi Shneiderman Diagramme werden die meisten bekannter Techniken eines TextEditors unterstützt. Der Editor arbeitet jedoch nicht mit Text, sondern
mit graphischen Objekten.
4.1 Copy und Paste
Wie in jedem Editor hat man auch im NSD-Editor die Möglichkeit, Teile des Codes
auszuwählen, zu kopieren, auszuschneiden oder an anderer Stelle wieder einzufügen.
Beim NSD-Editor werden diese Kopieraktionen auf der Ebene der graphischen Repräsentationen für Statement, Schleifen oder Fallunterscheidungen durchgeführt. Man kann
einzelne Statements kopieren, aber auch mehrere Statements auf einmal.
Dies erfolgt, indem man eine oder mehrere Statements mit Hilfe der Maus oder auch
der Pfeiltasten auswählt. Wie beim Windows Explorer kann man, wenn man die ShiftTaste drückt, einen ganzen Bereich von Statements auswählen. Drückt man zeitgleich
zur Mausaktion die Strg-Taste, so kann man mehrere (auch) voneinander entfernte Statements auswählen.
4.2 Drag und Drop
Im bestehenden Diagramm kann man ganze Blöcke verschieben und an anderen Stellen
wieder einfügen. Dies gelingt, indem man die entsprechenden Statements auswählt,
Alt und die linke Maustaste drückt und den neu erzeugten Statement-Block an der
gewünschten Stelle einfügt. Dabei entspricht die Reihenfolge der Statements im neu
erzeugten Statement-Block der Reihenfolge der Auswahl.
Will man einen Block oder ein Statement nur eine Stelle nach vorne verschieben, so
kann man dies auch über die Tastur mittels Drücken der Alt-Taste und der Pfeil-NachOben- beziehungsweise der Pfeil-Nach-Unten-Taste.
Der Toolbar enthält graphische Repräsentationen von Objekten, Attributen oder Methoden. Diese können auch mittels Drag & Drop eingefügt werden. Dazu bewegt man
die Maus über die entsprechende Graphik, drückt die linke Maustaste und schiebt die
Graphik an die gewünschte Stelle im Nassi Shneiderman Diagramm. (Der Code wird
nur dann eingefügt, falls dies an dieser Stelle möglich ist).
7
4 Verwendete Konzepte der graphischen Programmierung
4.3 Autocompletion
Bis zu einem gewissen Grad wird Autocompletion unterstützt. So ergänzt der Editor
automatisch obligatorische Bestandteile wie schließende Klammern bei Schleifen oder
das Zuweisungs- und Plus-Symbol der Inkrementation bei Loop.
4.4 Fehlervermeidung
An einigen Stellen im Diagramm können nur spezielle Werte eingefügt werden wie
boolsche Ausdrücke oder Ganzzahlen. Der Editor verhindert das fehlerhaftes Einfügen,
indem er eine Drag & Drop Operation im Fehlerfall nicht zuläßt oder die Tastatureingabe
auf spezielle Zeichen - wie beispielsweise Zahlen bei positiven Ganzzahlwerten - beschränkt.
(Das Löschen eines Astes einer Fallunterscheidung oder des Rumpfes einer Schleife kann
gleichfalls unterbunden werden).
8
5 Arbeiten im Java-Mode
In diesem Kapitel wird die Arbeit mit Hilfe des Java-Modes gezeigt. Die Modes wurden
auf folgende Weise konfiguriert.
• Nur Statements (Java 1)
• Statements & If (Java 2)
• Statements,If & For (Java 3)
• Statements,If,For & While (Java 4)
• Statements,If,For,While & Do (Java 5)
Diese Einteilung, die hier in erster Linie der Darstellung der Umsetzung der einzelnen
Konstrukte einer Programmiersprache dient, kann sinnvoll sein, will man den Schüler
langsam an die Programmierung heranführen und nach und nach die Möglichkeiten und
Probleme aufzeigen, welche die einzelnen Konstrukte mit sich bringen. (So kann man
beispielsweise den Sprung von Loop nach While aufzeigen).
5.1 Java1
5.1.1 Beschreibung
Diese Konfiguration ist die einfachst mögliche und könnte dafür verwendet werden, den
Schüler mit dem Editor erstmals vertraut zu machen. Das einzige unterstützte programmiersprachliche Konstrukt sind einfache Anweisungen, welche beispielsweise per Drag &
Drop eingegeben werden können.
Großartiges läßt sich mit Hilfe dieser Konfiguration natürlich nicht programmieren,
sie ist aber ausreichend um die Bedienung des Editors zu demonstrieren. Verzichtet man
zusätzlich auf die Tastatureingabe von Statements, so hat man überdies die Gewissheit,
dass die erstellten Programme kompilier- und lauffähig sind (wenn auch nicht unbedingt
sinnvoll), und kann somit jedem Schüler ein anfängliches Erfolgserlebnis garantieren.
Geschrieben wird das Programm Circle, welches den Marienkäfer gegen den Uhrzeigersinn
einmal im Kreis gehen läßt. Der Kreis habe dabei den Radius 1.
9
5 Arbeiten im Java-Mode
5.1.2 Die Mode-Datei
In diesem Mode ist das Einfügen einzelner Java Anweisungen erlaubt. Der Eintrag für
das Menü könnte daher aussehen wie folgt:
...
[+menu, "/NSD/insert/simple statement", s, C-i, javaInsertSimpleStatement]
...
Figure 5.1: Das Programm Circle von Java1 (SVG-Export)
5.1.3 Das Java-Programm
public class PJava1 extends GJavaKaraProgramBase {
public void myProgram() {
GJavaKara kara = new GJavaKara();
kara.move();
kara.removeLeaf();
kara.move();
kara.move();
kara.putLeaf();
}
}
10
5.1 Java1
Figure 5.2: Das Programm PassTree von Java2 (SVG-Export)
11
5 Arbeiten im Java-Mode
5.2 Java2
5.2.1 Beschreibung
In diese Konfiguration sind nun auch Fallunterscheidungen möglich. Das Programm
PassTree bewegt den Marienkäfer zwei Schritte nach vorne. Steht vor dem Marienkäfer
ein Baum, so versucht er links vorbei zu gehen, steht links ein Baum, so versucht er rechts
vorbeizugehen, steht auch dort ein Baum so bleibt er stehen. Es wird die vereinfachende
Annahme gemacht, dass zwei Bäume nicht vertikal nebeneinander stehen dürfen.
5.2.2 Die Mode-Datei
...
[+menu,"/NSD/insert/simple statement", s, C-i, javaInsertSimpleStatement]
[+menu,"/NSD/insert/if statement", f, C-f, javaInsertIfStatement]
...
5.2.3 Das Java-Programm
public class PJava2 extends GJavaKaraProgramBase {
public void myProgram() {
GJavaKara kara = new GJavaKara();
if(kara.treeFront() ){
if(kara.treeLeft() ){
if(kara.treeRight() ){
;
}else{
kara.turnRight();
kara.move();
kara.turnLeft();
}
}else{
kara.turnLeft();
kara.move();
kara.turnRight();
}
}else{
kara.move();
}
}
}
12
5.3 Java3
5.3 Java3
5.3.1 Beschreibung
In diese Konfiguration sind nun auch For-Schleifen möglich. Das Programm PassTree2
bewegt wie PassTree den Marienkäfer zwei Schritte nach vorne. Steht vor dem Marienkäfer
ein Baum, dann versucht er links vorbei zu gehen und zwar, indem er maximal 3 Schritte
nach links geht. Versperrt auch dann noch ein Baum den Weg, so geht er zurück und
versucht es rechts (auch maximal 3 Schritte).
Figure 5.3: Das Nassi Shneiderman Diagramm von Java4 (SVG-Export)
13
5 Arbeiten im Java-Mode
5.3.2 Die Mode-Datei
...
[+menu,"/NSD/insert/simple statement", s, C-i, javaInsertSimpleStatement ]
[+menu,"/NSD/insert/if statement", f, C-f, javaInsertIfStatement ]
[+menu,"/NSD/insert/loop statement", l, C-l, javaInsertLoopStatement ]
...
5.3.3 Das Java-Programm
public class PassTree2 extends GJavaKaraProgramBase {
public void myProgram() {
GJavaKara kara = new GJavaKara();
if(kara.treeFront() ){
kara.turnLeft();
for( int i=0; i<3; i++ ) {
kara.move();
if(kara.treeRight() ){
continue;
}else{
kara.turnRight();
kara.move();
kara.move();
kara.turnRight();
for( int j=0; j<=i; j++ ) {
kara.move();
}
kara.turnLeft();
break;
}
}
}else{
kara.move();
kara.move();
}
}
}
14
5.4 Java 4
5.4 Java 4
5.4.1 Beschreibung
In diese Konfiguration sind nun auch While-Schleifen erlaubt. Im Programm Tree
durchläuft der Marienkäfer vollständig einen ’Baum’ und zwar in Preorder. Die Äste
des ’Baumes’ werden durch Pfade der Breite 1 in einem Wald von Bäumen repräsentiert. Er bleibt stehen, wenn er den Baum vollständig durchlaufen hat und wieder
beim Startpunkt, der Wurzel, angekommen ist. An dieser befindet sich zur besonderen
Kennzeichnung der einzige Pilz.
Figure 5.4: Das Nassi Shneiderman Diagramm von Java4 (SVG-Export)
5.4.2 Die Mode-Datei
...
[+menu,"/NSD/insert/if statement", f, C-f, javaInsertIfStatement ]
[+menu,"/NSD/insert/loop statement", l, C-l, javaInsertLoopStatement ]
[+menu,"/NSD/insert/while statement", w, C-w, javaInsertWhileStatement ]
[+menu,"/NSD/insert/do statement", d, C-d, javaInsertDoStatement ]
...
15
5 Arbeiten im Java-Mode
5.4.3 Das Java-Programm
public class Tree extends GJavaKaraProgramBase {
public void myProgram() {
GJavaKara kara = new GJavaKara();
while( !kara.mushroomFront() ) {
if(kara.treeRight() ){
while( kara.treeFront() ) {
kara.turnLeft();
}
}else{
kara.turnRight();
}
kara.move();
}
}
}
16
6 Loop / While
Es existiert auch ein spezieller Mode für die Programmiersprache(n) Loop/While.
6.1 Spezifikation Loop / While
Die hier unterstützten Programmiersprachen unterscheiden sich leicht von der ursprünglichen Sprache Loop/While. So wird neben der einfachen Inkrementation auch die Addition von Variablen oder Ganzzahlen erlaubt, des weiteren gibt es die Fallunterscheidungen if.
6.1.1 Datentyp Integer
Der einzige erlaubte Datentyp sind positive Ganzzahlen. Diese sind definiert wie folgt:
<integer> := ( <digit> )+
<digit> := ’0’..’9’
6.1.2 Variablenbezeichner
Variablenbezeichner beginnen mit einem oder mehreren Buchstaben, anschließend folgt
eine beliebig lange Sequenz von Buchstaben und Zahlen und Punkten. Die Verwendung
von Sonderzeichen in Variablenbezeichnern ist nicht erlaubt.
<identifier> := <char> (<char> | <digit> | ’.’ )*
<char> := ’a’..’z’ | ’A’..’Z’
<digit> := ’0’..’9’
6.1.3 Macroaufruf
Der Makroaufruf unterscheidet sich wenig von einem Funktionsaufruf, wie man ihn in
Java kennt. Es werden jedoch keine Argumente übergeben. Der Makrobezeichner selbst
ist ein gewöhnlicher Variablenbezeichner.
<macrocall> := <identifier> ’(’ ’)’
Hier ein Beispiel für einen Makroaufruf:
kara.move()
17
6 Loop / While
6.1.4 Zuweisung
Eine mögliche Zuweisung ist die Zuweisung Variable zu Wert oder Variable zu Variable,
wobei als Zuweisungsoperator ’:=’ verwendet wird. Auf der rechten Seite kann auch das
Ergebnis einer einfachen Addition stehen.
<assignment> := <identifier> ’:=’
( <identifier> | <digit> )
( ’+’ ( <identifier> | <digit> ))?
6.1.5 If
Das If-Statement ist beschränkter als das If-Statement bei Java. Bei der Bedingung
handelt es sich in jedem Fall um einen Vergleich einer Variablen mit einem Integerwert
oder mit einer weiteren Variablen. (Daher ist es sinnvoll, die Prädikate von kara - sofern
man sie in Loop verwenden will - derart zu überschreiben, dass sie an Stelle von true
und false 1 oder 0 zurückgeben). Das If-Statement ist definiert wie folgt:
<if-statement> := ’if’ <condition>
’then’ ( <statement> )*
’else’ ( <statement> )* ’endif’
<condition> :=
<id> ( ’==’ | ’!=’ ) ( <id> | <integer> )
also beispielsweise
if a0 == 2 then
kara.move()
else
a0 := a1 + a2
endif
6.1.6 Loop
Das Loop-Statement hat folgende Syntax:
<loop-statement> := ’loop’ ( <identifier> | <integer> )
’do’ ( <statement> )* ’enddo’
Ein Beispiel, welches Kara im Kreis gehen läßt.
loop 4 do
karamove
karaturnleft
enddo
18
6.2 Der Mode
6.1.7 Loop
Das Loop-Statement hat folgende Syntax:
<loop-statement> := ’while’ <condition> ’do’ ( <statement> )* ’enddo’
Die Bedingung entspricht der Bedingung von If.
while a0 != a1
a0 := a0 + 1
enddo
do
6.2 Der Mode
Es existieren 2 Modi, einer für Loop und einer für While, letzte sind aber fast identisch.
Bei While ist zusätzlich zu allen Konstrukten von Loop die While-Schleife erlaubt. Auf
Grund der großen Ähnlichkeit werden die beiden Modi hier gemeinsam besprochen.
Der Loop/While Mode unterscheidet sich kaum vom Java Mode, dass heißt, es wird
weiterhin mit Nassi Shneiderman Diagrammen programmiert, welche per Drag & Drop
erstellt werden können. Allerding ist man bei der Eingabe stärker restringiert. Anders
als im Java-Mode ist die Eingabe mittels der Tastatur nicht völlig frei. Die einzelnen
Statements sind vielmehr in mehrere Felder unterteilt, zwischen denen mittels Alt und
der linken beziehungsweise rechten Pfeiltaste gewechselt werden kann, und dies funktioniert auch nur, falls die vorherige Eingabe dies zuläßt. ( Die Eingabe in diese Felder kann
daher erheblich stärker beschränkt werden, da aufgrund der Einfachheit der Sprache
Loop bisweilen klar ist, was für ein Ausdruck erwartet wird.
Die Schlichtheit der Sprache Loop / While erlaubt auch das automatische Hinzufügen
von Code, beispielsweise, wenn man von einem Macroaufruf zu einer Zuweisung (’:=’)
und von einer Zuweisung zu einer Addition (’+’) wechselt. Da in den Felder nur
Buchstaben und Zahlenwerte eingegeben werden müssen und auch nur können, ist die
Möglichkeit zu syntaktischen Fehlern zusätzlich reduziert.
Im Loop Mode hat man auch die Möglichkeit die Datei als Loop-Datei zu speichern
und als solche wieder einzulesen. Da JavaKara ein Java-Programm erwartet, muss man
jedoch die Loop-Datei, die in Kara laufen soll, vorher als Java-Datei abspeichern. Der
generierte Code unterscheidet sich wenig vom Generat der Java-Modes, es wird jedoch
eine andere Wrapper-Klasse für JavaKara verwendet, da Datentypen wie Boolean nicht
erlaubt sind! Die Wrapper-Klasse gibt bei den Prädikaten an Stelle von true/false 1/0
zurück.
19
6 Loop / While
Figure 6.1: Das Loop-Programm (SVG-Export)
a0 := 0
while kara.treeFront() != 1
kara.move()
enddo
if kara.onLeaf() == 1 then
kara.removeLeaf()
else
kara.putLeaf()
endif
kara.turnRight()
a0 := a0 + 1
do
Figure 6.2: Das Loop-Programm (Loop-Export)
20
6.2 Der Mode
public class Square extends GLoopKaraProgramBase {
public void myProgram() {
GLoopKara kara = new GLoopKara();
int a0=0;
a0 = 0 ;
do{
while( kara.treeFront() != 1
kara.move()
;
}
if( kara.onLeaf() == 1 ){
kara.removeLeaf()
;
}else{
kara.putLeaf()
;
}
kara.turnRight()
;
a0 = a0 + 1 ;
} while( a0 != 4 );
){
}
}
Figure 6.3: Der Java-Export des Loop-Programms
21
6 Loop / While
22
7 Toolbar und Punktnotation
In diesem Kapitel wird etwas detailierter auf den Toolbar eingegangen. Insbesondere
wird herausgearbeitet, inwieweit er für die Erklärung der Punktnotation im Schulunterricht herangezogen werden kann.
7.1 Der Toolbar
Beim Toolbar werden graphischen Symbolen Code-Fragmente sowie der Datentyp der
ganzen Fragments zugeordnet. Bei der Default-Einstellung des Toolbars wird immer
Objekt+Methode eingefügt, was sicherlich für den Anfang einfacher ist. Man kann den
Toolbar jedoch mit Hilfe von Konfigurationsdateien so anpassen, dass Objekte, Attribute
und Methoden einzeln eingefügt werden.
7.2 Eintrag für ein Objekt
Ein Eintrag für ein Objekt sieht aus wie folgt:
...
object:
[ kara,
object,
’Kara’,
’img/kara.gif’
]
...
#
#
#
#
Code Fragment
Datentyp
ToolTip Text
ToolBar Icon
Figure 7.1: Eintrag in der ToolBar Konfigurationsdatei für ein Objekt
Das Object an der 2. Stelle im Eintrag besagt, dass ein Statement nach dem Einfügen
vom Datentyp object ist. Dies bedeutet, dass nun Einträge des Typs ’method’ oder
’attribute’ eingefügt werden können.
23
7 Toolbar und Punktnotation
...
method:
[ .move(),
void,
’Schritt vor’,
’img/move.gif’
]
...
#
#
#
#
Code Fragment
Datentyp
ToolTip Text
ToolBar Icon
Figure 7.2: Eintrag in der ToolBar Konfigurationsdatei für eine Methode
7.3 Eintrag für eine Methode
Das Ikon beziehungsweise der dahinterliegende Code kann nur dann angefügt werden,
falls das Statement im Moment den Typ objekt hat. Man beachte: Der Code wird
angefügt und nicht wie bei Object.method ersetzt!
7.4 Eintrag für ein Attribut
...
method:
[ .stepCount,
int,
’Anzahl Schritte vor’,
’img/step.gif’
]
...
#
#
#
#
Code Fragment
Datentyp
ToolTip Text
ToolBar Icon
Figure 7.3: Eintrag in der ToolBar Konfigurationsdatei für ein Attribut
Beim Einfügen eines Attributes gelten die selben Beschränkungen wie bei einer Methode.
Eine Übersicht über die Flags und Datentypen bei Toolbar, sowie eine detailliertere
Beschreibung findet sich im Anhang.
24
8 Erweitern von JavaKara
Wie bereits in früheren Kapiteln erwähnt, kann man den Editor auf vielfache Art anpassen. Die Anpassung geht so weit, dass man auch - vor dem Anwender versteckt - das
Objekt der verwendeten Toy World modifizieren kann. Die dazu notwendigen Schritte
sind eine Anpassung der Konfigurationsdatei für den Toolbar sowie eine Anpassung der
Code-Template-Datei.
8.1 Anpassen der Template-Datei
Zum Verständnis der folgenden Schritte ist eine rudimentäre Kenntnis des Aufbaus
von Kara und der Anbindung des Editors an Kara notwendig. Bei einem normalen
Kara-Programm arbeitet das Programm mit einer Instanz von Kara, welche in einem
statischen Attribut gespeichert und bereits erzeugt ist. Die JavaKaraKlasse ist eine innere Klasse von JavaKaraProgram. Dies ist didaktisch und vom rein objektorientierten
Standpunkt aus gesehen eher unschön und erschwert zudem die Erweiterung des Objektes Kara.
Das Problem wurde mittels Delegation Inheritance gelöst, das heißt es wurde eine
Wrapperklasse erzeugt, welche eine Instanz von Kara enthält und gleichnamige Methoden hat, welche schlicht die Methoden der Instanz aufrufen.
Diese Klasse wurde, um Verwirrungen zu vermeiden, durch eine abgeleitete Klasse
verdeckt, welche nun normal mittels eines Konstruktors erzeugbar ist, und wo man
auch zusätzliche Methoden oder Attribute zur Verfügung stellen beziehungsweise alte
Methoden auch überschreiben kann.
Im folgenden Beispiel wird das Objekt Kara wie folgt modifiziert:
• Die neue Methode turnLeft180() soll den Marienkäfer um 180 Grad gegen den
Uhrzeiger Sinn drehen.
• Der Käfer wird weiterhin mit der Methode move(int s) erweitert, welche ihn s
Schritte nach vorne bewegt.
• Die Methode move() ohne Argument bewegt den Marienkäfer nicht mehr um einen
Schritt, sondern ermittelt die auszuführende Schrittzahl anhand des Wertes des
Attributes stepCount. Letzteres soll auch im NSD-Editor setzbar sein.
• Die Methoden removeLeaf() und putLeaf werden so verändert, dass der Marienkäfer
nur soviele Kleeblätter hinlegen kann, wie er auch aufgehoben hat.
25
8 Erweitern von JavaKara
...
import JavaKaraProgram;
/* BEFEHLE: kara.
*
move() turnRight() turnLeft()
*
putLeaf() removeLeaf()
*
* SENSOREN: kara.
*
treeFront() treeLeft() treeRight()
*
mushroomFront() onLeaf()
*/
public class FindeBaum extends JavaKaraProgram {
// hier koennen Sie eigene Methoden definieren
public void myProgram() {
// hier kommt das Hauptprogramm hin, zB:
while (!kara.treeFront()) {
kara.move();
}
}
}
Figure 8.1: JavaKara Template
public class GJavaKaraProgramBase extends JavaKaraProgram
{
{
GJavaKaraBase.kara = kara;
}
}
Figure 8.2: Die neue Basisklasse für Programme
26
8.1 Anpassen der Template-Datei
public class GJavaKaraBase
{
public static JavaKaraProgram.JavaKara kara;
public void move()
{
kara.move();
}
public void turnLeft()
{
kara.turnLeft();
}
public void turnRight()
{
kara.turnRight();
}
...
public void checkKaraInWorld()
{
kara.checkKaraInWorld();
}
}
Figure 8.3: Die neue Basisklasse für JavaKara
public class GJavaKara extends GJavaKaraBase
{
// Eigene Konstruktoren, Methoden, Attribute
...
}
Figure 8.4: Die neue JavaKara Klasse
27
8 Erweitern von JavaKara
Die neuen Methoden können direkt in der Klasse GJavaKara eingetragen werden. Hier
das Beispielprogramm.
public class GJavaKara extends GJavaKaraBase
{
public int stepCount = 2;
private int leafCount = 0;
public void turnLeft180()
{
turnLeft();
turnLeft();
}
public void move(int s)
{
for(int i=0;i<s;i++)move();
}
public void move()
{
move(steps);
}
public void putLeaf()
{
if(leafCount > 0){
leafCount--;
super.putLeaf();
}
}
public void removeLeaf()
{
leafCount++;
super.removeLeaf();
}
}
Damit JavaKara das Program findet, ist es am einfachsten, es zu kompilieren, und
in das allkara.ja einzufügen. Alternativ kann man die Datei auch im Verzeichnis des
Java-Generats ablegen.
28
8.2 Anpassen oder Erstellen einer neuen Toolbar-Datei
8.2 Anpassen oder Erstellen einer neuen Toolbar-Datei
Damit die neuen Methoden auch im Editor per drag and drop verwendet werden können,
müssen im Toolbar Einträge eingefügt werden, in denen den neuen Methoden Icons,
eine Beschreibung und eine ToolTip zugeordnet wird. Der zusätzliche Eintrag für obere
Erweiterung in einer ToolBar-Datei sähe aus wie folgt:
object.method:
...
[
kara.move(),
void,
’Bewegt Kara um kara.stepCount/i Schritte nach vorne’,
’img/kara_move.gif’
]
[
kara.stepCount,
int,
’Anzahl der Schritte bei Aufruf von move ohne Argument’,
’img/kara_step_count.gif’
]
...
29
8 Erweitern von JavaKara
30
9 Die Konfigurationsdateien
In diesem Kapitel wird auf die Syntax und Semantik der Konfigurationsdateien eingegangen. Mit diesen läßt sich das Aussehen und Verhalten des Editors nicht unerheblich
verändern.
9.1 Allgemeine Konfiguration des Editors
Die Datei editor.txt ist die zentrale Konfigurationsdatei des Editor, und die einzige,
deren relativer Pfad nicht frei wählbar ist. In ihr wird festgelegt, welches Code-Template
verwendet werden soll, in welcher Datei die einzelnen Modes aufgelistet sind und in
welchen Dateien die Pfade der zuletzt geöffneten/gespeicherten Dateien eingetragen
werden sollen. Außerdem kann der zunächst zu verwendende Toolbar so wie das CodeTemplate angegeben werden. Beispiel für die Datei editor.txt:
[graphic, config/graphic.txt ]
[modes,config/modes.txt ]
[save, config/save.txt ]
[open, config/open.txt ]
[toolbar,config/toolbar-java.txt ]
[template,config/template-java.txt ]
Die Reihenfolge der Einträge spielt hierbei keine Rolle.
9.2 Graphik Konfiguration
Die Syntax der Datei zur Konfiguration der Darstellung der Nassi Shneiderman Diagramme und der Buffer ist stark an CSS orientiert.
nsdEditor.core.graphic.storage.GComponent
{
border-color:
#333333 #222222 #333333 #222222;
border-width:
1 1 1 1;
color:
#004400;
font-family:
Courier;
background-color:
#EEEEEE;
}
31
9 Die Konfigurationsdateien
Oberer Auszug steuert die Darstellung aller Instanzen von GComponent. Da dies die
Basisklasse von allen graphischen NSD-Komponenten ist, beziehen sich obere Angaben
auf die Darstellungen aller NSD-Konstrukte. Man kann die Werte für die Unterklassen
jedoch auch explizit definieren. In diesem Fall werden die Werte der Basisklasse von den
spezielleren Werten überschrieben.
9.2.1 Einfacher Konfigurationseintrag
Ein einfacher Konfigurationseintrag besteht aus dem qualifizierten Klassennamen des zu
konfigurierenden Objekts, gefolgt von einer öffnenden geschweiften Klammern, danach
beliebig viele Feature-Einträge des Objekts und eine abschließende geschweifte Klammer.
obj1 {
... }
Man kann auch einen Eintrag für mehrere Objekte schreiben. Dabei werden die einzelnen
Objekte durch Kommata getrennt:
obj1, obj2, ..., objn { ... }
Nach einem Objekt kann auch das Attribut .selected stehen. Dies bedeutet, dass die
angegebenen Styleinformationen nur dann greifen, wenn das Objekt ausgewählt ist.
obj1 .selected {
... }
9.2.2 Vererbung
Augrund der Oberunterklassenbeziehung einzelner graphischer Objekte, ist Vererbung
möglich. Die Vererbung der Werte funktioniert nur dann, wenn die Werte der Basisklasse vor den Werten der spezialisierten Klasse gesetzt werden. Die mit dem Attribut .selected ‘spezialisierten’ Objekte können gleichfalls von ihren Basisklassen, den
nicht attributierten Objekten gleichen Namens, erben.
9.2.3 Angabe von RGB-Farbwerten
Farben werden mit Hilfe ihres RGB-Hexadezimalcodes angegeben. Dieser hat entweder
die Länge 7 oder 9.
• Länge 7: #RRGGBB
• Länge 9: #RRGGBBAA
Die mit R bezeichneten Stellen spezifizieren den Rotwert, die mit G bezeichneten Stellen
den Grünwert und die mit B bezeichneten Stellen den Blauwert. A bezeichnet die
Transparenz. Wird keine Transparenz angegeben, so ist die Farbe nicht transparent.
Beispiele: #FFFFFF (weiß), #FF0000 (rot), #00FF0055 (transparentes Grün).
32
9.2 Graphik Konfiguration
9.2.4 Übersicht über die konfigurierbaren graphischen Objekte
Die folgenden graphischen Objekte sind konfigurierbar:
Package: nsdEditor.core.graphic.storage
• GComponent: Basisklasse alle graphischen Objekte
• GContainer: Basisklasse alle graphischen Container-Objekte
• GStatement: Basisklasse alle primiven Statements
• GIfStatement: Basisklasse alle If-Statements
• GLoopStatement: Basisklasse alle Loop-Statements, auch For-Schleife
• GWhileStatement: Basisklasse alle While-Statements
• GDoStatement: Basisklasse alle Do-Statements
Package: nsdEditor.modules.loop
• LStatement: Loop/While-Variante des einfachen Statements
• LIfStatement: Loop/While-Variante des If-Statements
• LLoopStatement: Loop/While-Variante des Loop-Statements
• LWhileStatement: Loop/While-Variante des While-Statements
Package: nsdEditor.modules.java
• JStatement: Java-Variante des einfachen Statements
• JIfStatement: Java-Variante des If-Statements
• JLoopStatement: Java-Variante des Loop-Statements (For-Schleife)
• JWhileStatement: Java-Variante des While-Statements
• JDoStatement: Java-Variante des Do-Statements
Package: nsdEditor.core.Buffer
• TextBuffer: Basisklasse aller Buffer zum Darstellen von Text
• PanelBuffer: Basisklasse aller Buffer zum Darstellen von graphischen Komponenten
33
9 Die Konfigurationsdateien
9.2.5 Übersicht über die konfigurierbaren Features
• border-color: Farbe der Kanten. 1 oder 4 RGB-Farbwerte (für oben,rechts,unten,links).
• border-width: Breite der Kanten. 1 oder 4 Intgerwerte (für oben,rechts,unten,links).
• font-size: Schriftgröße. Als Werte sind, anders als bei CSS, nur positive Ganzzahlen
zugelassen.
• font-family: Schriftname wie ’Courier’
• font-weight: Das Zeichenformat. Werte: ’bold’, ’normal’, ’italic’
• line-height: Der Zeilenabstand. Beim Wert handelt es sich um eine Fließkommazahl, wobei die Zahl 1.0 die Höhe einer Zeile beschreibt.
• color: Schriftfarbe. Wert: RGB-Farbwert.
• background-color: Hintergrundfarbe. Wert: RGB-Farbwert.
9.3 Die Modes-Datei
In der in der Datei editor.txt unter ’modes:’ angegebenen Datei werden die erlaubten
Modes aufgelistet, so wie die Dateien, in welcher diese spezifiziert sind. Ein Eintrag
besteht jeweils aus einer eckigen Klammer, gefolgt von dem Namen des Modes, einem
Komma, der Spezifikationsdatei und einer schließenden eckigen Klammer. Beispiel:
[
[
[
[
[
"Java1","modes/java1.txt"
"Java2","modes/java2.txt"
"Java3","modes/java3.txt"
"Java4","modes/java4.txt"
"Java5","modes/java5.txt"
]
]
]
]
]
Hier werden die Modes Java1 bis 5 erlaubt, wobei die jeweiligen Spezifikationsdateien
unter ’modes/java1.mode’ bis ’modes/java5.mode’ zu finden sind. (Anführungszeichen
sind nur dann notwendig, falls die Bezeichnung oder der Pfad ein Leerzeichen, eine eckige
Klammer oder ein Komma enthält). Der zuerst angegebene Mode ist der Default-Mode.
9.4 Die Mode-Datei
Dies ist vermutlich die komplexeste Konfigurationsdatei. Hier wird festgelegt, welche
Befehle erlaubt sind, welche Tastaturkürzel diese haben und wo und unter welchem
Menü sie aufrufbar sind. Überdies kann der zu verwendende Toolbar und das CodeTemplate angegeben werden.
34
9.4 Die Mode-Datei
# Toolbar
[toolbar,
"config/toolbar-loop.txt" ]
# Code-Template
[template,"config/template-loop.txt" ]
# Module
[+module, nsdEditor.modules.nsd.EditModule
[+module, nsdEditor.modules.java.JModule
[+module, nsdEditor.modules.nsd.NsdModule
...
[-menu,
[+menu,
[+menu,
[+menu,
[+menu,
...
]
]
]
/File ]
/File/New,n,C-n,nsdFileNew ]
/File/Open,,,nsdFileOpen
]
/File/Save,,,nsdFileSave
]
"/File/Save As/Svg File",,, nsdFileSaveAsSvg]
9.4.1 Module
Mit +module können Module geladen weden, mit -module wird einem Modul mitgeteilt,
dass es nicht weiter benötigt wird. Module sind eine Einheit, in der im Editor verwendbare Befehle zusammengefasst sind. Sie erlauben das gemeinschaftliche Laden der
Befehle. Der Eintrag:
[+module, nsdEditor.modules.nsd.NsdModule
]
läd das Module nsdEditor.modules.nsd.NsdModule, sofern dies noch nicht bereits geladen
wurde. Es existieren die folgenden Module:
• nsdEditor.modules.nsd.EditModule: Edit Commands wie copy/paste/cut
• nsdEditor.modules.java.JModule: Commands zum Einfügen von den Java Varianten der Grundbausteine der Nassi Shneiderman Diagramme.
• nsdEditor.modules.java.JModule: Commands zum Einfügen von den Loop Varianten der Grundbausteine der Nassi Shneiderman Diagramme.
• nsdEditor.modules.nsd.NModule: Commands, die in allen Varianten der Bausteine
des Nassi Shneiderman Diagramms gleich sind, wie die Auswahl des letzten oder
des nächsten Statements.
• nsdEditor.modules.nsd.TbModule: Commands zum Laden, Anzeigen und Verstecken des Toolbars.
35
9 Die Konfigurationsdateien
• nsdEditor.modules.nsd.OptionModule: Optionen wie Zoom oder Look & Feel.
• nsdEditor.core.editor.CoreModule: Commands, welche zum Kern des Editors gehören
und nicht von irgendeinem Mode abhängig sind, wie das Öffnen oder Schließen von
Fenstern.
9.4.2 Menü
[-menu, /File ]
Oberer Eintrag entfernt den Menüpunkt /File sowie alle Untermenüs. Mit +menu werden Menüs eingefügt. Der Eintrag
[+menu, /File/New,n,C-n,nsdFileNew ]
fügt den Menüpunkt /File/New ein, welcher n als Mnemonic und C-n als Shortcut
hat. Bei Aktivierung des Menüs wird der Command nsdFileNew ausgeführt. Soll ein
Menüpunkt kein Menomic oder kein Tastaturkürzel haben, so läßt man die entsprechende
Stelle im Eintrag frei:
[+menu, /File/Save,,,nsdFileSave
]
Kommentare kann man auch hier mit Hilfe des ’#’ einfügen. Der Text bis Ende der
Zeile wird dann ignoriert.
9.5 Konfiguration des Toolbars
Die in der Datei editor.txt oder in den Mode-Dateien als toollbar gekennzeichnete Datei
dient als abstrakte Beschreibung des Objekts und zur Erzeugung des Toolbars.
Die Datein besteht aus mehreren optionalen Sektionen welche mit den Flags ’object:’,
’object.method:’, ’object.attribute:’,’method:’ oder ’attribute:’ eingeleitet werden.
...
object:
...
object.method:
...
object.attribute:
...
method:
...
attribute:
...
36
9.5 Konfiguration des Toolbars
Diese Flags steuern die Art des Einfügens. So wird beispielsweise beim Verschieben
eines Icons mit der Auszeichnung ’object.method:’ der vorherige Eintrag gelöscht, bei
’method:’ wird überprüft, ob der aktuelle Eintrag vom Typ Object ist, und gegebenenfalls wird die Methode angehängt. Auch wird beim Einfügen auf den Datentyp geachtet
und die Drag & Drop Operation gegebenenfalls abgebrochen. Die Reihenfolge der Flags
ist nicht festgelegt, und es kann auch mehrfach dasselbe Flag auftauchen.
Jede mit einem Flag eingeleitete Sektion kann mehrere Einträge enthalten. Ein Eintrag besteht aus dem Namen des Objekt, beziehungsweise des Attributes oder der Operation, gefolgt vom Rückgabewert beziehungsweise dem Datentyp, einer kurzen Beschreibung, die als ToolTip dient, und dem Pfad des Bildes.
[ kara.move(),
void,
’Schritt vor’,
’img/kara_command_move.gif’
]
#
#
#
#
Name der Operation
Datentyp
ToolTip Text
ToolBar Icon
Die Reihenfolge der Einträge spiegelt die Reihenfolge der Icons im Toolbar wieder.
object.method:
...
[
kara.onLeaf(),
boolean,
’Kleeblatt unten?’,
’img/kara_sensor_cloverleaf.gif’
]
[
kara.mushroomFront(),
boolean,
’Pilz vorne?’,
’img/kara_sensor_mushroom.gif’
]
...
In oberem Beispiel folgt das ToolBar-Icon von ’kara.mushroomFront()’ direkt auf das
Icon von ’kara.onLeaf()’.
Mit ’#’ können Kommentare eingefügt werden, welche sich bis zum Ende der Zeile
erstrecken.
9.5.1 Übersicht über die Flags bei Toolbar
• Object/object: Ein Objekt, beispielsweise kara
• Object.attribute/object.attribute: Objekt & Attribut, zum Beispiel kara.stepCount
37
9 Die Konfigurationsdateien
• Object.method/object.method: Objekt & Methode, zum Beispiel kara.move()
• Attribute/attribute: Nur ein Attribut, beispielsweise .stepCount
• Method/method: Nur eine Methode, zum Beispiel .move()
9.5.2 Übersicht über die Datentypen bei Toolbar
• int: Ganzzahlwert
• boolean: Wahrheitswert
• object: Objekt
• methodVoid: Methode ohne Rückgabewert
• methodInt: Methode mit Ganzzahl als Rückgabewert
• methodBoolean: Methode mit Wahrheitswert als Rückgabewert
• methodObject: Methode mit Objekt als Rückgabewert
9.6 Code-Generierung
Bei der Generierung des Java-Codes wird der aus den NSD-Diagrammen gewonnene
Code in eine Templatedatei eingefügt, welche beliebigen Java-Code enthalten kann.
Beispiel:
public class @Filename extends GJavaKaraProgramBase {
public void myProgram() {
GJavaKara kara = new GJavaKara();
@Content
}
}
Bei @Filename wird der Name der Datei eingefügt, bei @Content der aus den NSDDiagrammen gewonnene Inhalt. Letzterer hat eine standardmäßige Einrückung von
zwei Tabulatoren.
38
10 Appendix A
In diesem Kapitel findet sich ein kurzer Umriß des Aufbaus des Editors.
Der NsdEditor ist im Prinzip wie ein normaler Texteditor aufgebaut. Was die Komponenten betrifft, so orientiert er sich am Gnu Emacs, er ist aber natürlich wesentlich
schlichter. Es gibt eigene Klassen für Fenster, Buffer Menüs, Modes, welche Darstellung
und Bearbeitung eines Buffers beeinflussen, Commands sowie ein Event-Model. Die
Klassen und das Event-Model werden im Folgenden kurz beleuchtet.
10.1 Buffer
Unter Buffern werden hier Objekte verstanden, welche den Inhalt eines Fensters speichern. Der Inhalt wird aber nicht unbedingt angezeigt.
Der Editor kann mehrer Buffer verwalten. Er kann bei der Anzeige zwischen den
einzelnen Buffern wechseln, wobei der Wechsel der Buffer bis zu einem gewissen Grad
mitgespeichert wird. Dies bedeutet, dass Befehle wie lade letzten Buffer oder nächsten
Buffer prinzipiell möglich sind. Bei den Buffern kann es sich um TextBuffer handeln
oder auch um PanelBuffer, in welche gezeichnet werden soll.
10.2 Window
Ein Window ist ein Fenster, in dem jeweils ein Buffer angezeigt wird.
Im Gegensatz zu Buffern sind Windows immer sichtbar. Windows sind die Slots, in
welche die Buffer eingefügt werden, wobei diese Binding Window zu Buffer flexibel ist.
So kann der in einem Window dargestellt Buffer zur Laufzeit wechseln. (Ein bisher
sichtbarer Buffer wird jetzt nicht mehr sichtbar, dafür wird ein neuer Buffer oder ein
vorher nicht sichtbarer Buffer jetzt angezeigt.)
Windows können sowohl horizontal als auch vertikal gesplittet oder auch geschlossen
werden, letzteres, sofern es sich nicht um das letzte Window handelt. Diese Funktionalität wird ähnlich der Bufferfunktionalität momentan wenig gebraucht, dient aber der
Erweiterbarkeit des Editors zu mehr als einem Spezialzweckeditor.
39
10 Appendix A
10.3 Event
Das Event-Model unterscheidet sich nicht stark von dem, welches Java zur Verfügung
stellt. Jeder Buffer hat die Funktionalität einer Swing-Componenten und kann damit auf
Events, die sich auf ihn beziehen, entsprechend dem Java Event-Model reagieren. Allerdings gibt es zusätzlich die Möglichkeit, sich beim Editor für Events auch anderer Buffer
einzutragen/auszutragen. Dies kann dazu genutzt werden, mehrere Buffer miteinander
zu synchronisieren, beispielsweise um parallel zur Erzeugung des NSD-Diagrams den
dazugehörigen Code in einem weiteren Buffer zu sehen.
10.4 Menu
Die Menüs werden pro Buffer erzeugt und sind abhängig von dessen jeweiligen Mode.
(Daher kann man das Menü auch mittels der entsprechenden Mode-Konfigurationsdatei
anpassen)
10.5 Command
Command sind eine Abstraktion für Befehle, welche in einem Buffer oder im ganzen
Editor verwendet werden können. Commands können hinter Menüs hinterlegt werden und/oder mittels Shortcuts oder über Mausaktionen aktivierbar sein. (Ein Command besteht aus einer Beschreibung, einer ausführbaren Funktion, einem Array, das
mögliche Argumente besitzt, ein Tastaturkürzeln, mit welchen er aktiviert werden soll,
und Metainformationen zum Beispiel darüber, ob er momentan aktiv ist oder nicht.
Commands werden sowohl zentral gespeichert als auch pro Buffer, das heißt, Buffer
können Commands des Editors sozusagen überschreiben. Die Commands sind von
grøßem praktischem Interesse auch für den Anwender, da er beispielsweise bei der Konfiguration der Modes diese direkt modifizieren kann.
10.6 Nsd Buffer
Der NSD Buffer ist ein Buffer der speziell für das Erzeugen von NSD-Diagrammen programmiert ist. Im Prinzip handelt es sich bei diesem Buffer um eine JPanel, dessen
Method repaint überschrieben wurde. Die Daten des NSD-Diagrammes werden in eigenen leichtgewichtigen Komponenten gespeichert (aus denen dann auch direkt Code oder
SVG generiert werden kann), die überschriebene Methode traversiert diese Komponenten und stellt das JPanel dann dementsprechend dar. Dies bedeutet, dass das Layout
auch über die normalen Java-LayoutManager hinaus anpassbar ist, was ja auch über die
Graphik-Konfigurationsdatei ohne jegliche Programmierung funktioniert. Bei gravierenden Änderungen muss man vermutlich doch in Java programmieren.
40
11 Appendix B
11.1 Toolbar Konfigurationsdatei (keine Punktnotation)
Object.method:
[kara.move(), void, ’Schritt vor’, ’img/kara_command_move.gif’ ]
[kara.turnLeft(), void,’Links drehen’,’img/kara_command_turnleft.gif’]
[kara.turnRight(), void, ’Rechts drehen’, ’img/kara_command_turnright.gif’ ]
[kara.removeLeaf(), void, ’Kleeblatt aufnehmen’, ’img/kara_command_pickup.gif’]
[kara.putLeaf(), void, ’Kleeblatt legen’,’img/kara_command_putdown.gif’ ]
[kara.onLeaf(),boolean, ’Kleeblatt unten?’, ’img/kara_sensor_cloverleaf.gif’ ]
[kara.mushroomFront(), boolean,’Pilz vorne?’,’img/kara_sensor_mushroom.gif’ ]
[kara.treeFront(), boolean, ’Baum vorne?’, ’img/kara_sensor_treefront.gif’ ]
[kara.treeLeft(), boolean, ’Blatt links?’, ’img/kara_sensor_treeleft.gif’ ]
[kara.treeRight(), boolean, ’Baum rechts?’, ’img/kara_sensor_treeright.gif’ ]
11.2 Toolbar Konfigurationsdatei (Punktnotation)
Object:
[kara, object,’Der Marienkaefer Kara’, ’img/kara_object_kara.gif’ ]
Method:
[.move(), object, ’Schritt vor’, ’img/kara_command_move.gif’ ]
[.left(), void, ’Links drehen’,’img/kara_command_turnleft.gif’ ]
[.right(),void, ’Rechts drehen’, ’img/kara_command_turnright.gif’]
[.removeLeaf(), void, ’Kleeblatt aufnehmen’, ’img/kara_command_pickup.gif’ ]
[.putLeaf(), void, ’Kleeblatt legen’, ’img/kara_command_putdown.gif’ ]
[.mushroomFront(), boolean, ’Pilz vorne?’, ’img/kara_sensor_mushroom.gif’ ]
[.treeFront(), boolean,’Baum vorne?’, ’img/kara_sensor_treefront.gif’ ]
[.treeLeft(), boolean, ’Blatt links?’, ’img/kara_sensor_treeleft.gif’ ]
[.treeRight(), boolean,’Baum rechts?’,’img/kara_sensor_treeright.gif’ ]
41
11 Appendix B
11.3 Mode Konfigurationsdatei Java (5)
# Toolbar
[toolbar,
"config/toolbar-java.txt" ]
# Code-Template
[template,"config/template-java.txt" ]
# Module
[+module,
[+module,
[+module,
[+module,
[+module,
[+module,
nsdEditor.modules.nsd.EditModule ]
nsdEditor.modules.java.JModule ]
nsdEditor.modules.nsd.NModule ]
nsdEditor.modules.nsd.TbModule ]
nsdEditor.modules.nsd.OptionModule ]
nsdEditor.core.editor.CoreModule ]
# File
[-menu, /File ]
[+menu, /File/New, n, C-n, nsdFileNew ]
[+menu,"/File/Open", , , nsdFileOpen ]
[+menu,"/File/Save", ,, nsdFileSave ]
[+menu,"/File/Save As/Svg File", , , nsdFileSaveAsSvg ]
[+menu,"/File/Save As/Java File", , , javaSaveAsJavaFile ]
# Edit
[-menu,/Edit ]
[+menu,/Edit/Copy, c, C-c, editCopyStatement ]
[+menu,/Edit/Paste, a,C-v, editPasteStatement ]
[+menu,/Edit/Cut, u, C-x, editCutStatement ]
# NSD-Loop
[-menu,/NSD ]
[+menu,"/NSD/insert/simple statement",s, C-i,javaInsertSimpleStatement ]
[+menu,"/NSD/insert/if statement", f, C-f, javaInsertIfStatement ]
[+menu,"/NSD/insert/loop statement", l, C-l, javaInsertLoopStatement ]
[+menu,"/NSD/insert/while statement", w, C-w, javaInsertWhileStatement ]
[+menu,"/NSD/insert/do statement", d, C-d, javaInsertDoStatement ]
[+menu,"/NSD/show code", , , nsdOpenJavaCodeWindow ]
[+menu,/NSD/previous, p, C-p,nsdPreviousStatement ]
[+menu, /NSD/next, n, C-n, nsdNextStatement ]
42
11.3 Mode Konfigurationsdatei Java (5)
# Toolbar
[+menu,"/NSD/toolbar/toolbar open", o,, tbOpen ]
[+menu,"/NSD/toolbar/toolbar show", s,, tbShow ]
[+menu,"/NSD/toolbar/toolbar hide", h,, tbHide ]
# Options
[-menu,/Options ]
[+menu,"/Options/Zoom in", i, C-p, optionsZoomIn ]
[+menu,"/Options/Zoom out", o,C-m, optionsZoomOut ]
[+menu,"/Options/Mode/Java1", , , coreMode ]
[+menu,"/Options/Mode/Java2", , , coreMode ]
[+menu,"/Options/Mode/Java3", , , coreMode ]
[+menu,"/Options/Mode/Java4", , , coreMode ]
[+menu,"/Options/Mode/Java5", , , coreMode ]
[+menu,"/Options/Mode/Loop", , , coreMode ]
[+menu,"/Options/Mode/While", , , coreMode ]
# Window
[-menu, /Window ]
[+menu, /Window/Close, , , coreWinClose ]
[+menu, /Window/Split/Vertically, , , coreWinSplitVertical ]
[+menu,/Window/Split/Horizontally, , ,coreWinSplitHorizontal ]
[+menu,"/Window/Look And Feel/Windows", , , coreWinLookAndFeelWindows ]
[+menu,"/Window/Look And Feel/Motif", , , coreWinLookAndFeelMotif ]
[+menu,"/Window/Look And Feel/Metal", , , coreWinLookAndFeelMetal ]
43
11 Appendix B
11.4 Graphik Konfigurationsdatei
nsdEditor.core.graphic.storage.GComponent{
border-color: #888888 #777777 #888888 #777777;
border-width: 1 1 1 1;
color: #004400;
font-family: Courier;
line-height: 1.4;
font-weight: normal;
background-color: #EEEEEE;
}
nsdEditor.core.graphic.storage.GComponent .selected{
background-color: #BBBBFF;
}
nsdEditor.core.graphic.storage.GControlContainer{
border-width: 1 1 1 1;
}
nsdEditor.modules.java.JStatement,
nsdEditor.modules.java.JIfStatement,
nsdEditor.modules.java.JLoopStatement,
nsdEditor.modules.java.JWhileStatement,
nsdEditor.modules.java.JDoStatement {
border-width: 1 1 1 1;
border-color: #AAAACC;
}
nsdEditor.core.buffer.TextBuffer,
nsdEditor.core.buffer.PanelBuffer{
color: #555555;
font-family: Arial;
font-size: 11;
font-weight: normal;
background-color: #CCCCCC;
}
nsdEditor.core.buffer.TextBuffer .selected,
nsdEditor.core.buffer.PanelBuffer .selected{
color: #222222;
font-size: 11;
background-color: #FFFFFF;
}
44
Bibliography
[1] R. Reichert. Programmieren mit Kara. Berlin: Springer, 2003.
45