JadeIDE (Integrierte Entwicklungsumgebung für JavaTM) ist ein Produkt von "Wolfgang Kurz, Im Asemwald 2/18, D-70599 Stuttgart".
( Anmerkung: Java ist ein eingetragenes Warenzeichen der SUN Corporation. )
Um den Autor zu kontaktieren, senden Sie bitte eine E-Mail an info@wkurz.com
.
Informationen über weitere Produkte des Autors finden Sie auf seiner Homepage, der "Homesite of Jade". Sie erreichen diese Seite (sofern Sie mit dem Internet verbunden sind) durch anklicken des "Jade Icons"
oder über den Hyperlink http://wkurz.com.
Hier finden Sie auch immer die neueste Version von JadeIDE.
Das Jade Integrated Development Environment ist eine unkomplizierte aber mächtige Entwicklungsumgebung für Java. Sie erlaubt einem Programmierer, der mit einem JDK (Java Development Kit z.B. von SUN Microsystems) arbeitet, ohne jedesmal die betriebssystemabhängigen Befehlszeilenaufrufe der dort angebotenen Entwicklungswerkzeuge verwendeten zu müssen, Java Quellencode
zu editieren sowie Java Klassen umzuwandeln. Auch der Testaufruf eines Java Programmes oder Java Applets ist unterstützt, und zwar mittels der Java Klasse, die die "main()" bzw. "init()" Methode enthält. Dies schließt die Übergabe der erforderlichen Ausführungsparameter an die "main()" Methode der Anwendung bzw. die "init()" Methode des Applets mit ein.
JadeIDE stellt eine Schicht über das SUN JDK bereit, die die Benutzung dieses Toolkits erleichtert. JadeIDE enthält auch einen eigenen, auf Java-Kodierung optimierten Editor, unterstützt daneben aber auch die Verwendung beliebiger unabhängiger Editoren. JadeIDE überlässt also jedem Programmierer die Wahl seines bevorzugten Editors oder seiner bevorzugten Editoren.
(Anmerkung: Der unabhängige Editor mit dem JadeIDE am intensivsten getestet wurde ist "Programmer's File Editor" von Alan Phillips. Siehe auch unter Installation).
Obwohl manche Editoren auch den Aufruf von anderen Programmen (z.B eines Compilers) zulassen, ist die Projektarbeit mit JadeIDE in der Regel flexibler und effizienter, da der Jade Editor alle mit ihm geöffneten Dateien sichert, bevor eine Umwandlung aus dem Editor heraus gestartet wird, da sehr leicht zwischen verschieden externen Editoren umgeschaltet werden kann, da durch JadeIDE nur relevante Dateien eines Projektes zur Bearbeitung angeboten werden, da zusätzlich Codegenerierungen sowie elementares Debugging möglich sind und da in mehreren "Threads" parallel gearbeitet werden kann.
Die folgenden Funktionen werden durch JadeIDE bereitgestellt:
Alle von JadeIDE angebotenen Aktionen werden über die Menüs des JadeIDE Hauptfensters gesteuert.
Informationen, die für die durchzuführenden Aktionen interessant und wichtig sind, werden in diesem JadeIDE Hauptfensters präsentiert. Dabei zeigt der Fenstertitel den Namen des aktuellen Projektes. In der Fensterfläche befindet sich das übergeordnete Nachrichtenfeld, die Anzeige der zuletzt ausgewählten (der aktuellen) Datei sowie Schaltflächen zum Aufruf des Editors und des Compilers. Diese Schaltflächen sind notwendig, wenn nicht mit dem Jade Editor, sondern mit einem externen Editor gearbeitet werden soll.
Das JadeIDE Hauptfenster wird im oberen Teil des Bildschirmes ausgegeben (kann aber verschoben werden) und ist nur 80 Pixel tief, so dass genügend Raum für andere Fenster übrigbleibt (z.B. die Editiorfenster) und damit eine angenehme Projektarbeit gewährleistet ist.
Die wichtigen Werkzeuge des "SUN Development Toolkits" haben für den Aufruf alle relativ komplizierte ASCII Befehle ("command line interface"), jedoch keine bequeme graphische Benutzerschnittstelle. Ohne die Unterstützung einer Entwicklungsoberfläche muss ein Programmierer während der Entwicklungstätigkeit also sehr viel Informationen bereit haben, immer wieder Befehle modifizieren und diese über das "DOS Fenster" eintippen. Dies ist sehr umständlich, zeitaufwendig und vor allem fehleranfällig.
Um die Programmierarbeit effizienter zu gestalten, stellt JadeIDE eine graphische Benutzerschnittstelle bereit, die es erlaubt, die erforderlichen Befehle in der an die spezielle Installation angepassten Form abzuspeichern und immer wieder abzurufen.
Da viele Entwickler sehr häufig mehrere unterschiedliche Text-Editoren, Web-Browser und HTML-Editoren gleichzeitig verwenden, erlaubt JadeIDE die Speicherung der Aufrufe all dieser verschiedenen Werkzeuge als Basisparameter.
Für jede Entwicklungssitzung kann dann der bevorzugte Befehl für die Verwendung aktiviert werden.
Da für ein Entwicklungsprojekt in der Regel immer der gleiche Satz an Befehlen Verwendung findet, werden die für ein Projekt am besten geeigneten Parameter als Gruppe unter einem Prokjektnamen abgespeichert und dann als Gesamtheit auf einmal aktiviert, wenn ein Projekt geöffnet wird.
Da Befehle eigentlich immer aus einem gleichbleibenden Teil und einem zu modifizierenden Teil zusammengesetzt sind, speichert JadeIDE die Befehle nicht in der endgültigen Form, so wie sie ins DOS Fenster eingetippt werden müssten, sondern JadeIDE speichert sogenannte Befehlsschablonen. Diese Befehlsschablonen repräsentieren den beständigen Teil eines Befehles. Eine Schablone muss dann vor der Befehlsausführung mit den variablen Teilen (z.B. Dateinamen, Pfaden, usw.) ergänzt werden. Den fehlerfreien Zusammenbau der endgültigen Befehle übernimmt JadeIDE für die einzelnen durchzuführenden Aktionen.
Die "Setup" Dialoge zur Festlegung der JadeIDE Parameter
Die für die Entwicklungsarbeit mit JadeIDE erforderlichen Parameter kann man in zwei Gruppen gliedern. Die erste Gruppe ist die Gruppe der Basisparameter, das sind die Parameter, die bei jeder Programmentwicklung notwendig sind. Die zweite Gruppe sind die Projektparameter, also Parameter, die für ein bestimmtes Programmierprojekt spezifisch sind.
Basisparameter sind:
BC_BRWS - Schablone für den Aufruf eines Web-Browsers um damit die JadeIDE Hilfe, die Java API Dokumentation und eventuell die mit Javadoc erstellte Projektdokumentation anzuzeigen.
Beispiel: C:\Programme\Netscape\Netscp.exe
BC_EDIT - Schablone für den Aufruf eines externen Editors um damit eine bestehende Java Quellencode-Datei zu editieren. Der JadeIDE eigene Editor braucht nicht definiert zu werden, kann aber als "JadeEdit" spezifiziert werden, sofern der automatisch generierte Eintrag entfernt wurde.
Beispiel: C:\Programme\PFE\PFE32.EXE (bzw. JadeEdit)
BC_HTML - Schablone für den Aufruf eines speziellen HTML Editors um damit HTML Dateien (z.B. für den Aplet-Aufruf oder für die Projektdokumentation) zu editieren.
Beispiel: C:\Programme\HTMLFormat\HFwin.exe
Anmerkung: HTML Dateien können natürlich auch mit dem Jade Editor bearbeitet werden, der Aufruf muss dann allerdings über das "Edit" Icon im Hauptfenster erfolgen und der Jade Editor muss im BC_Edit Parameter spezifiziert sein.
BC_XML - Schablone für den Aufruf eines speziellen XML Editors um damit XML Dateien (z.B. für die Projektdokumentation) zu editieren.
Beispiel: C:\Programme\XMLEdit\XMLEdit.exe
Anmerkung: XML Dateien können natürlich auch mit dem Jade Editor bearbeitet werden, der Aufruf muss dann allerdings über das "Edit" Icon im Hauptfenster erfolgen und der Jade Editor muss im BC_Edit Parameter spezifiziert sein.
BC_JCK - Schablone für den Aufruf des Code-Checkers JiveLint von Sureshot um damit Java Code Dateien auf bestimmte Kodierungsfehler und Schwachstellen zu untersuchen.
Beispiel: C:\Programme\JiveLint\jivelint.exe
BC_JDK - Schablone (Top-level Ordner des JDK) für die Generierung der Aufrufe der einzelnen SUN JDK Werkzeuge (Compiler, Launcher, AppletViewer, JavaDoc, ...).
Beispiel: C:\Programme\J2SDK1.4.0\
Die Projektparameter sind:
BC_COMP - Schablone für den Java Compiler Aufruf
Beispiel: D:\J2SDK1.4.0\BIN\JAVAC.EXE -classpath
Dieser Parameter wird von JadeIDE aus dem für das Projekt vorgegeben Java Development Kit (siehe Basisparameter BC_JDK) abgeleitet.
BC_RUN - Schablone für den Aufruf des Java Application Launchers
Beispiel: D:\J2SDK1.4.0\BIN\JAVA.EXE -classpath
Dieser Parameter wird von JadeIDE aus dem für das Projekt vorgegeben Java Development Kit (siehe Basisparameter BC_JDK) abgeleitet.
BC_AVIEW - Schablone für den Aufruf des Java Applet Viewers
Beispiel: D:\J2SDK1.4.0\BIN\APPLETVIEWER.EXE
Dieser Parameter wird von JadeIDE aus dem für das Projekt vorgegeben Java Development Kit (siehe Basisparameter BC_JDK) abgeleitet.
ClassPath - Der "Class Path" der vom "Java Compiler" und vom "Java Application Launcher" verwendet werden soll.
Der "Class Path" wird normalerweise automatisch ermittelt, so dass in der Regel nur die Komponente angegeben werden muss, in der sich die Projektpakete befinden. Weiter können erforderliche Java Bibliotheken (als .ZIP oder .JAR Dateien) in den ClassPath aufgenommen werden.
Beispiel: D:\WORK\JAVA oder D:\WORK\JAVA;D:\WORK\LIB\privlib.zip;D:\WORK\LIB\prjlib.jar;
ProjPack - Der Paketname eines Projektes (Hinweis: dieser Name dient als Projektname!)
Beispiel: com.kur.ide
ProjPath - Der Pfad, der zu den Dateien eines Projektes führt (ohne Paket Angabe!)
Beispiel: E:\WORK\JAVA\
MainClass - Die Klasse eines Anwendungsystemes die die "main()" Methode enthält
Der "MainClass" Eintrag kann um die Parameter erweitert werden, die die "main()" Methode beim Aufruf erwartet. Achtung: auf Groß/Kleinschreibung achten. Java Klassennamen sind "case sensitive"!
Beispiel: Control LANG=D
ANMERKUNG: Die "Vorsilbe BC" im Parameternamen bedeutet "Basis Componente". BC Parameter sind also der konstante Teil eines Befehles. Dieser Teil muss (wie bereits erwähnt) durch JadeIDE noch um einen variablen Teil (z.B. den Klassennamen) erweitert werden, um den Befehl ausführbar zu machen.
Da die Befehlsschablonen nicht in jeder Installation gleich sind (z.B. ist das Sun JDK nicht immer auf demselben Laufwerk gespeichert und die Editoren, die zur Verfügung stehen, sind unterschiedlich), kann JadeIDE diese Schablonen nicht vorgeben. Sie müssen vom Benutzer von JadeIDE zuerst entsprechend den Erfordernissen der vorliegenden Installation definiert werden. Dazu stellt JadeIDE die nachfolgend beschriebenen "Setup" Dialoge zur Verfügung.
Bevor mit JadeIDE gearbeitet werden kann, muss als allererste Aktion nach der Produktinstallation mindestens ein Wert für jeden Basisparameter über diesen Dialog festgelegt und zum Defaultwert gemacht werden.
Der Dialog zur Definition der Basisparameter-Schablonen
Der Dialog zur Festlegung der Basisparameter erlaubt die Definition beliebig vieler Werte (Parameterschablonen) für jeden der 6 Basisparameter Typen "Browser", "Externe Editoren", "HTML Editoren", "Code Checker", "Java Dev. Kit" und "Java Dokumentation".
Im Dialogfenster werden in Auswahllisten alle bereits gegebenen Werte aufgeführt. Über entsprechende Schaltflächen (Buttons) können dann weitere Werte hinzugefügt werden, einzelne Werte entfernt werden, ein bestimmter Wert als Standardwert festgelegt werden oder ein bestimmter Wert verändert werden.
Der Dialog zur Definition der Parameterschablonen wird im JadeIDE Hauptfensters über das Menü "Datei" und den Menüpunkt "Basisparameter verwalten" aufgerufen.
Die allgemeine Schaltfläche "Hier starten" sollten Sie als erste Setup Aktion anklicken.
Sie führt zuerst eine Suche nach den installierten Java Development Kits und Web-Browsern durch (gesucht wird dabei nach den Dateien "iexplore.exe", "netscape.exe", "netscp6.exe", "netscp.exe", "opera.exe", "mozilla.exe" und "konquerer"). Dann wird eine Nachricht angezeigt, die daran erinnert soll, dass als nächste "Setup" Aktionen ein Wert für jeden Parametertyp definiert und zum "Default Wert" gemacht werden muss.
Hinweis: In manchen Installationen gibt es Dateien mit den angegebenen Namen in verschiedenen Verzeichnissen. Das Suchprogramm hat kein Kriterium zur Erkennung einer wirklichen Browser-Startdatei. Es empfiehlt sich daher dringend, solch ungültige Einträge aus der Liste der verfügbaren Web-Browser zu löschen. Sie sollten aber auf keinen Fall zum Default-Wert gemacht werden.
Achten Sie auch darauf, dass manche Browser unter Windows ohne aktivierten "Quickstarter" nicht sofort starten, wenn sie als Unterprozess ausgeführt werden sollen (z.B. Opera 6 und Netscape 6.2). Diese Browser müssen zuerst ausserhalb von JadeIDE gestartet werden.
Mittels des Dialoges können nun folgende Aktionen durchgeführt werden:
Anlegen eines neuen Wertes: Um einen neuen Basisparameter anzulegen (und zwar unabhängig von Typ) sollte zuerst überprüft werden, ob der zu definierende Wert nicht bereits in der Auswahlliste enthalten ist. Ist dies nicht der Fall, dann wird über die dem Parameter-Typ zugeordnete Schaltfläche "Hinzufügen" der systemspezifische Dateisuchdialog aufgerufen, über den die gewünschte ".exe" Datei gesucht werden kann. Wird im Dateisuchdialog eine Datei ausgewählt und der Dialog ordnungsgemäß geschlossen, dann wird der ausgewählte Wert in die Liste der bestehenden Werte des entsprechenden Basisparameters übernommen.
Suchen der installierten Java Development Kits: Eine Besonderheit besteht bei der Spezifikation der verfügbaren Java Development Kits. Die Schaltfläche "Suchen" durchsucht alle Verzeichnisse eines Rechners nach dem Programm "appletviewer.exe". Wird dieses Programm in einem "/bin" Unterverzeichnis gefunden, dann wird daraus abgeleitet, dass es sich um eine Java Development Kit Installation handelt, die dann automatisch in die Auswahlliste übernommen wird, wenn sie noch nicht eingetragen ist.
Hinweis: Je nach Größe des belegten Plattenspeichers und des verwendeten Prozessors kann diese Suche einige Zeit dauern.
Entfernen eines bestehenden Wertes: Zum entfernen eines bestehenden Wertes ist der zu löschende Wert in der Auswahlliste des entsprechenden Basisparameter-Typs zu markieren (aufblättern der Liste über deren rechte Expandier-Schaltfläche und anklicken des gewünschten Wertes). Der markierte Wert wird hervorgehoben. Durch Betätigung der dem Parameter-Typ zugeordneten Schaltfläche "Entfernen" wird der markierte Wert aus der Liste der definierten Werte gelöscht.
Bestehenden Wert als aktiven Wert (Default Wert) auswählen: Zum aktivieren eines bestehenden Wertes ist der gewünschte Wert in der Auswahlliste des entsprechenden Basisparameter-Typs zu markieren (aufblättern der Liste über deren rechte Expandier-Schaltfläche und anklicken des gewünschten Wertes). Der markierte Wert wird hervorgehoben. Durch Betätigung der dem Parameter-Typ zugeordneten Schaltfläche "Als Default" wird der markierte Wert als aktivierter Wert gekennzeichnet. Alle aktivierten Werte werden im Dialog "Aktuelle Parameterauswahl" angezeigt.
Ändern eines bestehenden Eintrages: Zum ändern eines bestehenden Wertes ist der gewünschte Wert in der Auswahlliste des entsprechenden Basisparameter-Typs zu markieren (aufblättern der Liste über deren rechte Expandier-Schaltfläche und anklicken des gewünschten Wertes). Der markierte Wert wird hervorgehoben. Durch Betätigung der dem Parameter-Typ zugeordneten Schaltfläche "Editieren" wird der markierte Wert in das Feld "gewählter Eintrag" übertragen. In diesem Feld kann der Wert entsprechend den jeweiligen Erfordernissen abgeändert werden. Über die allgemeine Schaltfläche "Eintrag ändern" wird der bearbeitete Eintrag in seiner neuen Form in die Auswahlliste zurück übertragen.
Hinweis: Zur Erleichterung von Java Updates wurde in JadeIDE Version 3.7 die Rubrik JDK Dokumentation aufgenommen. Damit ist es möglich, die Java Development Kit Dokumentation, die sich bei Updates des Development Kits normalerweise nicht ändert (z.B. Update von JDK1.5.0_01 auf JDK1.5.0_02) in ein separates Verzeichnis einzustellen. Dieses Verzeichnis muss als letztes Unterverzeichnis die Bezeichnung "docs" haben. In diesem Verzeichnis muss dann der Ordner "api" und darin die Datei "index.html" liegen. Beim Suchen wird normalerweise so ein Verzeichnis nicht gefunden. Es muss also explizite hinzugefügt und gegebenenfalls im Namen angepasst werden. Beispiel: "C:/Java/J5Doku/docs/". JadeIDE ergänzt dann "api/index.html".
Alle bestehenden Einträge löschen: Um eine Grundstellung der Dialog-Anzeige durchzuführen ist die allgemeine Schaltfläche "Alle löschen" zu betätigen. Grundstellung bedeutet dabei, das alle Einträge für alle 5 Parametertypen gelöscht werden.
Die allgemeine Schaltfläche "Beenden" oder die "X" (Exit) Schaltfläche in der rechten oberen Fensterecke schließt den Dialog.
Bevor ein Projekt mit JadeIDE bearbeitet werden kann, muss es in JadeIDE eingerichtet werden. Weiter müssen seine Parameter, die die Projektarbeit kontrollieren, vorgegeben werden.
Der Dialog zur Definition der Projektparameter-Schablonen
Der Dialog dient der Benennung eines Entwicklungsprojektes und der Festlegung der für das Projekt gewünschten Steuerungsparameter.
Die Felder des Dialoges und ihre Bedeutung:
Name des Projektpaketes (Projektname): Diese Feld definiert das Java Paket des Projektes. Der Paketname wird in JadeIDE gleichzeitig als Projektname verwendet.
Um eindeutige Paketnamen zu garantieren (z.B. wichtig, wenn ein Applet entwickelt werden soll, das in der Public Domain des Internet verwendet wird), sollten die von SUN vorgeschlagenen Namenskonventionen verwendet werden. SUN schlägt einen dreiteiligen Paketnamen vor, wobei die einzelnen Namenskomponenten durch einen Punkt getrennt werden. Die erste Namenskomponente ist eine der im Internet gebräuchlichen Domänenkennzeichnungen, z.B. "com" für Commercial, "org" für Organisation oder "de" für Deutschland. Die zweite Nameskomponente sollte eine Abkürzung des Unternehmens sein, das Eigentümer der Anwendung sein wird, z.B. "sun" für Sun Microsystems. Die dritte Nameskomponente sollte eine Abkürzung für die zu entwickelnde Anwendung sein, z.B. "ide" für "Integrated Development Environement". Es ist vorteilhaft, nur Kleinbuchstaben und keine Sonderzeichen zu verwenden.
Projektbibliothek: Dieses Feld nimmt die Pfandangabe für die Projektbibliothek auf z.B. "C:\WORK\". In dieser Bibliothek wird das Projekt Paket angelegt. Die Java Quellendateien und Class-Dateien werden sich dann im untersten Ordner der Hierarchie finden. Beispiel: ProjektName: "com.kur.ide", Projektbibliothek: "C:\JadeIDE". Die Dateispezifikation der Java Quellencode Datei "test.java" wäre dann "C:\JadeIDE\com\kur\ide\test.java".
Die Projektbibliothek sollte mit einem Datei-Trennzeichen (Windows: "\", Linux; "/" ) am Ende eingegeben werden.
Die Projektbibliothek kann auch über den Datei-Suchdialog ermittelt werden, wenn eine bereits vorhandene Bibliothek verwendet werden soll (Aufruf über die Schaltfläche "Suchen" hinter dem Eingabefeld).
Ist die Bibliothek noch nicht vorhanden, so kann sie hier auch erstellt werden, indem man die Schaltfläche "Anlegen" hinter dem Eingabefeld anklickt.
Gewünschte JAVA Bibliothek: Dieses Auswahlfeld enthält die Namen der Bibliotheken, in denen Java Entwicklungstoolkits gespeichert sind. Nur der hierarchisch höchste Name darf angegeben werden. Unterverzeichnisse dürfen nicht spezifiziert sein. Aus dem für das Projekt selektierten Namen bildet JadeIDE die entsprechenden Parameterschablonen für den Compiler, den Launcher, den AppletViewer usw.. JadeIDE geht von der Standardnamensstruktur eines JDK aus. Es wird also angenommen, dass die entsprechenden Programme im "bin" Verzeichnis des JDK liegen. Für den Compiler würde also bei einem als "C:\Development\jdk1.3.1\" angegebenen JDK Verzeichnis die Spezifikation "C:\Development\jdk1.3.1\bin\javac.exe" in der Variablen BC_COMP abgelegt.
Für die Projektdefinition muss ein gegebener Name ausgewählt werden. Wenn der gewünschte Name noch nicht vorgegeben ist, so kann mittels der Schaltfläche "Suchen" hinter dem Auswahlfeld ein neuer Eintrag über den System-Dateisuchdialog erstellt werden. Der neue Bibliotheksname wird in die Liste der Namen aufgenommen und kann dann markiert werden.
(Anmerkung: Man kann hier nur neue Namen hinzufügen. Hinfällig gewordenen Namen müssen über den Dialog zur Verwaltung der Basisparameter gelöscht werden.)
ClassPath Erweiterungen: Als Projekt ClassPath wird das Projektverzeichnis verwendet. Sind zusätzlich noch JAR oder ZIP Archive anzugeben, so sind diese hier als ClassPath Erweiterung zu spezifizieren.
Über die Schaltflächen "Suchen" hinter dem Eingabefeld können die einzelnen Archive mittels des systemspezifischen Datei-Suchdialoges ermittelt werden. Jedes gefundene Archiv wird an den bestehenden Eintrag angehängt.
Umwandlungsoptionen: In diesem Feld können die erforderlichen Compiler-Optionen angegeben werden. Eine genaue Beschreibung der möglichen Optionen findet man in der Dokumentation der Werkzeuge des Java Development Toolkits von SUN.
Über die Schaltflächen "Erzeugen" hinter dem Eingabefeld können die einzelnen Optionen mittels eines gesonderten Dialoges generiert werden.
Ausführungsoptionen: In diesem Feld können die erforderlichen Ausführungs-Optionen angegeben werden. Eine genaue Beschreibung der möglichen Optionen findet man in der Dokumentation der Werkzeuge des Java Development Toolkits von SUN.
Über die Schaltflächen "Erzeugen" hinter dem Eingabefeld können die einzelnen Optionen mittels eines gesonderten Dialoges generiert werden.
Standard Doclet Optionen: In diesem Feld können die gewünschten Optionen für das Java Standard Doclet angegeben werden. Eine genaue Beschreibung der möglichen Optionen findet man in der Dokumentation der Werkzeuge des Java Development Toolkits von SUN.
Über die Schaltflächen "Erzeugen" hinter dem Eingabefeld können die einzelnen Optionen mittels eines gesonderten Dialoges generiert werden.
Aufruf Klasse: In diesem Feld wird die Ausführungsklasse (Klasse mit der main() Methode) angegeben.
Über die Schaltflächen "Erzeugen" hinter dem Eingabefeld kann die Ausführungsklasse (bzw. das JAR Archiv, das die Startklasse enthält) zusammen mit den erforderlichen Ausführungsparametern mittels eines gesonderten Dialoges generiert werden.
Aufruf Parameter: In diesem Feld werden die erforderlichen Ausführungsoptionen angegeben. Wurde die Startklasse über den Generierungsdialog generiert, so werden die Ausführungsparameter hierher übertragen.
Die allgemeinen Schaltflächen des Dialoges und die zugehörigen Aktionen:
Sucht nach einer Projektdefinition mit dem im Feld Projektpaket angegebenen Namen.
Setzt alle Felder und Auswahllisten des Dialoges auf Grundstellung.
Löscht die aktuell angezeigte Projektdefinition.
Ändert die gespeicherte Projektdefinition auf die aktuell angezeigten Werte.
Erstellt eine neue Projektdefinition mit den aktuell angezeigten Werten. Gegebenenfalls wird die "Öffnen" Schaltfläche aktiviert.
Das Projekt mit der aktuell angezeigten Spezifikation wird geöffnet. Alle aktivierten Werte werden im Dialog "Aktuelle Parameterauswahl" angezeigt.
Der Dialog zur Festlegung der Optionen für den Java Compiler
Der Dialog zur Definition der "Umwandlungsoptionen" erscheint, wenn im Dialog zur Definition der Projektparameter hinter dem Feld "Umwandlungsoptionen" die "Erzeugen" Schaltfläche angeklickt wird. Ist zu diesem Zeitpunkt ein Eintrag im diesem Textfeld, so werden diese Werte in die Felder des aktivierten Dialoges übernommen. Dadurch entsteht eine einfache Möglichkeit zur Abwandlung bestehender Einträge.
Der Dialog erlaubt die Auswahl der wichtigsten Optionen, die für das Java Umwandlungsprogramm JAVAC.EXE des SUN JDK (Version 1.3 und aktueller) vorgesehen sind. Die Wirkung der Optionen ist in der "SUN JDK Tools Dokumentation" genau beschrieben. Die "Parm-Hilfe" Schaltfläche führt direkt zur Tool-Dokumentation, falls diese Dokumenation in "...\docs\tooldocs\win32\javac.html" beziehungsweise in "...\docs\tooldocs\linux\javac.html" abgelegt ist.
Sind die übernommenen Werte nicht erforderlich oder insgesamt nicht brauchbar, so können die Dialogfelder durch anklicken der Schaltfläche "Grundstellung" in den Grundzustand versetzt werden.
Ausgewählt wird eine Option durch anklicken des entsprechenden Auswahlfeldes. Ein nochmaliges anklicken deselektiert eine bereits markierte Option wieder.
Für Optionen, die einen Parameter einschließen (Ausgabedir. und Source Pfad) wird ebenfalls der betriebssystemspezifische Dateiauswahldialog aufgerufen, um die Auswahl und Übernahme eines Verzeichnisnamens oder eines Dateinamens zu ermöglichen. Die Option wird verwendet, wenn das Parameterfeld belegt ist. Grundsätzlich können Parameterfelder, die über den Dateisuchdialog gefüllt wurden, noch nachbearbeitet werden. Das schließt auch die völlige Löschung des Inhaltes mit ein.
Anmerkung zur Nachbearbeitung des Source Pfades: in den Sourcepfad können mehrere Verzeichnisse, sowie ZIP und JAR Archive eingestellt werden (durch mehrfaches anklicken der Schaltfläche "Suchen"). Normalerweise können im Dateidialog keine Verzeichnisse, sondern nur Dateien ausgewählt werden, darum muss bei einer Verzeichniskomponente die Dateiangabe durch Nachbearbeitung manuell entfernt werden.
Sind der Compiler und die gewünschten Optionen ausgewählt, dann wird der zusammengestellte Wert durch anklicken der Schaltfläche "Übernehmen" ins Feld "Umwandlungsoptionen" des Steuerungsdialoges übertragen. Dort kann der Wert verifiziert werden. Dort kann der Wert - sofern erforderlich - auch durch weitere Optionen ergänzt werden, die durch den JadeIDE Definitionsdialog nicht festgelegt werden können.
Anklicken der Schaltfläche "Übernehmen" schließt das Dialogfenster nicht, denn es könnten ja noch Änderungen an den definierten Werten erforderlich werden. Das Dialogfenster wird entweder durch anklicken der Schaltfläche "Zurück" oder durch anklicken der "X" (Exit) Schaltfläche in der rechten oberen Fensterecke geschlossen.
Der Dialog zur Festlegung der Optionen für den "Java Launcher"
Der Dialog zur Definition der "Ausführungsoptionen" erscheint, wenn im Dialog zur Definition der Projektparameter hinter dem Feld "Ausführungsoptionen" die "Erzeugen" Schaltfläche angeklickt wird. Ist zu diesem Zeitpunkt ein Eintrag im diesem Textfeld enthalten, so werden die Werte dieser Zeile in die Felder des aktivierten Dialoges übernommen. Dadurch entsteht eine einfache Möglichkeit zur Abwandlung bestehender Einträge.
Sind die übergebenen Werte nicht erforderlich oder insgesamt nicht brauchbar, so können die Dialogfelder durch anklicken der Schaltfläche "Grundstellung" in den Grundzustand versetzt werden.
Der Dialog erlaubt die Auswahl der wichtigsten Optionen, die für das Steuerungsprogramm JAVA.EXE des SUN JDK (Version 1.3 und aktueller) vorgesehen sind. Die Wirkung der Optionen ist in der "SUN JDK Tools Dokumentation" genau beschrieben. Die "Parm-Hilfe" Schaltfläche führt direkt zur Tool-Dokumentation, falls diese Dokumenation in "...\docs\tooldocs\win32\java.html" beziehungsweise in "...\docs\tooldocs\linux\java.html" abgelegt ist. Besonders erwähnt seien hier nur die "DebugOptions". Wenn ausgewählt, wird der Wert "-Xdebug -Xrunjdwp:transport=dt_shmem,server=y,suspend=n" eingesetzt. Die Option "-Xnoagent" muss notfalls manuell und die Option "-Djava.compiler=NONE" kann gegebenenfalls als "Eigenschaft (Property)" eingefügt werden.
Ausgewählt wird eine Option durch anklicken des entsprechenden Auswahlfeldes. Ein nochmaliges anklicken deselektiert eine bereits markierte Option wieder.
Das Java Steuerprogramm kann benutzerspezifische Eigenschaften (sogenannte Properties) für eine Anwendung bereithalten. Dazu wird die -D Option verwendet. Die Anzahl der -D Optionen ist nicht begrenzt und eine bestimmte Reihenfolge ist nicht vorgeschrieben. Im Dialog können mittels der Felder Name und Wert die -D Optionen zusammengestellt werden. Dazu ist die Eingabe des gewünschten Optionsnamens ins Feld "Name" und die Eingabe des gewünschten Optionswertes in das Feld "Wert" erforderlich. Sind die Daten bereitgestellt, dann ist die Schaltfläche "Neu" zu drücken. Dies überträgt die Option in der Form "-DEigenschaftsname=Eigenschaftwert" an das Ende des Textbereichs mit der Bezeichnung "Eigenschaften". Ist ein Eintrag fehlerhaft übertragen worden, dann kann er auch wieder gelöscht werden, indem man die zu entfernenden Stelle hervorhebt und dann die Schaltfläche "Entfernen" anklickt.
Sind die gewünschten Optionen ausgewählt, dann wird der zusammengestellte Wert für die Parameterschablone durch anklicken der Schaltfläche "Übernehmen" ins Feld des aufrufenden Dialoges übertragen. Dort kann der Wert verifiziert werden. Dort kann der Wert - sofern erforderlich - auch durch weitere Optionen ergänzt werden, die durch den JadeIDE Definitionsdialog nicht festgelegt werden können.
Anklicken der Schaltfläche "Übernehmen" schließt das Dialogfenster nicht, denn es könnten ja noch Änderungen an den definierten Werten erforderlich werden. Das Dialogfenster wird entweder durch anklicken der Schaltfläche "Zurück" oder durch anklicken der "X" (Exit) Schaltfläche in der rechten oberen Fensterecke geschlossen.
Der Dialog zur Festlegung der Optionen für das "Java Standard Doclet"
Der Dialog zur Definition der "Optionen für das Java Standard Doclet" erscheint, wenn im Dialog zur Definition der Projektparameter hinter dem Feld "Standard Doclet Optionen" die "Erzeugen" Schaltfläche angeklickt wird. Ist zu diesem Zeitpunkt ein Eintrag im diesem Textfeld enthalten, so werden die Werte dieser Zeile in die Felder des aktivierten Dialoges übernommen. Dadurch entsteht eine einfache Möglichkeit zur Abwandlung bestehender Einträge.
Sind die übergebenen Werte nicht erforderlich oder insgesamt nicht brauchbar, so können die Dialogfelder durch anklicken der Schaltfläche "Default" in den Grundzustand versetzt werden.
Der Dialog erlaubt die Auswahl der wichtigsten Optionen, die für das Steuerungsprogramm JAVADOC.EXE des SUN JDK (Version 1.3 und aktueller) ohne Verwendung einer benutzergeschriebenen "Doclet" Klasse vorgesehen sind. Die Wirkung der Optionen ist in der "SUN JDK Tools Dokumentation" genau beschrieben. Die "Hilfe" Schaltfläche führt zu dieser Beschreibung, wenn die erforderlichen Dateien in der Dokumentation des Java Toolkits (Beispiel: "D:/j2sdk1.4.0/docs/tooldocs/javadoc/index.html") abgelegt sind.
Ausgewählt wird eine Option durch anklicken des entsprechenden Auswahlfeldes. Ein nochmaliges anklicken deselektiert eine bereits markierte Option wieder. Eine Option wird definiert, indem das entsprechende Eingabefeld ausgefüllt wird.
Sind die gewünschten Optionen ausgewählt, dann wird der zusammengestellte Wert für die Parameterschablone durch anklicken der Schaltfläche "Sichern" ins Feld des aufrufenden Dialoges übertragen. Dort kann der Wert verifiziert werden.
Anklicken der Schaltfläche "Sichern" schließt das Dialogfenster nicht, denn es könnten ja noch Änderungen an den definierten Werten erforderlich werden. Das Dialogfenster wird entweder durch anklicken der Schaltfläche "Zurück" oder durch anklicken der "X" (Exit) Schaltfläche in der rechten oberen Fensterecke geschlossen.
Der Dialog zur Festlegung der Startklasse und der erforderlichen Startparameter
Der Dialog zur Festlegung der Startklasse und der erforderlichen Startparameter erscheint, wenn im Dialog zur Definition der Projektparameter hinter dem Feld "Aufruf Klasse" die "Erzeugen" Schaltfläche angeklickt wird. Ist zu diesem Zeitpunkt ein Eintrag in diesem Textfeld, so werden diese Werte in die Felder des aktivierten Dialoges übernommen. Dadurch entsteht eine einfache Möglichkeit zur Abwandlung bestehender Einträge.
Sind die übergebenen Werte nicht erforderlich oder insgesamt nicht brauchbar, so können die Dialogfelder durch anklicken der Schaltfläche "Löschen" in den Grundzustand versetzt werden.
Der Dialog erlaubt entweder die Auswahl der gewünschten Startklasse (Klasse mit der main() Methode) oder eines Benutzerarchives ( .jar Datei). Diese Auswahlen schließen sich gegenseitig aus. Wird ein Archiv spezifiziert, so muss die Manifestdatei des Archives die Startklasse festlegen. Für beide Alternativen können zusätzlich eventuell erforderliche Aufrufparameter definiert werden, die die main() Methode der Startklasse erwartet. Diese Werte sind natürlich projektspezifisch.
Die Startklasse und das Benutzerarchiv kann über den betriebssystemspezifischen Dateisuchdialog ausgewählt werden. Dazu ist die Schaltfläche "Suche" hinter dem entsprechenden Textfeld anzuklicken. Ein aus dem Dateisuchdialog übernommener Wert kann selbstverständlich mit den normalen Textbearbeitungsfunktionen nachbearbeitet und auch gelöscht werden.
Wenn ein Aufrufparameter eine Dateispezifikation oder eine Verzeichnisspezifikation ist, dann kann mittels der Schaltfläche "Datei als Arg. anfügen" die Spezifikation mittels des betriebssystemspezifischen Datei Dialoges ermittel werden.
Die Schaltfläche "Sel. Argument löschen" löscht ein hervorgehobenes Argument aus dem Textbereich "Argumente"
Sind die Startklasse und die Aufrufparameter definiert, dann werden diese Werte durch anklicken der Schaltfläche "Übernehmen" in die Felder "Aufruf Klasse" und "Aufruf Parameter" des aufrufenden Dialoges übertragen. Dort kann der Wert verifiziert werden. Dort kann der Wert - sofern erforderlich - auch weiter ergänzt werden.
Anklicken der Schaltfläche "Übernehmen" schließt das Dialogfenster nicht, denn es könnten ja noch Änderungen an den definierten Werten erforderlich werden. Das Dialogfenster wird entweder durch anklicken der Schaltfläche "Zurück" oder durch anklicken der "X" (Exit) Schaltfläche in der rechten oberen Fensterecke geschlossen.
Mit Hilfe des Dialoges "Anzeigefont-Eigenschaften ändern" können die für die Dialog-Fenster von JadeIDE verwendeten Fonts an eine bestimmte Umgebung angepasst werden. Dies kann wünschenswert sein, wenn wegen der verwendeten Bildschirmauflösung bestimmte Texte zu klein oder unvollständig angezeigt werden.
Es können 3 verschieden Fonts modifiziert werden:
Der "Dialog-Font", das ist der Font, der zur Anzeige der Fenstertexte (dunkelblaue Texte) verwendet wird.
Der "Button-Font", das ist der Font, der zur Anzeige der Schaltflächenbeschriftung (weisse Aufschriften) verwendet wird.
Der "Text-Font", das ist der Font, der zur Anzeige der Feldinhalte (schwarze Texte) verwendet wird.
Mit der Schaltfläche werden die von JadeIDE festgelegten Werte eingestellt. Die Schaltfläche aktiviert die manuell eingegebenen Werte. Es kann notwendig sein, JadeIDE zu schließen und erneut zu öffnen um die Änderung für bestimmte Anzeigen wirksam werden zu lassen. Die eingestellten Werte werden in der "JadeIDE.ini" Datei als Parameter gesichert und in Zukunft für die Initialisierung von JadeIDE verwendet, und zwar solange, bis sie erneut modifiziert werden.
Um zu überprüfen, welche Parameterschablonen gerade aktiv sind, kann der Dialog "Aktuelle Parameterauswahl" verwendet werden. Diese Anzeige erscheint, wenn im Hauptfenster von JadeIDE der Untermenüpunkt "Ausgewählte Werte anzeigen" innerhalb des "Datei" Menüs angeklickt wird.
Die Datei jadeide.ini darf niemals mit einem Editor bearbeitet werden. Dies könnte diese Datei unbrauchbar machen. Die Datei enthält binäre Zeigerwerte, die bei einer Längenänderung der Datei ungültig werden.
Wenn alle gewünschten und erforderlichen Parameterschablonen in der "Setup" Phase definiert worden sind, kann mit der Projektarbeit begonnen werden.
Die einzelnen Aktionen der Projektarbeit werden über die Menüs und Menüpunkte des JadeIDE Hauptfensters gesteuert. Dabei werden zwei Gruppen von Aktionen unterschieden:
Funktionen, die die Projektarbeiten flankieren. Dazu gehören die Anzeige der Dokumentation von Java API's (eigene und SUN API's), die Anzeige des Inhaltes der System-Zwischenablage und der Aufruf eines HTML Editors, wenn HTML Dateien (z.B. Hilfedateien im HTML Format) bearbeitet werden müssen.
Projektaktionen, die während des Programmierprozesses auftreten. Dazu gehört die Ersterstellung von Klassen, die Bearbeitung von Klassen, die Generierung von individuellen Dialogfenstern, die Generierung von Applet-Aufrufdateien, die Löschung von Dateien, die Umwandlung von Klassen (einzeln und projektweise), die Generierung der Java Doc Projektdokumentation, die Testausführung der erstellten Anwendung und der gewollte Abbruch einer Aktion (z. B. einer Testausführung, die in eine Schleife geraten ist).
Die Funktion "Projekt auswählen" dient zur Vorbereitung und Aktivierung der für das Projekt erforderlichen Parameterschablonen und dem Aufbau der Menüpunkte der Menüs "Java Dateien" und "HTML Dateien".
Wenn im Datei Menü der Eintrag "Projekt auswählen" angeklickt wird, öffnet sich ein Auswahldialog, der eine Liste aller bestehenden Projekte päsentiert. Projekte werden durch den ihnen zugeordneten Paketnamen identifiziert.
In der expandierten Liste der Projektnamen ist der Name des Projektes zu selektieren, das bearbeitet werden soll. Danach ist die Schaltfläche "Start" anzuklicken um das Projekt zu starten.
Die projektspezifischen Parameterwerte werden gegen das momentan vorhandene Umfeld geprüft und aktiviert, wenn kein Fehler festgestellt wurde. Alle ".java" Dateien des Projektes werden ins Menü "Java Dateien" und alle ".htm(l)" Dateien des Projektes werden ins Menü "HTML Dateien" übertragen. Sofern das "JADE - Aktuelle Parameterauswahl" Fenster offen ist, wird sein Inhalt aktualisiert.
Im Titel des Hauptfensters wird der Name des ausgewählten Projektes angezeigt.
Wenn für das Projekt noch keine ".java" Dateien im Paketordner gefunden werden (Anzahl .java Dateien = 0) dann wird automatisch die Schablone einer Startklasse (mit Namen $StartClass) generiert, die den Anforderungen entsprechend modifiziert werden kann.
Anmerkung: Solange die $StartClass die einzige ".java" Datei im Paketordner ist, wird sofort eine neue Startklasse generiert, wenn die alte Startklasse gelöscht wird.
Über diesen Dialog kann mittels der Schaltfläche "Ändern" auch der Dialog zur Definition der Projektparameter aufgerufen werden, wenn die Projektparameter modifiziert werden sollen, bevor das Projekt gestartet wird.
Anmerkung: Ein ausgewähltes Projekt mit dem gearbeitet wird, wird als aktives Projekt gekennzeichnet. Es wird automatisch wieder gestartet, wenn JadeIDE das nächste Mal aufgerufen wird. Wird ein Projekt ordnungsgemäß geschlossen (mittels der "Projekt beenden" Funktion), dann gibt es kein aktives Projekt mehr. Das bedeutet, dass JadeIDE kein Projekt automatisch starten kann, sondern dass der Projektstart über diese Funktion ausgeführt werden muss.
Projekt beenden
Die Funktion "Projekt beenden"(Datei -> Projekt beenden) dient der Deaktivierung des ausgewählten Projektes. Der Menüpunkt "Functionen -> Java API Doku anzeigen", die Menüs "Java Dateien" und "HTML Dateien" werden deaktiviert und die Textfelder des Hauptfensters werden gelöscht. Alle aktiven projektspezifischen Parameterschablonen werden deaktiviert.
Das Menu "Funktionen" des JadeIDE Hauptfensters zeigt die Menüpunkte zum Aufruf der die Projektarbeit flankierenden Aktionen.
Hauptfenster nach oben
Die Funktion "Hauptfenster nach oben" positioniert das JadeIDE Hauptfenster am oberen Rand des Bildschirmes, passt seine horizontale Ausdehnung an die Bildschirmbreite an und setzt die Höhe auf den Standardwert (80 Pixel).
Standard Look and Feel setzen
Die Funktion "Standard Look and Feel setzen" veranlasst, dass für alle neu zu öffnenden Fenster die Systemstandards für das "Look and Feel" verwendet werden. Die Auswahl wird im Basisparameter BC_LAF (Wert=D) gespeichert. BC_LAF wird verwendet, wenn JadeIDE neu gestartet wird. Das bedeutet, dass das JadeIDE Hauptfenster erst bei Neustart von JadeIDE an das geänderte "Look and Feel" angepasst wird.
Cross Platform Look and Feel setzen
Die Funktion "Cross Platform Look and Feel setzen" veranlasst, dass für alle neu zu öffnenden Fenster das plattformübergreifende "Java Look and Feel" verwendet wird. Die Auswahl wird im Basisparameter BC_LAF (Wert=X) gespeichert. BC_LAF wird verwendet, wenn JadeIDE neu gestartet wird. Das bedeutet, dass das JadeIDE Hauptfenster erst bei Neustart von JadeIDE an das geänderte "Look and Feel" angepasst wird.
Anmerkung: Unter Linux sind beide "Look and Feel" Einstellungen identisch.
Benutzerfunktion aufrufen
Die Funktion "Benutzerfunktion aufrufen" erlaubt es ein benutzerspezifisches Dialogfenster zu öffnen, über das Funktionen, die ein Benutzer bereitgestellt hat, aufgerufen werden können. Dazu muss die Klasse UserExit, deren Quellencode JadeIDE bereitstellt, angepasst und umgewandelt werden. Das Projekt "com.kur.ide" für die Modifikation und Umwandlung der Klasse muss vom Benutzer definiert werden.
Folgende Eingaben sind dazu erforderlich:
Name des Projektpaketes = com.kur.ide
Projektbibliothek = die Installationsbibliothek von JadeIDE
Aufruf Klasse = Control
Aufruf Parameter = Lang=D
Unmodifizierte Form des "UserExit" Dialoges.
HTML-Editor aufrufen
Die Funktion "HTML-Editor aufrufen" öffnet den HTML Editor, der momentan über den JadeIDE Programmaufrufparameter (Parameter HTML=...) ausgewählt ist.
XML-Editor aufrufen
Die Funktion "XML-Editor aufrufen" öffnet den XML Editor, der momentan über den JadeIDE Programmaufrufparameter (Parameter XML=...) ausgewählt ist.
UML-Editor UMLet aufrufen
Die Funktions "UML-Editor UMLet aufrufen" öffnet den UML Editor UMLet der von der Technischen Universität Wien entwickelt wird. Um UMLet auszuführen, muss die Datei "umlet.jar" in die Bibliothek "....\com\kur\ide\jars" geladen werden. Wenn diese Bibliothek nicht existiert, dann muss eine angelegt werden. Wird die Datei "umlet.jar" nicht gefunden, so ist der Menü-Eintrag inaktiv.
Java API Dokumentation anzeigen
Die Funktion "Java API Doku anzeigen" öffnet zur Anzeige der "SUN Java JDK API Dokumentation" (spezifiziert über Parameter JAPI....) den Web-Browser, der über den JadeIDE Programmaufrufparameter (Parameter BRWS=.....) spezifiziert worden ist. Diese Funktion ist nur aktiv, wenn ein gültiges Projekt selektiert ist.
Package API Dokumentation anzeigen
Die Funktion "Package API Doku anzeigen" öffnet zur Anzeige der "JavaDoc HTML-Datei" eines ausgewählten Projektes den Web-Browser, der über den JadeIDE Programmaufrufparameter (Parameter BRWS=.....) spezifiziert worden ist. Voraussetzung ist, dass eine JavaDoc Datei für das Projekt erzeugt worden ist (siehe: "Java Doc generieren" im Menü "Projektaktionen").
Die JavaDoc Datei wird über die Liste der definierten Pakete bestimmt. Die Anzeige wird dann über die "Start"-Schaltfläche gestartet.
Zwischenablageinhalt anzeigen
Die Funktion "Zwischenablageinhalt anzeigen" öffnet ein Fenster, das in einem Textbereich den momentanen Inhalt der System-Zwischenablage präsentiert. Damit kann leicht überprüft werden, was bei einer folgenden Einfügungsoperation an der Caret-Position eingefügt würde.
Durch anklicken der Schaltfläche "Löschen" kann der Inhalt der Zwischenablage gelöscht werden.
Die JadeIDE Projektaktionen
Das Menu "Projektaktionen" des JadeIDE Hauptfensters zeigt die Menüpunkte zum Aufruf der eigentlichen Projekt Aktionen. Dabei ist das Menü in 4 Abschnitte gegliedert. Der erste Abschnitt enthält alle Einzeldatei (bzw. Klasse) bezogenen Aktivitäten. Der zweite Abschnitt enthält die gesamtprojektbezogenen Aktionen, der dritte Abschnitt enthält den Aufruf zum Abbrechen von momentan laufenden Prozessen und der vierte Abschnitt stellt die archivierungsbezogenen Aktionen bereit.
Datei erzeugen und initialisieren
Um eine neue Quellendatei zu erzeugen und zu initialisieren wir der "Datei erzeugen und initialisieren" Dialog verwendet:
Der Dialog erlaubt die Generierung und Initialisierung von Projektdateien vom Typ ".java", ".html", ".xml" und ".jct". Um eine neue Datei zu erzeugen sind folgende Aktionen durchzuführen:
Der Name der neu zu erzeugenden Datei (bzw. Klasse) ist in Feld "Datei / Klassen Name" einzugeben.
Der gewünschte Dateityp ist durch anklicken der entsprechenden Checkbox auszuwählen. Erlaubt sind die Dateitypen .java, .html, .xml und .jct Der angebenen Dateityp bestimmt die Art der Initialisierung. Dieser Vorschlag kann aber geändert werden.
Die Initialisierungsart ist zu wählen. Möglich sind:
keine
keine oder nur rudimentäre Initialisierung
standard
Initialisierung mit der JadeIDE Standard Schablone. Für eine ".html" Datei wird der "HTML Datei erzeugen" Dialog aufgerufen um eine HTML-Datei für einen Applet-Aufruf zu generieren.
Übernehmen aus
Die Datei wird mit dem Inhalt der ausgewählten Datei initialisiert.
Anklicken der Schaltfläche. Dies erzeugt und initialisiert die Datei. Die neue Datei wird automatisch dem entsprechenden Menü ("Java Dateien", "HTML Datein" bzw. "Code Schablonen") in JadeIDE Hauptfenster als Eintrag hinzugefügt und das Feld Aktuelle Klasse/ Aktuelle URL wird gefüllt. Dadurch wird die neue Datei zur aktive Datei und kann sofort editiert werden.
Die Schaltflächen setzt alle Eingabefelder auf die Vorgabewerte und die Schaltfläche schließt das Dialogfenster.
Kleiner Hinweis: Wenn Sie in Ihren Java Quellencode in der Klassenbeschreibung eine @author Zeile einfügen, die am Zeilenende den Text "last change:" enthält (Beispiel: " * @author xxxxxx yyyyy last change: "), dann setzt der JadeEditor beim Speichern der Quellendatei an dieser Stelle einen Zeitstempel mit dem aktuellen Datum und der aktuellen Zeit ein, so dass Sie immer wissen, wann die Klasse zum letzten Mal auf ein persistentes Medium (Platte, Diskette, ...) gespeichert worden ist.
Projektdatei löschen
Der Dialog "Projektdatei löschen" wird verwendet um Projektdateien vom Type .java, .html, .xml und .jct zu entfernen. Der Dialog stellt für jeden Dateityp ein Auswahlfeld bereit, das mit den Dateispezifikationen aller bestehenden Projektdatein initialisiert ist.
Um eine Datei aus dem Projektordner oder dem Schablonenordner zu löschen sind folgende Aktionen durchzuführen:
Der Eintrag des entsprechenden Auswahlfeldes, der die zu löschende Datei repräsentiert, ist zu markieren. Dazu ist das Feld zu expandieren und die entsprechende Zeile anzuklicken. Der ausgewählte Eintrag wird in Feld "Ausgewählte Datei" übertragen, um eine Überprüfung der Auswahl zu ermöglichen.
Die Schaltfläche ist anzuklicken.
Über eine Nachricht wird gebeten, die Löschaktion durch nochmaliges anklicken der Schaltfläche zu bestätigen. Das Feld "Aktuelle Datei / Aktuelle URL" im Hauptfenster von JadeIDE wird gelöscht und der Inhalt des entsprechenden Menüs wird erneuert, wenn die Löschung erfolgreich war.
Achtung: wenn eine zu löschende Datei gerade über den JadeEditor angezeigt wird, dann wird das Editorfenster geschlossen, bevor die Datei gelöscht wird. Dies gilt nicht, wenn sie über einen externen Editor geöffnet ist. Der externe Editor wird die Datei möglicherweise neu erzeugen.
Um das Dialogfenster zu schließen wird die Schaltfläche angeklickt.
Editieren mit JADE-Editor
Um eine Datei mit dem JADE-Editor zu editieren, sind folgende Aktionen durchzuführen:
Aus der Liste der selektierbaren Klassen (Menü "Java Dateien") direkt bzw. über den angebotenen Filedialog oder die Liste der selektierbaren URLs (Menü "HTML Dateien") ist eine Datei auszuwählen. Der Name der ausgewählten Datei wird ins Textfeld "Akt. Klasse / Aktuelle URL" übertragen.
Ist kein externer Editor spezifiziert, dann wird eine Java Datei sofort im JadeEditor angezeigt. Ist ein externer Editor spezifiziert, so wird der Inhalt der ausgewählten Datei über den JADE-Editor angezeigt, wenn der Menüpunkt "Editieren mit JADE-Editor" angeklickt wird. Alternativ kann auch die "edit" Schaltfläche (rechts im Informationsteil des Fensters) angeklickt werden. Ist bereits ein Editor für die entsprechende Datei offen, so wird dieses Fenster in den Vordergrund gerückt. Mehrfachanzeige einer Datei ist über den JADE Editor nicht möglich. Es kann aber eine Datei zusätzlich über einen externen Editor präsentiert werden. Dies sollte aber nur für Textvergleiche verwendet werden, da Veränderungen in mehreren Editoren zu Konflikten bzw. auch zu Verlusten vermeintlich eingegebener Werte führen kann.
Editieren mit externem Editor
Um eine Datei mit einem externen Editor zu editieren, sind folgende Aktionen durchzuführen:
Aus der Liste der selektierbaren Klassen (Menü "Java Dateien") direkt bzw. über den angebotenen Filedialog oder die Liste der selektierbaren URLs (Menü "HTML Dateien") ist eine Datei auszuwählen. Der Name der ausgewählten Datei wird ins Textfeld "Akt. Klasse / Aktuelle URL" übertragen.
Der Inhalt der ausgewählten Datei wird über den momentan aktivierten externen Editor angezeigt, wenn der Menüpunkt "Editieren mit externem Editor" angeklickt wird.
Selektierte Datei umwandeln
Um ein Quellenprogramm (identifiziert durch den Klassennamen) mit dem momentan aktiven Java Compiler in Java Bytecode umzuwandeln, sind folgende Aktionen durchzuführen:
Aus der Liste der selektierbaren Klassen (Menü "Java Dateien") direkt bzw. über den angebotenen Filedialog ist eine Datei auszuwählen sofern des Feld "Akt. Klasse" nicht bereits den Namen der umzuwandelnden Klasse anzeigt. Wird eine Datei ausgewählt, so wird der Name der ausgewählten Datei wird ins Textfeld "Akt. Klasse" übertragen.
Der Quellenprogrammcode der ausgewählten Klasse wird mit dem momentan aktivierten Umwandlungsprogramm kompiliert, wenn der Menüpunkt "Selektierte Datei umwandeln" angeklickt wird. Alternativ kann auch die Schaltfläche "C" (rechts im Informationsteil des Fensters) angeklickt werden. Nach Beendigung der Umwandlung zeigt eine Nachricht den Erfolg oder Misserfolg der Umwandlung an. Im Fehlerfalle zeigt ein "Nachrichten und Fehler" Dialog die während der Umwandlung generierten Nachrichten an (Nachrichten: maximal 64 K Bytes oder bis zu 300 Nachrichten, Fehler: maximal 64 K Bytes oder bis zu 300 Nachrichten).
Windowframe erzeugen
Der Steuerungsdialog zur Generierung eines Window Frames wird geöffnet, wenn der Menüpunkt "Windowframe erzeugen" angeklickt wird.
Dialogfenster erzeugen
Der Steuerungsdialog zur Generierung eines Dialogfensters wird geöffnet, wenn der Menüpunkt "Dialogfenster erzeugen" angeklickt wird.
Aktives Projekt umwandeln
Die Funktion "Aktives Projekt umwandeln" dient der Umwandlung aller Klassen, die in einem Projekt definiert sind. Wird eine Klasse nicht fehlerfrei umgewandelt, so wird für diese Klasse ein "Fehler- und Nachrichtendialog" angezeigt. Damit die Zuordnung der Fehler zur kompilierten Klasse erhalten bleibt, können mehrere solcher Dialoge gleichzeitig geöffnet sein. Aufgetretene Fehler können also der Reihe nach abgearbeitet werden. Zur Korrektur der Quellenprogramme kann die Edit-Funktion für die entsprechende Klasse direkt aus dem Fehlerdialog aufgerufen werden.
Header Dateien für JNI erzeugen
Die Funktion "Header Dateien für JNI erzeugen" dient dazu, für die aktuell.ausgewählte Klasse (sofern sie C/C++ Methoden definiert und verwendet) die erforderlichen C/C++ Header Dateien zu generieren und in der Projektbibiliothek zu speichern. Diese Dateien müssen ins C/C++ Programm übernommen werden, um die korrekten Signaturen der definierten Methoden zu erstellen. Die generierten Dateien können über Menü "Andere Dateien" bearbeitet werden. Eine funktionelle Modifikation dieser automatisch generierten Dateien sollte jedoch vermieden werden.
JAR Archivdatei generieren
Durch anklicken des Menüpunktes "JAR Archivdatei generieren" wird der Dialog "Jar Archiv erstellen" für das aktuelle Projekt (Paket) aufgerufen.
Die JAR Datei wird im JadeIDE Installationsordner abgespeichert. Der Jar-Dateiname wird aus der letzten Namenskomponente des Projektpaketes unter Anfügung von "JAR.jar" gebildet. Beispiel: Projektbezeichnung: com.kur.test, resultierender Archivname: testJAR.jar. Im gleichen Verzeichnis wird auch eine Datei zur Sicherung der aktuellen Eingabe zur Generierung des Java Archives gespeichert. Ihr Name wird aus der letzten Namenskomponente des Projektpaketes unter Anfügung von "JDI.txt" gebildet also z.B. testJDI.txt.
Der Dialog "JAR Archivdatei generieren" dient der Festlegung der Optionen für den JAR Befehl sowie der Dateien, die in das Archiv übernommen werden sollen. Die gesamte Eingabe in diesen Dialog wird in der Datei xxxxxJDI.txt gespeichert, so dass sie später wieder verwendet werden kann. Gibt es eine Datei xxxxJDI.txt im JadeIDE Installationsordner, dann wird deren Inhalt zur Initialisierung des Dialoges verwendet. Im Dialog können die folgenden Elemente spezifiziert werden:
Optionen
Diese Zeile enthält die Kontrollkästchen zur Auswahl der Verarbeitungsoptionen.
Folgende Optionen stehen zur Verfügung:
aktuelles Paket
ausgewählt: Alle ".class" Dateien des aktuelle Pakets (des Projektpakets) wird in das Archiv übernommen.
(".java" Dateien werden nicht übernommen. Wenn ".java" Dateien ins Archiv übernommen werden sollen, dann muss dazu die Funktion "Zusätzliche Ordner und Dateien" verwendet werden.)
nicht ausgewählt: Das Projektpaket wird nicht ins Archiv aufgenommen.
Anmerkung: Wenn dieses Kontrollkästchen angeschaltet wird, dann wird das "Update" Kästchen ausgeschaltet. Ein Ausschalten dieses Kästchens beeinflusst das "Update" Kästchen jedoch nicht.
ZIP Kompression
ausgewählt: Ein Archiv soll mit ZIP Kompression erstellt werden (keine 0 - Option).
nicht ausgewählt: Eine Archivdatei soll in unkomprimierter Form erzeugt werden (0 - Option).
Manifestdatei
ausgewählt: Ins Archiv soll eine Manifestdatei mit aufgenommen werden (keine M - Option).
nicht ausgewählt: Ins Archiv soll keine Manifestdatei eingefügt werden (M - Option).
update
ausgewählt: Ein bestehendes Archiv soll geändert (fortgeschrieben) werden (u - Option).
Hinweis: Da bei einem Update unvorhersehbare Fehler auftreten können, ist es günstiger (und schneller) ein Java Archiv immer neu zu erstellen.
nicht ausgewählt: Eine neue Archivdatei soll erzeugt werden (c - Option).
Note: Wenn dieses Kontrollkästchen angeschaltet wird, dann wird das "aktuelles Paket" Kästchen ausgeschaltet. Ein Ausschalten dieses Kästchens beeinflusst das "aktuelles Paket" Kästchen jedoch nicht.
verbose
ausgewählt: Die Jar-Tool Nachrichten werden im StandardError und StandardOut Dialog Fenster angezeigt ( v - Option).
nicht ausgewählt: Die Jar-Tool Nachrichten werden nicht angezeigt.
Temp.Files halten
ausgewählt: Die temporäre Jar-Tool Eingabedatei und die temporäre Jar-Tool Manifestdatei wird nach Beendigung des JAR-Erzeugungsprozesses nicht entfernt.
nicht ausgewählt: Die temporären Dateien werden am Ende des JAR-Erzeugungsprozesses gelöscht.
Zusätzliche Pakete
Diese Liste definiert alle Pakete, die zusätzlich zum Projektpaket in das Archiv aufgenommen werden sollen. Die Pakete müssen mit dem JadeIDE Projektauswahldialog definiert werden ("Pakete suchen" Schaltfläche). Die Schaltfläche "Paket entfernen" löscht einen bestehenden Eintrag aus dieser Liste.
Auch hier gilt, es werden nur ".class" Dateien ins Archiv übernommen.
Download Extension JAR Dateien
In dieses Text-Eingabefeld können die Namen von JAR Dateien eingegeben werden (jeweils durch eine Leerstelle voneinander getrennt), die Erweiterungsklassen (Klassen von externen Anwendungen) enthalten, die aus der Anwendung heraus aufgerufen werden sollen, die aber nicht in der JAR-Datei der Anwendung enthalten sind. Ein Eintrag in dieses Feld erzeugt einen "Class-Path:" Eintrag in der Manifest Datei der zu generierenden JAR-Datei z.B. in der Form "Class-Path: AnwendungX.jar AnwendungY.jar".
Es sollten nur Dateien mit der Dateierweiterung ".jar" eingegeben werden, die sich in derselben Bibliothek (Directory) befinden, in der sich auch die momentan zu generierende "JAR-Datei" später befinden soll, denn "Download Extension JAR Dateien" müssen in der gleichen Bibliothek gespeichert sein wie die JAR-Datei der Basisanwendung.
Zusätzliche Ordner und Dateien
Diese Liste definiert alle zusätzlichen Dateien, die ins JAR Archiv übernommen werden sollen. Die gewünschten Dateien oder Ordner müssen durch den Dateiauswahldialog des Systemes definiert werden (Schaltflächen "Ordner suchen" und "Dateien suchen").
Wenn nur Dateien eines Ordners mit einer bestimmten Dateierweiterung übernommen werden sollen, dann kann man diese Dateierweiterung im Dateierweiterungsfeld angeben. Beispiel: um nur alle ".gif" Dateien zu übernehmen, die in einem Ordner abgelegt sind, dann ist in das Dateierweiterungsfeld der Wert "gif" einzugeben und dann die Schaltfläche "Ordner suchen" anzuklicken.
Mit der Schaltfläche "Eintrag entfernen" kann ein bestehender Eintrag wieder aus der Liste entfernt werden.
Die über die Schaltflächen aufzurufenden Funktionen:
Parm.Hilfe
Schaltfläche, um die "Sun Jar-Tool Dokumentation" anzuzeigen. Die SUN Tools-Dokumentation muss an der von SUN definierten Position installiert sein.
Fensterhilfe
Schaltfläche, um die JadeIDE Hilfe für dieses Fenster (diesen Abschnitt) anzuzeigen.
Grundstellung
Schaltflächen, um die Elemente des Dialogfensters in den Grundzustand (auf die Default-Werte) zu setzen.
Ausführen
Schaltfläche, um den Jar Generierungsprozess anzustroßen.
Zurück
Schaltfläche, um das Fenster zu schließen und zum rufenden Prozess zurückzukehren.
Java Doc generieren (standard)
Die Java Dokumentation für ein aktives Projekt wird durch anklicken des Menüpunktes "Java Doc generieren (standard)" erzeugt.
Die Java Dokumentation wird in einem Ordner innerhalb des Projektordners angelegt. Der Name des Dokumentationsordners wird aus dem letzten Teil der Projektspezifikation erweitert um den Anhang "Doc" gebildet. Beispiel: Projektbezeichnung com.kur.test, Ordnername: testDoc.
In diesem Ordner befindet sich die Startdatei "index.html".
Java Doc generieren (modifiziert)
Durch anklicken des Menüpunktes "Java Doc generieren (modifiziert)" wird der Dialog "JavaDoc Projektdokumentation erzeugen" für das aktuelle Projekt aufgerufen.
Der Dialog "JavaDoc Projektdokumentation erzeugen" erlaubt die Anpassung der Parameter und Optionen, die an das JavaDoc Werkzeug übergeben werden sollen. Die folgenden Elemente können angepasst werden:
Taglet Name
Dieses Feld definiert den Namen einer benutzergeschriebenen Dokumentations-Taglet Klasse, die durch das Java Standard Doclet aufgerufen werden soll. JadeIDE stellt ein Jade Benutzertaglet (com.kur.ideJadeTaglet) zur Verfügung, das projektspezifisch modifiziert werden kann. Vorhanden ist sowohl die Klasse als auch der Quellenkode.
Wenn das JadeTaglet angepasst werden soll, dann ist ein Projekt "com.kur.ide" zu definieren und zwar in der gleichen Weise wie für den Benutzer-Ausgang. Bitte beachten: für die Umwandlung des Taglets muss Datei ".....\lib\tools.jar" im Classpath sein.
Anmerkung: wenn ein benutzergeschriebenes Doclet verwendet werden soll, das nicht fähig ist, benutzergeschriebene Taglets aufzurufen, dann muss dieses Feld leer sein.
Taglet Pfad
Dieses Feld legt den Pfad zur benutzergeschriebenen Taglet Klasse fest. Standardwert ist der Pfad zu JadeTaglet Klase.
Gültige Benutzer-Tags
Dieses Feld legt die Benutzertags fest, die vom JadeIDE Taglet bearbeitet werden sollen. Der Eintrag definiert (als Liste) die Tag-Namen/Tag-Überschrift Paare. Die erforderliche Eingabeform ist: Tag-Name Komma Tag-Überschrift Doppelpunkt. Die Paare müssen durch Semicolons getrennt werden [Beispiel: "todo,To Do:;new,New Function:;....."].
Ausgabeordner
Dieses Feld legt den Ordner fest, in welchen das Ergebnis der Dokumentationsgenerierung geschrieben werden soll. Standardwert ist der JadeIDE Ausgabeordner, der aus der Projektbezeichnung generiert wird, und zwar so wie unter "Java Doc generieren (standard)" weiter oben beschrieben ist.
Zusätzliche Pakete
Dieses Feld spezifiziert zusätzliche Pakete, die gemeinsam mit dem aktuellen Paket dokumentiert werden sollen. Die zusätzlichen Pakete müssen JadeIDE Projekte sein. Die "Suchen" Schaltfläche kann benutzt werden, um die Pakete einzusetzen. Im Suchdialog muss dazu nur das gewünschte Projekt selektiert und dann die "Auswählen" Schaltfläche angeklickt werden. Der Vorgang ist so oft wie erforderlich zu wiederholen.
Aktuelle Doc.Optionen
Dieses (eingabegeschützte) Feld zeigt die Optionen, die an das Doclet übergeben werden. Um diese Optionen temporär anzupassen, muss der Dialog "Optionen für Standard Doclet anpassen" über die Schaltfläche "Prm anpassen" aufgerufen werden. Die Schaltfläche "Sichern" überträgt die angepassten Werte in das Feld, aber sie ändert die Werte nicht ab, die während der Projektdefinition festgelegt worden sind.
Siehe "Dialog zur Festlegung der Optionen für das Java Standard Doclet".
Die über die Schaltflächen aufzurufenden Funktionen:
Prm anpassen
Schaltfläche zum Aufruf des Dialoges "Optionen für Standard Doclet anpassen".
Taglet suchen
Schaltfläche zum Aufruf des "Standard File Dialogs" zur Lokalisierung der Benutzer Taglet Klasse.
OutDir suchen
Schaltfläche zum Aufruf des "Standard File Dialogs" zur Lokalisierung der Ausgabebibliothek.
Ausführen
Schaltfläche zum Starten des JavaDoc Prozesses.
Hilfe
Schaltfläche zum Starten der JadeIDE Hilfe.
Speichern
Schaltfläche zum Starten des "Standard File Dialogs", um eine Datei festzulegen, in der der generierte JavaDoc Befehl gespeichert werden soll.
Dieser Befehl kann später dazu benutzt werden um die Dialog Felder zu initialisieren (Schaltfläche "Laden") oder um z.B über ein Perl Script den Befehl auszuführen.
Anmerkung: es wird empfohlen, einen Ordner "docCmds" anzulegen, und zwar in der JadeIDE Projektbibliothek (z.B. D:\JadeIDE\docCmds (Windows Form) ).
Laden
Schaltfläche zum Starten des "Standard File Dialogs", um eine Datei auszuwählen, die einen JavaDoc Befehl gespeichert hat. Die Dialogfelder werden entsprechend des Dateiinhaltes initialisiert.
Zurück
Schaltfläche zum Verlassen des Dialoges.
Applet ausführen
Um die Startklasse (Klasse mit der init() Methode) eines Projektes als Applet mittels des definierten Appletviewers zu starten, sind folgende Aktionen auszuführen:
Der gewünschte URL Eintrag ist über das Menü "HTML Dateien" auszuwählen.
Die Appletausführung wird gestartet, wenn der Menüpunkt "Applet ausführen" angeklickt wird. Nachdem die Anwendung beendet worden ist, zeigt eine Nachricht den Erfolg oder Misserfolg des Tests an. Ein "Nachrichten und Fehler" Dialog zeigt die während der Ausführung generierten Nachrichten an (Nachrichten: maximal 64 K Bytes oder bis zu 300 Nachrichten, Fehler: maximal 64 K Bytes oder bis zu 300 Nachrichten).
Anwendung ausführen
Die Parameterschablone "MainClass" definiert die Startklasse eines Projektes (Klasse mit der main() Methode) zusammen mit den erforderlichen Aufrufparametern. Um die Startklasse eines Projektes als Anwendung zu starten, sind folgende Aktionen auszuführen:
Überprüfen, ob die korrekte "MainClass" Parameterschablone aktiv ist.
Falls erforderlich die Parameterschablone wechseln oder korrigieren. Dies kann dann notwendig sein, wenn die Startklasse bezüglich der Parameterübergabe verändert worden ist.
Die Programmausführung wird gestartet, wenn der Menüpunkt "Anwendung ausführen" angeklickt wird. Nachdem die Anwendung beendet worden ist, zeigt eine Nachricht den Erfolg oder Misserfolg des Tests an. Ein "Nachrichten und Fehler" Dialog zeigt die während der Ausführung generierten Nachrichten an (Nachrichten: maximal 64 K Bytes oder bis zu 300 Nachrichten, Fehler: maximal 64 K Bytes oder bis zu 300 Nachrichten).
Im Falle eines Ausführungsfehlers (d.h. wenn ein "Exception Trace Stack" im "StandardError" Anzeigedialog präsentiert wird) kann man direkt zur Quellenkodezeile Springen, durch die der Fehler ausgelöst wurde. Dazu ist im StandardError Dialog auf die Zeile zu klicken, die den Fehler meldet. Voraussetzung dafür ist allerdings, dass der Fehler im gerade getesteten Paket liegt und dass das Paket ein JadeIDE Projekt repräsentiert.
Aktive Aktion abbrechen
Um eine laufenden Umwandlung oder Programmausführung zu unterbrechen und abzubrechen ist auf den Menüpunkt "Aktive Aktion abbrechen" zu klicken. Nachdem die Anwendung beendet worden ist, zeigt eine Nachricht den Abbruch an. Ein "Nachrichten und Fehler" Dialog zeigt die während der Ausführung generierten Nachrichten an (Nachrichten: maximal 64 K Bytes oder bis zu 300 Nachrichten, Fehler: maximal 64 K Bytes oder bis zu 300 Nachrichten).
Archive verwalten
Um die bestehenden Archiv-Ordner eines Projektes zu verwalten ist auf den Menüpunkt "Archive verwalten" zu klicken.
Es öffnet sich das Fenster mit dem Titel "bestehende Archive verwalten" das alle potentiellen Archiv-Ordner eines Projektes in aufsteigender Sortierfolge auflistet - d.h. in der Reihenfolge ihres Entstehens: ältestes Archiv ganz oben, jüngstes Archiv ganz unten.
Durch die Auswahl eines Archives in der Liste und durch anschließendes Drücken der Schaltfläche "Löschen" wird der markierte Ordner gelöscht. Vorsicht: es wird keine Bestätigung der Löschaktion verlangt!
Das Fenster wird mittels der Schaltfläche "Verlassen" oder der Schaltfläche "X" (Exit) in der rechten oberen Fensterecke wieder geschlossen.
Aktuelles Projekt archivieren
Um einen momentanen Zwischenstand eines Entwicklungsprojektes dauerhaft abzuspeichern ist auf den Menüpunkt "Aktuelles Projekt archivieren" zu klicken.
Durch diese Aktion wird ein Archiv-Ordner als Unterordner im aktuellen Projektordner erzeugt. Der Ordner erhält als Namen den aktuellen Generierungszeitpunkt (Form JJJJMMTTSSMM - Jahr, Monat, Tag, Stunde, Minute). In diesen neu generierten Ordner werden Kopien aller Quellendateien des Projektes (Dateierweiterung .jav, .java, .htm, .html) gespeichert. Die erfolgreiche Anlegung des Archives wird angezeigt und protokolliert.
Archiviertes Projekt zurückladen
Um die zu einem früheren Zeitpunkt gesicherten Quellendateien eines Projektes aus einem bestehenden Archiv-Ordner wieder für die aktuelle Projektarbeit zu aktivieren ist auf den Menüpunkt "Archiviertes Projekt zurückladen" zu klicken.
Es öffnet sich das Fenster mit dem Titel "Projekt von bestehendem Archiv laden" das alle potentiellen Archiv-Ordner eines Projektes in aufsteigender Sortierfolge auflistet - d.h. in der Reihenfolge ihres Entstehens: ältestes Archiv ganz oben, jüngstes Archiv ganz unten.
Durch die Auswahl eines Archives in der Liste und durch anschließendes Drücken der Schaltfläche "Übertragen" werden alle Quellendateien (Dateien mit der Endung .jav; .java; .htm; .html) des markierten Archiv-Ordners in den aktuellen Projektordner übertragen. Bestehende Dateien gleichen Namens werden dabei ohne weitere Warnung überschrieben. Sonstige Dateien im Projektordner (z.B. Dateien mit der Endung .class) bleiben erhalten. Wenn die Class-Dateien auf den Zustand des retaurierten Projektes angepasst werden müssen, dann ist eine Gesamtumwandlung des Projektes auszuführen!
Die Schaltfläche "DateiDialog" öffnet den plattformspezifischen Dateidialog. Über den Dateidialog kann eine einzelne Quellendatei ausgewählt werden, die retauriert werden soll. Dabei ist es zulässig, auch den Ordner zu wechseln. Der im Dateidialog angezeigte Ordner wird als Quelle der zu restaurierenden Datei verwendet. Die einzelne Datei wird restauriert, wenn die Schaltfläche "Übertragen" betätigt wird! Auch hier wird keine Bestätigung der Aktion verlangt!
Das Fenster wird mittels der Schaltfläche "Verlassen" oder der Schaltfläche "X" (Exit) in der rechten oberen Fensterecke wieder geschlossen.
Der Dialog zur Generierung der HTML File für den Appletaufruf
Der "Dialog zur Generierung der HTML Datei" dient der Festlegung der Parameter, die zur Initialisierung der HTML Datei erforderlich sind, über die ein Applet mittels eines Web-Browsers oder des "Appletviewers" gestartet werden soll.
Der "Dialog zur Generierung der HTML Datei" wird aus dem Dialog "Datei erzeugen und initialisieren" heraus aufgerufen (gestartet aus dem "JadeIDE" Hauptfenster über Menü "Projektaktionen" Menüpunkt "HTML Datei erzeugen/ändern") wenn Datei Typ ".html" und Schablone "standard" markiert wurde. Der Dialog enthält folgende Datenfelder:
Dateiname
Feld zur Eingabe des HTML Dateinamens. Der Dateiname muss die Namenserweiterung ".htm" oder ".html" haben.
CodeBase
Feld um die Stelle (Verzeichnis oder Server) anzugeben, an der das Applet zu finden ist.
JAR Archiv(e)
Feld um das JAR Archiv (die JAR Archive) für das aufzurufenden Applet anzugeben.
Die Pfadangabe sollte relativ zur HTML Datei gemacht werden; JadeIDE nimmt dabei an, dass sich die JAR Archive im Projektordner oder einem seiner Unterordner befinden, da auch die erzeugte HTML Datei im Projektordner abgelegt wird. Sind mehrere JAR Archive zu spezifizieren, dann sind die einzelnen Angaben durch ein Komma zu trennen. Über die Schaltfläche [... ] kann der betriebssystemspezifische Dateidialog aufgerufen werden, um die JAR Archive auszuwählen. Um mehrere JAR Dateien zu spezifizieren kann der Dateidialog auch mehrfach aufgerufen werden. Bei jedem Aufruf ist nur eine JAR Datei auszuwählen.
(Hinweis: nicht alle Browser unterstützen das "archive=" Schlüsselwort im "applet" HTML-Tag.)
Breite
Feld um die Breite des Fensters anzugeben, in dem das Applet präsentiert werden soll.
Höhe
Feld um die Höhe des Fensters anzugeben, in dem das Applet präsentiert werden soll.
Hor.Abst.
Feld um den horizontalen Abstand des Fensters vom Umfeld anzugeben.
Vert.Abst.
Feld um den vertikalen Abstand des Fensters vom Umfeld anzugeben.
Alt. Text
Feld um den Text einzugeben, der angezeigt werden soll, wenn der Web-Browser das Applet nicht ausführen kann.
Ausrichtung
Auswahl um die gewünschte Positionierung des Applets im Fenster anzugeben.
Parm.Liste
Textliste die alle momentan definierten Parameter und deren Werte enthält.
Parm.Name
Feld zur Eingabe des Namens eines zu definierenden Applet-Parameters.
Parm.Wert
Feld zur Eingabe des Wertes eines zu definierenden Applet-Parameters.
Der "Dialog zur Generierung der HTML Datei" stellt folgende Funktionen zur Verfügung:
Grundstellung der Datenfelder [Grundstellung]
Wenn die "Grundstellung" Schaltfläche gedrückt wird, werden alle Dialogfelder auf ihre Grundstellung (Default Values) zurückgesetzt. Bestehende Eingaben gehen verloren.
Neuen Parameter hinzufügen [Prm hinzufügen]
Um einen neuen Parameter hinzuzufügen, sind folgende Aktionen auszuführen:
Ins "Parm.Name" Feld den Namen des Parameters eingeben.
Ins "Parm.Wert" Feld den Wert des Parameters eingeben.
Die "Parm hinzufügen" Schaltfläche anklicken. Der Parametername und der Parameterwert wird ins "Parm.Liste" Feld übertragen und die Eingabefelder werden gelöscht.
Parameter um eine Position hochrücken [Prm höher]
Um einen Parameter in der Liste der definierten Parameter um eine Position nach oben zu rücken, sind folgende Aktionen durchzuführen:
Hochzurückenden Parameter durch anklicken mit der linken Maustaste markieren.
Die "Parm höher" Schaltfläche anklicken. Der Eintrag wird um eine Position in der Liste der definierten Parameter nach oben gerückt, sofern er nicht schon an der ersten Position steht.
Parameter um eine Position nach unten rücken [Prm tiefer]
Um einen Parameter in der Liste der definierten Parameter um eine Position nach unten zu rücken, sind folgende Aktionen durchzuführen:
Nach unten zu rückenden Parameter durch anklicken mit der linken Maustaste markieren.
Die "Parm tiefer" Schaltfläche anklicken. Der Eintrag wird um eine Position in der Liste der definierten Parameter nach unten gerückt, sofern er nicht schon an der letzten Position steht.
Ausgewählten Parameter löschen [Prm entfernen]
Um einen definierten Parameter aus der Liste der definierten Parameter zu löschen, sind folgende Aktionen durchzuführen:
Den zu löschenden Parameter durch anklicken mit der linken Maustaste markieren.
Die "Parm entfernen" Schaltfläche anklicken. Der Eintrag wird aus der Liste der definierten Parameter gelöscht.
Sichern und Dialog beenden [Erstellen]
Wenn die "Ende mit Sichern" Schaltfläche angeklickt wird, dann wird die bereitgestellte Eingabe geprüft. Wenn ein Fehler auftritt, wird eine entsprechende Meldung zum fehlerhaften Feld ausgegeben, so dass der Fehler behoben werden kann.
Ist alles OK, dann wird der Inhalt der HTML Datei generiert. Wenn erforderlich, wird eine neue HTML Datei erzeugt und initialisiert. Wenn die Datei bereits existiert, wird der bestehende Inhalt ohne weitere Warnung überschrieben.
Der Dialog zur Generierung des Quellencodes für ein Java Window Frame dient der Festlegung der Parameter, die den Generierungsprozess für den Quellencode steuern.
Der Dialog wird über den Eintrag "Windowframe erzeugen" aus dem Menü "Projektaktionen" des JadeIDE Hauptfensters aufgerufen (siehe: Die JadeIDE Projektaktionen).
Generiert wird durch den Dialog die Codeschablone für das Fenster mit dem Menübalken, den einzelnen Menüeinträgen, den Menüpunkten für jeden Menüeintrag sowie dem Inhalt des Fensters ("ContentPane"). Das Fenster kann mit den üblichen AWT (Label, TextField, TextArea, Choice, Button, usw.) beziehungsweise Swing Konstrukten (JLabel, JTextField, JTextArea, JButton, JComboBox usw.) aufgebaut werden.
Vorbereitung der Generierung
Zur Vorbereitung für die Generierung eines "Window Frames" sollte die gewünschte Menüstruktur und der gewünschte Fensterinhalt vollständig skizziert sein, also alle Hauptmenünamen, alle Namen der Menüeinträge inklusive der Buchstaben, die als Kürzel für den Tastaturaufruf verwendet werden sollen, sowie alle erforderlichen Fenstertexte und Datenfelder (gegliedert nach Fensterzeilen im "ContentPane").
Das Dialogfenster "Window Frame Erzeugen"
Das Dialogfenster stellt alle erforderlichen Eingabefelder sowie die Schaltflächen zur Auslösung der erforderlichen Aktionen zur Verfügung.
Der Dialog enthält folgende Datenfelder:
Fenstername
Im Feld "Fenstername" wird der Name der Window Frame Klasse vergeben. Der Name sollte den gültigen Konventionen für die Benennung von Javaklassen folgen.
mit Swing
Über die Checkbox "mit Swing" wird definiert, ob Swing Komponenten verwended werden sollen (Box angeklickt - Standardeinstellung) oder nicht (Box nicht angeklickt).
Hinweis: Swing Komponenten sind sogenannte "lightweight" Komponenten. Das bedeuted, ihre Standard-Eigenschaften sind nicht so stark festgelegt wie die der entsprechenden AWT Komponenten und können damit vom Entwickler viel weitgehender selbst bestimmt werden. Diese gewonnene Flexibilität muss allerdings durch einem zum Teil wesentlich höheren Programmieraufwand erkauft werden.
Fensterbreite
Im Feld "Breite" wird die horizontale Ausdehnung des Fensters in Pixeln (Bildpunkten) vorgegeben. Der Wert ist ein Initialisierungswert. Alle generierten Fenster werden so generiert, dass sie in der Größe verändert werden können. Soll die endgültige Größe des Fensters fest sein, so muss der generierte Quellencode entsprechend nachbearbeitet werden.
Fensterhöhe
Im Feld "Höhe" wird die vertikale Ausdehnung des Fensters in Pixeln (Bildpunkten) vorgegeben. Der Wert ist ein Initialisierungswert. Alle generierten Fenster werden so generiert, dass sie in der Größe verändert werden können. Soll die endgültige Größe des Fensters fest sein, so muss der generierte Quellencode entsprechend nachbearbeitet werden.
Definierte Menüs
Im aufklappbaren Auswahlfeld "Definierte Menüs" werden alle bereits definierten Hauptmenü Einträge angezeigt. Die Reihenfolge der Einträge legt die Reihenfolge der Hauptmenüeinträge im Menübalken von links nach rechts fest (erster Eintrag ganz links, letzter Eintrag ganz rechts).
Menü Einträge
Im aufklappbaren Auswahlfeld "Menü Einträge" werden alle bereits definierten Menüpunkte eines im Feld "Definierte Menüs" selektierten Hauptmenü Eintrages angezeigt. Die Reihenfolge der Einträge legt die Reihenfolge der Menüpunkte in der aufgeklappten Menüpunkteliste von oben nach unten fest (erster Eintrag ganz oben, letzter Eintrag ganz unten).
Neuer Eintrag
Im Feld "Neuer Eintrag" wird der Name eines neu zu definierenden Hauptmenüs bzw. eines Menüpunktes eingegeben. Die Art der Verwendung des Eintrages wird über die anschliessend betätigte Schaltfläche festgelegt.
Kürzel
Im Feld "Kürzel" wird das Zeichen (maximal eine Stelle) eingegeben, das zusammen mit der "Strg" Taste den Tastaturaufruf der entsprechenden Funktion zulässt.
Ein Kürzel wird nur für einen Menüpunkt Eintrag übernommen. Hauptmenüeinträge können keine Kürzel bekommen.
Anmerkung: Generiert wird nur die "Strg-Char" ("Ctrl-Char") Tastenfolge. Sollen andere Folgen (z.B. "Alt-Char") verwendet werden, so ist der generierte Code entsprechend zu modifizieren. Das gilt auch für die Verwendung von Funktionstasten (F1....F24). Auch Trennlinien müssen nachträglich in die Menüstruktur eingefügt werden.
Der Dialog stellt folgende Funktionen bereit:
nach oben
Über die Schaltflächen "nach oben" kann ein bereits in einer Liste enthaltener Eintrag um eine Position nach oben verschoben werden, sofern er nicht schon an der ersten Stelle steht.
nach unten
Über die Schaltfläche "nach unten" kann ein bereits in einer Liste enthaltener Eintrag um eine Position nach unten verschoben werden, sofern er nicht schon an der letzten Stelle steht.
entfernen
Über die Schaltfläche "entfernen" kann der in einer Liste markierte Eintrag entfernt werden. Hat ein Eintrag abhängige Einträge, so werden diese abhängigen Einträge auch entfernt.
Fensterinhalt definieren
Über die Schaltfläche "Fensterinhalt definieren" wird der Dialog zur Festlegung der Gliederungszeilen des Fensters aufgerufen.
Identisch zum Vorgehen bei der Definition eines Dialogfensters werden über diesen Dialog die erforderlichen Gliederungszeilen verwaltet. Folgende Schaltflächen stehen zur Verfügung:
alle definierten Gliederungszeilen wieder entfernen
und
Zurück
zum Ausgangsfenster zurückkehren, z.B. um ein definiertes Fenster testweise anzuzeigen oder den Java-Code zu generieren, wenn der Fensteraufbau den Anforderungen entspricht.
Neu als Menü
Über die Schaltfläche "Neu als Menü" wird der Eintrag aus den Feld "Neuer Eintrag" in die Liste der "Definierten Menüs" übertragen. Der Eintrag wird unmittelbar hinter der markierten Eintragung im Auswahlfeld "Definierte Menüs" eingefügt. Wenn keine explizite Markierung vorgenommen wurde, dann ist der zuletzt hinzugefügte Eintrag der markierte Eintrag.
Neu als Eintrag
Über die Schaltfläche "Neu als Eintrag" wird der Eintrag aus den Feld "Neuer Eintrag" kombiniert mit einem eventuell vorgegebenen "Kürzel" in die Liste der definierten "Menü Einträge" übertragen. Der Eintrag wird unmittelbar hinter der markierten Eintragung im Auswahlfeld "Menü Einträge" eingefügt. Wenn keine explizite Markierung vorgenommen wurde, dann ist der zuletzt hinzugefügte Eintrag der markierte Eintrag.
Grundstellung
Über die Schaltfläche "Grundstellung" werden alle Eingabefelder und Auswahlfelder in ihren Grundzustand zurückversetzt. Alle bereits eingegebenen Werte gehen dadurch verloren.
Beenden
Über die Schaltfläche "Beenden" wird das Dialogfenster geschlossen. Die eingegebenen Werte werden nicht für einen Folgeaufruf zwischengespeichert. Wurde also zuvor keine Codegenerierung vorgenommen, dann sind diese Werte verloren.
Fenster Testen
Über die Schaltfläche "Fenster Testen" wird die Generierung von Quellencode (unter Verwendung der momentan definierten Parameter) angestoßen und das Ergebnis als Testausgabe in einem besondern Fenster angezeigt. Für diese Funktion muss der "Fenstername" noch nicht und die "Fensterdimension" noch nicht endgültig vorgegeben sein. Eine erzeugte Testausgabe wird vielmehr verwendet, um die gewünschte und erforderliche Fenstergröße über Variation des Testfensters zu ermitteln, denn die aktuelle Größe wird im Überschriftsbalken des Testfensters angezeigt. Die Veränderung der Fenstergröße ist immer dann erforderlich, wenn offensichtlich nicht alle definierten Hauptmenüpunkte angezeigt werden. Sehr häufig fehlt der für die Anzeige erforderliche Platz und die Elemente tauchen auf, wenn das Fenster verbreitert wird.
Code Generieren
Über die Schaltfläche "Code Generieren" wird die endgültige Generierung des Quellencodes angestoßen. Für diese Funktion muss der Fenstername angegeben sein und die endgültige Fensterdimension sollte festgelegt sein. Der Quellencode wird im Ordner des momentan aktive Projektes erzeugt und die Klasse wird in die Liste der Klassen des Projektes aufgenommen. Der erzeugte Code kann dann mit den normalen Entwicklungsfunktionen (Editieren, Umwandeln, ..) weiterbearbeitet werden.
Beispiel eines definierten Fensters
Die folgende Eingabe erzeugt das darunter abgebildete Fenster.
Fenstername: DemoWindow
Fensterbreite: 500
Fensterhöhe: 400
Neuer Eintrag: File (aufnehmen über Schaltflächen "Neu als Menü")
Neuer Eintrag: Kürzel:
new
open
save S
save as
exit X
(über Schaltfläche "Neu als Eintrag" mit Menü "File" selektiert )
Neuer Eintrag: Edit (aufnehmen über Schaltflächen "Neu als Menü")
Neuer Eintrag: Kürzel:
undo
redo
cut
copy C
paste V
(über Schaltfläche "Neu als Eintrag" mit Menü "Edit" selektiert )
Neuer Eintrag: Help (aufnehmen über Schaltflächen "Neu als Menü")
Neuer Eintrag: Kürzel:
content
about
(über Schaltfläche "Neu als Eintrag" mit Menü "Help" selektiert )
Zeilendefinition:
Zeilen Name Element Typ Element Name Feldbreite
line1 mit Label Textfield
TextField TF1 40
line2 mit Label Textarea
TextArea TA1 40
line3 mit Label Selections
Checkbox Check1 1
Checkbox Check2 0
Choice/.. Combo1
line4 mit Label List
List List1
Label Canvas
Canvas Canvas1
line5 mit GridPanel GridPan1 (Klick: Panel füllen)
GridPan1 mit Button Help
Button Defaults
Button Return
Erzeugtes Fenster (bei Verwendung von AWT Konstrukten)
Erzeugtes Fenster (bei Verwendung von Swing Konstrukten)
Die Dialoge zur Generierung des Quellencodes für ein Dialog Fenster dienen der Festlegung der Parameter, die den Generierungsprozess für den Quellencode steuern.
Der Startdialog zur Generierung eines "Dialog Fensters" wird über den Eintrag "Dialogfenster erzeugen" aus dem Menü "Projektaktionen" des JadeIDE Hauptfensters aufgerufen (siehe: Die JadeIDE Projektaktionen). Der Aufruf des Unterdialoges erfolgt über eine Schaltfläche des Startdialoges.
Der Generierungsvorgang erfolgt nach folgendem Schema:
1. Festlegung der Basisparameter der Dialog Klasse
Für das Dialogfenster ist der Fenstername (das ist der Klassenname) sowie die Fensterbreite und die Fensterhöhe (in Bildpunkten - Pixeln) festzulegen.
2. Aufteilung des Dialoges in einzelne Zeilen
Das Dialogfenster wird in horizontale Abschnitte (Zeilen) aufgeteilt. Jede dieser Zeilen stellt einen Behälter für in der Zeile anzuzeigende Daten dar (das sind die Feldbezeichnungen und die Eingabefelder).
3. Festlegung der Zeileninhalte
Für jede Zeile werden die Datenfelder in der Reihenfolge definiert, in der sie später innerhalb der Zeile angezeigt werden sollen. Dabei kann jede Zeile ein oder mehrere (im Prinzip beliebig viele) Felder enthalten. Die auf der ersten Ebene definierten Felder werden als GridBagLayout Elemente angezeigt. Ein Feld kann dabei selbst wieder als Behälter (Container) für weitere Felder dienen. Diese Container werden als "Panel" mit GridLayout aufgefasst, die in Containern enthaltenen Felder sind also GridLayout Elemente.
Der Startdialog
Der Startdialog dient der Festlegung der Basisparameter (Fenstername und Fensterdimension) sowie der Zeilenstruktur des Dialogfensters. Der Startdialog ermöglicht auch die Testanzeige der generierten Struktur und schließlich die endgültige Generierung des Quellencodes für das neue Dialogfenster.
Der Startdialog enthält folgende Datenfelder:
Fenstername
Im Feld "Fenstername" wird der Name der Dialogklasse vergeben. Der Name sollte den gültigen Konventionen für die Benennung von Javaklassen folgen.
mit Swing
Über die Checkbox "mit Swing" wird definiert, ob Swing Komponenten verwended werden sollen (Box angeklickt) oder nicht (Box nicht angeklickt).
Hinweis: Swing Komponenten sind sogenannte "lightweight" Komponenten. Das bedeuted, ihre Standard-Eigenschaften sind nicht so stark festgelegt wie die der entsprechenden AWT Komponenten und können damit vom Entwickler viel weitgehender selbst bestimmt werden. Diese gewonnene Flexibilität muss allerdings durch einem zum Teil wesentlich höheren Programmieraufwand erkauft werden.
Breite
Im Feld "Breite" wird die horizontale Ausdehnung des Dialogfensters in Pixeln (Bildpunkten) vorgegeben. Der Wert ist ein Initialisierungswert. Alle generierten Fenster werden so generiert, dass sie in der Größe verändert werden können. Soll die endgültige Größe des Fensters fest sein, so muss der generierte Quellencode entsprechend nachbearbeitet werden.
Höhe
Im Feld "Höhe" wird die vertikale Ausdehnung des Dialogfensters in Pixeln (Bildpunkten) vorgegeben. Der Wert ist ein Initialisierungswert. Alle generierten Fenster werden so generiert, dass sie in der Größe verändert werden können. Soll die endgültige Größe des Fensters fest sein, so muss der generierte Quellencode entsprechend nachbearbeitet werden.
Zeilenliste
Im Auswahlfeld "Zeilenliste" sind alle bereits definierten Zeilen aufgelistet. Die Reihenfolge der Einträge legt die Reihenfolge der Zeilen (erster Eintrag: ganz oben, letzter Eintrag: ganz unten) im Fenster fest.
Zeilenname
Im Feld "Zeilenname" wird der Name einer neu zu definierenden Dialogfensterzeile eingeben.
Der Startdialog stellt folgende Funktionen bereit:
nach oben
Über die Schaltfläche "nach oben" kann ein bereits in der Zeilenliste enthaltener Eintrag (und damit die entsprechende Zeile) um eine Position nach oben verschoben werden, sofern er nicht schon an der ersten Stelle steht.
nach unten
Über die Schaltfläche "nach unten" kann ein bereits in der Zeilenliste enthaltener Eintrag (und damit die entsprechende Zeile) um eine Position nach unten verschoben werden, sofern er nicht schon an der letzten Stelle steht.
entfernen
Über die Schaltfläche "entfernen" kann der in der Zeilenliste markierte Eintrag (und damit die entsprechende Zeile) entfernt werden.
Zeile hinzufügen
Über die Schaltfläche "Zeile hinzufügen" wird der Eintrag aus den Feld "Zeilenname" in die "Zeilenliste" übertragen. Der Eintrag wird unmittelbar hinter der markierten Eintragung im Auswahlfeld "Zeilenliste" eingefügt. Wenn keine explizite Markierung vorgenommen wurde, dann ist der zuletzt hinzugefügte Eintrag der markierte Eintrag.
Zeile füllen
Über die Schaltfläche "Zeilen füllen" wird ein Sekundärdialog aufgerufen, über den die Datenelemente, die in einer Zeile enthalten sein sollen, festgelegt werden.
Umwandeln und Testen
Über die Schaltfläche "Umwandeln und Testen" wird die Generierung von Quellencode (unter Verwendung der momentan definierten Parameter) angestoßen und das Ergebnis als Testausgabe in einem besondern Fenster angezeigt. Für diese Funktion muss der "Fenstername" noch nicht und die "Fensterdimension" noch nicht endgültig vorgegeben sein. Eine erzeugte Testausgabe wird vielmehr verwendet, um die gewünschte und erforderliche Fenstergröße über Variation des Testfensters zu ermitteln, denn die aktuelle Größe wird im Überschriftsbalken des Testfensters angezeigt. Die Veränderung der Fenstergröße ist immer dann erforderlich, wenn offensichtlich nicht alle definierten Felder angezeigt werden. Sehr häufig fehlt der für die Anzeige erforderliche Platz und die Elemente tauchen auf, wenn das Fenster vergrößert wird.
Dialog Generieren
Über die Schaltfläche "Dialog Generieren" wird die endgültige Generierung des Quellencodes angestoßen. Für diese Funktion muss der Fenstername angegeben sein und die endgültige Fensterdimension sollte festgelegt sein. Der Quellencode wird im Ordner des momentan aktive Projektes erzeugt und die Klasse wird in die Liste der Klassen des Projektes aufgenommen. Der erzeugte Code kann dann mit den normalen Entwicklungsfunktionen (Editieren, Umwandeln, ..) weiterbearbeitet werden.
Hinweis: Wenn der Startdialog für die Fenstergenerierung geschlossen wird, gehen alle für die aktuelle Generierung gespeicherten Parameter verloren. Eine Sicherung der Rohdefinition eines Dialogfensters ist (momentan) nicht vorgesehen, da die erforderliche Anzahl der einzugebenden Parameter für die Generierung eines Fensters sehr gering ist und demzufolge der Generierungsprozeß so kurz ist, dass er eigentlich immer abgeschlossen werden kann.
Der Dialog zur Festlegung der Datenfelder (Sekundärdialog)
Der Sekundärdialog dient der Festlegung der Datenfelder die in einer Datengruppe enthalten sein sollen. Datengruppe kann dabei eine Fensterzeile sein, es kann aber auch ein sogenannter "Container" sein. Ein Container ist dabei ein Gruppierungselement, das zusammengehörige Elementardatenfelder zusammenfassen soll (Beispiel: eine Gruppe von Schaltflächen).
Der Sekundärdialog enthält folgende Datenfelder:
Containername
Im Feld "Containername" wird der Name der zu definierenden Datengruppe (Zeile oder Container) angezeigt.
Elementliste
Im Auswahlfeld "Elementliste" sind alle bereits definierten Datenelemente mit Feldname und Feldtyp aufgelistet. Die Reihenfolge der Einträge legt die Reihenfolge der Elemente (erster Eintrag: ganz links, letzter Eintrag: ganz rechts) in der zu definierenden Datengruppe fest. Wird ein Eintrag markiert, so werden die Felder "Elementtyp", "Elementname" und "Feldbreite" entsprechend gefüllt.
Elementtyp
Im Auswahlfeld "Elementtyp" stehen alle momentan verfügbaren Datenelementypen zur Selektion zur Verfügung. Verfügbar sind momentan die Elementtypen:
Button - Schaltfläche. Die Schaltfläche erhält den Elementnamen als Aufschrift.
Canvas - Zeichenfläche. Eine Fläche, in die mit "paint" Befehlen geometrische Elemente (Linien, Kreise, ...) sowie Schriften gezeichnet werden können. Dazu ist allerdings "SubClassing" der Canvas erforderlich!
Checkbox - Binärauswahl mit den Stati "ein" und "aus".
Choice/ComboBox - Aufklappbare Liste von Texteinträgen. Das oberste Feld enthält das in der Liste selektierte Element.
FlowPanelxxxx - Behälter für weitere Datenelemente, die zusammengehören sollen. xxxx gibt die Ausrichtung der enthaltenen Elemente an. Möglich sind: linksbündige (xxxx = Left), rechtsbündige (xxxx = Right) und mittige (xxxx = Center) Ausrichtung.
GridPanel - Behälter für weitere Datenelemente, die zusammengehören sollen. Die Ausrichtung erfolgt mittels eines Gitternetzes (grid).
Label - Bezeichner. Dient der Benennung eines Datenelementes. Angezeigt wird der im Feld "Elementename" vergebene Name.
List - Liste. Aufklappbare Liste von selektierbaren Texteinträgen.
TextArea - Mehrspaltiges und mehrzeiliges Texteingabe- oder Textanzeigefeld. Eine TextArea wird immer mit rechten und unteren "Scrollbars" und mit Eingabemöglichkeit generiert. Soll dies geändert werden, so ist eine Nachbearbeitung des generierten Quellencodes erforderlich.
TextField - Mehrspaltiges aber einzeiliges Texteingabe- oder Textanzeigefeld. Ein TextField wird immer mit Eingabemöglichkeit generiert. Soll dies geändert werden, so ist eine Nachbearbeitung des generierten Quellencodes erforderlich.
Elementname
Im Eingabefeld "Elementname" wird der Bezeichner des Datenfeldes vorgegeben. Der Name sollte den gültigen Konventionen für die Benennung von Java Datenfeldern folgen. Grundsätzlich sind Bezeichner zugelassen, die Leerzeichen enthalten. Diese Leerzeichen werden aber durch Unterstreichungsstriche ersetzt, um Umwandlungsfehler zu vermeiden.
Feldbreite
Das Eingabefeld "Feldbreite" ist mehrdeutig. Beim Elementtyp "TextArea" und "TextField" dient das Feld der Vorgabe einer Länge für ein Datenfeld. Diese Länge hat Einfluß auf den erforderlichen Raum auf den Bildschirm, bestimmt aber nicht die Anzahl der Zeichen, die eingegeben werden können.
Beim Elementtyp "Checkbox" dient das Feld der Vorgabe des Intitialisierungszustandes (Ein oder Aus - checked oder unchecked). Es sind dann nur die Werte "0" für "aus/unchecked" und "1" für "ein/checked" zulässig.
Der Sekundärdialog stellt folgende Funktionen bereit:
nach oben
Über die Schaltfläche "nach oben" kann ein bereits in der Elementliste enthaltener Eintrag um eine Position nach oben verschoben werden, sofern er nicht schon an der ersten Stelle steht.
nach unten
Über die Schaltfläche "nach unten" kann ein bereits in der Elementliste enthaltener Eintrag um eine Position nach unten verschoben werden, sofern er nicht schon an der letzten Stelle steht.
entfernen
Über die Schaltfläche "entfernen" kann der in der Elementliste markierte Eintrag entfernt werden.
Element ändern
Über die Schaltfläche "Element ändern" wird der momentan im Feld "Elementliste" markierte Eintrag überschrieben, und zwar mit den neuen Werten aus dem Feld "Elementname" verknüpft mit dem aktuell selektierten "Elementtyp".
Element hinzufügen
Über die Schaltfläche "Elem. hinzufügen" wird der Eintrag aus dem Feld "Elementname" verknüpft mit dem aktuell selektierten Elementtyp in die "Elementliste" übertragen. Der Eintrag wird hinter der markierten Eintragung im Auswahlfeld "Elementliste" eingefügt. Wenn keine explizite Markierung vorgenommen wurde, dann ist der zuletzt hinzugefügte Eintrag der markierte Eintrag.
Container füllen
Über die Schaltfläche "Container füllen" wird ein weiterer Sekundärdialog aufgerufen, über den die Datenelemente, die in einem "Container" enthalten sein sollen, festgelegt werden. Die Auswahl ist nur gültig, wenn in der Elementliste ein Eintrag vom Typ "Container" markiert ist. Container können so im Prinzip beliebig tief verschachtelt werden.
Tips für die Erzeugung von Dialogfenstern
Zur Erzeugung des Quellencodes für ein Dialogfenster sollte wie folgt vorgegangen werden:
Anfertigung einer rohen Skizze über die Anordnung der Elemente des Dialogfensters mit Festlegung der Elementnamen. Die Gliederung des Fensters in einzelne Zeilen sollte sichtbar sein.
Gruppierung der Elemente für jede Zeile. Festlegung der Container und eventuell notwendiger Subcontainer.
Eingabe der Zeilen im Startdialog.
Eingabe der Elemente im Sekundärdialog. Sofern Container definiert werden: Eingabe der Elemente für die Container und Subcontainer.
Ausführung einer Testumwandlung und Testanzeige.
Feststellen der optimalen Größe des Fensters durch schieben der Fensterränder. Es sollte solange mit der Größe experimentiert werden, bis alle definierten Elemente auch angezeigt werden.
Eventuell Modifikation des Layouts durch Veränderung der Feldbreiten und der Containerzuordnung der Felder vornehmen.
Übernahme der optimalen Fenstergröße in die Felder "Breite" und "Höhe" des Startdialoges.
Wenn die Anordnung akzeptabel ist: Eingabe des Fensternamens (sofern nicht schon geschehen) und endgültige Generierung des Fensters.
Durchführung der erforderlichen Überarbeitungen.
Erforderlich kann sein: Neupositionierung des automatisch bereitgestellten Nachrichten-Feldes, die Definition der Eingabefähigkeit [setEditable()],
eine Gewichtung von Feldbreiten und Tiefen [gbc.weightx, gbc.weighty], Einfügung nicht unterstützter Komponenten, Änderung der Container von GridLayout auf ein anderes Layout (z.B. FlowLayout - Vorsicht: Layout-Änderungen sind ein schwerer Eingriff in die etablierten Anordnungsregeln)....
Durchführung der erforderlichen Ergänzungen.
Auf jeden Fall erforderlich ist: die Festlegung der "Fill" Werte für Choice/ComboBox Elemente und die Definition der Aktionen für die Schaltflächen [handleXXXXXButton()].
Beispiel
Die folgende Eingabe erzeugt ungefähr den abgebildeten Dialog - links (bzw. oben) mit AWT Komponenten, rechts (bzw. unten) mit Swing Komponenten!
Startdialog:
Breite: 325, Höhe 300; hinzufügen Zeilen: Z1, Z2, Z3, Z4, Z5
Sekundärdialoge:
Für Z1: Label,Field 1; TextArea,Field_1,32;
Für Z2: Label,Checkmarks; GridPanel,GP1;
Für GP1: CheckBox,Box_1,0;
CheckBox,Box_2,0;
CheckBox,Box_3,1;
Für Z3: Label,Field 2; TextField,Field_2,32;
Für Z4: Label,Field 3; Choice/ComboBox,Field_3;
Für Z5: GridPanel,GP2
Für GP2: Button,Button_1;
Button,Button_2;
Button,Button_3;
