# JadeIDE Hilfe (V3.7 April 2005)

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.

## Inhaltsverzeichnis

- Einführung
- Die "Setup" Dialoge zur Festlegung der JadeIDE Parameter
  - Der Dialog zur Definition der Basisparameter
  - Der Dialog zur Definition der Projektparameter
  - Der Dialog zur Festlegung der Optionen für den Java Compiler
  - Der Dialog zur Festlegung der Optionen für den "Java Launcher"
  - Der Dialog zur Festlegung der Optionen für das "Java Standard Doclet"
  - Der Dialog zur Festlegung der Startklasse und der erforderlichen Startparameter
  - Eigenschaften der Anzeigefonts anpassen
  - Anzeige der momentan aktivierten Parameterwerte
- Die JadeIDE Projektarbeit

- Projekte zur Bearbeitung auswählen
- Projekt beenden
- Die JadeIDE Funktionsauswahl
- Die JadeIDE Projektaktionen
- Der Dialog zur Generierung der HTML File für den Appletaufruf
- Der Dialog zur Generierung eines Window Frames
- Die Dialoge zur Generierung eines Dialogfensters

- Der JADE Editor
  - Die Funktionen des Datei Menüs
  - Die Funktionen des Edit Menüs
  - Die Funktionen des Optionen Menüs
  - Die Funktionen des Lesezeichen Menüs
  - Die Funktionen des Pop-Up Menüss
  - Die Funktionen der Werkzeug-Auswahl
- Installation

- Voraussetzungen
- Installation
- Deinstallation
- Programmaufruf

## Einführung

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:

- Definition der erforderlichen Basisparameter (Funktionen => Basisparameter verwalten)
- Definition der erforderlichen Projekte und Projektparameter (Funktionen => Projektdefinition vornehmen)
- Auswahl eines zu bearbeitenden Projektes (Funktionen => Projekt auswählen)
- Jade Editor unter anderen mit folgenden Möglichkeiten:
  - direkt in eine Methode der editierten Klasse verzweigen
  - vorgegebene und selbsterzeugte Java Code Templates in den Quellentext einfügen
  - einfügen und verwalten von elementaren Debugging-Anweisungen (CheckPoints)
  - überprüfen des Codes mit dem Code-Checker JiveLint von Sureshot (zur Zeit nur Windows).
  (Projektaktionen => Editieren mit Jade Editor)
- Aufrufen eines frei wählbaren Editors zur Dateibearbeitung. (Projektaktionen => Editieren mit externem Editor)
- Aufruf eines frei wählbaren HTML-Editors (Funktionen => HTML-Editor aufrufen)
- Aufruf eines frei wählbaren XML-Editors (Funktionen => XML-Editor aufrufen)
- Aufruf des UML-Editors UMLet der TH Wien (Funktionen => UML-Editor UMLet aufrufen)
- Aufruf der JAVA API Dokumentation mittels eines Web-Browsers (Funktionen => Java API Doku anzeigen)
- Aufruf einer projektspezifischen API Dokumentation mittels eines Web-Browsers (Funktionen => Package API Doku anzeigen)
- Erstellen einer neuen Klasse mit Generierung einer Codeschablone. (Projektaktionen => Neue Klasse generieren)
- Erstellen/ändern einer HTML Datei für den Aufrufe eines Applets. (Projektaktionen => HTML Datei erzeugen/ändern)
- Löschen einer bestehenden Klasse oder HTML Datei. (Projektaktionen => Selektierte Datei löschen)
- Umwandeln einer bestehenden Klasse (Kompilieren). (Projektaktionen => Selektierte Datei umwandeln)
- Generierung und Test des Basiscodes für individuelle Java Fenster mit Menüleiste. (Projektaktionen => Windowframe erzeugen)
- Generierung und Test des Basiscodes für individuelle Java Dialogfenster. (Projektaktionen => Dialogfenster erzeugen)
- Gesamtumwandlung aller Klassen eines Java Paketes - d.h.eines Projektes. (Projektaktionen => Aktives Projekt umwandeln)
- C++/C Header Dateien für JNI erzeugen. (Projektaktionen => Header Dateien für JNI erzeugen)
- Die Java Dokumentation für ein Paket (Projekt) erzeugen. (Projektaktionen => Java Doc generieren (standard oder modifiziert) )
- Starten der Ausführung eines Java Applets. (Projektaktionen => Applet ausführen)
- Starten der Ausführung eines Java Anwendungsprogrammes. (Projektaktionen => Anwendung ausführen)
- Abbruch einer laufenden Umwandlung oder Programmausführung (Projektaktionen => Aktive Aktion abbrechen)
- Anzeige des aktuellen Inhaltes der System Zwischenablage (Funktionen => Zwischenablageinhalt anzeigen)

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.

zum Inhaltsverzeichnis

## 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:

1. 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
2. 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)
3. 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.
4. 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.
5. 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
6. 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:

1. 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.
2. 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.
3. 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.
4. 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;
5. ProjPack - Der Paketname eines Projektes (Hinweis: dieser Name dient als Projektname!)
   Beispiel: com.kur.ide
6. ProjPath - Der Pfad, der zu den Dateien eines Projektes führt (ohne Paket Angabe!)
   Beispiel: E:\WORK\JAVA\
7. 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Der Dialog zur Definition der Basisparameter

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:

1. 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.
2. 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.
3. 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.
4. 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.
5. Ä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".
6. 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Der Dialog zur Definition der Projektparameter

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:

1. 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.
2. 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.
3. 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.)
4. 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.
5. 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.
6. 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.
7. 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.
8. 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.
9. 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.
|  | Das Dialogfenster wird geschlossen.

zum Kapitelanfang zum Inhaltsverzeichnis

### 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Eigenschaften der Anzeigefonts anpassen

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:

1. Der "Dialog-Font", das ist der Font, der zur Anzeige der Fenstertexte (dunkelblaue Texte) verwendet wird.
2. Der "Button-Font", das ist der Font, der zur Anzeige der Schaltflächenbeschriftung (weisse Aufschriften) verwendet wird.
3. 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Anzeige der momentan aktivierten Parameterwerte

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.

zum Kapitelanfang zum Inhaltsverzeichnis

#### Anmerkung zur JadeIDE.INI Datei

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.

zum Kapitelanfang zum Inhaltsverzeichnis

## Die JadeIDE Projektarbeit

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:

1. 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.
2. 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).

zum Kapitelanfang zum Inhaltsverzeichnis

### Projekte zur Bearbeitung auswählen

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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Die JadeIDE Funktionsauswahl

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:

1. Der Name der neu zu erzeugenden Datei (bzw. Klasse) ist in Feld "Datei / Klassen Name" einzugeben.
2. 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.
3. 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.

4. 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:

1. 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.
2. 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:

1. 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.
2. 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:

1. 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.
2. 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:

1. 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.
2. 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.

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 folgenden Elemente können 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).
    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.
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:

1. Der gewünschte URL Eintrag ist über das Menü "HTML Dateien" auszuwählen.
2. 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:

1. Überprüfen, ob die korrekte "MainClass" Parameterschablone aktiv ist.
2. Falls erforderlich die Parameterschablone wechseln oder korrigieren. Dies kann dann notwendig sein, wenn die Startklasse bezüglich der Parameterübergabe verändert worden ist.
3. 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### 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:

1. Ins "Parm.Name" Feld den Namen des Parameters eingeben.
2. Ins "Parm.Wert" Feld den Wert des Parameters eingeben.
3. 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:

1. Hochzurückenden Parameter durch anklicken mit der linken Maustaste markieren.
2. 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:

1. Nach unten zu rückenden Parameter durch anklicken mit der linken Maustaste markieren.
2. 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:

1. Den zu löschenden Parameter durch anklicken mit der linken Maustaste markieren.
2. 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.

