JAVA
Werbung
SYSTEMPROGRAMMIERUNG VISUALISIERUNG (UND VERGLEICH) VON VERSCHIEDENEN ALGORITHMEN ZUM ZEICHNEN VON LINIEN UND KREISEN PROJEKT: "LICIVI" - LINE-CIRCLE-VISUALIZER Vorgelegt von Michael Jahn, Matr.-Nr.: 313632 Michael Jahn 1997 Michael Jahn Abt-Hugo-Straße 11 36093 Künzell Email: [email protected] Systemprogrammierung Seite 2 Projekt: LiCiVi Systemprogrammierung Projekt: LiCiVi Inhaltsverzeichnis 1 VORWORT.......................................................................................................... 5 2 EINLEITUNG ....................................................................................................... 6 2.1 Aufgabenstellung .................................................................................................................................... 6 2.2 Allgemeine Überlegungen ...................................................................................................................... 6 2.3 Die Vorteile von JAVA ........................................................................................................................... 7 3 SYSTEMGESTALTUNG ..................................................................................... 9 3.1 Groborganisation .................................................................................................................................... 9 3.2 Detailorganisation ................................................................................................................................. 10 3.3 Entwurf der grafischen Benutzeroberfläche ...................................................................................... 12 3.4 Interaktionsdiagramme ........................................................................................................................ 13 4 PROGRAMMIERUNG ....................................................................................... 15 4.1 Erstellung einer Zeichenfläche, die Vergrößerungen erlaubt ........................................................... 15 4.2 Realisierung eines "Debug"-Modus für den Grafik-Algorithmus ................................................... 16 4.3 Threads unter JAVA ............................................................................................................................ 18 4.4 Gesamtklassenmodelle für API 1.0 und API 1.1 ................................................................................ 18 5 ERWEITERBARKEIT VON LICIVI .................................................................... 21 5.1 Implementierung eines neuen grafischen Algorithmus ..................................................................... 21 5.2 Erweiterung der Parameterauswertung ............................................................................................. 22 5.3 Aufrufen des neuen Algorithmus ........................................................................................................ 23 6 ANHANG ........................................................................................................... 25 6.1 LiCiVi-Parametereinstellungen ........................................................................................................... 27 6.2 LiCiVi-HTML-Seiten ........................................................................................................................... 29 6.3 Programmdokumentation (API 1.0) ................................................................................................... 31 6.4 Programmdokumentation (API 1.1) ................................................................................................... 33 6.5 LiCiVi und HTML-Browser, Applet-Viewer ..................................................................................... 37 6.6 Programmierrichtlinien ....................................................................................................................... 39 6.7 Entwicklungsumgebung ....................................................................................................................... 41 Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 3 Systemprogrammierung Projekt: LiCiVi 6.8 Literaturliste ......................................................................................................................................... 43 6.9 GNU General Public License ............................................................................................................... 45 Seite 4 Systemprogrammierung Projekt: LiCiVi 1 V O RW O RT Linien und Kreise sind die wichtigsten Elemente der grafischen Datenverarbeitung. Ohne diese Bausteine gäbe es keine grafischen Benutzeroberflächen, wie man sie heute von jedem Computer - Arbeitsplatz kennt. Jedoch ist die Konvertierung der natürlichen Formen von Kreis und Linie auf die "grobe" Rastergrafik eines Rechners nicht immer trivial. Zu diesem Zweck gibt es eine ganze Reihe unterschiedlicher Algorithmen. Dieses Projekt soll dabei helfen, den mathematischen Hintergrund dieser Algorithmen zu visualisieren und Besonderheiten aufzeigen. Besonderer Wert wurde auf die Möglichkeit der Vergrößerung der Linien und Kreise gelegt, um zu verdeutlichen, wie die einzelnen Algorithmen ihre Punkte verteilen. Auf Grund dieser Gegebenheiten lag es nahe, das Projekt unter einem speziellen Werkzeug (z. B. Toolbook) zu entwickeln, jedoch mangelt es bei dieser Art Werkzeugen immer an Laufzeitumgebungen, die auf jeder Rechner-Plattform verfügbar sind. Deshalb fiel die Wahl auf die objektorientierte Sprache JAVA, die von der Firma SUN entwickelt wurde, und schon heute auf den meisten Plattformen verfügbar ist. In Verbindung mit einer HTML1-Seite kann das fertige Programm sogar über das Internet geladen und sofort ausgeführt werden, denn auch die meisten HTML-"Browser" unterstützen Programme in JAVA. "LiCiVi" ist eine Kombination aus "JAVA-Applet" und HTML-Seiten, wobei das Applet (das JAVA-Programm) die Algorithmus-Visualisierung und die HTML-Seiten den Textbereich übernehmen. Die vorliegende Projektarbeit der Systemprogrammierung wurde im Rahmen einer Hausarbeit in der Zeit von Oktober bis Dezember 1997 realisiert. Das Thema wurde von Herrn Prof. Dr. Siegmar Groß vorgeschlagen. Ich versichere, daß ich diese Arbeit allein ausgeführt und dokumentiert habe. Als Hilfe stand mir nur die im Anhang aufgeführte Literatur zur Verfügung. (Michael Jahn) 1 Hyper Text Markup Language Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 5 Systemprogrammierung Projekt: LiCiVi 2 E I N LE I T U NG 2.1 Au fgabenstellung Das Projekt, im folgenden LiCiVi genannt, soll das Visualisieren und den Vergleich verschiedener Linien bzw. Kreisalgorithmen ermöglichen. Dabei soll der Ablauf der einzelnen Algorithmen dargestellt werden. Ferner soll es möglich sein, die vom Algorithmus gezeichneten Punkte zu vergrößern, um dessen Güte (Rundungsfehler in Form von Löchern) bewerten zu können. Im Rahmen dieses Projektes sollen die folgenden Linien- und Kreisalgorithmen realisiert werden: Linienalgorithmen Horizontale Linie Vertikale Linie Direkte Methode Direkte Methode mit Fallunterscheidung Algorithmus nach Bresenham Kreisalgorithmen Standardform Parameterdarstellung Kreisalgorithmus nach Bresenham 2.2 Al lgemeine Überlegungen Bei der Planung und Realisierung von LiCiVi (Line Circle Visualizer) stehen mehrere Aspekte im Vordergrund. LiCiVi soll in erster Linie das Problem der Visualisierung von Linien- und Kreisalgorithmen realisieren, jedoch soll es aber später auch möglich sein, das Programm durch neue Elemente zu erweitern. LiCiVi soll portabel sein, d. h. auf möglichst vielen Plattformen bzw. Betriebssystemen lauffähig sein. Das Programm soll intuitiv steuerbar sein, sowie einen Textbereich enthalten, der den notwendigen theoretischen Hintergrund zu den einzelnen Algorithmen liefert. Außerdem wäre es von Vorteil, einen Algorithmus im Schrittmodus zu durchlaufen um gleichzeitig die zugehörigen Grafikausgaben zu betrachten ("Trace" bzw. "Debug"Modus). LiCiVi soll eine Art Lernprogramm mit integrierter Simulation verkörpern, welches aber über das Internet geladen werden kann, um es dann sofort ausführen zu können. Angesichts dieser Vorüberlegungen liegt es nahe, das Programm über ein spezielles Werkzeug (z. B. Autorensystem, Simulationspaket, etc.) zu realisieren. Diese Werkzeuge sind aber i. d. R. plattformabhängig und benötigen spezielle Laufzeitbibliotheken, die nicht immer lizenzfrei verfügbar sind. Die weitverbreiteten Programmiersprachen wie C, Pascal oder Basic Seite 6 Systemprogrammierung Projekt: LiCiVi sind zwar auf vielen Plattformen verfügbar, aber die Programmierung selbst ist vielfach systemabhängig und erfordert systemtypische Bibliotheken. 2.2.1.1 Die Lösung: JAVA Die beste Lösung findet sich in der recht jungen Programmiersprache JAVA, die von SUN Microsystems 1991 im Rahmen eines Forschungsprojektes zur Software-Entwicklung für Elektronikgeräte wie Fernseher, Videorecorder, etc. entwickelt wurde. Dabei wurde das Ziel verfolgt, eine Sprache zu entwickeln, die schnell, effizient und leicht auf vielfältige Hardware-Systeme portierbar ist. Das gleiche Ziel machte aus JAVA eine ideale Sprache zur Verbreitung ausführbarer Programme über das World Wide Web (WWW) und auch eine universelle Programmiersprache zur Entwicklung von Programmen, die bedienungsfreundlich und auf verschiedene Plattformen portierbar sind. 2.3 Die Vorteile von J AV A JAVA ist plattformunabhängig, d. h., daß ein Programm auf jedem beliebigen Computersystem ausgeführt werden kann. JAVA-Programme laufen auf jedem System, auf dem eine virtuelle JAVA-Maschine installiert ist (i. d. R. übernimmt diese Aufgabe eine HTML-Browser). Die Plattformunabhängigkeit hört aber nicht bei der Quellebene auf. Auch JAVA-Binärdateien sind plattformunabhängig und laufen auf verschiedenen Maschinen ohne Notwendigkeit, den Quellcode neu compilieren zu müssen. Die Abbildung 2.1 soll den Übersetzungsvorgang von JAVA-Anwendungen darstellen. Java-Interpreter (Pentium) JAVA Code JAVA Compiler JAVA Bytecode Java-Interpreter (Pow er PC) Java-Interpreter (SUN) Java-Interpreter (Silicion Graphics) plattformunabhängig plattformabhängig Abbildung 2.1 Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 7 Systemprogrammierung Projekt: LiCiVi Nach Erstellung des JAVA-Quellcodes wird dieser zunächst über einen JAVA-Compiler übersetzt. Der daraus entstehende Bytecode bleibt weiterhin plattformunabhängig. Diesen Binärcode kann man auch als Maschinensprache für einen virtuellen Prozessor bezeichnen. Um das übersetzte Programm auszuführen, benötigt man schließlich eine plattformabhängigen JAVA-Interpreter (virtuelle JAVA-Maschine), welcher den Bytecode interpretiert und ausführt. Diese Interpreter sind als eigenständige Programme erhältlich bzw. in aktuellen HTML-Browsern bereits integriert. JAVA ist objektorientiert, wobei die Grammatik stark an C++ angelehnt wurde. Dies bedeutet eine höhere Wiederverwendbarkeit und meist auch Übersichtlichkeit der geschriebenen Programme. JAVA ist leicht zu lernen. JAVA lehnt sich stark an die Sprachkonstrukte von C an, es wurden jedoch Zeiger-Arithmetiken komplett ausgeschlossen. Außerdem werden Datentypen wie Felder oder Zeichenketten als vollwertige Objekte geführt. Dies verbessert in diesem Zusammenhang die meist fehlerbehaftete Programmierung unter C. JAVA erlaubt die Erstellung von sog. "Applets" oder Anwendungen. Applets werden in einem Browser-Fenster direkt ausgeführt, während Anwendungen immer eigene Fenster erzeugen müssen, um Grafikausgaben zu ermöglichen. Es ist aber auch möglich, beide Konzepte zu kombinieren, so daß eine Anwendung alleine (in einem eigenen Fenster), wie auch in einem Applet ausgeführt werden kann. Für weitere Informationen sei auf die Literatur im Anhang verwiesen. Seite 8 Systemprogrammierung Projekt: LiCiVi 3 S Y S TE M GE S TAL T U N G 3.1 Groborganisation Im Folgenden sollen alle Anforderungen an das Projekt LiCiVi aufgeführt werden. Die Einteilung der Anforderungen soll nach den folgenden Bereichen erfolgen: Funktionalität Grafische Benutzeroberfläche Programmierrichtlinien 3.1.1 Funktionalität JAVA und HTML-Seiten lassen sich sehr gut miteinander kombinieren. Gerade für ein Lernprogramm ist diese Möglichkeit ideal, da Lernsysteme einen relativ hohen Textanteil besitzen, der sich mit konventionellen Programmiersprachen eher mühsam realisieren läßt (Schriftarten, Farben, Erweiterbarkeit, etc.). Aus diesem Grund soll die Programmierung von LiCiVi nur den simulationstechnischen Teil in Form eines Applets lösen. Den Textbereich übernimmt dann eine HTML-Seite, in der dieses Applet eingebettet ist. Über das Applet wird dann das Simulationsfenster mit einer grafischen Benutzeroberfläche geöffnet. Die Funktionalität von LiCiVi soll die folgenden Anforderungen abdecken: LiCiVi soll es ermöglichen, grafische Algorithmen zu visualisieren, d. h. das einerseits ein bestimmter Algorithmus dargestellt werden kann, aber zusätzlich dieser auch durchlaufen werden kann. Die zugehörigen Grafikausgaben sollen gleich neben dem Algorithmus auf einer Zeichenfläche erscheinen. LiCiVi soll interaktiv vom Benutzer gesteuert werden können. Auf Knopfdruck soll die Simulation gestartet, angehalten und neu initialisiert werden können. Es soll auch die Möglichkeit eines Schrittmodus und Schnellmodus gegeben sein, um den Algorithmus besser studieren zu können. Die einzelnen Variablen (und deren aktuelle Werte) des entsprechenden Algorithmus sollen ebenfalls während der Simulation sichtbar sein. Nachfolgend seien alle wichtigen Funktionalitäten noch einmal zusammengestellt: Realisierung in Form eines Applets Möglichkeit der Auswahl eines Grafikalgorithmus Interaktive Kommunikation mit dem Benutzer Schrittmodus und Schnellmodus für den Ablauf des Zeichenalgorithmus Ausgabe der Variablen und deren Werte während der Simulation Anzeigen der aktuellen Programmposition Grafikalgorithmus zurücksetzen 3.1.2 Grafische Benutzeroberfläche Bei der Entwicklung der grafischen Benutzeroberfläche wird davon ausgegangen, daß es sich bei dem Projekt um ein Lernsystem mit integrierter Simulation handelt. Lernsysteme besitzen im Idealfall eine klare, übersichtliche Anordnung der Steuerelemente, die nach Möglichkeit eindeutig beschriftet sein sollen. Zur Anzeige des eigentlichen grafischen Objekts wird eine Zeichenfläche benötigt, die es erlaubt, Punkte zu setzen und diese Punkte beliebig zu vergrößern ("Zooming"). Weiterhin ist Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 9 Systemprogrammierung Projekt: LiCiVi ein Textfeld erforderlich, wo der Quellcode des grafischen Algorithmus angezeigt und einzelne Zeilen markiert werden können. Ein weiteres Textfeld zur Anzeige von Variablen und deren Werte ergänzt den Quelltext des Algorithmus um wichtige Informationen. Außerdem ist sind verschiedene Steuerelemente erforderlich, mit denen die Simulation gestartet, angehalten, neu initialisiert und im Schrittmodus ausgeführt werden kann. Für die Einstellung der Vergrößerung auf der Zeichenfläche, sowie das Festlegen der Simulationsgeschwindigkeit werden zwei weitere Steuerelemente benötigt. Die grafische Benutzeroberfläche sollte so programmiert sein, daß sie auf jedem System angezeigt werden kann - systemspezifische Programmierungen sind zu vermeiden. Alle Anforderungen an die grafische Benutzeroberfläche sind nachfolgend noch einmal zusammengefaßt: Übersichtliche Gestaltung der Oberfläche Komponenten Zeichenfläche mit Möglichkeit der Vergrößerung des Inhalts Textfeld zur Anzeige des Quellcodes mit Markierungsmöglichkeit einer Zeile Textfeld zur Anzeige von Variablen des Algorithmus und deren Inhalt Schaltknöpfe "Start" zum Starten der Simulation "Schritt" zum Ausführen im Schrittmodus "Schnell" zum sofortigen zeichnen des Grafikobjekts "Neu" zur Neuinitialisierung der Simulation Schiebeleisten "Zoom" zur Einstellung der Vergrößerung auf der Zeichenfläche "Ablauf" zur Steuerung der Ablaufgeschwindigkeit der Simulation Systemunabhängige Programmierung 3.1.3 Programmierrichtlinien Die im Anhang beigefügten Programmierrichtlinien stammen aus der Vorlesung "Programmieren in C" von Herrn Prof. Dr. Groß, und sind für das Projekt allgemein gültig, sofern die Regeln mit der Objektorientierung von JAVA vereinbar sind. LiCiVi sollte unbedingt so entwickelt werden, daß es leicht durch neue Zeichenalgorithmen erweiterbar ist. 3.2 Detailorganisation Innerhalb der Detailorganisation sollen die Anforderungen an LiCiVi präzisiert werden. Dazu gehören sog. Szenarien, die einzelne Problemstellungen aufgreifen, um diese genauer erläutern und Maskenentwürfe für die Gestaltung der grafischen Oberfläche. Seite 10 Systemprogrammierung 3.2.1 Projekt: LiCiVi Aufstellung der Szenarien 3.2.1.1 Szenario "LiCiVi wird aufgerufen" Nachdem der Benutzer eine LiCiVi-HTML-Seite mit einem bestimmten Algorithmus ausgewählt hat, erscheint auf der Seite nach einem erklärenden Text ein Knopf mit der Aufschrift "Simulation...". Betätigt der Benutzer diesen Knopf, öffnet sich ein einzelnes Fenster, welches die Benutzeroberfläche für LiCiVi bereitstellt. Hier kann der Benutzer den gewählten Algorithmus studieren. 3.2.1.2 Szenario "Algorithmus wird gestartet" Auf der grafischen Benutzeroberfläche befinden sich mehrere Schaltknöpfe. Betätigt der Benutzer den Knopf "Start", wird die Ausführung des Algorithmus gestartet. Der Benutzer kann dabei genau beobachten, wie die einzelnen Punkte auf einem Zeichenbereich des Fensters gesetzt werden. Außerdem kann er zu jeder Zeit die aktuellen Variablenwerte des Algorithmus einsehen und die Position der aktuellen Anweisung innerhalb des Algorithmus erkennen. 3.2.1.3 Szenario "Algorithmus wird im Schrittmodus ausgeführt" Betätigt der Benutzer den Schaltknopf "Schritt" (dabei ist es gleich, ob der Algorithmus bereits nach 3.2.2 gestartet wurde), wird der grafische Algorithmus bei der nächsten Anweisung angehalten. Die Anzeige der aktuellen Position sowie der Variablen bleiben jedoch erhalten. Nach jedem erneuten betätigen des "Schritt"-Knopfes, setzt der Algorithmus seine Arbeit um eine Anweisung fort. Die entsprechenden Veränderungen können über die Zeichenfläche und der Anzeige der Variablen eingesehen werden. Der Schrittmodus wird im allgemeinen auch als "Trace" bzw. "Debug"-Modus bezeichnet. 3.2.1.4 Szenario "Algorithmus wird im Schnellmodus ausgeführt" Wenn es darum geht, lediglich das Ergebnis eines grafischen Algorithmus zu betrachten, verfügt LiCiVi über einen "Schnellmodus". Durch die Wahl des Schaltknopfes "Schnell" erscheint sofort das Ergebnis des Algorithmus auf der Zeichenfläche. Informationen über Variablenwerte bzw. Programmpositionen werden hier nicht angezeigt. 3.2.1.5 Szenario "Algorithmus wird neu initialisiert" Um den Inhalt des Zeichenfeldes zu löschen und den Algorithmus neu zu initialisieren verfügt LiCiVi über den Schaltknopf "Neu". Bei Betätigung dieses Knopfes wird die Ausführung des Algorithmus beendet, alle Variablen zurückgesetzt und die Programmposition auf die erste Zeile des grafischen Algorithmus eingestellt. Die Simulation kann danach über die Knöpfe "Start", "Schnell" oder "Schritt" neu gestartet werden. 3.2.1.6 Szenario "Vergrößerung der Zeichenfläche einstellen" Der Vergrößerungsfaktor der Zeichenfläche kann jederzeit über eine Schiebeleiste verändert werden. Zieht der Benutzer diese Schiebeleiste ganz nach links, so beträgt der Vergrößerungsfaktor "1" und das grafische Objekt innerhalb der Zeichenfläche wird in Originalgröße dargestellt (Punktgröße = 1 * 1 Pixel). Zieht der Benutzer dagegen die Schiebeleiste ganz nach rechts, wird das grafische Objekt bis zu einem Vergrößerungsfaktor von "30" dargestellt (Punktgröße = 30 * 30 Pixel). 3.2.1.7 Szenario "Ablaufgeschwindigkeit einstellen" Die Ablaufgeschwindigkeit der Simulation (Simulation wird über den Knopf "Start" ausgeführt) kann über eine weitere Schiebeleiste eingestellt werden. Wird die Schiebeleiste ganz nach links gezogen, läuft die Simulation mit minimaler Verzögerung, also maximaler Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 11 Systemprogrammierung Projekt: LiCiVi Geschwindigkeit ab. Stellt der Benutzer die Schiebeleiste ganz nach rechts, so wird der Algorithmus sehr langsam ausgeführt und der Benutzer kann den Programmablauf besser erkennen. 3.2.1.8 Szenario "Simulationsfenster verlassen" Das Simulationsfenster kann jederzeit (auch während der Ausführung des Algorithmus) geschlossen werden. Der Benutzer wählt dazu den systemspezifischen Befehl bzw. Schaltknopf auf dem Fensterrand bzw. Systemmenü aus. Bevor das Fenster geschlossen wird, wird der grafische Algorithmus angehalten und alle Variablen zurückgesetzt. 3.2.1.9 Szenario "HTML-Seite wird verlassen" Springt der Benutzer auf eine andere HTML-Seite, so werden alle Systemresourcen freigegeben, die von LiCiVi reserviert wurden. Zuvor wird jedoch das Simulationsfenster geschlossen. 3.3 Entw urf der grafischen Benutz eroberfläche Die nachfolgende Skizze stellt den groben Entwurf der grafischen Benutzeroberfläche innerhalb des Simulationsfensters exemplarisch dar. LiCiVi Algorithmus mit Zeilenmarkierer Zeichenfläche mit Möglichkeit der Vegrößerung Steuerleiste für Simulation (Buttons) Schiebeleiste zur Veränderung der Simulationsgeschw indigkeit Start Schritt Schnell Neu Ablauf (+/-) Auflistung der Variablen und deren Inhalt Schiebeleiste für die Einstellung der Vergrößerung Zoom (+/-) Logo LiCiVi-Logo Seite 12 Systemprogrammierung Projekt: LiCiVi 3.4 Interaktionsdiagramme 3.4.1 "Benutzer startet Simulation" Hauptfenster (Applet) Benutzer öffnet HTML-Seite Simulationsfenster Benutzeroberfläche Zeichenalgorithmus aktiviert Benutzer betätigt Knopf "Simulation" aktiviert aktiviert Benutzeroberfläche wird initialisiert aktiviert Benutzer startet Simulation AlgorithmusQuellcode Variablendaten SOLANGE nicht alle Punkte gezeichnet Punktdaten Variablendaten Algorithmus zeichnet Punkt ENDE SOLANGE deaktiviert Benutzer schließt Fenster Benutzer verläßt HTML-Seite deaktiviert Erklärung: Nachdem der Benutzer die Simulation gestartet hat, wird der Zeichenprozess gestartet. Wenn alle Punkte auf der Zeichenfläche ausgegeben wurden, beendet sich der Prozess selbst. Nach einer gewissen Zeit schließt der Benutzer das Fenster. Dabei wird zunächst die grafische Benutzeroberfläche und dann das Fenster selbst deaktiviert (geschlossen). Verläßt der Benutzer schließlich die HTML-Seite, wird auch das Applet geschlossen. Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 13 Systemprogrammierung 3.4.2 Projekt: LiCiVi "Benutzer startet Simulation im Schrittmodus" Hauptfenster (Applet) Benutzer öffnet HTML-Seite Simulationsfenster Benutzeroberfläche Zeichenalgorithmus aktiviert Benutzer betätigt Knopf "Simulation" aktiviert aktiviert Benutzeroberfläche wird initialisiert Benutzer startet Simulation im Schrittmodus aktiviert AlgorithmusQuellcode Variablendaten SOLANGE nicht alle Punkte gezeichnet Benutzer betätigt "Schritt"Knopf nächster Schritt Punktdaten Algorithmus zeichnet Punkt Variablendaten anhalten ENDE SOLANGE deaktiviert Benutzer schließt Fenster Benutzer verläßt HTML-Seite deaktiviert Erklärung: Nachdem der Benutzer die Simulation im Schrittmodus gestartet hat, wird der Zeichenalgorithmus aktiviert und die grafische Benutzeroberfläche wird mit allen nötigen Daten gefüllt. Betätigt der Benutzer erneut den "Schritt"-Knopf, berechnet der Zeichenprozess einen Punktwert und gibt diesen mit den aktuellen Variablendaten an die Benutzeroberfläche. Danach legt sich dieser Prozess automatisch "schlafen". Der Benutzer kann jetzt den Zeichenprozess solange "wecken", bis alle Punkte gezeichnet wurden. Danach wird der Zeichenprozess automatisch beendet. Seite 14 Systemprogrammierung Projekt: LiCiVi 4 P R OG R AM MI E R U N G LiCiVi soll mit der Programmiersprache JAVA realisiert werden. Derzeit gibt es zwei verschiedene Sprachversionen. Die Version 1.0 ist weitverbreitet und wird von jedem besseren HTML-Browser standardmäßig unterstützt. Die Version 1.1 ist aktueller und wurde durch einige Zusätze und Verbesserungen ausgestattet. Leider wird momentan diese Version von nur sehr wenigen HTML-Browsern unterstützt, jedoch ist davon auszugehen, daß alle zukünftigen Browser diese Version unterstützen werden. Aus diesem Grund soll LiCiVi für beide Versionen entwickelt werden. Dieses Kapitel soll einige Problematiken der Programmierung von LiCiVi behandeln. Außerdem werden zwei Gesamtklassen-Modelle (für JDK 1.0 und 1.1) vorgestellt, die den prinzipiellen Aufbau von LiCiVi darstellen. 4.1 Erstellung einer Zeichenfläche, die Vergrößerungen erlaubt LiCiVi benötigt zur Darstellung der grafischen Objekte eine Zeichenfläche, die es erlaubt, die Objekte bis auf Pixel-Ebene vergrößern zu können. Diese Zeichenfläche kann man auch als eine Punktmatrix interpretieren, die eine gewisse Anzahl Punkte speichern kann. Die Größe dieser Punkte, also die wirkliche Breite und Höhe in Bildpunkten, beeinflußt die Größe des zu zeichnenden Objekts. Man benötigt somit eine Klasse, die eine Matrix zur Speicherung der Punkte enthält und diese auf Befehl auf einer bestimmten Fläche ausgibt. Als Parameter kann die Größe der einzelnen quadratischen Punkte eingestellt werden. Struktur der Klasse: Punktmatrix öff entliche Variablen: keine Methoden: reset () setPixel (x, y) setPixelWidth (w idth) draw Grid () draw AllPixel () Methode "reset ()": Löscht die Matrix und somit alle Punkte von der Zeichenfläche. Methode "setPixel (x, y)": Fügt einen neuen Punkt mit seinen Koordinaten der Matrix hinzu und zeigt den Punkt mit der entsprechenden Pixelgröße an. Methode "setPixelWidth (width)": Stellt die Punktbreite auf eine bestimmte Pixel-Anzahl ein. Methode "drawGrid ()": Zeichnet ein Gitternetz. Die Breite und Höhe eines Gitterelements entspricht der Breite eines Punktes. Methode "drawAllPixel ()": Zeichnet alle Punkte auf der Zeichenfläche neu. Vorteilhaft ist die Erstellung als Subklasse der sog. "Canvas"-Klasse. Diese Klasse stellt eine leere Fläche zur Verfügung, auf die Grafikmethoden angewandt werden können. Die einzelnen Punkte mit der entsprechenden Pixelbreite können dann leicht als gleichseitige, gefüllte Rechtecke realisiert werden. Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 15 Systemprogrammierung Projekt: LiCiVi Zusatz: Doppeltes Puffern Beim schnellen Setzen von Punkten auf einem "Canvas"-Objekt treten unerwünschte Flimmereffekte auf, da das Zeichnen quasi "beobachtet" werden kann. Eine sehr effektive Eliminierung diese Flimmerns kann durch die Methode des "Doppelten Pufferns" (Double Buffering) erzielt werden. Dabei werden alle Operationen auf die Zeichenfläche zunächst außerhalb des Bildschirms durchgeführt (Offscreen). Nach Beendigung dieses Vorgangs wird dann das gesamte Objekt auf die wirkliche, am Bildschirm sichtbare, Zeichenfläche übertragen. Mit Hilfe dieser Technik lassen sich u. a. sogar flüssige Animationen erstellen. Zur Realisierung unter JAVA werden zwei weitere Objekte benötigt: Eine Instanz der Klasse Graphics zur Bereitstellung der "Offscreen"-Grafik. Eine Instanz der Klasse Image zur Aufnahme des "Onscreen"-Canvas Objekts. 4.2 Realisierung eines "Debug" -Modus für den Grafik - Algorithmus LiCiVi soll es ermöglichen, grafische Algorithmen in einem Schrittmodus auszuführen, d. h., nach jedem Betätigen eines Knopfes soll der Algorithmus eine weitere Anweisung ausführen. Diese Funktion läßt sich auf zwei verschiedene Arten realisieren. Eine Möglichkeit wäre, den Algorithmus so umzuschreiben (z. B. durch eine "switch"Anweisung), daß er bei jedem Aufruf nur eine Zeile ausführt. Die jeweilige Position ließe sich über eine Objektvariable zwischenspeichern. LiCiVi soll aber leicht durch neue Algorithmen erweiterbar sein - diese Forderung keinesfalls erfüllt. Eine bessere Lösung ergibt sich aus der Implementation einer "debug"-Funktion. Diese Art der Schrittsteuerung wird von allen handelsüblichen Debuggern für Programme verwendet. Die "debug"-Funktion wird dabei vor jede Anweisung gesetzt. Sie übernimmt die Überwachung der Variablen und wartet auf die Bestätigung des Benutzers. Diese Vorgehensweise läßt sich auch in LiCiVi umsetzen. Es ergibt sich jedoch ein Problem: Die Realisierung der Wartefunktion. Normalerweise wartet ein Debugger aktiv (Rechenleistung wird verbraucht) auf weiter Benutzereingaben, in LiCiVi kann dies aber nur durch passives Warten gelöst werden. Die Lösung ist der Einsatz eines Threads, der die Ausführung des Zeichenalgorithmus übernimmt. Dieser Thread kann zusätzlich auch für die Einstellung der Simulationsgeschwindigkeit verwendet werden. Befindet sich die Simulation im Schrittmodus wird zunächst de Algorithmus bis zur nächsten debug-Anweisung ausgeführt. Diese Funktion legt dann - nach Aktualisierung aller Variablen und Markierung der nächsten Anweisung - den Thread und damit auch sich selbst schlafen. Betätigt der Benutzer den Schritt-Knopf erneut, wird dieser Thread wieder "aufgeweckt" - er setzt seine Arbeit an der gleichen Stelle fort. Das folgende Ablaufdiagramm soll die Arbeitsweise noch einmal detailieren. Seite 16 Systemprogrammierung Projekt: LiCiVi debug-Funktion wird durch Grafik-Algorithmus mit Parameter n aufgerufen Variablen-Anzeige aktualisieren Markiere Anweisung mit Position n im Quellcodefenster nein Schrittmodus ? Thread für eine gewisse Zeit schlafen legen ja Thread schlafen legen (anhalten) Zeichenalgorithmus fotsetzen Die Debug-Funktion wird mit einem zusätzlichen Parameter n aufgerufen, der die Zeile im Quellcode-Bereich angibt, die der gerade ausgeführten Anweisung entspricht. Diese Zeilenposition wird durch die Debug-Funktion markiert. Threads können unter JAVA auf zwei verschiedene Arten erzeugt werden. Entweder durch eine selbständige Klasse, die von der Klasse Thread abgeleitet wurde, oder durch die Implementierung der "runnable"Schnittstelle. Die zweite Variante erweist sich in den meistens Fällen als die einfachere und besser überschaubarere Lösung. Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 17 Systemprogrammierung Projekt: LiCiVi 4.3 Threads unter J AV A Die Erstellung von Threads erfolgt unter JAVA sehr einfach, jedoch sind damit auch einige Probleme verbunden. Die eigentliche Realisierung der Threads wird von der "virtuellen JAVA Maschine", dem eigentlichen Interpreter, übernommen. Sie bestimmt auch das Scheduling der einzelnen Threads. Außerdem spielen dabei auch systemspezifische Merkmale eine große Rolle. Aus diesen Gründen kann nicht immer eindeutig bestimmt werden, wie Threads auf dem ein oder anderen System behandelt werden. Die Folge sind eventuell fehlerhaft laufende Programme bzw. sogar Systemabstürze. Insbesondere auf das Scheduling aufbauende Programme sind deshalb kaum plattformunabhängig realisierbar. LiCiVi benötigt keine besondere Art von Scheduling und sollte theoretisch auf jedem System lauffähig sein. Dem Anhang dieses Dokuments wurde deshalb eine Liste der gebräuchlichsten "Applet-Viewer" bzw. HTML-Browsern angefügt, die mit LiCiVi getestet wurden. 4.4 Gesamtklassenmodelle für API 1.0 und API 1.1 JAVA wurde für zwei verschiedene JAVA-Versionen (APIs) entwickelt. Um den prinzipiellen Aufbau von LiCiVi darzustellen sind Klassenmodelle erforderlich. Sie eignen sich zur Planung der Programmierung und zur späteren Orientierung. In größeren Projekten sind dazu unbedingt Schnittstellenbeschreibungen erforderlich, insbesondere wenn die Programmierarbeit auf mehrere Personen aufgeteilt werden soll. Unterschiede zwischen API 1.0 und API 1.1 in Bezug auf LiCiVi Die größten Unterschiede zwischen API 1.0 und API 1.1 liegen in der Ereignisverwaltung. Bei der API 1.0 werden grundsätzlich alle Steuerelemente, egal welcher Art, in die Ereignisverwaltung aufgenommen. Dies hat den Nachteil, daß nicht benötigte Steuerelemente trotzdem abgefragt werden - dadurch wird Rechenleistung verschwendet. Ein weiterer Nachteil ist die Abfrage der einzelnen Ereignistypen - diese müssen mühsam über switch bzw. if-then Abfragen ermittelt werden. Der Grund liegt darin, daß alle Ereignisse Instanzen der Event-Klasse sind, und diese über Identifikations-Nummern abgefragt werden müssen. Der dritte Nachteil liegt in der Vererbbarkeit. So lassen sich keine globalen EreignisverwaltungsKlassen definieren, die Folge ist eine Zergliederung der Ereignisverwaltung. Das Gesamtklassenmodell von LiCiVi, API 1.1 besitzt deshalb eine eigene Klasse, die alle Ereignisse verwaltet und entsprechende Aktionen einleitet. Bei API 1.1 werden alle Steuerelemente explizit der Ereignisverwaltung gemeldet. Die einzelnen Ereignistypen können dann über separate Methoden global abgefragt werden. Diese Vorgehensweise ist sehr übersichtlich und damit leicht erweiterbar. Die globale Ereignisverwaltungsklasse wird auch als "Listener" bezeichnet. Die JAVA API 1.1 wurde ferner durch neue Steuerelemente und Bibliotheken ergänzt. Diese sollen hier aber nicht weiter aufgeführt sein, da LiCiVi diese besonderen Merkmale nicht nutzt. Seite 18 Systemprogrammierung Projekt: LiCiVi LiCiVi_Parameter LiCiVi_Fenster Punktmatrix LiCiVi LiCiVi_GUI Graf ikObjekt LinieBresenham LinieDirekt LinieDirektFU HorizontaleLinie VertikaleLinie KreisBresenham KreisParameter KreisStandard Legende: Klasse Klasse Klasse mit Steuerungsfunktion VererbungsBeziehung AggregationsBeziehung Abstrakte Klasse NachrichtenBeziehung BenutzerSchnittstelle Fachhochschule Fulda, Fachbereich AI, Michael Jahn LiCiVi Line - Circle - Visualizer Gesamtklassenmodell API 1.0 Seite 19 Systemprogrammierung Projekt: LiCiVi LiCiVi_Parameter LiCiVi_EventHandler Punktmatrix LiCiVi_Fenster LiCiVi LiCiVi_GUI Graf ikObjekt LinieBresenham LinieDirekt LinieDirektFU HorizontaleLinie VertikaleLinie KreisBresenham KreisParameter KreisStandard Legende: Klasse Klasse Seite 20 Klasse mit Steuerungsfunktion VererbungsBeziehung AggregationsBeziehung Abstrakte Klasse NachrichtenBeziehung BenutzerSchnittstelle LiCiVi Line - Circle - Visualizer Gesamtklassenmodell API 1.1 Systemprogrammierung Projekt: LiCiVi 5 E R WE I TE R B AR K E I T V ON L I C I V I LiCiVi wurde so entwickelt, daß sehr leicht neue grafische Algorithmen implementiert werden können. Die notwendigen Implementierungsschritte und Vorgehensweisen sollen in diesem Kapitel erläutert werden. 5.1 Implementierung eines neuen grafischen Al gorithmus Zunächst muß der eigentliche grafische Algorithmus erstellt werden. Dazu wird eine neue Klasse erstellt, die von der Klasse GrafikObjekt erbt. Diese Klasse enthält bereits alle wichtigen Komponenten zum Starten, Stoppen und Rücksetzen des Algorithmus. Die neue Klasse muß deswegen nur noch Algorithmus-spezifische Variablen und Methoden enthalten: 1. 2. 3. 4. 5. 6. Einen Konstruktor Variablen für den grafischen Algorithmus Ein Feld mit Namen String[] ProgrammListing - beinhaltet alle Zeilen des Quellcodes Die Methode void zeichnen () - sie enthält den eigentlichen Algorithmus Die Methode void reset () - sie setzt alle notwendigen Variablen des Algorithmus zurück Die Methode String GetVarAusgabe () - gibt eine Zeichenkette mit den aktuellen Variableninhalten des Algorithmus zurück. Als Orientierungshilfe soll das folgende Beispiel dienen: (Konstruktor) public class LinieHorizontal extends GrafikObjekt { int int int int int x1; y1; x2; x; xend; /* Linien-Koordinaten */ /* aktuelle x-Position /* letzte x-Position */ */ (Variablen) (Quellcode) public String[] ProgrammListing = { "if (x1 < x2)", "{", " x = x1;", " xend = x2;", "}", "ELSE", "{", " x = x2;", " xend = x1;", "};", ... }; public LinieHorizontal (LiCiVi_GUI Gui, int x1, int y1, int x2) { this.Gui = Gui; this.x1 = x1; this.y1 = y1; this.x2 = x2; Verzoegerung = Gui.GetVerzoegerung (); Gui.SetProgCode (ProgrammListing); } Seite 21 (Konstruktor) Systemprogrammierung Projekt: LiCiVi Hinweis: Der Parameter vom Typ LiCiVi_GUI wird für die Grafikausgabe benötigt und muß immer vorhanden sein! public void reset_vars () { x = 0; xend = 0; } (Variablen rücksetzen) String GetVarAusgabe () { String Text; (Variablen ausgeben) Text = "x1: " + x1 + "\n" + "y1: "x2: " + x2 + "\n" + "x: "xend: " + xend; return (Text); " + y1 + "\n" + " + x + "\n" + } public void zeichnen () { debug (0); if (x1 < x2) { debug (2); x = x1; debug (3); xend = x2; } else ... } (Zeichenalgorithmus) Hinweis: Die debug-Funktion hält den Algorithmus an diesen Stellen an, aktualisiert Ausgaben und setzt das Programm fort. Der Parameter gibt die Zeile innerhalb des Feldes ProgrammListing an, die markiert werden soll. 5.2 Erw eiterung der Parameterausw e rtung Um den oben erwähnten Algorithmus auch auswählen zu können ist, eine entsprechende Ergänzung in der Klasse LiCiVi_Parameter vorzunehmen. Dort befindet sich ein Feld mit der folgenden Struktur: String[] AlgNamen = { "LinieHorizontal", "LinieVertikal", "LinieDirekt", "LinieDirektFU", "LinieBresenham", "KreisStandard", "KreisParameter", "KreisBresenham" }; Der Name des neuen grafischen Algorithmus muß in dieses Feld eingefügt werden. Damit kann der Parameter ausgewertet werden. Seite 22 Systemprogrammierung Projekt: LiCiVi 5.3 Au frufen des neuen Algorithmus Der eigentliche Algorithmus wird in der Hauptklasse LiCiVi instanziert. Die in Kapitel 5.2 genannte Klasse LiCiVi_Paramter wertet die Parameter des Applets aus und gibt diese an die Hauptklasse zurück. Die Nummer des ausgewählten Algorithmus entspricht exakt der Position des Algorithmusnamens im genannten Feld (beginnend bei 0). Die Hauptklasse entscheidet dann über eine switch-Anweisung, welcher Algorithmus auszuwählen ist. Diese Aufgabe übernimmt die Methode void setGrafObj (). private void setGrafObj () { /* Algorithmustyp bestimmen (analog Definition in Klasse * LiCiVi_Parameter switch (Param.alg) { case 0: /* Horizontale Linie this.GrafObj = new LinieHorizontal (Gui Param.x1, Param.y1, Param.x2); Fenstername = "LiCiVi - Linie (horizontal)"; break; case 1: /* Vertikale Linie */ */ */ ... Für weitere Algorithmen können entsprechende Aufrufe in die Abfrage eingefügt werden. Die Variable Fenstername gibt dabei den Namen des Fensters an, das die grafische Benutzeroberfläche enthält. Fachhochschule Fulda, Fachbereich AI, Michael Jahn Seite 23 Systemprogrammierung 6 A N H AN G Seite 25 Projekt: LiCiVi Systemprogrammierung Projekt: LiCiVi 6.1 LiCiVi -Parametereinstellunge n LiCiVi kann über Parameter, die innerhalb der HTML-Seite angegeben werden, konfiguriert werden. Die möglichen Parameter sind in diesem Abschnitt aufgeführt. Sollten Parameterwerte ungültig sein, werden entsprechende Fehlermeldungen ausgegeben und Standardwerte verwendet. Bei fremden bzw. falschen Parametern erfolgt keine Fehlermeldung! Mögliche Parameter und deren Verwendung Parametername Algorithmus X Y R x1 x2 y1 y2 Bg Fg Plot_fg Plot_bg GridColor LogoPicture Standardwert LinieHorizontal 10 10 10 0 10 0 20 darkCyan black red white lightGray keine Standardeinstellung Mögliche Werte siehe Tabelle für Algorithmen 0..200 (ganzzahlig) 0..200 (ganzzahlig) 0..200 (ganzzahlig) 0..200 (ganzzahlig) 0..200 (ganzzahlig) 0..200 (ganzzahlig) 0..200 (ganzzahlig) siehe Farbtabelle siehe Farbtabelle siehe Farbtabelle siehe Farbtabelle siehe Farbtabelle Dateiname des Bildes Verwendung Auswahl des grafischen Algorithmus Koordinate x für Kreise Koordinate y für Kreise Koordinate r für Kreise Koordinate x1 für Linien Koordinate x2 für Linien Koordinate y1 für Linien Koordinate y2 für Linien Hintergrundfarbe Fenster Schriftfarbe für Fenster Zeichenfarbe für Algorithmus Hintergrundfarbe Zeichenfläche Farbe für Gitternetz Einfügen eines Logo's Algorithmen Parameterwert LinieHorizontal LinieVertikal LinieDirekt LinieDirektFU LinieBresenham KreisStandard KreisParameter KreisBresenham Bedeutung Algorithmus für horizontale Linien Algorithmus für vertikale Linien Algorithmus für Linien, direkte Methode Algorithmus für Linien, direkte Methode mit Fallunterscheidung Algorithmus für Linien, Bresenham Algorithmus für Kreise, Standardform Algorithmus für Kreise, Parameterform Algorithmus für Kreise, Bresenham Farben Parameterwert blue cyan darkGray gray green lightGray magenta Seite 27 Farbe blau cyan dunkel grau grau grün hell grau magenta Systemprogrammierung orange pink red white yellow black darkBlue darkCyan darkGreen Projekt: LiCiVi orange pink rot weiß gelb schwarz dunkel blau dunkel cyan dunkel grün Beispiel für die Konfiguration von LiCiVi über die Parameterliste eines Applets: <HTML> <HEAD> <TITLE>LiCiVi</TITLE> </HEAD> <BODY> <APPLET CODE="LiCiVi.class" <PARAM NAME="Algorithmus" <PARAM NAME="GridColor" <PARAM NAME="bg" <PARAM NAME="fg" <PARAM NAME="LogoPicture" </APPLET> </BODY> </HTML> Seite 28 HEIGHT=40 WIDTH=100 NAME="LiCiVi"> VALUE="KreisBresenham"> VALUE="lightGray"> VALUE="darkBlue"> VALUE="white"> VALUE="LiCiVi.gif"> Systemprogrammierung 6.2 LiCiVi -HTML -Seiten Seite 29 Projekt: LiCiVi Systemprogrammierung Projekt: LiCiVi 6.3 Programmdokumentation ( API 1.0) 6.3.1 Klassenbeschreibung Das Programm besteht aus insgesamt 15 Klassen. Die genauen Funktionen der einzelnen Klassen und deren Methoden können im Quellcode des Programmes eingesehen werden. Die folgende kurze tabellarische Auflistung soll einen Gesamtüberblick verschaffen: Klasse GrafikObjekt KreisBresenham KreisParam KreisWurzel LiCiVi LiCiVi_Fenster LiCiVi_GUI LiCiVi_Parameter LinieBresenham LinieDirekt LinieDirektFU LinieHorizontal LinieVertikal Logo Punktmatrix 6.3.2 Funktion Abstrakte Klasse für grafische Algorithmen Kreisalgorithmus nach Bresenham Kreisalgorithmus in Parameterform Kreisalgorithmus in Standardform (Wurzel) Hauptklasse (Hauptprogramm), Ereignisverwaltung Implementierung eines Fensters mit Farbeinstellung, Ereignisverwaltung Implementierung einer grafischen Benutzeroberfläche Parameterauswertung von HTML-Seite Linienalgorithmus nach Bresenham Linienalgorithmus nach direkter Methode Linienalgorithmus nach direkter Methode, Fallunterscheidung Horizontale Linie Vertikale Linie Komponente zur Darstellung eines Bildes Komponente zur Darstellung einer Punktmatrix mit Vergrößerungsmöglichkeit Übersetzung des Programmes Das Programm ist bereits in Bytecode übersetzt worden und sollte unter jeder JAVA-fähigen Umgebung laufen. Das Quellprogramm kann aber mit der folgenden Anweisung erneut übersetzt werden: javac *.java Außerdem ist ein "Makefile" dem Verzeichnis beigefügt worden. Seite 31 Systemprogrammierung Projekt: LiCiVi 6.4 Programmdokumentation ( API 1.1) 6.4.1 Klassenbeschreibung Das Programm besteht aus insgesamt 16 Klassen. Die genauen Funktionen der einzelnen Klassen und deren Methoden können im Quellcode des Programmes eingesehen werden. Die folgende kurze tabellarische Auflistung soll einen Gesamtüberblick verschaffen: Klasse GrafikObjekt KreisBresenham KreisParam KreisWurzel LiCiVi LiCiVi_EventHandler LiCiVi_Fenster LiCiVi_GUI LiCiVi_Parameter LinieBresenham LinieDirekt LinieDirektFU LinieHorizontal LinieVertikal Logo Punktmatrix 6.4.2 Funktion Abstrakte Klasse für grafische Algorithmen Kreisalgorithmus nach Bresenham Kreisalgorithmus in Parameterform Kreisalgorithmus in Standardform (Wurzel) Hauptklasse (Hauptprogramm) Ereignisverwaltung Implementierung eines Fensters mit Farbeinstellung Implementierung einer grafischen Benutzeroberfläche Parameterauswertung von HTML-Seite Linienalgorithmus nach Bresenham Linienalgorithmus nach direkter Methode Linienalgorithmus nach direkter Methode, Fallunterscheidung Horizontale Linie Vertikale Linie Komponente zur Darstellung eines Bildes Komponente zur Darstellung einer Punktmatrix mit Vergrößerungsmöglichkeit Übersetzung des Programmes Das Programm ist bereits in Bytecode übersetzt worden und sollte unter jeder JAVA-fähigen Umgebung laufen. Das Quellprogramm kann aber mit der folgenden Anweisung erneut übersetzt werden: javac *.java Außerdem ist ein "Makefile" dem Verzeichnis beigefügt worden. Seite 33 Systemprogrammierung Seite 35 Projekt: LiCiVi Systemprogrammierung Projekt: LiCiVi 6.5 LiCiVi und HTML -Brow ser, Applet -View er Die nachfolgende Tabelle zeigt eine Übersicht aller Browser bzw. Applet-Viewer, die mit LiCiVi getestet wurden. JAVA Laufzeitumgebungen Microsoft Internet Explorer 4.0 Microsoft Internet Explorer 3.0 Netscape Navigator 4.0 JAVA Workshop Browser 1.0 JAVA Workshop Browser 1.0 Appletviewer JDK 1.1 Appletviewer JDK 1.1 Appletviewer JDK 1.0 Netscape Navigator 3.0 Seite 37 Plattform, Betriebssystem Intel Pentium, Windows 95 Intel Pentium, Windows 95 Intel Pentium, Windows 95 Intel Pentium, Windows 95 Sun Sparc, Solaris Intel Pentium, Windows 95 Intel Pentium, Linux 5.0 Sun Sparc, Solaris Sun Sparc, Solaris Status o.k. o.k. o.k. o.k. o.k. o.k. o.k. o.k. Schrittmodus funktioniert nicht Systemprogrammierung 6.6 Programmierrichtlinien Seite 39 Projekt: LiCiVi Systemprogrammierung 6.7 Entw icklungsumgebung LiCiVi wurde unter der folgenden Systemumgebung entwickelt: Hardware: Intel Pentium Rechner, 100MHz, 48 MB Arbeitsspeicher Grafikauflösung 1280 x 1024, Farbtiefe 8 bit Betriebssystem: Windows 95 Programmeditor: Microsoft J++, Version 1.1 Compiler: SUN Java Development Kit 1.1 Seite 41 Projekt: LiCiVi Systemprogrammierung 6.8 Literaturliste Computer-Grafik Fellner, Wolf-Dietrich: BI-Wissenschaftsverlag JAVA 1.1 in 21 Tagen Laura Lemay, Charles L. Perkins SAMS JAVA in a nutshell: a desktop quick reference Flanagan, David JAVA jetzt! Stephen R. Davis Microsoft Press Teilskriptum Graphische Datenverarbeitung, März 1994 Prof. Dr. Werner Heinzel Fachhochschule Fulda Skriptum Programmieren in C Prof. Dr. Siegmar Groß Fachhochschule Fulda Skriptum Praxis der Systemprogrammierung Prof. Dr. Werner Heinzel Fachhochschule Fulda Skriptum Systemprogrammierung, Teilbereich Parallele Prozesse Prof. Dr. Siegmar Groß Fachhochschule Fulda Skriptum Systemprogrammierung, Teilbereich Graphische Systeme Prof. Dr. Siegmar Groß Fachhochschule Fulda Skriptum Software Engineering, Entwurfsverfahren Prof. Dr. Wolfgang Ehrenberger Fachhochschule Fulda Seite 43 Projekt: LiCiVi Systemprogrammierung 6.9 GNU General Public License Seite 45 Projekt: LiCiVi