zum Kapitelanfang zum Inhaltsverzeichnis

### Der Dialog zur Generierung eines Window Frames

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:

  Zeile hinzufügen
    eine einzelne Gliederungszeile hinzugefügt,
  nach oben, nach unten
    Reihenfolge der Gliederungszeilen ändern,
  entfernen
    nicht mehr benötigte Gliederungszeile entfernen,
  Zeile füllen
    Dialog zum Füllen der Gliederungszeile aufrufen.
  Grundstellung
    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)

zum Kapitelanfang zum Inhaltsverzeichnis

### Die Dialoge zur Generierung eines Dialogfensters

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:
  1. Button - Schaltfläche. Die Schaltfläche erhält den Elementnamen als Aufschrift.
  2. 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!
  3. Checkbox - Binärauswahl mit den Stati "ein" und "aus".
  4. Choice/ComboBox - Aufklappbare Liste von Texteinträgen. Das oberste Feld enthält das in der Liste selektierte Element.
  5. 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.
  6. GridPanel - Behälter für weitere Datenelemente, die zusammengehören sollen. Die Ausrichtung erfolgt mittels eines Gitternetzes (grid).
  7. Label - Bezeichner. Dient der Benennung eines Datenelementes. Angezeigt wird der im Feld "Elementename" vergebene Name.
  8. List - Liste. Aufklappbare Liste von selektierbaren Texteinträgen.
  9. 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.
  10. 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:

1. 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.
2. Gruppierung der Elemente für jede Zeile. Festlegung der Container und eventuell notwendiger Subcontainer.
3. Eingabe der Zeilen im Startdialog.
4. Eingabe der Elemente im Sekundärdialog. Sofern Container definiert werden: Eingabe der Elemente für die Container und Subcontainer.
5. Ausführung einer Testumwandlung und Testanzeige.
6. 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.
7. Eventuell Modifikation des Layouts durch Veränderung der Feldbreiten und der Containerzuordnung der Felder vornehmen.
8. Übernahme der optimalen Fenstergröße in die Felder "Breite" und "Höhe" des Startdialoges.
9. Wenn die Anordnung akzeptabel ist: Eingabe des Fensternamens (sofern nicht schon geschehen) und endgültige Generierung des Fensters.
10. 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)....
11. 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;

zum Kapitelanfang zum Inhaltsverzeichnis

## Der JADE Editor

Der JADE Editor ist ein Editor, der speziell auf die Bedürfnisse eines Programmierers angepasst ist, der Java Quellencode erstellen will. Der JADE Editor fügt sich nahtlos in die JadeIDE ein und ist deren bevorzugter Editor. Bei der Gestaltung des Editors wurde speziell auf Funktionalität und erst an zweiter Stelle auf ein gefälliges Erscheinungsbild geachtet, und zwar, um den Editor möglichst klein und damit (trotz vollständiger Implementierung in Java) ausreichend schnell zu machen.

Das JADE Editor Fenster umfasst einen Menübalken, eine seitlich angeordnete Werkzeugauswahl (tool bar), einen Text-Anzeigebereich, einen (eingabegeschützten) Zeilennummer-Anzeigebereich und (in der unteren linken Ecke) ein Feld, das die Position des Mauszeigers (nicht zu verwechseln mit der Caretposition) im Quellentext anzeigt. Dabei ist die vordere Zahl die Zeilennummer, in der sich der Mauszeiger befindet und die hintere Zahl ist die Zeichenposition in der Textzeile. Der höchste Wert für die Zeichenposition ist die jeweilige Zeilenlänge.

Hinweis: Die Caretposition wird von Textbeginn gezählt, ist also eine Aussage für die Position eines Zeichens gezählt vom Anfang eines Textes. Das erste Textzeichen steht auf Caretposition 0, das letzte Textzeichen steht auf Caretposition = Textlänge-1.

zum Kapitelanfang zum Inhaltsverzeichnis

### Die Funktionen des Datei-Menüs

Über das Datei-Menü des Editors werden die flankierenden Funktionen der Quellencodebearbeitung aufgerufen. Die meisten dieser Funktionen können auch über ihre zugeordnete Tastenkombination aufgerufen werden.
(Achtung: die Tastaturaktivierung ist nur wirksam, wenn das Editorfenster den Eingabefokus hat. Dies ist dann der Fall, wenn der Fenstertitel hervorgehoben ist!)
Die Funktionen (mit ihren Tastaturkombinationen) sind im folgenden Bild aufgeführt:

#### Sichern (auch im Tool-Bar enthalten)

Mit der Funktion "Sichern" wird der momentane Zustand des Quellentextes permanent auf einen Datenträger gespeichert. Damit verschwindet auch der Hinweis auf nicht gesicherte Änderungen in der Kopfzeile des Editors.

#### Alles sichern, Klasse umwandeln (auch im Tool-Bar enthalten)

Mit der Funktion "Alles sichern, Klasse umwandeln" wird der aktuelle Zustand aller über den JADE Editor momentan geöffneten Quellentexte gesichert und daran anschließend eine Kompilierung der Klasse ausgeführt, die im Fenster editiert wird, von dem aus die Aktion aufgerufen worden ist. Damit lässt sich schnell und bequem eine Zwischenkompilation einer Klasse zur Feststellung eventueller Kodierungsfehler vornehmen. Fehler und Nachrichten zur Kompilation werden in den entsprechenden Jade-Fenstern ("Standard Out" und "Standard Error") angezeigt. Aus der "Standard Error" Anzeige heraus kann direkt zur fehlerhaften Zeile gesprungen werde. Dazu ist in dieser Fehleranzeige der entsprechende Fehlerblock anzuklicken. Ist die Klasse, die den Fehler enthält, momentan nicht mittels des Jade-Editors angezeigt, so wird ein Editorfenster für diese Klasse automatisch geöffnet. Allerdings ist es dabei nicht möglich, die fehlerhafte Zeile direkt in die erste Zeile des Anzeigebereiches zu stellen. Vielmehr ist es erforderlich, dazu die Aktion nochmals auszuführen.
Die Umwandlungsnachrichten und Umwandlungsfehlermeldungen können auch über den JadeEditor angedruckt werden. Dazu sind sie über Schaltfläche "Im Editor anzeigen" in den JadeEditor zu übertragen. Aus dem JadeEditor kann dann die Druckvorschau und das endgültige ausdrucken angestoßen werden. Diese Verfahren erlaubt damit auch, dass die Nachrichtendatei vor dem Drucken um bestimmte Bemerkungen ergänzt werden kann.
Mit Auswahl der Funktion "Alles sichern, Klasse umwandeln" verschwindet auch der Hinweis auf nicht gesicherte Änderungen in den Kopfzeilen der offenen Jade-Editoren.
Achtung: Quellentext, der mittels externer Editoren geöffnet wurde und noch offen ist und der eventuell modifiziert worden ist, wird durch diese Aktion nicht gesichert.

#### Papierformat für Druckausgabe festlegen

Die Funktion "Papierformat festlegen" zeigt das Untermenü der verfügbaren Papierformate an, über das dann das gewünschte Papieformat gewählt werden kann. Unterstützt sind zur Zeit die 6 gängigsten Papierformate. Das sind

- DIN A 4 Hoch (210 x 297 mm),
- DIN A 4 Quer (297 x 210 mm),
- US Letter Hoch (207 x 279 mm bzw. 8.5 x 11 Zoll),
- US Letter Quer (279 x 207 mm bzw. 11 x 8.5 Zoll),
- US Legal Hoch (207 x 356 mm bzw. 8.5 x 14 Zoll)
  und
- US Legal Quer (356 x 207 mm bzw. 14 x 8.5 Zoll).

#### Druck-Vorschau aufrufen

Die Funktion "Druck-Vorschau" erlaubt, die Druckausgabe vor dem eigentlichen Drucken zu beurteilen. Der Dialog lässt die Positionierung der Druckausgabe über die Funktionstasten der Werkzeugleiste (rote Pfeiltasten) auf die erste oder die letzte Seite zu. Weiter kann von der jeweils aktuell angezeigten Seite zur vorigen Seite bzw. zur folgenden Seite weitergeblättert werden.

Das Fester des Dialoges lässt sich in der Größe ändern. Die Druckausgabe wird dabei an die jeweilige Fenstergröße angepasst.

Aus dem Dialog heraus lässt sich ebenfalls der Druckvorgang starten. Es kann entweder das ganze Dokument gedruckt werden, es kann aber auch nur die momentan agezeigte Seite ausgegeben werden. Mit der "Exit" Taste kann der Dialog verlassen werden, ohne dass ein Druckvorgang ausgelöst wird.

..........
..........

#### Dokument drucken (auch im Tool-Bar enthalten)

Die Funktion "Dokument drucken" erlaubt die Druckausgabe einer Java Quellendatei. Zur Druckerauswahl wird der systemspezifische "Druck-Dialog" angezeigt. Dieser "Druck-Dialog" erlaubt auch eine Druckumleitung in eine Datei vorzunehmen sowie festzulegen, wieviele Kopien gedruckt werden sollen.

Jede Druckseite enthält in der Kopfzeile den Pfad und den Dateinamen der ausgegebenen Klasse. In der Fußzeile wird die Seitennummer und die genaue Druckausgabezeit angegeben.

#### Generiere HTML Ausgabe

Die Funktion "Generiere HTML Ausgabe" erzeugt von der Java Quellendatei eine Datei in HTML-Format. Diese Datei kann über einen Web Browser angezeigt werden.

#### Abbrechen (kein Sichern)

Mit der Funktion "Abbrechen (kein Sichern)" wird die Editor-Sitzung beendet, ohne dass der momentane Zustand des Quellentextes permanent abgespeichert wird. Damit kann vermieden werden, dass ein korrumpierter Quellentext dauerhaft abgespeichert wird. Auf dem permanenten Speicher bleibt der Zustand der letzten Sicherungsaktion erhalten.
Achtung: Wurde aus einem anderen Editor-Fenster die Funktion "Alles sichern, Klasse umwandeln" aufgerufen, so ist dies die letzte durchgeführte Sicherung des Quellentextes.

#### Ende mit Sichern

Mit der Funktion "Ende mit Sichern" wird der momentane Zustand des Quellentextes permanent auf einen Datenträger gespeichert und die Editor-Sitzung beendet. Die Ende Aktionen, die durch das System Menu des Fensters oder durch den Exit Knopf der Titleleiste ausgelöst werden, führen ebenfalls diese Funktion aus.

zum Kapitelanfang zum Inhaltsverzeichnis

### Die Funktionen des Edit-Menüs

Über das Edit-Menü des Editors werden bestimmte Edit- und Navigations-Funktionen zur Quellencodebearbeitung aufgerufen. Die meisten dieser Funktionen können auch über ihre zugeordnete Tastenkombination aufgerufen werden.
(Achtung: die Tastaturaktivierung ist nur wirksam, wenn das Editorfenster den Eingabefokus hat. Dies ist dann der Fall, wenn der Fenstertitel hervorgehoben ist!)
Die Funktionen (mit ihren Tastaturkombinationen) sind im folgenden Bild aufgeführt:

#### Aufheben (auch im Tool-Bar enthalten)

Die Funktion "Aufheben" hebt eine vorgenommene Edit-Aktion wieder auf. Mehrfaches rückgängig machen ist unterstützt.

#### Erneut ausführen (auch im Tool-Bar enthalten)

Die Funktion "Erneut ausführen" führt eine aufgehoben Edit-Aktion wieder aus. Mehrfache Wiederherstellung ist unterstützt.

#### Alle Prüfpunkte entfernen (auch im Pop-Up Menü enthalten)

Die Funktion "Alle Prüfpunkte entfernen" löscht alle /* CKPT */ Anweisungen im Quellencode der aktuellen Klasse.

#### Ausschneiden (auch im Tool-Bar enthalten)

Die Funktion "Ausschneiden" stellt die aktuelle Selektion (hellblaue Hervorhebung eines Textsegmentes) in die System-Zwischenablage und entfernt sie aus dem Quellentext.

#### Kopieren (auch im Tool-Bar enthalten)

Die Funktion "Kopieren" stellt die aktuelle Selektion in die System-Zwischenablage lässt den Quellentext aber unverändert.

#### Einfügen (auch im Tool-Bar enthalten)

Die Funktion "Einfügen" fügt an der aktuellen Caret-Position (Position des Einfügungszeigers) den Inhalt der System-Zwischenablage ein. Ist Text selektiert, so wird der selektierte Quellentext durch den Inhalt der System-Zwischenablage ersetzt.

#### Alles selektieren

Die Funktion "Alles selektieren" hebt den gesamten Quellentext als selektiert hervor, so dass er ausgeschnitten oder kopiert werden kann.

#### Zu Methode

Die Funktion "Zu Methode" zeigt den Dialog "Methode lokalisieren..." an. Dieser Dialog präsentiert den Klassen-Constructor und alle "public", "private" oder "protected" definierten Methoden einer Klasse in der Form eines "Tree-Views" (d.h. in der Reihenfolge ihres Auftretens) in einem Anzeigefeld. "Inner Classes" werden als Klassenknoten angezeigt. Wird eine Methode oder ein Klassenknoten durch anklicken selektiert und die Schaltfläche "Eintrag lokalisieren" gedrückt, dann wird die Quellentextanzeige auf diese Methode positioniert. Eine Positionierung auf den Aufruf der Methode ist über diesen Dialog nicht möglich. Dazu ist der "Suchen/Ersetzen" Dialog zu verwenden.

Die Schaltfläche "Aufrufende Klassen" des Dialoges "Methode lokalisieren..." erzeugt eine Liste aller Klassen eines Projektes, die entweder die selektierte Methode aufrufen oder eine Methode identischen Namens enthalten. Damit können Methodenaufrufe innerhalb eines Projektes leichter gefunden werden. Durch anklicken der Schaltfläche "Klasse editieren" wird eine selektierte Klasse angezeigt.

Die Schaltfläche "Zurück" beendet den Dialog ohne Neupositionierung des Quellentextes.

Hinweise:
1. Da es in Java kein eindeutiges Schlüsselwort zur Identifizierung einer Methode gibt, und da in der Methodendefinition auch beliebig viele Kommentare sowie selbst definierte Klassennamen als Definition des Types eines Rückgabewertes oder eines Parameterwertes vorkommen können, kann es in sehr seltenen Ausnahmefällen einmal vorkommen, dass JadeIDE eine Methodendefinition nicht richtig erkennt. In diesen Fällen muss zur Lokalisierung der Definition der "Suchen / Ersetzen" Dialog verwendet werden. Es ist daher ratsam, eine Methodendefinition möglichst ohne eingeschlossene Kommentare zu erstellen. Kommentare sollten im Methodenheader oder direkt nach der Methodendefinition angegeben werden.
2. Um die Identifikation von Construktor-Methoden zu erleichtern, sollten sie mit einem Visibility-Schlüsselwort (public, private, protected) definiert werden.
3. Werden im "Tree-View" offensichtlich nicht alle vorhandenen Methoden angezeigt, dann ist der sehr komplexe Analyse-Algorithmus vermutlich durch Stringkonstanten gestört worden, die solche Sonderzeichen enthalten, die im Java Quellencode eine syntaktische Bedeutung haben. Besonders kritisch sind dabei Zeichen wie / \ // ; { [ ' " usw.. Es ist sehr empfehlenswert und gute Kodierpraxis, solche Zeichen in Konstanten in der Form eines Unicodes ("\uxxxx") darzustellen. Die Zeichen können mit der Funktion Unicode einsetzen erzeugt werden. Ist ein Tree offensichtlich unvollständig, so liegt die Ursache in aller Regel in der als letzte angezeigten Methode. Sie sollte überprüft und entsprechend korrigiert werden.

#### Zu Zeile (auch im Tool-Bar enthalten)

Die Funktion "Zu Zeile" erlaubt die Positionierung der Quellentextanzeige auf eine bestimmte Textzeile. Nach Eingabe der Zeilennummer und Betätigung des "Eingabe" Knopfes, wird die Quellentextanzeige auf die entsprechende Zeile neu positioniert. Wird der Dialog über den "Schließen" Knopf (System Menü oder rechte obere Dialogecke) verlassen, dann erfolgt keine Neupositionierung der Quelltextanzeige.

#### Zur zugehörigen }-Klammer (auch im Tool-Bar enthalten)

Die Funktion "Zur zugehörigen }-Klammer" hebt einen "{..}" Block farblich (hellrot) hervor. Als Start Klammer wird die "{" Klammer betrachtet, die als erste nach der aktuellen Caret-Position auftritt.

#### Zur zugehörigen {-Klammer (auch im Tool-Bar enthalten)

Die Funktion "Zur zugehörigen {-Klammer" hebt einen "{..}" Block farblich (hellrot) hervor. Als Start Klammer wird die "}" Klammer betrachtet, die als erste nach der aktuellen Caret-Position auftritt.

#### Zum Anfang (auch im Tool-Bar enthalten)

Die Funktion "Zum Anfang" positioniert die Anzeige auf den Anfang des Quellentextes.

#### Zum Ende (auch im Tool-Bar enthalten)

Die Funktion "Zum Ende" positioniert die Anzeige auf das Ende des Quellentextes.

#### Suchen / Ersetzen (auch im Tool-Bar enthalten)

Die Funktion "Suchen / Ersetzen" erlaubt die Suche nach einem bestimmten Textsegment sowie die Ersetzung dieses Textsegmentes durch einen anderen Wert, sofern dies gewünscht wird. Die Quelltextanzeige wird auf ein gefundenes Textsegment positioniert und das Textsegment wird als Selektion (hellblau unterlegt) gekennzeichnet. Die Suche startet an der aktuellen Caret-Position (der Position des Einfügungszeigers). Die Suche kann zum Dokumentende sowie zum Dokumentanfang hin erfolgen.Bei "Alle suchen" wird das gesamte Dokument vorwärts durchsucht. Weiter ist eine Suche möglich, bei der die Groß/Kleinschreibung ignoriert wird.

Der Dialog unterstützt folgende Einzelfunktionen:

- Festlegung der Suchrichtung (zum Dokumentenanfang hin, zum Dokumentenende hin)und der Suchart (mit oder ohne Berücksichtigung der Groß-/Kleinschreibung ["alles klein"]) über die Suchoptionen.
- Alle Suchen (Schaltfläche "Alle Suchen"): Suchbeginn am Dateibeginn. Anzeige aller Fundstellen. Positionierung des Carets an der letzten Fundstelle.
- In allen offenen Dateien suchen (Schaltfläche "In offenen Dateien suchen"): Durchsuchen aller momentan mit dem Jade Editor geöffneten Dateien. Suchbeginn am Dateibeginn. Anzeige aller Fundstellen.
- Fortgesetzte Einzelsuche (Schaltfläche "Einzeln suchen"): Suchbeginn an der Caret Position. Suchrichtung wie unter Optionen ausgewählt. Anzeige einer Fundstelle. Neupositionierung des Carets je nach Suchrichtung hinter oder vor der Fundstelle zur Ermöglichung einer Weitersuche.
- Fortgesetzte Einzelersetzung (Schaltfläche "Ersetzen"): Suchbeginn an der Caret Position. Suchrichtung wie unter Optionen ausgewählt. Ersetzung eines gefundenen Textes und Positionierung des Quelltextes auf die Zeile, in der die Ersetzung vorgenommen wurde. Neupositionierung des Carets je nach Suchrichtung hinter oder vor der Ersetzungsstelle zur Ermöglichung einer weiteren Ersetzung. Wird eine Suchtext nicht gefunden, so erfolgt ein entsprechender Hinweis in der Nachrichtenzeile.
- Rücknahme der letzten Einzelersetzung (Schaltfläche "Letzte zurück"): Die zuletzt ausgeführte Einzelersetzung wird wieder zurückgenommen. Diese Rücknahme gilt wiederum als Ersetzung, so dass durch fortgesetztes Drücken des Funktionsknopfes zwischen zwei Werten hin- und hergesprungen werden kann.
- Komplettersetzung (Schaltfläche "Alles ersetzen"): Suchbeginn an Caret Position = 0 (Textbeginn). Ersetzung aller Fundstellen durch den Ersetzungstext bis zum Textende. Es werden keine Bestätigungen für Ersetzungen angefordert.
- Löschen der Eingabefelder (Schaltfläche "Löschen"): Die Eingabefelder "Such-Text" und "Ersetzungs-Text" werden gelöscht.
  Hinweise: Eingegebene Suchtexte bzw. Ersetzungstexte werden in die Auswahlbereiche "Verfügbare Suchtexte" bzw. "Verfügbare Ersetzungstexte" übernommen und können von dort wieder abgerufen werden. Die Werte bleiben für eine Sitzung erhalte, und werden für jede Editorinstanz angeboten, und zwar unabhängig vom Ort ihres Ursprunges.
  Die Eingabefelder können auch durch Textselektion gefüllt werden. Eine im Quellentext selektierte Textstelle wird als Suchwert übernommen.
- Die Schaltfläche "Zurück" beendet den Dialog ohne weitere Aktion.

#### Suchhervorhebungen aus (auch im Tool-Bar enthalten)

Die Funktion "Suchhervorhebungen aus" löscht die farbliche (hellblaue) Unterlegung der Suchergebnisse.

#### Zeilen einrücken

Die Funktion "Zeilen einrücken" erlaubt es, einen bestimmten Zeilenbereich um eine definierte Anzahl von Zeichen nach rechts einzurücken bzw. nach links auszurücken (sofern durch das Ausrücken kein Text verloren geht).

Im Dialogfenster wird die Nummer der ersten und die Nummer der letzten Zeile eingegeben, die eingerückt/ausgerückt werden sollen (Zeilen jeweils eingeschlossen). Weiter wird vorgegeben, wieviele Leerzeichen eingefügt bzw. entfernt werden sollen. Ein positiver Wert spezifiziert eine Einrückung (Verschiebung nach rechts), ein negativer Wert eine Ausrückung (Verschiebung nach links). Wird das Feld "zu / ist Kommentar" angeklickt, dann wird bei einer Einrückung zusätzlich noch das Java Kommentarzeichen "//" vorne angesetzt. Die Verschiebung beträgt also Anzahl Leerzeichen + 2. Bei einer Ausrückung wird die Zeichenkombination "//" am Zeilenanfang nicht als gültiger Text gewertet, also entfernt. Ist das Feld nicht angeklickt, dann wird nur dann ausgerückt, wenn kein Text verloren geht. Dabei zählt "//" als gültiger Text.

#### Unicode einsetzen

Die Funktion "Unicode einsetzen" erlaubt es, an beliebiger Stelle im Quellentext ein als Unicode (\uxxxx) dargestelltes Zeichen aus dem Bereich 0000 bis 007f einzufügen. Das Zeichen, das eingefügt werden soll, wird durch den Dialog ausgewählt.

Der Dialog erlaubt die Spezifikation von Zeichen auf zwei verschiedene Arten, je nachdem, um was für eine Art Zeichen es sich handelt. Soll ein (einzelnes) undruckbares Zeichen (Unicode 0000 bis Unicode 0020 sowie Unicode 007f) eingesetzt werden, dann ist die Auswahl über die Auswahlliste "undruckbare Zeichen" vorzunehmen (gewünschten Code selektieren). Es darf dann kein Zeichen im Eingabefeld "druckbare Zeichen" enthalten sein, denn dieses Eingabefeld hat bei der Auswahl Vorrang vor der Auswahlliste. Sollen druckbare Zeichen (Unicode 0021 bis 007e) eingesetzt werden, dann sind die Zeichen in das Feld "druckbare Zeichen" einzugeben. In diesem Fall wird nicht berücksichtigt, was in der Auswahlliste selektiert ist. Wenn der Knopf "Einsetzen" gedrückt wird, dann werden die gewählten Zeichen als Unicode an der momentanen Caretposition in den Quellentext eingefügt.
Wird der Knopf "Zurück" gedrückt, dann wird der Dialog ohne Aktion beendet.

#### Textschablone einfügen (auch im Pop-Up Menü enthalten)

Die Funktion "Textschablone einfügen" erlaubt es, eine Jade Code Schablone (Jade code template) an beliebiger Stelle im Quellentext einzufügen. Die Code Schablone muss als Datei mit einem Namen der Form "xxxxxxx.jct" im Unterordner "templates" des JadeIDE Installationsordners abgelegt sein.

Die Auswahl der einzufügenden Code Schablone erfolgt über den Datei-Auswahldialog. Im Dialog werden die verfügbaren Schablonen angezeigt. Wird der Knopf "Öffnen" gedrückt, dann wird die selektierte Schablone an der momentanen Caret-Position in den Quellentext eingefügt.
Der Knopf "Abbrechen" beendet den Dialog ohne weitere Aktion.

JadeIDE stellt eine Reihe vordefinierter Code Schablonen zur Verfügung. Diese Schablonen können nach eignen Vorstellungen abgeändert werden. Zusätzlich können beliebig viele eigene Code Schablonen in das Verzeichnis aufgenommen werden.

zum Kapitelanfang zum Inhaltsverzeichnis

### Die Funktionen des Optionen-Menüs

Über das Optionen-Menü des Editors werden Sonderfunktionen zur Quellencodebearbeitung aufgerufen. Einige dieser Funktionen können auch über ihre zugeordnete Tastenkombination aufgerufen werden.
(Achtung: die Tastaturaktivierung ist nur wirksam, wenn das Editorfenster den Eingabefokus hat. Dies ist dann der Fall, wenn der Fenstertitel hervorgehoben ist!)
Die Funktionen (mit ihren Tastaturkombinationen) sind im folgenden Bild aufgeführt:

#### Lange Zeilen umbrechen

Die Funktion "Lange Zeilen umbrechen" erlaubt es, Textzeilen umzubrechen, die wegen ihrer Länge nicht in die vorhandene Fensterbreite passen und deshalb nur ausschnittsweise angezeigt werden können.
Hinweis: Wird eine Umwandlung vorgenommen, wenn diese Option gesetzt ist, dann stimmen die Zeilennummern eventueller Fehlermeldung oft nicht mit den angezeigten Zeilennummern überein.

#### Zeilenumbruch aufheben

Die Funktion "Zeilenumbruch aufheben" hebt einen Zeilenumbruch auf. Lange Quellentextzeilen werden wieder nur ausschnittsweise angezeigt.

#### Paarigkeit prüfen

Die Funktion "Paarigkeit prüfen" testet, ob die Zeichen "/*" und "*/", "(" und ")", "{" und "}", "[" und "]", sowie einfache und doppelte Anführungszeichen paarig im Quellentext auftreten.
Hinweis: Da diese Zeichen auch in Kommentaren und Literalen ( z.B als "'" oder '"' ) auftauchen können ist nicht immer garantiert, dass das Analyseergebnis völlig korrekt ist. Notfalls muss der Java Compiler/Interpreter zur Prüfung verwendet werden.

#### Mit JiveLint überprüfen

Die Funktion "Mit JiveLint überprüfen" (momentan nur Windows) ruft den Code Checker JiveLint von Sureshot (siehe unter "http://www.bysoft.se/sureshot/javalint/index.html" ) auf, um den Java Code statisch zu analysieren.
Um die Funktion zu benützen, muss im Dialog zur Verwaltung von Basisparametern der Code Checker von Sureshot definiert sein (Base Parameter BC_JCK). Weiter sollte sich im "User Classpath" (der Bibliothek, in die JadeIDE installiert wurde und in der sich auch die "JadeIDE.ini" Datei befindet) die Datei "jconfig.txt" befinden, die den Ausschluß von JaveLint Regeln steuert (siehe dazu die entsprechende JiveLint Dokumentation). In der "jconfig.txt" Datei, die mit JadeIDE ausgeliefert wird, ist Regel 1022 standardmäßig ausgeschlossen.

Das Ergebnis des Tests wird im Anzeigedialog für StandardOut präsentiert. Ähnlich wie bei der Präsentation von Umwandlungsfehlern kann direkt zur fehlerhaften Quellencode-Zeile gesprungen werden, wenn der Cursor auf die gewünschte JiveLint Nachricht gesetzt und dann die "zu Fehler" Schaltfläche angeklickt wird.

#### Kommentare hervorheben ein/aus (auch im Tool-Bar enthalten)

Die Funktion "Kommentare hervorheben ein/aus" bewirkt, dass die Hervorhebung von Kommentaren im Java Quellentext ein- bzw. ausgeschaltet wird. Kommentare werden durch einen hellgrünen Hintergrund hervorgehoben. Wenn die Hervorhebung eingeschaltet ist, folgt sie zwar einer Textverschiebung (etwa wegen Texteinfügungen oder Textlöschungen), neu eingefügte Kommentare werden aber erst dann hevorgehoben, nachdem die Hervorhebungsfunktion aus- und dann wieder eingeschaltet worden ist.

#### Strings hervorheben ein/aus (auch im Tool-Bar enthalten)

Die Funktion "Strings hervorheben ein/aus" bewirkt, dass die Hervorhebung von Textliteralen (Strings) im Java Quellentext ein- bzw. ausgeschaltet wird. Textliterale werden durch einen hellroten Hintergrund hervorgehoben. Wenn die Hervorhebung eingeschaltet ist, folgt sie zwar einer Textverschiebung (etwa wegen Texteinfügungen oder Textlöschungen), neu eingefügte Literale werden aber erst dann hevorgehoben, nachdem die Hervorhebungsfunktion aus- und dann wieder eingeschaltet worden ist.

#### Schlüsselworte hervorheben ein/aus (auch im Tool-Bar enthalten)

Die Funktion "Schlüsselworte hervorheben ein/aus" bewirkt, dass die Hervorhebung von Java Schlüsselworten im Java Quellentext ein- bzw. ausgeschaltet wird. Schlüsselworte werden durch einen hellblauen Hintergrund hervorgehoben. Wenn die Hervorhebung eingeschaltet ist, folgt sie zwar einer Textverschiebung (etwa wegen Texteinfügungen oder Textlöschungen), neu eingefügte Java Schlüsselworte werden aber erst dann hevorgehoben, nachdem die Hervorhebungsfunktion aus- und dann wieder eingeschaltet worden ist.

#### Checkpoints hervorheben ein/aus (auch im Tool-Bar enthalten)

Die Funktion "Checkpoints hervorheben ein/aus" bewirkt, dass die Hervorhebung von Jade Checkpoints im Zeilennummernbereich ein- bzw. ausgeschaltet wird. Checkpoints werden weiss hervorgehoben. Angeschaltete Hervorhebungen folgen Textverschiebungen nicht. Um die Hervorhebungen zu aktualisieren muss die Hervorhebung einfach aus- und dann wieder eingeschaltet werden.

#### String Literale extrahieren

Die Funktion "String Literale extrahieren" extrahiert alle Textliterale (Zeichenketten, die durch doppelte Anführungszeichen begrenzt werden) des vorliegenden Java Quellentextes. Der Quellentext wird nicht verändert, vielmehr werden die extrahierten Literale in Form von auskommentierten "Sting Definitionen" ans Ende des Quellentextes angehängt. Ein Programmierer kann dadurch entscheiden, wie diese Anweisungen weiter behandelt werden sollen.

#### Selektion als Schablone sichern

Die Funktion "Selektion als Schablone sichern" erlaubt es, eine Selektion im Quellentext als eine Jade Code Schablone im Ordner "templates" abzuspeichern.

Der Dialog erlaubt die Eingabe eines Schablonen-Namens. Zulässig ist jeder gülte Dateiname, es sollte aber ein möglichst sprechender Name gewählt werden. Der Name wird durch JadeIDE automatisch mit der Endung ".jct" (Jade code template) ergänzt und der selektierte Text wird in den Ordner "templates" abgespeichert, wenn der Knopf "Sichern" gedrückt wird. Das Menü "Code Schablonen" wird um den neuen Eintrag ergänzt. Damit kann die Code Schablone sofort editiert werden.
Wenn der Knopf "Abbrechen" gedrückt wird, dann wird der Dialog ohne weitere Aktion beendet.

#### Editor Fontgröße ändern

Die Funktion "Editor Fontgröße ändern" erlaubt, die Größe des Editor Fonts zu ändern. Dazu ist im entsprechenden Dialog die gewünschte Punktgröße des Fonts zu spezifizieren und dann die "Auswählen" Taste zu drücken. Das Drücken der "Vorgabe" Taste setzt die Fontgröße auf den Vorgabewert 13 Punket! Das Schließen des Dialoges über den "X" Knopf ohne vorherige Auswahl lässt die Größe des Editor-Fonts unverändert.

Der gesetzte Wert wird in der INI Datei gespeichert und für alle wieteren Editor-Aufrufe verwendet.

zum Kapitelanfang zum Inhaltsverzeichnis

### Das Lesezeichen Menü

Über das Lesezeichen Menü des Editors können Lesezeichen im Quellencode gesetzt und wieder entfernt werden. Weiter kann über die einzelnen Lesezeichen zu den durch die Lesezeichen definierten Positionen im Quellencode gesprungen werden.
JadeEditor Lesezeichen sind Lesezeichen für die aktuellen Sitzung. Sie werden nicht für eine Folgesitzung aufbewahrt.
Als Lesezeichen verwendet der JadeEditor den gesamten Inhalt einer Quellencode Zeile allerdings ohne Zeilennummer. Die Zeilennummer wird ausgeschlossen, weil es während der Bearbeitung eines Quellentextes sehr wahrscheinlich ist, dass sich Zeilennummern ändern.

Das Lesezeichen Menü stellt folgende Funktionen bereit:

#### Zeile als Lesezeichen übernehmen

Die Funktion "Zeile als Lesezeichen übernehmen" fügt am Ende des Lesezeichen Menüs einen neuen Eintrag hinzu. Dieser Eintrag hat als Kennzeichnung die Zeichenfolge "BM:". Auf diese Kennung folgt der Text der Quellencode-Zeile, in der sich das Caret zum Zeitpunkt des Funktionsaufrufes befindet.

#### Lesezeichen entfernen

Die Funktion "Lesezeichen entfernen" löscht einen Eintrag im Lesezeichen Menü. Gelöscht wird der Eintrag, der (unterhalb des Trennstriches) als letzter Eintrag ausgewählt worden ist.

#### Zum Lesezeichen springen

Wird ein Lesezeichen (unterhalb des Trennstriches) angeklickt, dann positioniert der Editor die Quellencode Datei auf die durch das Lesezeichen definierte Textstelle und hebt sie hervor. Dies funktioniert allerdings nur dann, wenn die Textzeile im Dokument nicht geändert worden ist! Eine Änderung der Zeilennummer (verursacht durch Textlöschungen oder Texteinfügungen) hat keine Auswirkungen, da immer nach dem Text selbst gesucht wird. Gibt es mehrere identische Textzeilen in einem Quellentext, dann wird immer auf die Erste dieser identischen Zeilen positioniert.

zum Kapitelanfang zum Inhaltsverzeichnis

### Die Funktionen des Pop-Up Menüs

Wird die Steuerungstaste ("Strg") und eine Maustaste (links oder rechts) gleichzeitig betätigt, dann erscheint an der momentanen Caret-Position ein Pop-Up Menü.

Das Pop-Up Menü stellt folgende Funktionen bereit:

#### Prüfpunkt oberhalb hinzufügen

Die Funktion "Prüfpunkt oberhalb hinzufügen" fügt einen Prüfpunkt ( /* CKPT */ Anweisung ) oberhalb der momentanen Caret-Position in den Quellencode der aktuellen Klasse ein.

#### Prüfpunkt unterhalb hinzufügen

Die Funktion "Prüfpunkt unterhalb hinzufügen" fügt einen Prüfpunkt ( /* CKPT */ Anweisung ) unterhalb der momentanen Caret-Position in den Quellencode der aktuellen Klasse ein.

Mit den obigen Funktionen können zwei Arten von Prüfpunkten eingefügt werden:

1. Einfache Prüfpunkte, die beim Testen lediglich das Durchlaufen der markierten Stelle als eine Standard-Out Nachricht anzeigen.
und
2. Prüfpunkte mit Variablen-Ausgabe, das sind Prüfpunkte, die zusätzlich noch den momentanen Inhalt einer vorgegebenen Variablen in der Standard-Out Nachricht anzeigen.

Definition der Variablen: Eine auszugebende Variable wird definiert, indem man (bei geöffnetem Pop-Up Menü) mit der Maus die Variable markiert (hervorhebt). Dies ist allerdings nur in der Zeile möglich, in der sich das Caret beim aufrufen des Pop-Up Menüs befindet.
Die Vorgehensweise ist wie folgt:

1. "Strg"-Taste drücken und festhalten.
2. Mit der Maus an den Anfang des Namens der auszugebenden Variablen fahren.
3. Eine Maustaste drücken und festhalten (lässt das Pop-Up Menü erscheinen und setzt die Caret-Position!).
4. Mit der Maus ans Ende des Namens der auszugebenden Variablen fahren und dort die Maustaste loslassen!
   ( Vorsicht! ist der Namen falsch markiert, dann kann beim Umwandeln der Klasse ein Umwandlungsfehler entstehen. Manuelle Korrektur einer Zeile ist allerding möglich! )
5. Mit der Maus auf die gewünschte Menüzeile (oberhalb oder unterhalb einfügen) fahren und die Zeile anklicken. (Die Anweisung wird aufgebaut, eingefügt und hervorgehoben!)

Prüfpunkt-Nachrichten werden als "Standard Out" [ System.out.println ... ] Nachrichten ausgegeben. Sie werden im Nachrichten Window angezeigt, wenn ein Aufruf über JadeIDE ausgeführt wird.

#### Prüfpunkt entfernen

Die Funktion "Prüfpunkt entfernen" löscht die durch die aktuelle Caret-Position definierte /* CKPT */ Anweisungen im Quellencode der aktuellen Klasse.

#### Alle Prüfpunkte entfernen

Die Funktion "Alle Prüfpunkte entfernen" löscht alle /* CKPT */ Anweisungen im Quellencode der aktuellen Klasse. (Siehe auch: Alle Prüfpunkte entfernen im Edit Menü).

#### Textschablone einfügen

Die Funktion "Textschablone einfügen" erlaubt es, eine Jade Code Schablone (Jade code template) an der momentanen Caret-Position in den Quellentext einzufügen. (Siehe auch: Textschablone einfügen im Edit Menü).

#### Zeile zu // Kommentar machen

Die Funktion "Zeile zu // Kommentar machen" erlaubt es, die Jade Code Zeile in der sich das Caret befindet in eine Java Kommentartzeile umzuwandeln.

#### // von Kommentarzeile entfernen

Die Funktion "// von Kommentarzeile entfernen" erlaubt es, die Zeichenfolge // aus der Java-Kommentarzeile in der sich das Caret befindet, zu entfernen. Entfernt wird die // Folge allerdings nur, wenn ihr unmittelbar eine Leerstelle, ein * (Stern) oder ein - (Minus) Zeichen folgt.

#### Getter Methode generieren

Die Funktion "Getter Methode generieren" erlaubt es, eine "public Getter Methode" für die hervorgehobene Variable zu erzeugen. Die Getter Methode wird ans Ende der Quellecode Datei (also nach der "} /* end of class definition */ " Zeile) in den Qullencode eingefügt. Dieses Code-Segment muss dann manuell (mit Cut and Paste) an die gewünschte Stelle im Quellencode verschoben werden. Die Selektion des Variablen-Names muss gleich wie die Selektion des Variablen-Names für eine Prüfpunktgenerierung (siehe weiter oben) erfolgen.
Diese Funktion sollte nur in Zeilen für die Variablen-Definition (Klassen- bzw. Instanzvariablen) aufgerufen werden, da sie sonst ungültige Ergebnisse liefert.

#### Setter Methode generieren

Die Funktion "Setter Methode generieren" erlaubt es, eine "public Setter Methode" für die hervorgehobene Variable zu erzeugen. Die Setter Methode wird ans Ende der Quellecode Datei (also nach der "} /* end of class definition */ " Zeile) in den Qullencode eingefügt. Dieses Code-Segment muss dann manuell (mit Cut and Paste) an die gewünschte Stelle im Quellencode verschoben werden. Die Selektion des Variablen-Names muss gleich wie die Selektion des Variablen-Names für eine Prüfpunktgenerierung (siehe weiter oben) erfolgen.
Diese Funktion sollte nur in Zeilen für die Variablen-Definition (Klassen- bzw. Instanzvariablen) aufgerufen werden, da sie sonst ungültige Ergebnisse liefert.

#### Getter und Setter Methoden generieren

Die Funktion "Getter und Setter Methoden generieren" erlaubt es, eine "public Getter Methode" und eine "public Setter Methode" für die hervorgehobene Variable zu erzeugen. Die Methoden werden ans Ende der Quellecode Datei (also nach der "} /* end of class definition */ " Zeile) in den Qullencode eingefügt. Diese Code-Segmente müssen dann manuell (mit Cut and Paste) an die gewünschten Stellen im Quellencode verschoben werden. Die Selektion des Variablen-Names muss gleich wie die Selektion des Variablen-Names für eine Prüfpunktgenerierung (siehe weiter oben) erfolgen.
Diese Funktion sollte nur in Zeilen für die Variablen-Definition (Klassen- bzw. Instanzvariablen) aufgerufen werden, da sie sonst ungültige Ergebnisse liefert.

zum Kapitelanfang zum Inhaltsverzeichnis

#### Die Funktionen der Werkzeug-Auswahl

Die Werkzeugauswahl ist am linken Rand des Editor-Fensters angeordnet, um möglichst viel Platz für Editorzeilen bereitzustellen. Die verfügbare Zeilenlänge ist in der Regel weniger wichtig als die Anzahl der verfügbaren Zeilen selbst.

Die Werkzeugauswahl enthält den Aufruf für folgende Werkzeuge:

- Sichern
- Alles sichern, Klasse umwandeln
- Suchen / Ersetzen
- Dokument drucken
- Aufheben
- Erneut ausführen
- Ausschneiden
- Kopieren
- Einfügen
- Zu Zeile
- Zur zugehörigen }-Klammer
- Zur zugehörigen {-Klammer
- Zum Anfang
- Zum Ende
- Kommentare hervorheben ein/aus
- Strings hervorheben ein/aus
- Schlüsselworte hervorheben ein/aus
- Checkpoints hervorheben ein/aus
- Suchhervorhebungen aus

zum Kapitelanfang zum Inhaltsverzeichnis

## Installation

### Voraussetzungen

Um JadeIDE einzusetzen muss ein JDK 1.4 oder höher mit zugehöriger API Dokumentation (z.B. von SUN Microsystems) installiert sein. Zur Zeit (Februar 2004) empfehle ich JDK 1.4.2_02 zu verwenden. Das JDK ist kostenlos verfügbar vom SUN Download Center via "http://www.sun.com/software/shop/index.html#free".
Auf dem Rechnersystem sollten mindestens 3 MB freier Plattenspeicherplatz vorhanden sein. Der erforderliche Platz für das SUN JDK ist dabei nicht mit eingerechnet!
Das Rechnersystem sollte mindestens 64 MB Hauptspeicher haben und mit einem Prozessor mit mindestens 300 MHz Taktfrequenz ausgestattet sein. Schwächere Systeme funktionieren auch, die Ausführung ist dann halt etwas langsamer.

Wenn auch ein zu JadeIDE externer Editor verwendet werden soll, dann können als externe Progammeditoren z.B. "PFE (Programmers File Editor)" von Alan Phillips (Windows) zusätzlich installiert sein. Die Verwendung des Windows Notepad ist nicht zu empfehlen.
Für Linux (z.B. Suse Linux 7.x mit KDE2 oder 8.x mit KDE3) kann (unter anderen) der "kwrite" Editor verwendet werden.
Der PFE kann von URL "http://www.lancs.ac.uk/people/cpaap/pfe" oder über Winsite bzw. Simtel
(zur Zeit kostenlos) heruntergeladen werden.

Für die Funktion "Start HTML Editor" sollte ein HTML Editor und für die Funktion "Start XML Editor" sollte ein XML Editor installiert sein. "HTML Editor Phase 5.3" (Windows) von Hans-Dieter Berretz und "HTML-Format" (Windows und Linux) von Christian Diekmann sind ausgezeichnete HTML Editoren.
XMLMind ist ein hervorragender XML Editor der XML Products Division von Pixware, 78180 Montigny Le Bretonneux France [ "http://www.pixware.fr" ].

XMLmind kann von URL "http://www.xmlmind.com/xmleditor/download.shtml",
HTML Editor Phase 5.3 kann von URL "http://www.ftp-uploader.de/ftp-download.php4"
und
HTML-Format kann von URL "http://www.downloadbereich.de/HTML-Format/HF-download.htm"
heruntergeladen werden. Alle Produkte sind zur Zeit Freeware.
Für Linux (z.B. Suse Linux 7.x mit KDE2) kann (unter anderen) der "kwrite" Editor verwendet werden.

Um die Jade Editor Funktion "Mit JiveLint überprüfen" verwenden zu können muss der Java Code Checker "JiveLint" von Sureshot installiert sein. "JiveLint" kann von URL "http://www.bysoft.se/sureshot/javalint/index.html" heruntergeladen werden

Um die JadeIDE Funktion "UML-Editor UMLet aufrufen" verwenden zu können muss der UML Editor UMLet von der Technischen Universität Wien in der Bibliothek "/jars" unmittelbar unterhalb der JadeIDE Projektbibliothek installiert sein (z.B. "D:/JadeIDE/com/kur/ide/jars"). "UMLet" kann von URL "http://www.swt.tuwien.ac.at/umlet/index.html" heruntergeladen werden.

### Installation

Das Jade System wird als ZIP Datei zur Verfügung gestellt. Die Ordnerinformation ist in der ZIP Datei enthalten. Für Windows ist auch eine selbstentpackende .EXE Datei verfügbar.
Die ZIP Datei ist lediglich in ein Verzeichnis Ihrer Wahl mit einem Entpacker wie z.B. PKZIP, WINZIP, PowerArchiver, WINRAR oder dem Java JAR-Tool zu entpacken,
z.B. D:\jadeIDE (Windows) oder /home/xxxx/jadeIDE (Unix/Linux wobei xxxx die Benutzeridentifikation repräsentiert). Unter Linux kann JadeIDE natürlich auch in das /opt oder /usr Verzeichnis eingestellt werden, sofern die erforderlichen Zugriffsrechte gewährt werden.
Achten Sie darauf, dass beim Entpacken die Verzeichnisstruktur erhalten bleibt.
Beim Entpacken wird folgende Verzeichnisstruktur aufgebaut:
DOS/Windows Form:

    D:\jadeIDE                    user.dir (bzw. user.classpath),
                                  => nimmt jadeide.ini auf und enthält jconfig.txt sowie
                                     winjade.ico (Icon für Shortcuts auf dem Desktop)
      .....\com\kur\ide           => alle ".class" Dateien
      .....\com\kur\ide\images    => jade.gif, jadesmal.gif, noinput.gif,
                                     alle Icons die in den JadeIDE Fenstern verwendet werden,
      .....\com\kur\ide\jars      => JAR Archive für Java Anwendungen, die aus JadeIDE heraus
                                     aufgerufen werden können (z.B. UMLet),
      .....\com\kur\idedt         => Ordner für den Test von erzeugten Fenstern und Dialogen
      .....\help                  => jidehelp_x.htm
      .....\help\images           => alle Image-Dateien die für Help benötigt werden
      .....\templates             => alle bereitgestellten Code Schablonen

Unix/Linux Form (xxxx repräsentiert die Benutzeridentifikation):

    /home/xxxx/jadeIDE            user.dir (bzw. user.classpath),
                                  => nimmt jadeide.ini auf und enthält jconfig.txt sowie
                                     winjade.ico (Icon für Shortcuts auf dem Desktop)
      ...../com/kur/ide           => alle ".class" Dateien
      ...../com/kur/ide/images    => jade.gif, jadesmal.gif, noinput.gif,
                                     alle Icons die in den JadeIDE Fenstern verwendet werden,
      ...../com/kur/ide/jars      => JAR Archive für Java Anwendungen, die aus JadeIDE heraus
                                     aufgerufen werden können (z.B. UMLet),
      ...../com/kur/idedt         => Ordner für den Test von erzeugten Fenstern und Dialogen
      ...../help                  => jidehelp_x.htm
      ...../help/images           => alle Image-Dateien die für Help benötigt werden
      ...../templates             => alle bereitgestellten Code Schablonen

Um JadeIDE auszuführen sind neben den ".class" Dateien noch folgende Dateien in den angegebenen Ordnern erforderlich:

1. Die Datei mit den Entwicklungsparametern jadeide.ini in "user.dir" z.B. "D:\jadeIDE" oder "/home/xxxx/jadeIDE"
2. Die Jade Logo Datei JADE.GIF, die Jade Icon Datei JADESMAL.GIF und die Cursor Datei NOINPUT.GIF in user.dir\com\kur\ide\images z.B. "D:\jadeIDE\com\kur\ide\images" oder "/home/xxxx/jadeIDE/com/kur/ide/images"
3. Die Jade Hilfe Dateien JIDEHELP_D.HTM (bzw. JIDEHELP_E.HTM) in user.dir\help z.B. "D:\jadeIDE\help" oder "/home/xxxx/jadeIDE/help"
4. Die Graphiken zur JadeIDE Hilfe in user.dir\help\images z.B. "D:\jadeIDE\help\images" oder "/home/xxxx/jadeIDE/help/images"

"user.dir" repräsentiert das Verzeichnis aus dem heraus das Programm gestartet wird (in den Beispielen "jadeIDE").

Wenn Sie Plattenplatz einsparen wollen, dann können Sie für die Sprache, die Sie nicht nützen, die Help-Datei und die zugehörigen Graphiken aus den Verzeichnissen ....\help und .....\help\images löschen. Die Dateien sind durch den Suffix "_d" bzw. "_e" im Namen zu erkennen.

### Deinstallation

JadeIDE macht keinerlei Einträge in die Registry eines verwendeten Windows Betriebssystems. Zur rückstandlosen Deinstallation von JadeIDE unter Windows (und unter Linux) ist es deshalb ausreichend, den Ordner (mit allen Unter-Ordnern) zu löschen, in den die JadeIDE Dateien entpackt worden sind.

### Programmaufruf

JadeIDE ist in Java geschrieben. Es gibt also keine "...exe" Datei. Die steuernde EXE ist vielmehr der Java-Launcher (java.exe [Windows] bzw. java [Linux]), der die Hauptklasse "Control.class" von JadeIDE ansteuert. Zur Vereinfachung des relativ komplizierten Java-Programmaufrufes kann ein Script oder eine Batch Datei (.BAT) verwendet werden, die etwa wie folgt aussehen sollte:
DOS/Windows Form für einen Aufruf über ein DOS Fenster:
hier wird angenommen, dass das JDK im Ordner C:\j2sdk1.4.0 installiert ist

    C:\>d:
    D:\>cd jadeIDE
    D:\jadeIDE>C:\j2sdk1.4.0\bin\java.exe -classpath D:\jadeIDE; com.kur.ide.Control LANG=parm

Unix/Linux Form für einen Aufruf über ein Terminal ( xxxx repräsentiert die Benutzeridentifikation ):
hier wird angenommen, dass das JDK im Ordner /usr/java/j2sdk1.4.0 installiert ist

    xxxx@linux:~ >
    xxxx@linux:~ > cd jadeIDE
    xxxx@linux:~ /jadeIDE > /usr/java/j2sdk1.4.0/bin/java -classpath /home/xxxx/jadeIDE com.kur.ide.Control  LANG=parm

Achten Sie darauf, dass Zeile 3 des Aufrufs (der Text nach dem ">" Zeichen) als eine Zeile an den "Command-Interpreter" des Betriebssystemes übergeben wird !
Eine Nachricht der Art "Exception in thread "main" java.lang.NoClassDefFoundError" deutet darauf hin, dass ein Name (z.B. Control) nicht in der korrekten Groß-/Kleinschreibung eingegeben wurde.

In diesem Beispiel hat user.dir den Wert "D:\jadeIDE" oder "/home/xxxx/jadeIDE",
parm definiert die Sprache, die für die Programmausführung verwendet werden soll. Momentan ist "D" für Deutsch und "E" für Englisch unterstützt.
Beispiel: LANG=D.

Wenn Sie unter Windows dem "Shortcut" zur BAT Datei das Jade Icon zuweisen wollen, dann können Sie das Icon "winjade.ico" (im jadeIDE Verzeichnis) verwenden.

Sehr wichtiger Hinweis: Beachten Sie, dass Sie beim ersten Aufruf von JadeIDE unbedingt die erforderlichen Parameter setzen müssen. Dazu müssen Sie als erste Aktion über das Menü "Datei -> Basisparameter verwalten" und "Datei -> Projektdefinition vornehmen" die Setup-Dialoge mit ihren Unterdialogen durcharbeiten !
Siehe dazu: Die "Setup" Dialoge zur Festlegung der JadeIDE Parameter.

zum Kapitelanfang
zum Inhaltsverzeichnis