First Commit (Fobi)

imp/HSB.ctxt

@@ -0,0 +1,16 @@
+#BlueJ class context
+comment0.target=HSB
+comment0.text=\r\n\ Hilfsklasse\ f\u00FCr\ das\ HSB-Farbmodell\r\n\r\n\ @author\ Thomas\ Schaller\r\n\ @version\ V1.0\ 14.01.2020\r\n
+comment1.params=c
+comment1.target=double\ getHue(java.awt.Color)
+comment1.text=\r\n\ Liefert\ den\ Farbton\ als\ Winkel\ zwischen\ 0.0\u00B0\ und\ 360.0\u00B0.\r\n\ @param\ Color\ c\ Farbe,\ deren\ Farbton\ bestimmt\ werden\ soll.\r\n\ @return\ Farbton\ \r\n
+comment2.params=c
+comment2.target=double\ getSaturation(java.awt.Color)
+comment2.text=\r\n\ Liefert\ die\ S\u00E4ttigung\ als\ Wert\ zwischen\ 0.0\ (0%)\ und\ 1.0\ (100%).\r\n\ @param\ Color\ c\ Farbe,\ deren\ S\u00E4ttigung\ bestimmt\ werden\ soll.\r\n\ @return\ S\u00E4ttigung\r\n
+comment3.params=c
+comment3.target=double\ getBrightness(java.awt.Color)
+comment3.text=\r\n\ Liefert\ die\ Helligkeit\ als\ Wert\ zwischen\ 0.0\ (0%)\ und\ 1.0\ (100%).\r\n\ @param\ Color\ c\ Farbe,\ deren\ Helligkeit\ bestimmt\ werden\ soll.\r\n\ @return\ S\u00E4ttigung\r\n
+comment4.params=h\ s\ b
+comment4.target=java.awt.Color\ getColor(double,\ double,\ double)
+comment4.text=\r\n\ Liefert\ ein\ Java-Color-Objekt\ mit\ den\ angegebenen\ HSB-Werten.\r\n\ @param\ h\ Farbton\ (Hue)\r\n\ @param\ s\ S\u00E4ttigung\ (Saturation)\r\n\ @param\ b\ Brightness\ (Helligkeit)\r\n\ @return\ Java-Color-Objekt\r\n
+numComments=5

imp/HSB.java

@@ -0,0 +1,55 @@
+package imp;
+
+import java.awt.Color;
+
+/**
+ * Hilfsklasse für das HSB-Farbmodell
+ *
+ * @author Thomas Schaller
+ * @version V1.0 14.01.2020
+ */
+
+public class HSB 
+{
+    /**
+     * Liefert den Farbton als Winkel zwischen 0.0° und 360.0°.
+     * @param Color c Farbe, deren Farbton bestimmt werden soll.
+     * @return Farbton 
+     */
+    public static double getHue(Color c) {
+        float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), null);
+        return hsb[0];
+    }
+
+    /**
+     * Liefert die Sättigung als Wert zwischen 0.0 (0%) und 1.0 (100%).
+     * @param Color c Farbe, deren Sättigung bestimmt werden soll.
+     * @return Sättigung
+     */
+    public static double getSaturation(Color c) {
+        float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), null);
+        return hsb[1];
+    }
+
+    /**
+     * Liefert die Helligkeit als Wert zwischen 0.0 (0%) und 1.0 (100%).
+     * @param Color c Farbe, deren Helligkeit bestimmt werden soll.
+     * @return Sättigung
+     */    
+    public static double getBrightness(Color c) {
+        float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), null);
+        return hsb[2];
+    }
+
+    /**
+     * Liefert ein Java-Color-Objekt mit den angegebenen HSB-Werten.
+     * @param h Farbton (Hue)
+     * @param s Sättigung (Saturation)
+     * @param b Brightness (Helligkeit)
+     * @return Java-Color-Objekt
+     */
+    public static Color getColor(double h, double s, double b) {
+        return new Color(Color.HSBtoRGB((float) h, (float) s, (float) b));
+    }
+
+}

imp/NumberField.ctxt

@@ -0,0 +1,15 @@
+#BlueJ class context
+comment0.target=NumberField
+comment1.params=start\ end\ text
+comment1.target=void\ replaceText(int,\ int,\ java.lang.String)
+comment2.params=text
+comment2.target=void\ replaceSelection(java.lang.String)
+comment3.params=
+comment3.target=double\ getDoubleValue()
+comment4.params=
+comment4.target=int\ getIntValue()
+comment5.params=v
+comment5.target=void\ setValue(double)
+comment6.params=v
+comment6.target=void\ setValue(int)
+numComments=7

imp/NumberField.java

@@ -0,0 +1,43 @@
+package imp;
+
+import javafx.scene.control.TextField;
+
+public class NumberField extends TextField {
+
+    @Override public void replaceText(int start, int end, String text) {
+        if (text.matches("[0-9.]") || text == "") {
+            super.replaceText(start, end, text);
+        }
+    }
+
+    @Override public void replaceSelection(String text) {
+        if (text.matches("[0-9.]") || text == "") {
+            super.replaceSelection(text);
+        }
+    }
+
+    public double getDoubleValue() {
+        try{
+            return Double.parseDouble(this.getText());
+        } catch(Exception e) {
+            return 0.0;
+        }
+    }
+
+    public int getIntValue() {
+        try{
+            return Integer.parseInt(this.getText());
+        } catch(Exception e) {
+            return 0;
+        }
+    }
+
+    public void setValue(double v) {
+        setText(""+v);
+    }
+
+    public void setValue(int v) {
+        setText(""+v);
+    }
+
+}

imp/Picture.ctxt

@@ -0,0 +1,146 @@
+#BlueJ class context
+comment0.target=Picture
+comment0.text=\r\n\r\n\ Bildklasse\ fuer\ die\ Simulation\ von\ Processing-Befehlen\r\n\ \r\n\ Diese\ Klasse\ stellt\ ein\ BufferedImage\ bereit,\ in\ das\ mit\ Processing-Befehlen\ gezeichnet\r\n\ werden\ kann.\ \r\n\ Zusaetzlich\ kann\ ein\ Bildanzeiger\ ueber\ jede\ Aenderung\ des\ Bildes\ informiert\ werden,\r\n\ um\ "Zurueck"-Befehle\ zu\ ermoeglichen.\ Der\ Bildanzeiger\ ist\ entweder\ eine\ normale\ Java\r\n\ ScrollPane\ oder\ ein\ Actor\ aus\ Greenfoot.\r\n\ Die\ Dokumentation\ der\ einzelnen\ Zeichenmethoden\ ist\ der\ Processing-Reference\ \r\n\ (https\://processing.org/reference/\ steht\ unter\ CC-Lizenz\:\ https\://creativecommons.org/)\ \r\n\ entnommen\ und\ mit\ Deepl.com\ ins\ Deutsche\ uebersetzt.\r\n\r\n\ @version\ 1.0\ from\ 23.01.2019\r\n\ @author\ Thomas\ Schaller\ (ZPG\ Informatik\ Klasse\ 9)\r\n
+comment1.params=
+comment1.target=Picture()
+comment1.text=\ \r\n\ Erzeugt\ ein\ Bild\ mit\ Standardgroesse\ 500x400\r\n
+comment10.params=width\ height
+comment10.target=void\ size(int,\ int)
+comment10.text=\r\n\ Definiert\ die\ Dimension\ der\ Breite\ und\ Hoehe\ des\ Anzeigefensters\ in\ Pixeleinheiten.\ \r\n\ Die\ eingebauten\ Variablen\ Breite\ und\ Hoehe\ werden\ durch\ die\ an\ diese\ Funktion\ uebergebenen\ Parameter\ festgelegt.\ So\ weist\ beispielsweise\ \r\n\ der\ Befehl\ size(640,\ 480)\ der\ Variablen\ Breite\ 640\ und\ der\ Variablen\ Hoehe\ 480\ zu.\ \r\n\ @param\ width\ Breite\ des\ Bildes\r\n\ @param\ height\ Hoehe\ des\ Bildes\r\n
+comment11.params=
+comment11.target=int\ getWidth()
+comment11.text=\ \r\n\ Liefert\ die\ Breite\ des\ Bildes\ zurueck.\r\n\ @return\ Breite\ des\ Bildes\r\n
+comment12.params=
+comment12.target=int\ getHeight()
+comment12.text=\ \r\n\ Liefert\ die\ Hoehe\ des\ Bildes\ zurueck.\r\n\ @return\ Hoehe\ des\ Bildes\r\n
+comment13.params=
+comment13.target=void\ pushImage()
+comment13.text=\r\n\ Erzeugt\ eine\ Kopie\ des\ Bildes\ und\ uebergibt\ sie\ an\ den\ Observer\ (falls\ existent),\ damit\ dieser\ die\ Versionen\ speichern\ kann\r\n
+comment14.params=autoRefresh
+comment14.target=void\ setAutoRefresh(boolean)
+comment14.text=\r\n\ Legt\ fest,\ ob\ nach\ jedem\ Zeichenbefehl\ automatisch\ das\ Bild\ auch\ in\r\n\ der\ Oberflaeche\ aktualisiert\ wird.\ Die\ Einstellung\ "false"\ beschleunigt\r\n\ das\ Zeichnen\ aufwaendiger\ Bilder\ und\ verhindert\ "Flackern".\r\n\ Das\ Neuzeichnen\ kann\ durch\ die\ Methode\ "refresh"\ gezielt\ ausgeloest\ werden.\r\n\ @param\ autorefresh\ true\ \=\ nach\ jedem\ Zeichenbefehl\ die\ Anzeige\ aktualisieren,\ false\=\ nur\ durch\ die\ Methode\ refresh\ neu\ zeichnen\r\n
+comment15.params=
+comment15.target=void\ repaint()
+comment15.text=\r\n\ Auch\ die\ anzeigenden\ Klasse\ wird\ zum\ Neuzeichnen\ aufgefordert.\r\n
+comment16.params=
+comment16.target=void\ forceRepaint()
+comment16.text=\r\n\ Ein\ repaint()\ (das\ Neuzeichnen)\ kann\ manuell\ erzwungen\ werden.\r\n
+comment17.params=
+comment17.target=void\ clear()
+comment17.text=\ \r\n\ Loescht\ den\ Inhalt\ des\ Bildes.\r\n\ Der\ Hintergrund\ wird\ mit\ der\ Hintergrundfarbe\ neu\ gefuellt.\r\n
+comment18.params=coord\ mode
+comment18.target=void\ convert(int[],\ int)
+comment18.text=\ \r\n\ Konvertiert\ die\ in\ einem\ bestimmten\ Modus\ gegebenen\ Koordinaten\ in\ die\ Java-uebliche\ Links_Oben_Breite_Hoehe\ Version\r\n\ Die\ Aenderungen\ werden\ direkt\ im\ Array\ vorgenommen\r\n\ @param\ coord\ Array\ mit\ vier\ Koordinateneintraegen\ im\ gegebenen\ Modus\r\n\ @param\ mode\ \ Modus\ der\ Koordinaten\ (CORNER,\ CORNERS,\ RADIUS\ oder\ CENTER)\r\n
+comment19.params=mode
+comment19.target=void\ rectMode(int)
+comment19.text=\r\n\ Aendert\ den\ Koordinaten-Modus\ beim\ Zeichnen\ von\ Rechtecken.\r\n\ Aendert\ die\ Position,\ von\ der\ aus\ Rechtecke\ gezeichnet\ werden,\ indem\ es\ die\ Art\ und\ Weise\ aendert,\ wie\ Parameter,\ die\ an\ rect()\ uebergeben\ werden,\ interpretiert\ werden.\r\n\ Der\ Standardmodus\ ist\ rectMode(Bild.CORNER),\ der\ die\ ersten\ beiden\ Parameter\ von\ rect()\ als\ die\ linke\ obere\ Ecke\ der\ Form\ interpretiert,\ \r\n\ waehrend\ der\ dritte\ und\ vierte\ Parameter\ seine\ Breite\ und\ Hoehe\ sind.\r\n\ rectMode(Bild.CORNERS)\ interpretiert\ die\ ersten\ beiden\ Parameter\ von\ rect()\ als\ die\ Position\ einer\ Ecke\ \r\n\ und\ die\ dritten\ und\ vierten\ Parameter\ als\ die\ Position\ der\ gegenueberliegenden\ Ecke.\r\n\ rectMode(Bild.CENTER)\ interpretiert\ die\ ersten\ beiden\ Parameter\ von\ rect()\ als\ Mittelpunkt\ der\ Form,\ \r\n\ waehrend\ der\ dritte\ und\ vierte\ Parameter\ seine\ Breite\ und\ Hoehe\ sind.\r\n\ rectMode(RADIUS)\ verwendet\ auch\ die\ ersten\ beiden\ Parameter\ von\ rect()\ als\ Mittelpunkt\ der\ Form,\ \r\n\ verwendet\ aber\ den\ dritten\ und\ vierten\ Parameter,\ um\ die\ Haelfte\ der\ Breite\ und\ Hoehe\ der\ Formen\ festzulegen.\r\n\ @param\ mode\ Modus\ der\ Koordinateninterpretation\ (CORNER,\ CORNERS,\ CENTER\ oder\ RADIUS)\r\n
+comment2.params=width\ height
+comment2.target=Picture(int,\ int)
+comment2.text=\r\n\ Erzeugt\ ein\ Bild\ der\ angegeben\ Groesse\r\n\ @param\ width\ Breite\ des\ Bildes\r\n\ @param\ height\ Hoehe\ des\ Bildes\r\n
+comment20.params=mode
+comment20.target=void\ ellipseMode(int)
+comment20.text=\r\n\ Aendert\ den\ Koordinaten-Modus\ beim\ Zeichnen\ von\ Kreisen/Ellipsen.\r\n\ Aendert\ die\ Position,\ von\ der\ aus\ Kreise/Ellipsen\ gezeichnet\ werden,\ indem\ es\ die\ Art\ und\ Weise\ aendert,\ wie\ Parameter,\ die\ an\ ellipse()\ uebergeben\ werden,\ interpretiert\ werden.\r\n\ Der\ Standardmodus\ ist\ ellipseMode(Bild.CENTER),\ der\ die\ ersten\ beiden\ Parameter\ von\ ellipse()\ als\ Mittelpunkt\ der\ Form\ interpretiert,\ \r\n\ waehrend\ der\ dritte\ und\ vierte\ Parameter\ seine\ Breite\ und\ Hoehe\ sind.\r\n\ ellipseMode(Bild.CORNER)\ interpretiert\ die\ ersten\ beiden\ Parameter\ von\ ellipse()\ als\ die\ Position\ einer\ Ecke\ \r\n\ und\ die\ dritten\ und\ vierten\ Parameter\ als\ Breite\ und\ Hoehe\ der\ Form.\r\n\ ellipseMode(Bild.CORNERS)\ interpretiert\ die\ ersten\ beiden\ Parameter\ von\ ellipse()\ als\ die\ Position\ einer\ Ecke\ \r\n\ und\ die\ dritten\ und\ vierten\ Parameter\ als\ die\ Position\ der\ gegenueberliegenden\ Ecke.\r\n\ ellipseMode(RADIUS)\ verwendet\ auch\ die\ ersten\ beiden\ Parameter\ von\ ellipse()\ als\ Mittelpunkt\ der\ Form,\ \r\n\ verwendet\ aber\ den\ dritten\ und\ vierten\ Parameter,\ um\ die\ Haelfte\ der\ Breite\ und\ Hoehe\ der\ Formen\ festzulegen.\r\n\ @param\ mode\ Modus\ der\ Koordinateninterpretation\ (CORNER,\ CORNERS,\ CENTER\ oder\ RADIUS)\r\n
+comment21.params=mode
+comment21.target=void\ textMode(int)
+comment21.text=\r\n\ Aendert\ den\ Koordinaten-Modus\ beim\ Zeichnen\ von\ Texten.\r\n\ Aendert\ die\ Position,\ an\ der\ Texte\ gezeichnet\ werden,\ indem\ es\ die\ Art\ und\ Weise\ aendert,\ wie\ Parameter,\ die\ an\ text()\ uebergeben\ werden,\ interpretiert\ werden.\r\n\ Der\ Standardmodus\ ist\ textMode(Bild.CORNER),\ der\ die\ Koordinaten\ von\ text()\ als\ \r\n\ linke\ untere\ Ecke\ des\ Textes\ interpretiert.\r\n\ textMode(Bild.CENTER)\ interpretiert\ sie\ als\ Koordinaten\ des\ Mittelpunktes\ des\ Textes..\r\n\ @param\ mode\ Modus\ der\ Koordinateninterpretation\ (CORNER,\ CENTER)\r\n
+comment22.params=x1\ y1\ x2\ y2
+comment22.target=void\ line(int,\ int,\ int,\ int)
+comment22.text=\r\n\ Zeichnet\ eine\ Linie\ (einen\ direkten\ Weg\ zwischen\ zwei\ Punkten)\ auf\ den\ Bildschirm.\ \r\n\ Um\ eine\ Linie\ einzufaerben,\ verwenden\ Sie\ die\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}\ Funktion.\ Eine\ Zeile\ kann\ nicht\ gefuellt\ werden,\ daher\ hat\ die\ Funktion\ fill()\ keinen\ \r\n\ Einfluss\ auf\ die\ Farbe\ einer\ Zeile.\ Linien\ werden\ standardmaessig\ mit\ einer\ Breite\ von\ einem\ Pixel\ gezeichnet,\ dies\ kann\ jedoch\ mit\ der\ Funktion\ \r\n\ {@link\ \#strokeWeight(double)\ strokeWeight()}\ geaendert\ werden.\r\n\ @param\ x1\ x-Koordinate\ des\ 1.\ Punktes\r\n\ @param\ y1\ y-Koordinate\ des\ 1.\ Punktes\r\n\ @param\ x2\ x-Koordinate\ des\ 2.\ Punktes\r\n\ @param\ y2\ y-Koordinate\ des\ 2.\ Punktes\r\n
+comment23.params=a\ b\ c\ d
+comment23.target=void\ rect(int,\ int,\ int,\ int)
+comment23.text=\r\n\ Zeichnet\ ein\ Rechteck\ auf\ das\ Bild.\ \r\n\ Standardmaessig\ legen\ die\ ersten\ beiden\ Parameter\ die\ Position\ der\ linken\ oberen\ Ecke\ fest,\ der\ dritte\ die\ Breite\ und\ der\ vierte\ die\ Hoehe.\ \r\n\ Die\ Art\ und\ Weise,\ wie\ diese\ Parameter\ interpretiert\ werden,\ kann\ jedoch\ mit\ der\ Funktion\ {@link\ \#rectMode(int)\ rectMode()}\ geaendert\ werden.\r\n\ Durch\ den\ Befehl\ {@link\ \#fill(int,int,int)\ fill()}\ /{@link\ \#noFill()\ noFill()}\ \ kann\ die\ Fuellfarbe\ des\ Rechtecks\ gewaehlt\ werden,\ durch\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}/{@link\ \#noStroke()\ noStroke()}\ \ die\ Rahmenfarbe.\r\n\ @param\ a\ meist\ die\ x-Koordinate\ der\ linken\ oberen\ Ecke\ (kann\ durch\ rectMode()\ geaendert\ werden).\r\n\ @param\ b\ meist\ die\ y-Koordinate\ der\ linken\ oberen\ Ecke\ (kann\ durch\ rectMode()\ geaendert\ werden).\r\n\ @param\ c\ meist\ die\ Breite\ des\ Rechtecks\ (kann\ durch\ rectMode()\ geaendert\ werden).\r\n\ @param\ d\ meist\ die\ Hoehe\ des\ Rechtecks\ (kann\ durch\ rectMode()\ geaendert\ werden).\r\n\ \r\n
+comment24.params=a\ b\ c\ d
+comment24.target=void\ ellipse(int,\ int,\ int,\ int)
+comment24.text=\r\n\ Zeichnet\ eine\ Ellipse/Kreis\ auf\ das\ Bild.\ \r\n\ Standardmaessig\ legen\ die\ ersten\ beiden\ Parameter\ die\ Position\ des\ Mittelpunkts\ fest,\ der\ dritte\ die\ Breite\ und\ der\ vierte\ die\ Hoehe.\ \r\n\ Die\ Art\ und\ Weise,\ wie\ diese\ Parameter\ interpretiert\ werden,\ kann\ jedoch\ mit\ der\ Funktion\ {@link\ \#ellipseMode(int)\ ellipseMode()}\ geaendert\ werden.\r\n\ Durch\ den\ Befehl\ {@link\ \#fill(int,int,int)\ fill()}\ /{@link\ \#noFill()\ noFill()}\ kann\ die\ Fuellfarbe\ des\ Rechtecks\ gewaehlt\ werden,\ durch\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}/{@link\ \#noStroke()\ noStroke()}\ \ die\ Rahmenfarbe.\r\n\ @param\ a\ meist\ die\ x-Koordinate\ des\ Mittelpunkts\ (kann\ durch\ ellipseMode()\ geaendert\ werden).\r\n\ @param\ b\ meist\ die\ y-Koordinate\ des\ Mittelpunkts\ (kann\ durch\ ellipseMode()\ geaendert\ werden).\r\n\ @param\ c\ meist\ die\ Breite\ des\ Rechtecks\ (kann\ durch\ ellipseMode()\ geaendert\ werden).\r\n\ @param\ d\ meist\ die\ Hoehe\ des\ Rechtecks\ (kann\ durch\ ellipseMode()\ geaendert\ werden).\r\n\ \r\n
+comment25.params=x1\ y1\ x2\ y2\ x3\ y3
+comment25.target=void\ triangle(int,\ int,\ int,\ int,\ int,\ int)
+comment25.text=\r\n\ Zeichnet\ ein\ Dreieck\ auf\ das\ Bild.\ \r\n\ Ein\ Dreieck\ ist\ eine\ Ebene,\ die\ durch\ die\ Verbindung\ von\ drei\ Punkten\ entsteht.\ Die\ ersten\ beiden\ Argumente\ spezifizieren\ den\ \r\n\ ersten\ Punkt,\ die\ mittleren\ beiden\ Argumente\ spezifizieren\ den\ zweiten\ Punkt\ und\ die\ letzten\ beiden\ Argumente\ spezifizieren\ den\ dritten\ Punkt.\ \r\n\ Durch\ den\ Befehl\ {@link\ \#fill(int,int,int)\ fill()}\ /{@link\ \#noFill()\ noFill()}\ kann\ die\ Fuellfarbe\ des\ Rechtecks\ gewaehlt\ werden,\ durch\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}/{@link\ \#noStroke()\ noStroke()}\ \ die\ Rahmenfarbe.\r\n\ @param\ x1\ meist\ die\ x-Koordinate\ des\ 1.\ Punkts.\r\n\ @param\ y1\ meist\ die\ y-Koordinate\ des\ 1.\ Punkts.\r\n\ @param\ x2\ meist\ die\ x-Koordinate\ des\ 2.\ Punkts.\r\n\ @param\ y2\ meist\ die\ y-Koordinate\ des\ 2.\ Punkts.\r\n\ @param\ x3\ meist\ die\ x-Koordinate\ des\ 3.\ Punkts.\r\n\ @param\ y3\ meist\ die\ y-Koordinate\ des\ 3.\ Punkts.\r\n
+comment26.params=x1\ y1\ x2\ y2\ x3\ y3\ x4\ y4
+comment26.target=void\ quad(int,\ int,\ int,\ int,\ int,\ int,\ int,\ int)
+comment26.text=\r\n\ Zeichnet\ ein\ Viereck\ auf\ das\ Bild.\ \r\n\ Ein\ Viereck\ ist\ ein\ vierseitiges\ Polygon.\ Es\ ist\ aehnlich\ wie\ ein\ Rechteck,\ aber\ die\ Winkel\ zwischen\ seinen\ Kanten\ \r\n\ sind\ nicht\ auf\ neunzig\ Grad\ beschraenkt.\ Das\ erste\ Paar\ von\ Parametern\ (x1,y1)\ setzt\ den\ ersten\ Scheitelpunkt\ und\ die\ nachfolgenden\ \r\n\ Paare\ sollten\ im\ Uhrzeigersinn\ oder\ gegen\ den\ Uhrzeigersinn\ um\ die\ definierte\ Form\ herum\ verlaufen.\ \r\n\ Durch\ den\ Befehl\ {@link\ \#fill(int,int,int)\ fill()}\ /{@link\ \#noFill()\ noFill()}\ kann\ die\ Fuellfarbe\ des\ Rechtecks\ gewaehlt\ werden,\ durch\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}/{@link\ \#noStroke()\ noStroke()}\ \ die\ Rahmenfarbe.\r\n\ @param\ x1\ meist\ die\ x-Koordinate\ des\ 1.\ Punkts.\r\n\ @param\ y1\ meist\ die\ y-Koordinate\ des\ 1.\ Punkts.\r\n\ @param\ x2\ meist\ die\ x-Koordinate\ des\ 2.\ Punkts.\r\n\ @param\ y2\ meist\ die\ y-Koordinate\ des\ 2.\ Punkts.\r\n\ @param\ x3\ meist\ die\ x-Koordinate\ des\ 3.\ Punkts.\r\n\ @param\ y3\ meist\ die\ y-Koordinate\ des\ 3.\ Punkts.\r\n\ @param\ x4\ meist\ die\ x-Koordinate\ des\ 3.\ Punkts.\r\n\ @param\ y4\ meist\ die\ y-Koordinate\ des\ 3.\ Punkts.\r\n
+comment27.params=x\ y
+comment27.target=void\ polygon(int[],\ int[])
+comment27.text=\r\n\ Zeichnet\ ein\ Polygon\ auf\ das\ Bild.\r\n\ Gleich\ lange\ Listen\ von\ x\ und\ y-Koordinaten\ bestimmen\ die\ Eckpunkte\ des\ Polygons.\r\n\ Durch\ den\ Befehl\ {@link\ \#fill(int,int,int)\ fill()}\ /{@link\ \#noFill()\ noFill()}\ kann\ die\ Fuellfarbe\ des\ Rechtecks\ gewaehlt\ werden,\ durch\ {@link\ \#stroke(int,\ int,\ int)\ stroke()}/{@link\ \#noStroke()\ noStroke()}\ die\ Rahmenfarbe.\r\n\ @param\ x\ Liste\ der\ x-Koordinaten\ der\ Punkte.\r\n\ @param\ y\ Liste\ der\ y-Koordinaten\ der\ Punkte.\r\n
+comment28.params=x\ y
+comment28.target=void\ point(int,\ int)
+comment28.text=\r\n\ Zeichnet\ einen\ Punkt,\ d.h.\ einen\ Kreis\ in\ der\ Dimension\ eines\ Pixels.\ \r\n\ Der\ erste\ Parameter\ ist\ der\ x-Wert\ fuer\ den\ Punkt,\ der\ zweite\ Wert\ ist\ der\ y-Wert\ fuer\ den\ Punkt.\ \r\n\ @param\ x\ x-Koordinate\ des\ Punktes\r\n\ @param\ y\ y-Koordinate\ des\ Punktes\r\n
+comment29.params=s\ x\ y
+comment29.target=void\ text(java.lang.String,\ int,\ int)
+comment29.text=\r\n\ Gibt\ einen\ Text\ an\ den\ gegebenen\ Koordinaten\ aus\r\n\ Zur\ Ausgabe\ des\ Textes\ wird\ der\ ausgewaehlte\ Font\ verwendet.\ Dieser\ muss\ vorher\ mit\ {@link\ \#textFont(Font)\ textFont()\ }\ festgelegt.\r\n\ @param\ s\ Text,\ der\ angezeigt\ werden\ soll\r\n\ @param\ x\ x-Koordinate\ des\ Textanfangs\r\n\ @param\ y\ y-Koordinate\ der\ Grundlinie\ des\ Textes.\r\n
+comment3.params=filename
+comment3.target=Picture(java.lang.String)
+comment3.text=\ \r\n\ Erzeugt\ ein\ Bild\ aus\ einer\ Datei\r\n\ @param\ filename\ Dateiname\ des\ Bildes\r\n
+comment30.params=font
+comment30.target=void\ textFont(java.awt.Font)
+comment30.text=\r\n\ Legt\ die\ Schriftart\ fuer\ Textausgaben\ fest.\r\n\ Jeder\ uebliche\ Java-Font\ kann\ verwendet\ werden.\ Er\ kann\ mit\ z.B.\ Font\ f\ \=\ new\ Font(\ "Arial",\ Font.PLAIN,\ 14\ );\ definiert\ werden.\ \r\n\ @param\ font\ ein\ Font-Objekt\ \r\n
+comment31.params=color
+comment31.target=java.awt.Color\ decode(java.lang.String)
+comment31.text=\ \r\n\ Hilfsfunktion\ zur\ Interpretation\ von\ Farben\r\n
+comment32.params=color
+comment32.target=java.awt.Color\ decode(int)
+comment32.text=\ \r\n\ Hilfsfunktion\ zur\ Interpretation\ von\ Farben\r\n
+comment33.params=pencolor
+comment33.target=void\ stroke(java.lang.String)
+comment33.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Linien\ und\ Raender\ um\ Formen\ gezeichnet\ werden.\ \r\n\ Diese\ Farbe\ wird\ hexadezimal\ in\ Form\ der\ RGB\ angegeben\:\ z.B.\ \ "CCFFAA"\ oder\ "004E23".\ Die\ Syntax\ verwendet\ sechs\ Ziffern\ -\ je\ zwei\ fuer\ die\ roten,\ gruenen\ und\ blauen\ Komponenten,\r\n\ um\ eine\ Farbe\ anzugeben\ (genau\ wie\ Farben\ typischerweise\ in\ HTML\ und\ CSS\ angegeben\ werden).\ \r\n\ @param\ pencolor\ Stiftfarbe\ in\ Hexadezimaldarstellung\r\n
+comment34.params=pencolor
+comment34.target=void\ stroke(int)
+comment34.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Linien\ und\ Raender\ um\ Formen\ gezeichnet\ werden.\ \r\n\ Diese\ Farbe\ wird\ entweder\ als\ Graustufe\ (0-255)\ oder\ als\ 3-Byte\ RGB-Wert\ angegeben\r\n\ @param\ pencolor\ Stiftfarbe\ (0-255\:\ Graustufe\ zwischen\ 0\ schwarz\ und\ 255\ weiss,\ sonst\:\ c\ wird\ als\ 3-Byte\ RGB-Wert\ interpretiert)\r\n
+comment35.params=r\ g\ b
+comment35.target=void\ stroke(int,\ int,\ int)
+comment35.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Linien\ und\ Raender\ um\ Formen\ gezeichnet\ werden.\ \r\n\ Diese\ Farbe\ wird\ komponentenweise\ als\ RGB-Wert\ angegeben\r\n\ @param\ r\ Rotanteil\ (0-255)\ der\ Stiftfarbe\r\n\ @param\ g\ Gruenanteil\ (0-255)\ der\ Stiftfarbe\r\n\ @param\ b\ Blauanteil\ (0-255)\ der\ Stiftfarbe\r\n
+comment36.params=
+comment36.target=void\ noStroke()
+comment36.text=\r\n\ Legt\ fest,\ dass\ keine\ Linien\ oder\ Raender\ um\ Formen\ gezeichnet\ werden\ soll.\ \r\n
+comment37.params=width
+comment37.target=void\ strokeWeight(double)
+comment37.text=\r\n\ Legt\ die\ Breite\ des\ Strichs\ fuer\ Linien,\ Punkte\ und\ den\ Rand\ um\ Formen\ fest.\ \r\n\ Alle\ Breiten\ werden\ in\ Pixeleinheiten\ angegeben.\ \r\n\ @param\ width\ Breite\ in\ Pixel\r\n
+comment38.params=fillcolor
+comment38.target=void\ fill(java.lang.String)
+comment38.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Formen\ gefuellt\ werden.\ \r\n\ Diese\ Farbe\ wird\ hexadezimal\ in\ Form\ der\ RGB\ angegeben\:\ z.B.\ \ "CCFFAA"\ oder\ "004E23".\ Die\ Syntax\ verwendet\ sechs\ Ziffern\ -\ je\ zwei\ fuer\ die\ roten,\ gruenen\ und\ blauen\ Komponenten,\r\n\ um\ eine\ Farbe\ anzugeben\ (genau\ wie\ Farben\ typischerweise\ in\ HTML\ und\ CSS\ angegeben\ werden).\ \r\n\ @param\ fillcolor\ Fuellfarbe\ in\ Hexadezimaldarstellung\r\n
+comment39.params=fillcolor
+comment39.target=void\ fill(int)
+comment39.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Formen\ gefuellt\ werden.\r\n\ Diese\ Farbe\ wird\ entweder\ als\ Graustufe\ (0-255)\ oder\ als\ 3-Byte\ RGB-Wert\ angegeben.\r\n\ @param\ fillcolor\ Fuellfarbe\ (0-255\:\ Graustufe\ zwischen\ 0\ schwarz\ und\ 255\ weiss,\ sonst\:\ c\ wird\ als\ 3-Byte\ RGB-Wert\ interpretiert)\r\n
+comment4.params=width\ height\ background
+comment4.target=Picture(int,\ int,\ java.lang.String)
+comment4.text=\r\n\ Erzeugt\ ein\ Bild\ der\ angegebenen\ Groesse\ mit\ festgelegtem\ Hintergrund\r\n\ @param\ width\ Breite\ des\ Bildes\r\n\ @param\ height\ Hoehe\ des\ Bildes\r\n\ @param\ background\ Farbe\ des\ Hintergrunds\r\n
+comment40.params=r\ g\ b
+comment40.target=void\ fill(int,\ int,\ int)
+comment40.text=\r\n\ Legt\ die\ Farbe\ fest,\ mit\ der\ Formen\ gefuellt\ werden.\r\n\ Diese\ Farbe\ wird\ komponentenweise\ als\ RGB-Wert\ angegeben.\r\n\ @param\ r\ Rotanteil\ (0-255)\ der\ Fuellfarbe\r\n\ @param\ g\ Gruenanteil\ (0-255)\ der\ Fuellfarbe\r\n\ @param\ b\ Blauanteil\ (0-255)\ der\ Fuellfarbe\r\n
+comment41.params=
+comment41.target=void\ noFill()
+comment41.text=\ Legt\ fest,\ dass\ die\ Formen\ nicht\ gefuellt\ werden\ sollen.\r\n
+comment42.params=c
+comment42.target=void\ background(int)
+comment42.text=\r\n\ Die\ Funktion\ background()\ setzt\ die\ Farbe,\ die\ fuer\ den\ Hintergrund\ des\ Bildes\ verwendet\ wird.\ Der\ Standardhintergrund\ ist\ hellgrau.\ \r\n\ Es\ ist\ nicht\ moeglich,\ den\ Alpha-Parameter\ Transparenz\ mit\ Hintergrundfarben\ auf\ der\ Hauptzeichnungsoberflaeche\ zu\ verwenden.\ \r\n\ @param\ c\ Farbe\ fuer\ den\ Hintergrund\ (0-255\:\ Graustufe\ zwischen\ 0\ schwarz\ und\ 255\ weiss,\ sonst\:\ c\ wird\ als\ 3-Byte\ RGB-Wert\ interpretiert)\r\n
+comment43.params=r\ g\ b
+comment43.target=void\ background(int,\ int,\ int)
+comment43.text=\r\n\ Die\ Funktion\ background()\ setzt\ die\ Farbe,\ die\ fuer\ den\ Hintergrund\ des\ Bildes\ verwendet\ wird.\ Der\ Standardhintergrund\ ist\ hellgrau.\ \r\n\ Es\ ist\ nicht\ moeglich,\ den\ Alpha-Parameter\ Transparenz\ mit\ Hintergrundfarben\ auf\ der\ Hauptzeichnungsoberflaeche\ zu\ verwenden.\ \r\n\ @param\ r\ Rotanteil\ (0-255)\ der\ Hintergrundfarbe\r\n\ @param\ g\ Gruenanteil\ (0-255)\ der\ Hintergrundfarbe\r\n\ @param\ b\ Blauanteil\ (0-255)\ der\ Hintergrundfarbe\r\n
+comment44.params=filename
+comment44.target=void\ load(java.lang.String)
+comment44.text=\ \r\n\ Laedt\ ein\ Bild\ aus\ dem\ Dateisystem.\r\n\ Laedt\ ein\ Bild\ von\ einem\ Datentraeger\ und\ setzt\ Stiftfarbe\ und\ Fuellfarbe\ auf\ Standardwerte\ zurueck.\r\n\ @param\ filename\ Dateiname\ des\ Bildes\r\n
+comment45.params=filename
+comment45.target=void\ save(java.lang.String)
+comment45.text=\ \r\n\ Speichert\ ein\ Bild.\r\n\ Speichert\ ein\ Bild\ auf\ einem\ Datentraeger.\ Zulaessig\ sind\ die\ Dateiformate\ PNG\ und\ GIF.\ Die\ Dateiendung\ legt\ den\ Typ\ fest.\r\n\ Standardmaessig\ wird\ die\ Dateiendung\ .png\ ergaenzt,\ wenn\ keine\ angegeben\ ist.\r\n\ @param\ filename\ Dateiname\ des\ Bildes\r\n
+comment46.params=
+comment46.target=java.awt.Color[][]\ getPixelArray()
+comment46.text=\r\n\ Liefert\ das\ Bild\ als\ zweidimensionales\ Pixel-Array.\r\n\ @return\ zweidimensionales\ Array\ von\ Color-Objekten,\ die\ den\ Pixeln\ des\ Bildes\ entsprechen.\r\n
+comment47.params=pixel
+comment47.target=void\ setPixelArray(java.awt.Color[][])
+comment47.text=\r\n\ Setzt\ das\ Bild\ neu\ auf\ Basis\ des\ Pixel-Arrays.\r\n\ Die\ Groesse\ des\ Bildes\ wird\ nicht\ automatisch\ an\ das\ Array\ angepasst.\r\n\ @param\ pixel\ zweidimensionales\ Array\ von\ Color-Objekten\r\n
+comment48.params=millis
+comment48.target=void\ delay(int)
+comment48.text=\r\n\ Hilfsfunktion\ zum\ Verzoegern\ der\ Ausgabe\r\n\ @param\ millis\ Wartezeit\ in\ Millisekunden\r\n
+comment5.params=
+comment5.target=void\ showInFrame()
+comment6.params=observer
+comment6.target=void\ setObserver(PictureViewer)
+comment6.text=\ \r\n\ \ \ Legt\ fest,\ wer\ das\ Bild\ anzeigt.\r\n\ Diese\ ermoeglicht\ die\ Benachrichtung\ des\ Observers,\ wenn\ sich\ das\ Bild\ aendert.\r\n\ @param\ observer\ Anzeiger\ des\ Bildes\r\n
+comment7.params=
+comment7.target=PictureViewer\ getObserver()
+comment8.params=b
+comment8.target=void\ setImage(java.awt.image.BufferedImage)
+comment8.text=\ \r\n\ Direktes\ Setzen\ des\ Bildes\ (fuer\ interne\ Zwecke)\r\n\ @param\ b\ Bild,\ das\ gespeichert\ werden\ soll.\r\n
+comment9.params=
+comment9.target=java.awt.image.BufferedImage\ getImage()
+comment9.text=\ \r\n\ Direktes\ Abfragen\ des\ Bildes\ (fuer\ interne\ Zwecke)\r\n\ @return\ Bild,\ das\ gerade\ gespeichert\ ist.\r\n
+numComments=49

imp/Picture.java

@@ -0,0 +1,715 @@
+package imp;
+
+import java.awt.image.*;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.BasicStroke;
+import java.util.Vector;
+import javax.imageio.*;
+import java.io.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.Random;
+import java.awt.geom.AffineTransform;
+
+/**
+ *
+ * Bildklasse fuer die Simulation von Processing-Befehlen
+ * 
+ * Diese Klasse stellt ein BufferedImage bereit, in das mit Processing-Befehlen gezeichnet
+ * werden kann. 
+ * Zusaetzlich kann ein Bildanzeiger ueber jede Aenderung des Bildes informiert werden,
+ * um "Zurueck"-Befehle zu ermoeglichen. Der Bildanzeiger ist entweder eine normale Java
+ * ScrollPane oder ein Actor aus Greenfoot.
+ * Die Dokumentation der einzelnen Zeichenmethoden ist der Processing-Reference 
+ * (https://processing.org/reference/ steht unter CC-Lizenz: https://creativecommons.org/) 
+ * entnommen und mit Deepl.com ins Deutsche uebersetzt.
+ *
+ * @version 1.0 from 23.01.2019
+ * @author Thomas Schaller (ZPG Informatik Klasse 9)
+ */
+
+public class Picture{
+
+    // Einstellungmoeglichkeiten fuer das Zeichnen von Rechtecken und Ellipsen 
+    // RADIUS = Mittelpunkt+Radius wird gegeben, CENTER = Mittelpunkt und Breite/Hoehe wird gegeben, 
+    // CORNER = Linke obere Ecke + Breite/Hoehe,  CORNERS = Linke obere und rechte untere Ecke
+    public static final int RADIUS = 1;
+    public static final int CENTER = 2;
+    public static final int CORNER = 3;
+    public static final int CORNERS = 4;
+
+    // gespeichertes Bild, 
+    private BufferedImage image;
+
+    // aktuelle Farbeinstellungen
+    private Color background;
+    private Color pencolor;
+    private Color fillcolor;
+
+    // aktuelle Stiftdicke
+    private double stroke;
+
+    // aktueller Koordinatenmodus von Rechtecken und Ellipsen
+    private int ellipseMode = CENTER;
+    private int rectMode = CORNER;
+    private int textMode = CORNER;
+
+    // aktueller Font
+    private Font textfont = null;
+
+    // muss ein Bildanzeiger benachrichtigt werden
+    private PictureViewer observer = null;
+    private boolean autorefresh = true;
+
+    /** 
+     * Erzeugt ein Bild mit Standardgroesse 500x400
+     */
+    public Picture() {
+        this(500,400);
+    }
+
+    /**
+     * Erzeugt ein Bild der angegeben Groesse
+     * @param width Breite des Bildes
+     * @param height Hoehe des Bildes
+     */
+    public Picture(int width, int height) {
+        this(width,height, "D0D0D0");
+    }
+
+    /** 
+     * Erzeugt ein Bild aus einer Datei
+     * @param filename Dateiname des Bildes
+     */
+    public Picture(String filename) {
+        load(filename);
+    }
+
+    /**
+     * Erzeugt ein Bild der angegebenen Groesse mit festgelegtem Hintergrund
+     * @param width Breite des Bildes
+     * @param height Hoehe des Bildes
+     * @param background Farbe des Hintergrunds
+     */
+    public Picture(int width, int height, String background) {
+        this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+        this.background = decode(background);
+        this.pencolor = new Color(0,0,0);
+        this.stroke = 1;
+        this.fillcolor = null;
+        Graphics2D g = (Graphics2D) this.image.getGraphics();
+        g.setColor(this.background);
+        g.fillRect(0,0,width-1, height-1);
+    }
+
+    public void showInFrame() {
+        new PictureViewer(this);
+
+
+        
+    }
+
+    /** 
+     *   Legt fest, wer das Bild anzeigt.
+     * Diese ermoeglicht die Benachrichtung des Observers, wenn sich das Bild aendert.
+     * @param observer Anzeiger des Bildes
+     */
+
+    public void setObserver(PictureViewer observer) {
+        this.observer= observer;
+    }
+
+    public PictureViewer getObserver() {
+        return observer;
+    }
+
+    /** 
+     * Direktes Setzen des Bildes (fuer interne Zwecke)
+     * @param b Bild, das gespeichert werden soll.
+     */
+    public void setImage(BufferedImage b) {
+        image = b;
+    }
+
+    /** 
+     * Direktes Abfragen des Bildes (fuer interne Zwecke)
+     * @return Bild, das gerade gespeichert ist.
+     */
+    public BufferedImage getImage() {
+        return image;
+    }
+
+    /**
+     * Definiert die Dimension der Breite und Hoehe des Anzeigefensters in Pixeleinheiten. 
+     * Die eingebauten Variablen Breite und Hoehe werden durch die an diese Funktion uebergebenen Parameter festgelegt. So weist beispielsweise 
+     * der Befehl size(640, 480) der Variablen Breite 640 und der Variablen Hoehe 480 zu. 
+     * @param width Breite des Bildes
+     * @param height Hoehe des Bildes
+     */
+    public void size(int width, int height){
+        pushImage();
+        this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+        Graphics2D g = (Graphics2D) this.image.getGraphics();
+        g.setColor(background);
+        g.fillRect(0,0,width-1, height-1);
+        repaint();
+    }
+
+    /** 
+     * Liefert die Breite des Bildes zurueck.
+     * @return Breite des Bildes
+     */
+    public int getWidth() {
+        return image.getWidth();
+    }
+
+    /** 
+     * Liefert die Hoehe des Bildes zurueck.
+     * @return Hoehe des Bildes
+     */
+    public int getHeight() {
+        return image.getHeight();
+    }
+
+    /**
+     * Erzeugt eine Kopie des Bildes und uebergibt sie an den Observer (falls existent), damit dieser die Versionen speichern kann
+     */
+    private void pushImage() {
+        if(observer != null) {
+            observer.pushImage();
+        }
+    }   
+    
+
+    /**
+     * Legt fest, ob nach jedem Zeichenbefehl automatisch das Bild auch in
+     * der Oberflaeche aktualisiert wird. Die Einstellung "false" beschleunigt
+     * das Zeichnen aufwaendiger Bilder und verhindert "Flackern".
+     * Das Neuzeichnen kann durch die Methode "refresh" gezielt ausgeloest werden.
+     * @param autorefresh true = nach jedem Zeichenbefehl die Anzeige aktualisieren, false= nur durch die Methode refresh neu zeichnen
+     */
+    public void setAutoRefresh(boolean autoRefresh) {
+        this.autorefresh = autoRefresh;
+    }
+
+    /**
+     * Auch die anzeigenden Klasse wird zum Neuzeichnen aufgefordert.
+     */
+    private void repaint() {
+        if(observer != null && autorefresh) {
+            observer.repaint();
+        }
+    }
+
+    /**
+     * Ein repaint() (das Neuzeichnen) kann manuell erzwungen werden.
+     */
+    public void forceRepaint() {
+        if(observer != null) {
+            observer.repaint();
+        }
+    }
+
+    // ----------------------------------------- Zeichenfunktionen -----------------------------------------------
+    /** 
+     * Loescht den Inhalt des Bildes.
+     * Der Hintergrund wird mit der Hintergrundfarbe neu gefuellt.
+     */
+
+    public void clear(){
+        pushImage();
+        image = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
+        Graphics2D g = (Graphics2D) this.image.getGraphics();
+        g.setColor(background);
+        g.fillRect(0,0,image.getWidth()-1, image.getHeight()-1);
+        repaint();
+    }
+
+    /** 
+     * Konvertiert die in einem bestimmten Modus gegebenen Koordinaten in die Java-uebliche Links_Oben_Breite_Hoehe Version
+     * Die Aenderungen werden direkt im Array vorgenommen
+     * @param coord Array mit vier Koordinateneintraegen im gegebenen Modus
+     * @param mode  Modus der Koordinaten (CORNER, CORNERS, RADIUS oder CENTER)
+     */
+    private void convert(int[] coord, int mode) {
+        switch(mode) {
+            case CORNER: break;
+            case CORNERS: coord[2] -= coord[0]; coord[3] -= coord[1]; break;
+            case RADIUS: coord[2] *= 2; coord[3] *=2;
+            case CENTER: coord[0] -= coord[2]/2; coord[1] -= coord[3]/2;
+        }
+    }
+
+    /**
+     * Aendert den Koordinaten-Modus beim Zeichnen von Rechtecken.
+     * Aendert die Position, von der aus Rechtecke gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an rect() uebergeben werden, interpretiert werden.
+     * Der Standardmodus ist rectMode(Bild.CORNER), der die ersten beiden Parameter von rect() als die linke obere Ecke der Form interpretiert, 
+     * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind.
+     * rectMode(Bild.CORNERS) interpretiert die ersten beiden Parameter von rect() als die Position einer Ecke 
+     * und die dritten und vierten Parameter als die Position der gegenueberliegenden Ecke.
+     * rectMode(Bild.CENTER) interpretiert die ersten beiden Parameter von rect() als Mittelpunkt der Form, 
+     * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind.
+     * rectMode(RADIUS) verwendet auch die ersten beiden Parameter von rect() als Mittelpunkt der Form, 
+     * verwendet aber den dritten und vierten Parameter, um die Haelfte der Breite und Hoehe der Formen festzulegen.
+     * @param mode Modus der Koordinateninterpretation (CORNER, CORNERS, CENTER oder RADIUS)
+     */
+    public void rectMode(int mode) {
+        rectMode = mode;
+    }
+
+    /**
+     * Aendert den Koordinaten-Modus beim Zeichnen von Kreisen/Ellipsen.
+     * Aendert die Position, von der aus Kreise/Ellipsen gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an ellipse() uebergeben werden, interpretiert werden.
+     * Der Standardmodus ist ellipseMode(Bild.CENTER), der die ersten beiden Parameter von ellipse() als Mittelpunkt der Form interpretiert, 
+     * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind.
+     * ellipseMode(Bild.CORNER) interpretiert die ersten beiden Parameter von ellipse() als die Position einer Ecke 
+     * und die dritten und vierten Parameter als Breite und Hoehe der Form.
+     * ellipseMode(Bild.CORNERS) interpretiert die ersten beiden Parameter von ellipse() als die Position einer Ecke 
+     * und die dritten und vierten Parameter als die Position der gegenueberliegenden Ecke.
+     * ellipseMode(RADIUS) verwendet auch die ersten beiden Parameter von ellipse() als Mittelpunkt der Form, 
+     * verwendet aber den dritten und vierten Parameter, um die Haelfte der Breite und Hoehe der Formen festzulegen.
+     * @param mode Modus der Koordinateninterpretation (CORNER, CORNERS, CENTER oder RADIUS)
+     */
+    public void ellipseMode(int mode) {
+        ellipseMode = mode;
+    }
+
+    /**
+     * Aendert den Koordinaten-Modus beim Zeichnen von Texten.
+     * Aendert die Position, an der Texte gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an text() uebergeben werden, interpretiert werden.
+     * Der Standardmodus ist textMode(Bild.CORNER), der die Koordinaten von text() als 
+     * linke untere Ecke des Textes interpretiert.
+     * textMode(Bild.CENTER) interpretiert sie als Koordinaten des Mittelpunktes des Textes..
+      * @param mode Modus der Koordinateninterpretation (CORNER, CENTER)
+     */
+    public void textMode(int mode) {
+        textMode = mode;
+    }
+    
+    /**
+     * Zeichnet eine Linie (einen direkten Weg zwischen zwei Punkten) auf den Bildschirm. 
+     * Um eine Linie einzufaerben, verwenden Sie die {@link #stroke(int, int, int) stroke()} Funktion. Eine Zeile kann nicht gefuellt werden, daher hat die Funktion fill() keinen 
+     * Einfluss auf die Farbe einer Zeile. Linien werden standardmaessig mit einer Breite von einem Pixel gezeichnet, dies kann jedoch mit der Funktion 
+     * {@link #strokeWeight(double) strokeWeight()} geaendert werden.
+     * @param x1 x-Koordinate des 1. Punktes
+     * @param y1 y-Koordinate des 1. Punktes
+     * @param x2 x-Koordinate des 2. Punktes
+     * @param y2 y-Koordinate des 2. Punktes
+     */
+    public void line(int x1, int y1, int x2, int y2) {
+        pushImage();  
+        Graphics2D g = (Graphics2D) image.getGraphics();
+        if (stroke > 0) {
+            g.setColor(pencolor);
+            g.setStroke(new BasicStroke((float) stroke));
+            g.drawLine(x1, y1, x2, y2);
+        }
+        repaint();
+    }
+
+    /**
+     * Zeichnet ein Rechteck auf das Bild. 
+     * Standardmaessig legen die ersten beiden Parameter die Position der linken oberen Ecke fest, der dritte die Breite und der vierte die Hoehe. 
+     * Die Art und Weise, wie diese Parameter interpretiert werden, kann jedoch mit der Funktion {@link #rectMode(int) rectMode()} geaendert werden.
+     * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()}  kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()}  die Rahmenfarbe.
+     * @param a meist die x-Koordinate der linken oberen Ecke (kann durch rectMode() geaendert werden).
+     * @param b meist die y-Koordinate der linken oberen Ecke (kann durch rectMode() geaendert werden).
+     * @param c meist die Breite des Rechtecks (kann durch rectMode() geaendert werden).
+     * @param d meist die Hoehe des Rechtecks (kann durch rectMode() geaendert werden).
+     * 
+     */
+    public void rect(int a, int b, int c, int d) {
+        pushImage();
+        Graphics2D g = (Graphics2D) image.getGraphics();
+        int[] coord = {a,b,c,d};
+        convert(coord, rectMode);
+        if(fillcolor != null) {
+            g.setColor(fillcolor);
+            g.fillRect(coord[0], coord[1], coord[2], coord[3]);
+        }
+        if(pencolor != null) {
+            g.setColor(pencolor);
+            g.setStroke(new BasicStroke((float) stroke));
+            g.drawRect(coord[0], coord[1], coord[2], coord[3]);
+        }  
+        repaint();
+    }
+
+    /**
+     * Zeichnet eine Ellipse/Kreis auf das Bild. 
+     * Standardmaessig legen die ersten beiden Parameter die Position des Mittelpunkts fest, der dritte die Breite und der vierte die Hoehe. 
+     * Die Art und Weise, wie diese Parameter interpretiert werden, kann jedoch mit der Funktion {@link #ellipseMode(int) ellipseMode()} geaendert werden.
+     * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()}  die Rahmenfarbe.
+     * @param a meist die x-Koordinate des Mittelpunkts (kann durch ellipseMode() geaendert werden).
+     * @param b meist die y-Koordinate des Mittelpunkts (kann durch ellipseMode() geaendert werden).
+     * @param c meist die Breite des Rechtecks (kann durch ellipseMode() geaendert werden).
+     * @param d meist die Hoehe des Rechtecks (kann durch ellipseMode() geaendert werden).
+     * 
+     */
+    public void ellipse(int a, int b, int c, int d) {
+        pushImage();      
+        Graphics2D g = (Graphics2D) image.getGraphics();
+        int[] coord = {a,b,c,d};
+        convert(coord, ellipseMode);
+        if(fillcolor != null) {
+            g.setColor(fillcolor);
+            g.fillOval(coord[0], coord[1], coord[2], coord[3]);
+        }
+        if(pencolor != null) {
+            g.setColor(pencolor);
+            g.setStroke(new BasicStroke((float) stroke));
+            g.drawOval(coord[0], coord[1], coord[2], coord[3]);
+        }  
+        repaint();
+    }
+
+    /**
+     * Zeichnet ein Dreieck auf das Bild. 
+     * Ein Dreieck ist eine Ebene, die durch die Verbindung von drei Punkten entsteht. Die ersten beiden Argumente spezifizieren den 
+     * ersten Punkt, die mittleren beiden Argumente spezifizieren den zweiten Punkt und die letzten beiden Argumente spezifizieren den dritten Punkt. 
+     * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()}  die Rahmenfarbe.
+     * @param x1 meist die x-Koordinate des 1. Punkts.
+     * @param y1 meist die y-Koordinate des 1. Punkts.
+     * @param x2 meist die x-Koordinate des 2. Punkts.
+     * @param y2 meist die y-Koordinate des 2. Punkts.
+     * @param x3 meist die x-Koordinate des 3. Punkts.
+     * @param y3 meist die y-Koordinate des 3. Punkts.
+     */
+    public void triangle(int x1, int y1, int x2, int y2, int x3, int y3) {
+        int px[] = {x1, x2, x3};
+        int py[] = {y1, y2, y3};
+        polygon(px, py);
+    }
+
+    /**
+     * Zeichnet ein Viereck auf das Bild. 
+     * Ein Viereck ist ein vierseitiges Polygon. Es ist aehnlich wie ein Rechteck, aber die Winkel zwischen seinen Kanten 
+     * sind nicht auf neunzig Grad beschraenkt. Das erste Paar von Parametern (x1,y1) setzt den ersten Scheitelpunkt und die nachfolgenden 
+     * Paare sollten im Uhrzeigersinn oder gegen den Uhrzeigersinn um die definierte Form herum verlaufen. 
+     * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()}  die Rahmenfarbe.
+     * @param x1 meist die x-Koordinate des 1. Punkts.
+     * @param y1 meist die y-Koordinate des 1. Punkts.
+     * @param x2 meist die x-Koordinate des 2. Punkts.
+     * @param y2 meist die y-Koordinate des 2. Punkts.
+     * @param x3 meist die x-Koordinate des 3. Punkts.
+     * @param y3 meist die y-Koordinate des 3. Punkts.
+     * @param x4 meist die x-Koordinate des 3. Punkts.
+     * @param y4 meist die y-Koordinate des 3. Punkts.
+     */
+    public void quad(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
+        int px[] = {x1, x2, x3, x4};
+        int py[] = {y1, y2, y3, y4};
+        polygon(px, py);
+    }
+
+    /**
+     * Zeichnet ein Polygon auf das Bild.
+     * Gleich lange Listen von x und y-Koordinaten bestimmen die Eckpunkte des Polygons.
+     * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe.
+     * @param x Liste der x-Koordinaten der Punkte.
+     * @param y Liste der y-Koordinaten der Punkte.
+     */
+
+    public void polygon(int[] x, int[] y) {
+        pushImage();     
+        Graphics2D g = (Graphics2D) image.getGraphics();
+
+        if(fillcolor != null) {
+
+            g.setColor(fillcolor);
+            g.fillPolygon(x,y, y.length);
+        }
+        if(pencolor != null) {
+            g.setColor(pencolor);
+            g.setStroke(new BasicStroke((float) stroke));
+            g.drawPolygon(x, y, x.length);
+        }  
+        repaint();
+    }
+
+    /**
+     * Zeichnet einen Punkt, d.h. einen Kreis in der Dimension eines Pixels. 
+     * Der erste Parameter ist der x-Wert fuer den Punkt, der zweite Wert ist der y-Wert fuer den Punkt. 
+     * @param x x-Koordinate des Punktes
+     * @param y y-Koordinate des Punktes
+     */
+    public void point(int x, int y) {
+        ellipse(x,y,1, 1);
+    }
+
+    // ----------------------------------------- Schriftdarstellung -----------------------------------------------
+
+    /**
+     * Gibt einen Text an den gegebenen Koordinaten aus
+     * Zur Ausgabe des Textes wird der ausgewaehlte Font verwendet. Dieser muss vorher mit {@link #textFont(Font) textFont() } festgelegt.
+     * @param s Text, der angezeigt werden soll
+     * @param x x-Koordinate des Textanfangs
+     * @param y y-Koordinate der Grundlinie des Textes.
+     */
+    public void text(String s, int x, int y) {
+        pushImage();     
+        Graphics2D g = (Graphics2D) image.getGraphics();
+        if(pencolor != null) {
+            g.setColor(fillcolor);
+            g.setStroke(new BasicStroke((float) stroke));
+            g.setFont(textfont);
+            if(textMode == CORNER) {
+              g.drawString(s, x, y);
+            } else { // textMode == CENTER
+              int dx = g.getFontMetrics().stringWidth(s)/2;
+              int dy = g.getFontMetrics().getAscent()/2;
+              g.drawString(s, x-dx, y+dy);
+            }
+        }  
+        repaint();
+    }
+
+    /**
+     * Legt die Schriftart fuer Textausgaben fest.
+     * Jeder uebliche Java-Font kann verwendet werden. Er kann mit z.B. Font f = new Font( "Arial", Font.PLAIN, 14 ); definiert werden. 
+     * @param font ein Font-Objekt 
+     */
+    public void textFont(Font font) {
+        this.textfont = font;
+    }
+
+    // ----------------------------------------- Farbfestlegungen -----------------------------------------------
+    /** 
+     * Hilfsfunktion zur Interpretation von Farben
+     */
+    private Color decode(String color) {
+        try{
+            return new Color(
+                Integer.valueOf( color.substring( 0, 2 ), 16 ),
+                Integer.valueOf( color.substring( 2, 4 ), 16 ),
+                Integer.valueOf( color.substring( 4, 6 ), 16 ) );
+        } catch (Exception e) {
+            System.out.println("Falscher Farbcode:"+color);
+            e.printStackTrace();
+            return Color.BLACK;
+        }
+    }
+
+    /** 
+     * Hilfsfunktion zur Interpretation von Farben
+     */
+    private Color decode(int color) {
+        try{
+            if(color >=0 && color < 256) {
+                return new Color(color,color,color);
+            } else {
+                int r = color / 0x010000 % 0xFF;
+                int g = color / 0x000100 % 0xFF;
+                int b = color % 0xFF;
+                // System.out.println(""+r+","+g+","+b);
+                return new Color(r, g, b );
+            }
+        } catch (Exception e) {
+            System.out.println("Falscher Farbcode:"+color);
+                        e.printStackTrace();
+            return Color.BLACK;
+        }
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. 
+     * Diese Farbe wird hexadezimal in Form der RGB angegeben: z.B.  "CCFFAA" oder "004E23". Die Syntax verwendet sechs Ziffern - je zwei fuer die roten, gruenen und blauen Komponenten,
+     * um eine Farbe anzugeben (genau wie Farben typischerweise in HTML und CSS angegeben werden). 
+     * @param pencolor Stiftfarbe in Hexadezimaldarstellung
+     */
+    public void stroke(String pencolor) {
+        this.pencolor = decode(pencolor);
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. 
+     * Diese Farbe wird entweder als Graustufe (0-255) oder als 3-Byte RGB-Wert angegeben
+     * @param pencolor Stiftfarbe (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert)
+     */
+    public void stroke(int pencolor) {
+        this.pencolor=decode(pencolor);
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. 
+     * Diese Farbe wird komponentenweise als RGB-Wert angegeben
+     * @param r Rotanteil (0-255) der Stiftfarbe
+     * @param g Gruenanteil (0-255) der Stiftfarbe
+     * @param b Blauanteil (0-255) der Stiftfarbe
+     */
+    public void stroke(int r, int g, int b) {
+        this.pencolor = new Color(r,g,b);
+    }
+
+    /**
+     * Legt fest, dass keine Linien oder Raender um Formen gezeichnet werden soll. 
+     */
+    public void noStroke() {
+        this.pencolor = null;
+    }
+
+    /**
+     * Legt die Breite des Strichs fuer Linien, Punkte und den Rand um Formen fest. 
+     * Alle Breiten werden in Pixeleinheiten angegeben. 
+     * @param width Breite in Pixel
+     */
+    public void strokeWeight(double width) {
+        this.stroke = width;
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Formen gefuellt werden. 
+     * Diese Farbe wird hexadezimal in Form der RGB angegeben: z.B.  "CCFFAA" oder "004E23". Die Syntax verwendet sechs Ziffern - je zwei fuer die roten, gruenen und blauen Komponenten,
+     * um eine Farbe anzugeben (genau wie Farben typischerweise in HTML und CSS angegeben werden). 
+     * @param fillcolor Fuellfarbe in Hexadezimaldarstellung
+     */
+    public void fill(String fillcolor) {
+        this.fillcolor = decode(fillcolor);
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Formen gefuellt werden.
+     * Diese Farbe wird entweder als Graustufe (0-255) oder als 3-Byte RGB-Wert angegeben.
+     * @param fillcolor Fuellfarbe (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert)
+     */
+    public void fill(int fillcolor) {
+        this.fillcolor=decode(fillcolor);
+    }
+
+    /**
+     * Legt die Farbe fest, mit der Formen gefuellt werden.
+     * Diese Farbe wird komponentenweise als RGB-Wert angegeben.
+     * @param r Rotanteil (0-255) der Fuellfarbe
+     * @param g Gruenanteil (0-255) der Fuellfarbe
+     * @param b Blauanteil (0-255) der Fuellfarbe
+     */
+    public void fill(int r, int g, int b) {
+        this.fillcolor = new Color(r,g,b);
+    }
+
+    /** Legt fest, dass die Formen nicht gefuellt werden sollen.
+     */
+    public void noFill() {
+        this.fillcolor = null;
+    }
+
+    /**
+     * Die Funktion background() setzt die Farbe, die fuer den Hintergrund des Bildes verwendet wird. Der Standardhintergrund ist hellgrau. 
+     * Es ist nicht moeglich, den Alpha-Parameter Transparenz mit Hintergrundfarben auf der Hauptzeichnungsoberflaeche zu verwenden. 
+     * @param c Farbe fuer den Hintergrund (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert)
+     */
+    public void background(int c) {
+        if(c < 256) {
+            this.background=new Color(c,c,c);
+        } else {
+            int r = c / 0x010000;
+            int g = c / 0x000100 % 0xFF;
+            int b = c % 0xFF;
+            this.background= new Color(r, g, b );
+        }
+
+        this.clear();
+    }
+
+    /**
+     * Die Funktion background() setzt die Farbe, die fuer den Hintergrund des Bildes verwendet wird. Der Standardhintergrund ist hellgrau. 
+     * Es ist nicht moeglich, den Alpha-Parameter Transparenz mit Hintergrundfarben auf der Hauptzeichnungsoberflaeche zu verwenden. 
+     * @param r Rotanteil (0-255) der Hintergrundfarbe
+     * @param g Gruenanteil (0-255) der Hintergrundfarbe
+     * @param b Blauanteil (0-255) der Hintergrundfarbe
+     */
+    public void background(int r, int g, int b) {
+        this.background=new Color(r,g,b);
+        this.clear();
+    }
+
+    // ----------------------------------------- Dateioperationen -----------------------------------------------
+    /** 
+     * Laedt ein Bild aus dem Dateisystem.
+     * Laedt ein Bild von einem Datentraeger und setzt Stiftfarbe und Fuellfarbe auf Standardwerte zurueck.
+     * @param filename Dateiname des Bildes
+     */
+    public void load(String filename) {
+        try{
+            this.image = ImageIO.read(new File(filename));
+            this.background = decode("D0D0D0");
+            this.pencolor = new Color(0,0,0);
+            this.fillcolor = null;
+            this.stroke = 1;
+            this.repaint();
+        } catch(Exception e) {
+            System.out.println("Fehler beim Einlesen der Bilddatei");
+        }
+    }
+
+    /** 
+     * Speichert ein Bild.
+     * Speichert ein Bild auf einem Datentraeger. Zulaessig sind die Dateiformate PNG und GIF. Die Dateiendung legt den Typ fest.
+     * Standardmaessig wird die Dateiendung .png ergaenzt, wenn keine angegeben ist.
+     * @param filename Dateiname des Bildes
+     */
+    public void save(String filename) {
+        try{
+            String[] fn = filename.split("\\.");
+            if (fn.length== 1) {
+                ImageIO.write(image, "PNG", new File(filename+".png"));
+            } else {
+
+                if (fn.length == 2 && (fn[1].toUpperCase().equals("PNG") ||
+                    fn[1].toUpperCase().equals("GIF"))){
+                    ImageIO.write(image, fn[1], new File(filename)); 
+                }else {
+                    System.out.println("Unbekanntes Bildformat");
+                }
+            }
+        } catch(Exception e) {
+            System.out.println("Fehler beim Speichern");
+        }
+    }
+
+    // ----------------------------------------- Sonstiges -----------------------------------------------  
+    /**
+     * Liefert das Bild als zweidimensionales Pixel-Array.
+     * @return zweidimensionales Array von Color-Objekten, die den Pixeln des Bildes entsprechen.
+     */
+
+    public Color[][] getPixelArray() {
+        Color[][] pixel = new Color[image.getWidth()][image.getHeight()];  
+        for(int x=0; x < image.getWidth(); x++){
+            for(int y=0; y < image.getHeight(); y++) {
+                pixel[x][y] = new Color(image.getRGB(x,y));
+            }
+        }
+        return pixel;
+    }
+
+    /**
+     * Setzt das Bild neu auf Basis des Pixel-Arrays.
+     * Die Groesse des Bildes wird nicht automatisch an das Array angepasst.
+     * @param pixel zweidimensionales Array von Color-Objekten
+     */
+    public void setPixelArray(Color[][] pixel) {
+        size(pixel.length,pixel[0].length);
+        Graphics2D g = (Graphics2D) image.getGraphics();
+        for(int x=0; x < image.getWidth(); x++){
+            for(int y=0; y < image.getHeight(); y++) {
+                g.setColor(pixel[x][y]);
+                g.fillRect(x, y, 1, 1);
+            }
+        }
+        repaint();
+    }
+
+    /**
+     * Hilfsfunktion zum Verzoegern der Ausgabe
+     * @param millis Wartezeit in Millisekunden
+     */
+    public void delay(int millis) {
+        try{
+            Thread.sleep(millis);
+        } catch(Exception e) {
+            System.out.println("Fehler beim Verzoegern der Ausgabe");
+        }
+    }
+}

imp/PictureViewer.ctxt

@@ -0,0 +1,39 @@
+#BlueJ class context
+comment0.target=PictureViewer
+comment1.params=
+comment1.target=PictureViewer()
+comment1.text=\r\n\ Erzeugt\ ein\ ScrollPanel\ mit\ integriertem\ Bild\ der\ Gr\u00F6\u00DFe\ 1000x1000\r\n
+comment10.params=
+comment10.target=void\ back()
+comment10.text=\r\n\ Ruft\ das\ letzte\ abgespeicherte\ Bild\ aus\ der\ History\ wieder\ auf.\r\n
+comment11.params=
+comment11.target=void\ repaint()
+comment11.text=\r\n\ Setzt\ das\ angezeigt\ Bild\ neu\ und\ beachtet\ dabei\ den\ Zoomfaktor.\r\n
+comment12.params=factor
+comment12.target=void\ setZoom(double)
+comment12.text=\r\n\ Setzt\ den\ Zoom-Faktor\ f\u00FCr\ das\ Bild.\r\n\ Als\ Zoomfaktor\ sind\ auch\ die\ Konstanten\ Bildanzeiger.FIT\ (auf\ Bildschirmgr\u00F6\u00DFe\ zoomen)\ und\ Bildanzeiger.NORMAL\ (100%)\ m\u00F6glich.\r\n\ @param\ factor\ Zoomfaktor\ (1.0\ \=\ 100%).\ \r\n
+comment2.params=width\ height
+comment2.target=PictureViewer(int,\ int)
+comment2.text=\r\n\ Erzeugt\ ein\ ScrollPanel\ mit\ integriertem\ Bild\ der\ angegebenen\ Gr\u00F6\u00DFe\ \r\n\ @param\ width\ Breite\ des\ Bildes\r\n\ @param\ height\ H\u00F6he\ des\ Bildes\r\n
+comment3.params=width\ height\ background
+comment3.target=PictureViewer(int,\ int,\ java.lang.String)
+comment3.text=\r\n\ Erzeugt\ ein\ ScrollPanel\ mit\ integriertem\ Bild\ der\ angegebenen\ Gr\u00F6\u00DFe\ \r\n\ @param\ width\ Breite\ des\ Bildes\r\n\ @param\ height\ H\u00F6he\ des\ Bildes\r\n\ @param\ background\ Farbe\ des\ Hintergrunds\ als\ HEX-String\ (z.B.\ "FF3A45")\r\n
+comment4.params=filename
+comment4.target=PictureViewer(java.lang.String)
+comment4.text=\r\n\ Erzeugt\ ein\ ScrollPanel\ mit\ integriertem\ Bild\ aus\ einer\ Bilddatei\r\n\ @param\ filename\ Name\ des\ Bildes\r\n
+comment5.params=picture
+comment5.target=PictureViewer(Picture)
+comment5.text=\r\n\ Erzeugt\ ein\ ScrollPanel\ und\ zeigt\ das\ Bild-Objekt\ an\r\n\ @param\ picture\ anzuzeigendes\ Bild\r\n
+comment6.params=picture\ saveOldImage
+comment6.target=void\ setImage(Picture,\ boolean)
+comment6.text=\r\n\ Setzt\ das\ anzuzeigende\ Bild\ neu\r\n\ @param\ picture\ anzuzeigendes\ Bild\r\n\ @param\ saveOldImage\ soll\ das\ aktuelle\ Bild\ in\ der\ Historie\ gespeichert\ werden\r\n
+comment7.params=
+comment7.target=Picture\ getImage()
+comment7.text=\r\n\ Liefert\ das\ angezeigte\ Bild\r\n\ @return\ angezeigtes\ Bild\r\n
+comment8.params=bi
+comment8.target=java.awt.image.BufferedImage\ deepCopy(java.awt.image.BufferedImage)
+comment8.text=\ \r\n\ Erzeugt\ eine\ Kopie\ eines\ BufferedImage.\r\n\ @param\ Originalbild\r\n\ @return\ Kopie\ des\ Bildes\r\n
+comment9.params=
+comment9.target=void\ pushImage()
+comment9.text=\r\n\ Speichert\ das\ \u00FCbergebene\ Bild\ in\ der\ History.\r\n\ @param\ b\ zu\ speicherndes\ Bild\r\n
+numComments=13

imp/PictureViewer.java

@@ -0,0 +1,207 @@
+package imp;
+
+/**
+ * Zeigt ein Bild in einem Scrollbereich an. 
+ * Es ist möglich das Bild zu zoomen und mehrere Versionen des Bildes zu speichern, um eine "Rückgängig" Operation durchzuführen.
+ * @author Thomas Schaller
+ * @version 1.0 vom 01.02.2019
+ */
+
+import javafx.scene.control.ScrollPane;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.embed.swing.SwingFXUtils;
+import java.util.Vector;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.WritableRaster;
+import javafx.geometry.Pos;
+
+public class PictureViewer extends ScrollPane
+{
+   
+  // das aktuelle Bild
+  private Picture picture;
+    
+  // Bilder für den Züruck-Modus speichern
+  private static final int ANZ_BACK = 20;  
+  private Vector<BufferedImage> history;
+  
+  // Zeichenfläche
+  private Image scrollImageIcon;
+  private ImageView imageLabel;
+  
+  // Zoom Faktor
+  private double zoomFactor;
+  public static final int FIT = -1;
+  public static final int NORMAL = 1;
+  
+  
+  
+  /**
+   * Erzeugt ein ScrollPanel mit integriertem Bild der Größe 1000x1000
+   */
+  public PictureViewer() {
+    this(1000,1000);
+  }
+
+  /**
+   * Erzeugt ein ScrollPanel mit integriertem Bild der angegebenen Größe 
+   * @param width Breite des Bildes
+   * @param height Höhe des Bildes
+   */
+  public PictureViewer(int width, int height) {
+    this(width,height, "D0D0D0");
+  }
+  
+  /**
+   * Erzeugt ein ScrollPanel mit integriertem Bild der angegebenen Größe 
+   * @param width Breite des Bildes
+   * @param height Höhe des Bildes
+   * @param background Farbe des Hintergrunds als HEX-String (z.B. "FF3A45")
+   */
+  public PictureViewer(int width, int height, String background) {
+    this(new Picture(width,height, background));
+  }
+ 
+  /**
+   * Erzeugt ein ScrollPanel mit integriertem Bild aus einer Bilddatei
+   * @param filename Name des Bildes
+   */
+  public PictureViewer(String filename) {
+    this(new Picture(filename));
+  }
+  
+  /**
+   * Erzeugt ein ScrollPanel und zeigt das Bild-Objekt an
+   * @param picture anzuzeigendes Bild
+   */
+  public PictureViewer(Picture picture)
+  {
+    this.picture=picture;
+    
+    zoomFactor=1;
+    
+    scrollImageIcon = SwingFXUtils.toFXImage(picture.getImage(), null);
+    //new Image(picture.getImage().getScaledInstance(picture.getImage().getWidth(), picture.getImage().getHeight(), Image.SCALE_FAST));
+    imageLabel = new ImageView(scrollImageIcon);
+    imageLabel.setPreserveRatio(true);
+    //imageLabel.setsetAlignment(Pos.TOP_CENTER);
+    //imageLabel.setHorizontalAlignment(JLabel.CENTER);
+    setContent(imageLabel);
+    
+//    this.setBorder(BorderFactory.createLineBorder(Color.black));
+    picture.setObserver(this);
+    history = new Vector<BufferedImage>();
+    
+  }
+  
+  
+  /**
+   * Setzt das anzuzeigende Bild neu
+   * @param picture anzuzeigendes Bild
+   * @param saveOldImage soll das aktuelle Bild in der Historie gespeichert werden
+   */
+  public void setImage(Picture picture, boolean saveOldImage) {
+      if (saveOldImage) pushImage();
+      this.picture = picture;
+      repaint();
+  }  
+  
+  /**
+   * Liefert das angezeigte Bild
+   * @return angezeigtes Bild
+   */
+  public Picture getImage() {
+      return this.picture;
+  }
+  
+
+  
+  
+  /** 
+   * Erzeugt eine Kopie eines BufferedImage.
+   * @param Originalbild
+   * @return Kopie des Bildes
+   */
+  private BufferedImage deepCopy(BufferedImage bi) {
+    ColorModel cm = bi.getColorModel();
+    boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
+    WritableRaster raster = bi.copyData(null);
+    return new BufferedImage(cm, raster, isAlphaPremultiplied, null).getSubimage(0, 0, bi.getWidth(), bi.getHeight());
+  }
+  
+  
+  /**
+   * Speichert das übergebene Bild in der History.
+   * @param b zu speicherndes Bild
+   */
+  public void pushImage() {
+      if( this.ANZ_BACK > 0) {
+        if(history.size() == this.ANZ_BACK) {
+            history.removeElementAt(0);
+        }
+        
+        history.add(deepCopy(picture.getImage()));
+      }   
+  }   
+  
+  /**
+   * Ruft das letzte abgespeicherte Bild aus der History wieder auf.
+   */
+  public void back() {
+    int anz = history.size();
+    if(anz>0) {
+      BufferedImage img = history.get(anz-1);
+      history.removeElementAt(anz-1);
+      picture.setImage(img);
+      repaint();
+    }
+  }
+
+
+  
+  /**
+   * Setzt das angezeigt Bild neu und beachtet dabei den Zoomfaktor.
+   */
+  public void repaint() {
+    if( picture != null) {
+      double factor= zoomFactor;
+      if (zoomFactor == FIT) {
+        double factorw = ((double) getWidth()-2) / picture.getWidth();
+        double factorh = ((double) getHeight()-2) / picture.getHeight();
+        factor = Math.min(factorw, factorh);
+      }
+      int width = (int) (picture.getWidth()*factor);
+      int height = (int) (picture.getHeight()*factor);
+      
+      scrollImageIcon = SwingFXUtils.toFXImage(picture.getImage(), null);
+      imageLabel.setFitWidth(width);
+      imageLabel.setFitHeight(height);
+      imageLabel.setImage(scrollImageIcon);
+      
+    //new Image(picture.getImage().getScaledInstance(picture.getImage().getWidth(), picture.getImage().getHeight(), Image.SCALE_FAST));
+//    imageLabel = new ImageView(scrollImageIcon);
+      
+   //   scrollImageIcon.setImage(picture.getImage().getScaledInstance(width, height, Image.SCALE_DEFAULT));
+   //   revalidate();
+    }
+  }
+
+  /**
+   * Setzt den Zoom-Faktor für das Bild.
+   * Als Zoomfaktor sind auch die Konstanten Bildanzeiger.FIT (auf Bildschirmgröße zoomen) und Bildanzeiger.NORMAL (100%) möglich.
+   * @param factor Zoomfaktor (1.0 = 100%). 
+   */
+  public void setZoom(double factor)
+  {
+    zoomFactor = factor;
+    repaint();
+  }
+  
+  
+
+  
+  
+  
+}

imp/Table.ctxt

@@ -0,0 +1,177 @@
+#BlueJ class context
+comment0.target=Table
+comment1.params=
+comment1.target=Table()
+comment1.text=\ \r\n\ Erzeugt\ leeres\ Tabellen-Dokument.\r\n
+comment10.params=filename\ options\ separator\ quote
+comment10.target=void\ saveCSV(java.lang.String,\ java.lang.String,\ char,\ char)
+comment10.text=\ \r\n\ Speichert\ das\ aktuelle\ Dokument\ als\ CSV-Datei.\ \r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enthalten,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ haben\ soll,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ haben\ soll.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n\ @param\ separator\ Trennzeichen\ f\u00FCr\ Spalten\ (meist\ ';'\ oder\ ','\ oder\ '\\t'\ f\u00FCr\ Tab)\r\n\ @param\ quote\ Kennung\ f\u00FCr\ Texte\ (meist\ '"').\ \r\n
+comment11.params=filename
+comment11.target=void\ saveXML(java.lang.String)
+comment11.text=\ Speichert\ die\ Tabelle\ als\ XML-Dokument.\r\n\ \ @param\ filename\ Dateiname\ des\ XML-Files\r\n
+comment12.params=cvsLine
+comment12.target=java.util.List\ parseLine(java.lang.String)
+comment12.text=\ HIlfsfunktion\ f\u00FCr\ die\ Analyse\ einer\ Dateizeile\r\n\ @param\ cvsLine\ Zeile\ aus\ der\ Datei\r\n\ @return\ Liste\ von\ String\ f\u00FCr\ die\ einzelnen\ Spalten\r\n
+comment13.params=cvsLine\ separator
+comment13.target=java.util.List\ parseLine(java.lang.String,\ char)
+comment13.text=\ HIlfsfunktion\ f\u00FCr\ die\ Analyse\ einer\ Dateizeile\r\n\ @param\ cvsLine\ Zeile\ aus\ der\ Datei\r\n\ @param\ sparator\ Trennzeichen\ f\u00FCr\ die\ Spalten\ \r\n\ @return\ Liste\ von\ String\ f\u00FCr\ die\ einzelnen\ Spalten\r\n
+comment14.params=cvsLine\ separator\ customQuote
+comment14.target=java.util.List\ parseLine(java.lang.String,\ char,\ char)
+comment14.text=\ HIlfsfunktion\ f\u00FCr\ die\ Analyse\ einer\ Dateizeile\r\n\ @param\ cvsLine\ Zeile\ aus\ der\ Datei\r\n\ @param\ sparator\ Trennzeichen\ f\u00FCr\ die\ Spalten\ \r\n\ @param\ customQuote\ Kennung\ f\u00FCr\ Strings\r\n\ @return\ Liste\ von\ String\ f\u00FCr\ die\ einzelnen\ Spalten\r\n
+comment15.params=name
+comment15.target=int\ findColumnNumber(java.lang.String)
+comment15.text=\ \r\n\ \ Sucht\ die\ Nummer\ einer\ durch\ Namen\ gegebenen\ Spalte.\r\n\ \ @param\ name\ Name\ der\ Spalte\r\n\ \ @return\ Nummer\ der\ Spalte\r\n
+comment16.params=
+comment16.target=void\ addColumn()
+comment16.text=\r\n\ F\u00FCgt\ eine\ neue\ Spalte\ am\ Ende\ der\ Tabelle\ an.\r\n
+comment17.params=title
+comment17.target=void\ addColumn(java.lang.String)
+comment17.text=\ \r\n\ F\u00FCgt\ eine\ neue\ Spalte\ am\ Ende\ der\ Tabelle\ an\ und\ benennt\ sie.\r\n\ @param\ title\ Bezeichnung\ der\ Spalte\r\n
+comment18.params=title\ type
+comment18.target=void\ addColumn(java.lang.String,\ java.lang.String)
+comment18.text=\r\n\ F\u00FCgt\ eine\ neue\ Spalte\ am\ Ende\ der\ Tabelle\ an\ und\ benennt\ und\ typisiert\ sie.\r\n\ @param\ title\ Bezeichnung\ der\ Spalte\r\n\ @param\ type\ Typ\ der\ Spalte\ (UNKNOWN,\ DOUBLE,\ INTEGER,\ FLOAT)\r\n
+comment19.params=i
+comment19.target=void\ removeColumn(int)
+comment19.text=\r\n\ L\u00F6scht\ eine\ Spalte.\r\n\ @param\ i\ Nummer\ der\ Spalte.\r\n
+comment2.params=filename\ options\ separator\ quote
+comment2.target=Table(java.lang.String,\ java.lang.String,\ char,\ char)
+comment2.text=\ \r\n\ Erzeugt\ Tabellen-Dokument\ aus\ einer\ CSV-Datei.\r\n\ Liest\ den\ Inhalt\ einer\ Datei\ und\ erstellt\ ein\ Tabellenobjekt\ mit\ seinen\ Werten.\ \r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ hat,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt.\r\n\ @param\ separator\ Trennzeichen\ f\u00FCr\ Spalten\ (meist\ ';'\ oder\ ','\ oder\ '\\t'\ f\u00FCr\ Tab)\r\n\ @param\ quote\ Kennung\ f\u00FCr\ Texte\ (meist\ '"').\ \r\n
+comment20.params=name
+comment20.target=void\ removeColumn(java.lang.String)
+comment20.text=\r\n\ L\u00F6scht\ eine\ Spalte\r\n\ @param\ name\ Name\ der\ Spalte\r\n
+comment21.params=
+comment21.target=int\ getColumnCount()
+comment21.text=\r\n\ Liefert\ die\ Anzahl\ der\ Spalten\ in\ der\ Tabelle\r\n\ @return\ Anzahl\ der\ Spalten\r\n
+comment22.params=
+comment22.target=int\ getRowCount()
+comment22.text=\r\n\ Liefert\ die\ Anzahl\ der\ Zeilen\ in\ der\ Tabelle\r\n\ @return\ Anzahl\ der\ Zeilen\r\n
+comment23.params=
+comment23.target=void\ clearRows()
+comment23.text=\ \r\n\ L\u00F6scht\ alle\ Zeilen\ der\ Tabelle.\r\n\ Die\ Spalten\u00FCberschriften\ und\ Typen\ bleiben\ erhalten.\r\n
+comment24.params=
+comment24.target=TableRow\ addRow()
+comment24.text=\r\n\ F\u00FCgt\ eine\ neue\ Zeile\ an\ das\ Ende\ der\ Tabelle\ an.\r\n\ @return\ ein\ TableRow-Objekt\ f\u00FCr\ diese\ neue\ Zeile\r\n
+comment25.params=i
+comment25.target=void\ removeRow(int)
+comment25.text=\r\n\ L\u00F6scht\ eine\ Zeile\r\n\ @param\ i\ Nummer\ der\ Zeile\r\n
+comment26.params=i
+comment26.target=TableRow\ getRow(int)
+comment26.text=\ \r\n\ Liefert\ eine\ Zeile\ der\ Tabelle\r\n\ @param\ i\ Nummer\ der\ Zeile\r\n\ @return\ TableRow-Objekt\ f\u00FCr\ diese\ Zeile\r\n
+comment27.params=
+comment27.target=TableRow[]\ rows()
+comment27.text=\r\n\ Liefert\ die\ ganze\ Tabelle\ als\ Array\ von\ TableRow-Objekten\r\n\ @return\ Array\ von\ TableRow-Objekten\ \r\n
+comment28.params=row\ column
+comment28.target=int\ getInt(int,\ int)
+comment28.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Integer-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment29.params=row\ name
+comment29.target=int\ getInt(int,\ java.lang.String)
+comment29.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Integer-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment3.params=filename\ options
+comment3.target=Table(java.lang.String,\ java.lang.String)
+comment3.text=\ \r\n\ Erzeugt\ Tabellen-Dokument\ aus\ einer\ CSV-Datei.\r\n\ Liest\ den\ Inhalt\ einer\ Datei\ und\ erstellt\ ein\ Tabellenobjekt\ mit\ seinen\ Werten\ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ hat,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt.\r\n
+comment30.params=row\ column\ value
+comment30.target=void\ setInt(int,\ int,\ int)
+comment30.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Integer-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment31.params=row\ name\ value
+comment31.target=void\ setInt(int,\ java.lang.String,\ int)
+comment31.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Integer-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment32.params=row
+comment32.target=int[]\ getIntRow(int)
+comment32.text=\r\n\ Liefert\ alle\ Werte\ einer\ Zeile\ als\ Integer-Array.\r\n\ @param\ row\ Nummer\ der\ Zeile\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Zeile\ enth\u00E4lt\r\n
+comment33.params=column
+comment33.target=int[]\ getIntColumn(int)
+comment33.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Integer-Array.\r\n\ @param\ column\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment34.params=name
+comment34.target=int[]\ getIntColumn(java.lang.String)
+comment34.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Integer-Array.\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment35.params=row\ column
+comment35.target=float\ getFloat(int,\ int)
+comment35.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment36.params=row\ name
+comment36.target=float\ getFloat(int,\ java.lang.String)
+comment36.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment37.params=row\ column\ value
+comment37.target=void\ setFloat(int,\ int,\ float)
+comment37.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment38.params=row\ name\ value
+comment38.target=void\ setFloat(int,\ java.lang.String,\ float)
+comment38.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment39.params=row
+comment39.target=float[]\ getFloatRow(int)
+comment39.text=\r\n\ Liefert\ alle\ Werte\ einer\ Zeile\ als\ Float-Array.\r\n\ @param\ row\ Nummer\ der\ Zeile\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Zeile\ enth\u00E4lt\r\n
+comment4.params=filename
+comment4.target=Table(java.lang.String)
+comment4.text=\ \r\n\ Erzeugt\ Tabellen-Dokument\ aus\ einer\ CSV-Datei.\r\n\ Liest\ den\ Inhalt\ einer\ Datei\ ohne\ Kopfzeile\ und\ erstellt\ ein\ Tabellenobjekt\ mit\ seinen\ Werten\ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n
+comment40.params=column
+comment40.target=float[]\ getFloatColumn(int)
+comment40.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Float-Array.\r\n\ @param\ column\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment41.params=name
+comment41.target=float[]\ getFloatColumn(java.lang.String)
+comment41.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Float-Array.\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment42.params=row\ column
+comment42.target=double\ getDouble(int,\ int)
+comment42.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment43.params=row\ name
+comment43.target=double\ getDouble(int,\ java.lang.String)
+comment43.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment44.params=row\ column\ value
+comment44.target=void\ setDouble(int,\ int,\ double)
+comment44.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment45.params=row\ name\ value
+comment45.target=void\ setDouble(int,\ java.lang.String,\ double)
+comment45.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment46.params=row
+comment46.target=double[]\ getDoubleRow(int)
+comment46.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Double-Array.\r\n\ @param\ row\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment47.params=column
+comment47.target=double[]\ getDoubleColumn(int)
+comment47.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Double-Array.\r\n\ @param\ column\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment48.params=name
+comment48.target=double[]\ getDoubleColumn(java.lang.String)
+comment48.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ Double-Array.\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment49.params=row\ column
+comment49.target=java.lang.String\ getString(int,\ int)
+comment49.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment5.params=filename
+comment5.target=void\ loadCSV(java.lang.String)
+comment5.text=\ \r\n\ Liest\ den\ Inhalt\ einer\ CSV-Datei\ ohne\ Kopfzeile\ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n
+comment50.params=row\ name
+comment50.target=java.lang.String\ getString(int,\ java.lang.String)
+comment50.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment51.params=row\ column\ text
+comment51.target=void\ setString(int,\ int,\ java.lang.String)
+comment51.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ column\ Spaltennummer\r\n\ @param\ text\ neuer\ Wert\ der\ Zelle\r\n
+comment52.params=row\ name\ text
+comment52.target=void\ setString(int,\ java.lang.String,\ java.lang.String)
+comment52.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ row\ Zeilennummer\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ text\ neuer\ Wert\ der\ Zelle\r\n
+comment53.params=row
+comment53.target=java.lang.String[]\ getStringRow(int)
+comment53.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ String-Array.\r\n\ @param\ row\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment54.params=column
+comment54.target=java.lang.String[]\ getStringColumn(int)
+comment54.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ String-Array.\r\n\ @param\ column\ Nummer\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment55.params=name
+comment55.target=java.lang.String[]\ getStringColumn(java.lang.String)
+comment55.text=\r\n\ Liefert\ alle\ Werte\ einer\ Spalte\ als\ String-Array.\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ int-Array,\ dass\ alle\ Werte\ der\ Spalte\ enth\u00E4lt\r\n
+comment56.params=value\ column
+comment56.target=TableRow\ findRow(java.lang.String,\ int)
+comment56.text=\r\n\ Sucht\ nach\ einem\ bestimmtem\ Wert\ in\ einer\ Zeile.\r\n\ @param\ value\ Wert\ der\ gesucht\ werden\ soll\r\n\ @param\ column\ Nummer\ der\ Spalte,\ die\ durchsucht\ werden\ soll\r\n\ @return\ TableRow-Objekt\ der\ Zeile,\ wenn\ der\ Wert\ gefunden\ wurde,\ sonst\ null\r\n
+comment57.params=value\ name
+comment57.target=TableRow\ findRow(java.lang.String,\ java.lang.String)
+comment57.text=\r\n\ Sucht\ nach\ einem\ bestimmtem\ Wert\ in\ einer\ Zeile.\r\n\ @param\ value\ Wert\ der\ gesucht\ werden\ soll\r\n\ @param\ name\ Name\ der\ Spalte,\ die\ durchsucht\ werden\ soll\r\n\ @return\ TableRow-Objekt\ der\ Zeile,\ wenn\ der\ Wert\ gefunden\ wurde,\ sonst\ null\r\n
+comment58.params=
+comment58.target=void\ trim()
+comment58.text=\ \r\n\ K\u00FCrzt\ alle\ Eintr\u00E4ge\ der\ Tabelle\ um\ unn\u00F6tige\ Leerzeichen\ am\ Anfang\ oder\ Ende\r\n
+comment6.params=filename\ options
+comment6.target=void\ loadCSV(java.lang.String,\ java.lang.String)
+comment6.text=\ \r\n\ Liest\ den\ Inhalt\ einer\ CSV-Datei\ \ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ hat,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt.\r\n
+comment7.params=filename\ options\ separator\ quote
+comment7.target=void\ loadCSV(java.lang.String,\ java.lang.String,\ char,\ char)
+comment7.text=\ \r\n\ Liest\ den\ Inhalt\ einer\ CSV-Datei.\r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ hat,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ enth\u00E4lt.\r\n\ @param\ separator\ Trennzeichen\ f\u00FCr\ Spalten\ (meist\ ';'\ oder\ ','\ oder\ '\\t'\ f\u00FCr\ Tab)\r\n\ @param\ quote\ Kennung\ f\u00FCr\ Texte\ (meist\ '"').\ \r\n
+comment8.params=filename
+comment8.target=void\ saveCSV(java.lang.String)
+comment8.text=\ \r\n\ Speichert\ das\ aktuelle\ Dokument\ als\ CSV-Datei\ ohne\ Kopfzeile\ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n
+comment9.params=filename\ options
+comment9.target=void\ saveCSV(java.lang.String,\ java.lang.String)
+comment9.text=\ \r\n\ Speichert\ das\ aktuelle\ Dokument\ als\ CSV-Datei\ (Separator\ \=\ ';',\ Kennung\ f\u00FCr\ Text\ \=\ '"').\ \r\n\ Wenn\ die\ Datei\ eine\ Kopfzeile\ enthalten,\ f\u00FCgen\ Sie\ "header"\ in\ den\ Parameter\ options\ ein.\ Wenn\ die\ Datei\ keine\ Kopfzeile\ haben\ soll,\ \r\n\ dann\ lassen\ Sie\ einfach\ die\ Option\ "header"\ weg.\r\n\ @param\ options\ Geben\ Sie\ hier\ "header"\ an,\ wenn\ die\ Datei\ eine\ Kopfzeile\ haben\ soll.\r\n\ @param\ filename\ Dateiname\ der\ CSV-Datei.\r\n
+numComments=59

imp/Table.java

@@ -0,0 +1,898 @@
+package imp;
+
+ 
+
+/**
+ * Die Klasse Table vereinfacht den Zugriff auf CSV-Dateien.
+ * Die Klassen Table und TableRow ermöglichen einen einfachen Zugriff auf tabellenbasierte
+ * Dokumente. 
+ * 
+ * @author Thomas Schaller
+ * @version 1.0 vom 01.02.2019
+ */
+
+import java.io.File; 
+import java.io.IOException; 
+import java.util.List;
+import java.util.ArrayList; 
+import java.io.*;
+import java.util.Scanner;
+
+import org.jdom.Document; 
+import org.jdom.Element; 
+import org.jdom.Attribute; 
+import org.jdom.JDOMException; 
+import org.jdom.input.SAXBuilder; 
+import org.jdom.output.XMLOutputter; 
+import org.jdom.output.Format;
+
+public class Table  
+{
+    // Standardtrennzeichen für Spalten
+    private static final char DEFAULT_SEPARATOR = ';';
+    // Standardmarkierung für Texte
+    private static final char DEFAULT_QUOTE = '"';
+    // Standardtrennzeichen für Dezimalzahlen
+    private static final char DEFAULT_COMMA = ',';
+
+    // mögliche Spaltentypen
+    private static final String UNKNOWN ="UNKOWN";
+    private static final String INT = "INTEGER";
+    private static final String DOUBLE = "DOUBLE";
+    private static final String FLOAT = "FLOAT";
+  
+    // interne Verwaltung des Dokuments als JDOM-Document-Objekt
+    private Document doc;
+    // Verweis auf Element für Kopfzeile
+    private Element header;
+    // Ende Attribute
+
+    /** 
+     * Erzeugt leeres Tabellen-Dokument.
+     */
+    public Table() {
+        this.doc = new Document();
+        doc.setRootElement(new Element("CSV-Data"));
+        this.header = new Element("Header");
+        doc.getRootElement().addContent(header);
+    }
+
+
+    /** 
+     * Erzeugt Tabellen-Dokument aus einer CSV-Datei.
+     * Liest den Inhalt einer Datei und erstellt ein Tabellenobjekt mit seinen Werten. 
+     * Wenn die Datei eine Kopfzeile enthält, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile hat, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param filename Dateiname der CSV-Datei.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile enthält.
+     * @param separator Trennzeichen für Spalten (meist ';' oder ',' oder '\t' für Tab)
+     * @param quote Kennung für Texte (meist '"'). 
+     */
+    public Table(String filename, String options, char separator, char quote) {
+        loadCSV(filename, options, separator, quote);
+    }
+
+    /** 
+     * Erzeugt Tabellen-Dokument aus einer CSV-Datei.
+     * Liest den Inhalt einer Datei und erstellt ein Tabellenobjekt mit seinen Werten (Separator = ';', Kennung für Text = '"'). 
+     * Wenn die Datei eine Kopfzeile enthält, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile hat, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param filename Dateiname der CSV-Datei.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile enthält.
+     */
+    public Table(String filename, String options) {
+        loadCSV(filename, options);
+    }
+
+    /** 
+     * Erzeugt Tabellen-Dokument aus einer CSV-Datei.
+     * Liest den Inhalt einer Datei ohne Kopfzeile und erstellt ein Tabellenobjekt mit seinen Werten (Separator = ';', Kennung für Text = '"'). 
+     * @param filename Dateiname der CSV-Datei.
+     */
+    public Table(String filename) {
+        loadCSV(filename);
+    }
+
+    // Anfang Methoden
+    /** 
+     * Liest den Inhalt einer CSV-Datei ohne Kopfzeile (Separator = ';', Kennung für Text = '"'). 
+     * @param filename Dateiname der CSV-Datei.
+     */
+    public void loadCSV(String filename) {
+        loadCSV(filename, "");
+    }
+
+    /** 
+     * Liest den Inhalt einer CSV-Datei  (Separator = ';', Kennung für Text = '"'). 
+     * Wenn die Datei eine Kopfzeile enthält, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile hat, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param filename Dateiname der CSV-Datei.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile enthält.
+     */
+    public void loadCSV(String filename, String options) {
+        loadCSV(filename, options, DEFAULT_SEPARATOR, DEFAULT_QUOTE);
+    }
+
+    /** 
+     * Liest den Inhalt einer CSV-Datei.
+     * Wenn die Datei eine Kopfzeile enthält, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile hat, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param filename Dateiname der CSV-Datei.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile enthält.
+     * @param separator Trennzeichen für Spalten (meist ';' oder ',' oder '\t' für Tab)
+     * @param quote Kennung für Texte (meist '"'). 
+     */
+  public void loadCSV(String filename, String options, char separator, char quote) {
+        doc = new Document(); 
+        doc.setRootElement(new Element("CSV-Data"));
+        header = new Element("Header");
+        doc.getRootElement().addContent(header);
+        try {
+            File f = new File(filename);
+            Scanner scanner = new Scanner(new File(filename));
+            if(options.toLowerCase().contains("header") && scanner.hasNext()) {
+                List<String> entries = parseLine(scanner.nextLine(), separator, quote);
+                int i= 0;
+                for(String s : entries) {
+                    Element entry = new Element("Column");
+                    header.addContent(entry);
+                    entry.setText(s);
+                    entry.setAttribute("type", "unknown");
+                    i++;
+                }
+            }
+
+            List<Element> cols = header.getChildren();
+
+            while (scanner.hasNext()) {
+                Element line = new Element("Row");
+                doc.getRootElement().addContent(line);
+                List<String> entries = parseLine(scanner.nextLine(), separator, quote);
+                int i= 0;
+
+                for(String s : entries) {
+
+                    if(i==cols.size()) {
+                        Element entry = new Element("Column");
+                        entry.setAttribute("type", "unknown");
+                        header.addContent(entry);
+                        cols = header.getChildren();
+                    }
+
+                    Element entry = new Element("Entry");
+                    entry.setText(s);
+                    line.addContent(entry);
+                    i++;
+                }
+            }
+            scanner.close();
+
+        } catch (Exception e) { 
+            System.out.println("Fehler beim Lesen der CSV-Datei");
+        }
+    }
+
+    /** 
+     * Speichert das aktuelle Dokument als CSV-Datei ohne Kopfzeile (Separator = ';', Kennung für Text = '"'). 
+     * @param filename Dateiname der CSV-Datei.
+     */
+    public void saveCSV(String filename) {
+        saveCSV(filename, "");
+    }
+
+    /** 
+     * Speichert das aktuelle Dokument als CSV-Datei (Separator = ';', Kennung für Text = '"'). 
+     * Wenn die Datei eine Kopfzeile enthalten, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile haben soll, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile haben soll.
+     * @param filename Dateiname der CSV-Datei.
+   */
+    public void saveCSV(String filename, String options) {
+        saveCSV(filename, options, DEFAULT_SEPARATOR, DEFAULT_QUOTE);
+    }
+
+    /** 
+     * Speichert das aktuelle Dokument als CSV-Datei. 
+     * Wenn die Datei eine Kopfzeile enthalten, fügen Sie "header" in den Parameter options ein. Wenn die Datei keine Kopfzeile haben soll, 
+     * dann lassen Sie einfach die Option "header" weg.
+     * @param options Geben Sie hier "header" an, wenn die Datei eine Kopfzeile haben soll.
+     * @param filename Dateiname der CSV-Datei.
+     * @param separator Trennzeichen für Spalten (meist ';' oder ',' oder '\t' für Tab)
+     * @param quote Kennung für Texte (meist '"'). 
+     */    
+    public void saveCSV(String filename, String options, char separator, char quote){
+        try{
+            File f = new File(filename);
+            PrintStream outputFile = new PrintStream (f);
+            System.out.println("Speicher in : "+f.getAbsolutePath());
+            List<Element> columns = header.getChildren();
+            String sq = ""+quote;
+            String ss = ""+separator;
+            if(quote =='"') sq = "\"";
+            if(separator =='"') ss = "\"";
+
+            if(options.toLowerCase().contains("header")) {
+                String h = "";
+                for(Element c : columns) {
+                    h += ss + sq + c.getText()+sq;
+                }
+                outputFile.println(h.substring(1));
+            }
+            for(int i = 0; i<getRowCount(); i++) {
+                String l = "";
+                for(String s: getStringRow(i)) {
+
+                    if(s.contains(""+separator)) {
+                        if(quote == '"' && s.contains("\"")) {
+                            s = s.replace("\"","\"\"");
+                        }
+                        l += ss + sq + s+sq;
+                    } else {
+                        l += ss+s;
+                    }
+
+                }
+                outputFile.println(l.substring(1));
+            }
+            outputFile.close();
+        }
+        catch(Exception e) {
+            System.out.println("Fehler beim Schreiben der Datei");
+        }
+    }
+
+    /** Speichert die Tabelle als XML-Dokument.
+     *  @param filename Dateiname des XML-Files
+     */
+    public void saveXML(String filename) {
+        try {
+            // new XMLOutputter().output(doc, System.out);
+            XMLOutputter xmlOutput = new XMLOutputter();
+
+            // display nice nice
+            xmlOutput.setFormat(Format.getPrettyFormat());
+            File f = new File(filename);
+            FileOutputStream outputFile = new FileOutputStream(f);
+            System.out.println("Speicher in : "+f.getAbsolutePath() );
+            xmlOutput.output(doc, outputFile);
+            outputFile.close();
+            System.out.println("File Saved!");
+        } catch (IOException io) {
+            System.out.println(io.getMessage());
+        }
+
+    }
+
+    //----------------------------------------------- Zeigerbewegungen --------------------------------------------------
+  
+    /** HIlfsfunktion für die Analyse einer Dateizeile
+      * @param cvsLine Zeile aus der Datei
+      * @return Liste von String für die einzelnen Spalten
+      */
+    private List<String> parseLine(String cvsLine) {
+        return parseLine(cvsLine, DEFAULT_SEPARATOR, DEFAULT_QUOTE);
+    }
+
+    /** HIlfsfunktion für die Analyse einer Dateizeile
+      * @param cvsLine Zeile aus der Datei
+      * @param sparator Trennzeichen für die Spalten 
+      * @return Liste von String für die einzelnen Spalten
+      */
+    private List<String> parseLine(String cvsLine, char separator) {
+        return parseLine(cvsLine, separator, DEFAULT_QUOTE);
+    }
+
+    /** HIlfsfunktion für die Analyse einer Dateizeile
+      * @param cvsLine Zeile aus der Datei
+      * @param sparator Trennzeichen für die Spalten 
+      * @param customQuote Kennung für Strings
+      * @return Liste von String für die einzelnen Spalten
+      */
+    private List<String> parseLine(String cvsLine, char separator, char customQuote) {
+
+        List<String> result = new ArrayList<>();
+
+        //if empty, return!
+        if (cvsLine == null && cvsLine.isEmpty()) {
+            return result;
+        }
+    
+        //ggf. Default-Value laden
+        if (customQuote == ' ') {
+            customQuote = DEFAULT_QUOTE;
+        }
+
+        if (separator == ' ') {
+            separator = DEFAULT_SEPARATOR;
+        }
+
+        StringBuffer curVal = new StringBuffer();
+        boolean inQuotes = false;
+        boolean startCollectChar = false;
+        boolean doubleQuotesInColumn = false;
+
+        char[] chars = cvsLine.toCharArray();
+
+        for (char ch : chars) {
+
+            if (inQuotes) {   // aktueller Text ist in Quotes eingeschlossen
+                startCollectChar = true;
+
+                if (ch == customQuote) {  // Quotes werden beendet, aber Achtung bei "" => Metazeichen
+                    inQuotes = false;
+                    if (ch == '\"') {
+                        doubleQuotesInColumn = true;
+                    }
+
+                } else {
+
+                    if (ch == '\"' && !doubleQuotesInColumn) {
+                        doubleQuotesInColumn = true;
+                    } else {
+                        curVal.append(ch);
+                        doubleQuotesInColumn = false;
+                    }
+
+                }
+            } else {
+                if (ch == customQuote) {
+
+                    inQuotes = true;
+
+                    //Fixed : allow "" in empty quote enclosed
+                    if (ch == '\"'){
+                        if(doubleQuotesInColumn) {
+                            curVal.append('"');
+                            doubleQuotesInColumn = false;
+                        } else doubleQuotesInColumn = true;
+
+
+                    } 
+                }
+                else {
+                    doubleQuotesInColumn = false;
+                    if (ch == separator) {
+
+                        result.add(curVal.toString());
+
+                        curVal = new StringBuffer();
+                        startCollectChar = false;
+
+                    } else if (ch == '\r') {
+                        //ignore LF characters
+                        continue;
+                    } else if (ch == '\n') {
+                        //the end, break!
+                        break;
+                    } else {
+                        curVal.append(ch);
+                    }
+                }
+            }
+
+        }
+        result.add(curVal.toString());
+        return result;
+    }
+  
+    /** 
+     *  Sucht die Nummer einer durch Namen gegebenen Spalte.
+     *  @param name Name der Spalte
+     *  @return Nummer der Spalte
+     */
+      
+    private int findColumnNumber(String name) {
+        List<Element> columns =  header.getChildren();
+        int i = 0;
+        for(Element c : columns) {
+            if (c.getText().toLowerCase().equals(name.toLowerCase())) {
+                return i;
+
+            }
+            i++;
+        }
+        return -1;
+    }
+  
+    /**
+   * Fügt eine neue Spalte am Ende der Tabelle an.
+   */
+    public void addColumn() {
+        Element entry = new Element("Column");
+        entry.setAttribute("type", Table.UNKNOWN);
+        header.addContent(entry); 
+    }
+  
+    /** 
+   * Fügt eine neue Spalte am Ende der Tabelle an und benennt sie.
+   * @param title Bezeichnung der Spalte
+   */
+    public void addColumn(String title) {
+        addColumn();
+        Element nc = ((List<Element>)(header.getChildren())).get(header.getChildren().size()-1);
+        nc.setText(title);
+    }  
+
+    /**
+   * Fügt eine neue Spalte am Ende der Tabelle an und benennt und typisiert sie.
+   * @param title Bezeichnung der Spalte
+   * @param type Typ der Spalte (UNKNOWN, DOUBLE, INTEGER, FLOAT)
+   */
+    public void addColumn(String title, String type) {
+        addColumn(title);
+        Element nc = ((List<Element>)(header.getChildren())).get(header.getChildren().size()-1);
+        nc.setAttribute("type", type);
+    }  
+  
+    /**
+   * Löscht eine Spalte.
+   * @param i Nummer der Spalte.
+   */
+    public void removeColumn(int i) {
+        List<Element> lines = doc.getRootElement().getChildren();
+        for(Element l : lines) {
+            if(l.getChildren().size()>i) l.removeContent(i);
+        }
+    }
+  
+   /**
+   * Löscht eine Spalte
+   * @param name Name der Spalte
+   */
+    public void removeColumn(String name) {
+        try{
+            removeColumn(findColumnNumber(name));
+        } catch(Exception e) { System.out.println("Unbekannter Spaltenname");}
+    }
+  
+  /**
+   * Liefert die Anzahl der Spalten in der Tabelle
+   * @return Anzahl der Spalten
+   */
+    public int getColumnCount() {
+        return header.getChildren().size();
+    }
+  
+  /**
+   * Liefert die Anzahl der Zeilen in der Tabelle
+   * @return Anzahl der Zeilen
+   */
+    public int getRowCount() {
+        return doc.getRootElement().getChildren().size()-1;
+    }
+  
+  /** 
+   * Löscht alle Zeilen der Tabelle.
+   * Die Spaltenüberschriften und Typen bleiben erhalten.
+   */
+    public void clearRows() {  
+        doc.getRootElement().removeChildren("Row");
+    }
+  
+  /**
+   * Fügt eine neue Zeile an das Ende der Tabelle an.
+   * @return ein TableRow-Objekt für diese neue Zeile
+   */
+    public TableRow addRow() {
+        Element row = new Element("Row");
+        doc.getRootElement().addContent(row);
+        return new TableRow(doc, row);
+    }
+  
+  /**
+   * Löscht eine Zeile
+   * @param i Nummer der Zeile
+   */
+    public void removeRow(int i) {
+        if(i<getRowCount()) {
+            doc.getRootElement().removeContent(i);
+        }
+    }
+  
+  /** 
+   * Liefert eine Zeile der Tabelle
+   * @param i Nummer der Zeile
+   * @return TableRow-Objekt für diese Zeile
+   */
+    public TableRow getRow(int i) {
+        if(i<getRowCount()) {
+            List<Element> rows = doc.getRootElement().getChildren();
+            return new TableRow(doc, rows.get(i+1));
+        }
+        return null;
+    }
+  
+  /**
+   * Liefert die ganze Tabelle als Array von TableRow-Objekten
+   * @return Array von TableRow-Objekten 
+   */
+    public TableRow[] rows() {
+        TableRow[] rows = new TableRow[getRowCount()];
+        for(int i = 0; i < getRowCount(); i++) {
+            rows[i] = getRow(i);
+        }
+        return rows;
+    }
+
+  /**
+   * Liefert den Wert einer Zelle als Integer-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @return Wert der Zelle
+   */
+    public int getInt(int row, int column) {
+        return getRow(row).getInt(column);
+    }
+
+  /**
+   * Liefert den Wert einer Zelle als Integer-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @return Wert der Zelle
+   */
+    public int getInt(int row, String name) {
+        return getRow(row).getInt(name);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Integer-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @param value neuer Wert der Zelle
+   */
+    public void setInt(int row, int column,int value) {
+        getRow(row).setInt(column, value);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Integer-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @param value neuer Wert der Zelle
+   */
+    public void setInt(int row, String name, int value) {
+        getRow(row).setInt(name, value);
+    }
+
+  /**
+   * Liefert alle Werte einer Zeile als Integer-Array.
+   * @param row Nummer der Zeile
+   * @return int-Array, dass alle Werte der Zeile enthält
+   */
+    public int[] getIntRow(int row) {
+        try{
+            TableRow trow = getRow(row);
+            int anz = getColumnCount();
+            int[] r = new int[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = trow.getInt(i);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als Integer-Array.
+   * @param column Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public int[] getIntColumn(int column) {
+        try{
+            int anz = getRowCount();
+            int[] r = new int[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = getInt(i, column);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }    
+
+  /**
+   * Liefert alle Werte einer Spalte als Integer-Array.
+   * @param name Name der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public int[] getIntColumn(String name) {
+        return getIntColumn(findColumnNumber(name));
+    }    
+
+  
+  /**
+   * Liefert den Wert einer Zelle als Float-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @return Wert der Zelle
+   */
+    public float getFloat(int row, int column) {
+        return getRow(row).getFloat(column);
+    }
+
+  /**
+   * Liefert den Wert einer Zelle als Float-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @return Wert der Zelle
+   */
+    public float getFloat(int row, String name) {
+        return getRow(row).getFloat(name);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Float-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @param value neuer Wert der Zelle
+   */
+    public void setFloat(int row, int column,float value) {
+        getRow(row).setFloat(column, value);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Float-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @param value neuer Wert der Zelle
+   */
+    public void setFloat(int row, String name, float value) {
+        getRow(row).setFloat(name, value);
+    }
+
+  /**
+   * Liefert alle Werte einer Zeile als Float-Array.
+   * @param row Nummer der Zeile
+   * @return int-Array, dass alle Werte der Zeile enthält
+   */
+    public float[] getFloatRow(int row) {
+        try{
+            TableRow trow = getRow(row);
+            int anz = getColumnCount();
+            float[] r = new float[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = trow.getFloat(i);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als Float-Array.
+   * @param column Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public float[] getFloatColumn(int column) {
+        try{
+            int anz = getRowCount();
+            float[] r = new float[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = getFloat(i, column);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }        
+
+  /**
+   * Liefert alle Werte einer Spalte als Float-Array.
+   * @param name Name der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public float[] getFloatColumn(String name) {
+        return getFloatColumn(findColumnNumber(name));
+    }    
+
+  /**
+   * Liefert den Wert einer Zelle als Double-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @return Wert der Zelle
+   */
+    public double getDouble(int row, int column) {
+        return getRow(row).getDouble(column);
+    }
+
+  /**
+   * Liefert den Wert einer Zelle als Double-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @return Wert der Zelle
+   */
+    public double getDouble(int row, String name) {
+        return getRow(row).getDouble(name);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Double-Zahl
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @param value neuer Wert der Zelle
+   */
+    public void setDouble(int row, int column,double value) {
+        getRow(row).setDouble(column, value);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als Double-Zahl
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @param value neuer Wert der Zelle
+   */
+    public void setDouble(int row, String name, double value) {
+        getRow(row).setDouble(name, value);
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als Double-Array.
+   * @param row Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public double[] getDoubleRow(int row) {
+        try{
+            TableRow trow = getRow(row);
+            int anz = getColumnCount();
+            double[] r = new double[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = trow.getDouble(i);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als Double-Array.
+   * @param column Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public double[] getDoubleColumn(int column) {
+        try{
+            int anz = getRowCount();
+            double[] r = new double[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = getDouble(i, column);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }    
+
+  /**
+   * Liefert alle Werte einer Spalte als Double-Array.
+   * @param name Name der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public double[] getDoubleColumn(String name) {
+        return getDoubleColumn(findColumnNumber(name));
+    }    
+
+  /**
+   * Liefert den Wert einer Zelle als String
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @return Wert der Zelle
+   */
+    public String getString(int row, int column) {
+        return getRow(row).getString(column);
+    }
+
+  /**
+   * Liefert den Wert einer Zelle als String
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @return Wert der Zelle
+   */
+    public String getString(int row, String name) {
+        return getRow(row).getString(name);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als String
+   * @param row Zeilennummer
+   * @param column Spaltennummer
+   * @param text neuer Wert der Zelle
+   */
+    public void setString(int row, int column,String text) {
+        getRow(row).setString(column, text);
+    }
+
+  /**
+   * Setzt den Wert einer Zelle als String
+   * @param row Zeilennummer
+   * @param name Name der Spalte
+   * @param text neuer Wert der Zelle
+   */
+    public void setString(int row, String name, String text) {
+        getRow(row).setString(name, text);
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als String-Array.
+   * @param row Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public String[] getStringRow(int row) {
+        try{
+            TableRow trow = getRow(row);
+            int anz = getColumnCount();
+            String[] r = new String[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = trow.getString(i);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+  /**
+   * Liefert alle Werte einer Spalte als String-Array.
+   * @param column Nummer der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public String[] getStringColumn(int column) {
+        try{
+            int anz = getRowCount();
+            String[] r = new String[anz];
+            for(int i=0; i<anz; i++) {
+                r[i] = getString(i, column);
+            }
+            return r;
+        } catch (Exception e) {
+            return null;
+        }
+    }    
+
+  /**
+   * Liefert alle Werte einer Spalte als String-Array.
+   * @param name Name der Spalte
+   * @return int-Array, dass alle Werte der Spalte enthält
+   */
+    public String[] getStringColumn(String name) {
+        return getStringColumn(findColumnNumber(name));
+    }    
+
+  
+  /**
+   * Sucht nach einem bestimmtem Wert in einer Zeile.
+   * @param value Wert der gesucht werden soll
+   * @param column Nummer der Spalte, die durchsucht werden soll
+   * @return TableRow-Objekt der Zeile, wenn der Wert gefunden wurde, sonst null
+   */
+    public TableRow findRow(String value, int column) {
+        for(int i=0; i<getRowCount(); i++) {
+            if(getString(i,column).equals(value)){
+                return getRow(i);
+            }
+        }
+        return null;
+    }
+
+  /**
+   * Sucht nach einem bestimmtem Wert in einer Zeile.
+   * @param value Wert der gesucht werden soll
+   * @param name Name der Spalte, die durchsucht werden soll
+   * @return TableRow-Objekt der Zeile, wenn der Wert gefunden wurde, sonst null
+   */
+    public TableRow findRow(String value, String name) {
+        return findRow(value, findColumnNumber(name));
+    }
+  
+  /** 
+   * Kürzt alle Einträge der Tabelle um unnötige Leerzeichen am Anfang oder Ende
+   */
+    public void trim() {
+        for(int y=0; y<getRowCount(); y++) {
+            for (int x =0; x<getColumnCount(); x++) {
+                setString(y,x,getString(y,x).trim());
+            }
+        }
+    }
+}

imp/TableRow.ctxt

@@ -0,0 +1,69 @@
+#BlueJ class context
+comment0.target=TableRow
+comment1.params=doc\ row
+comment1.target=TableRow(org.jdom.Document,\ org.jdom.Element)
+comment1.text=\r\n\ \ Erzeugt\ ein\ TableRow-Objekt.\r\n\ Diese\ Methode\ ist\ f\u00FCr\ den\ internen\ Gebraucht.\ Einige\ Methode\ der\ Table-Klasse\ erzeugen\ mit\ diesem\ Konstruktor\ TableRow-Objekte.\r\n\ @param\ doc\ JDOM-Dokument,\ das\ f\u00FCr\ die\ ganze\ Tabelle\ steht.\r\n\ @param\ row\ JDOM-Element,\ das\ f\u00FCr\ die\ aktuelle\ Zeile\ steht.\r\n
+comment10.params=name\ text
+comment10.target=void\ setString(java.lang.String,\ java.lang.String)
+comment10.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ text\ neuer\ Wert\ der\ Zelle\r\n
+comment11.params=i
+comment11.target=int\ getInt(int)
+comment11.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Int-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment12.params=name
+comment12.target=int\ getInt(java.lang.String)
+comment12.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Int-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment13.params=i\ value
+comment13.target=void\ setInt(int,\ int)
+comment13.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Int-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment14.params=name\ value
+comment14.target=void\ setInt(java.lang.String,\ int)
+comment14.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Int-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment15.params=i
+comment15.target=float\ getFloat(int)
+comment15.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment16.params=name
+comment16.target=float\ getFloat(java.lang.String)
+comment16.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment17.params=i\ value
+comment17.target=void\ setFloat(int,\ float)
+comment17.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment18.params=name\ value
+comment18.target=void\ setFloat(java.lang.String,\ float)
+comment18.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Float-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment19.params=i
+comment19.target=double\ getDouble(int)
+comment19.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment2.params=
+comment2.target=int\ getColumnCount()
+comment2.text=\r\n\ Liefert\ die\ Anzahl\ der\ Spalten\ der\ Zeile.\r\n\ @return\ Anzahl\ der\ Spalten\r\n
+comment20.params=name
+comment20.target=double\ getDouble(java.lang.String)
+comment20.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment21.params=i\ value
+comment21.target=void\ setDouble(int,\ double)
+comment21.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment22.params=name\ value
+comment22.target=void\ setDouble(java.lang.String,\ double)
+comment22.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ Double-Zahl\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @param\ value\ neuer\ Wert\ der\ Zelle\r\n
+comment3.params=i
+comment3.target=java.lang.String\ getColumnTitle(int)
+comment3.text=\r\n\ Liefert\ den\ Titel\ einer\ Spalte\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @return\ Name\ der\ Spalte\r\n
+comment4.params=name
+comment4.target=int\ getColumn(java.lang.String)
+comment4.text=\r\n\ Liefert\ die\ Nummer\ einer\ Spalte\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Nummer\ der\ Spalte\r\n
+comment5.params=i
+comment5.target=org.jdom.Element\ buildRow(int)
+comment5.text=\r\n\ Erzeugt\ eine\ neue\ Zeile\ mit\ i\ Spalten\r\n\ Wenn\ bisher\ nicht\ gen\u00FCgend\ Spalten\ vorhanden\ sind,\ werden\ automatisch\ neue\ Spalten\ hinzugef\u00FCgt\ (auch\ zum\ Header)\r\n\ @param\ i\ Anzahl\ der\ Spalten\r\n
+comment6.params=name
+comment6.target=org.jdom.Element\ buildRow(java.lang.String)
+comment6.text=\r\n\ Erzeugt\ eine\ neue\ Zeile.\r\n\ Es\ werden\ gen\u00FCgend\ Spalten\ erzeugt,\ dass\ ein\ Wert\ in\ Spalte\ "name"\ eingetragen\ werden\ kann\r\n\ @param\ name\ Name\ der\ Spalte\r\n
+comment7.params=i
+comment7.target=java.lang.String\ getString(int)
+comment7.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment8.params=name
+comment8.target=java.lang.String\ getString(java.lang.String)
+comment8.text=\r\n\ Liefert\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ name\ Name\ der\ Spalte\r\n\ @return\ Wert\ der\ Zelle\r\n
+comment9.params=i\ text
+comment9.target=void\ setString(int,\ java.lang.String)
+comment9.text=\r\n\ Setzt\ den\ Wert\ einer\ Zelle\ als\ String\r\n\ @param\ i\ Nummer\ der\ Spalte\r\n\ @param\ text\ neuer\ Wert\ der\ Zelle\r\n
+numComments=23

imp/TableRow.java

@@ -0,0 +1,319 @@
+package imp;
+
+   
+
+/**
+ * Repräsentiert eine Zeile eines Table-Objekts.
+ * Erlaubt einen einfachen Zugriff auf die einzelnen Einträge in dieser Zeile.
+ * 
+ * @author Thomas Schaller
+ * @version V1.0 vom 01.02.2019
+ */
+
+import java.io.File; 
+import java.io.IOException; 
+import java.util.List;
+import java.util.ArrayList; 
+import java.io.*;
+import java.util.Scanner;
+
+import org.jdom.Document; 
+import org.jdom.Element; 
+import org.jdom.Attribute; 
+import org.jdom.JDOMException; 
+import org.jdom.input.SAXBuilder; 
+import org.jdom.output.XMLOutputter; 
+import org.jdom.output.Format;
+import java.text.NumberFormat;
+
+ 
+
+public class TableRow  
+{
+    // Verweis auf das ganze Dokument
+  private Document doc;
+    // Verweis auf die Zeile, für die dieses Objekt steht
+  private Element current;
+    // Verweis auf die Kopfzeile
+  private Element header;
+    // Für die Interpretation von Zahlenwerten
+  NumberFormat format = NumberFormat.getInstance();
+
+    // Ende Attribute
+    /**
+   *  Erzeugt ein TableRow-Objekt.
+   * Diese Methode ist für den internen Gebraucht. Einige Methode der Table-Klasse erzeugen mit diesem Konstruktor TableRow-Objekte.
+   * @param doc JDOM-Dokument, das für die ganze Tabelle steht.
+   * @param row JDOM-Element, das für die aktuelle Zeile steht.
+   */
+  public TableRow(Document doc, Element row) {
+    this.doc = doc;
+    this.current = row;
+    this.header = doc.getRootElement().getChild("Header");
+  }
+  
+  /**
+   * Liefert die Anzahl der Spalten der Zeile.
+   * @return Anzahl der Spalten
+   */
+  public int getColumnCount() {
+    return current.getChildren().size();
+  }
+  
+  /**
+   * Liefert den Titel einer Spalte
+   * @param i Nummer der Spalte
+   * @return Name der Spalte
+   */
+  public String getColumnTitle(int i) {
+    if(i< getColumnCount()) {
+      return ((List<Element>) (header.getChildren())).get(i).getText();
+    } else {
+      return "";
+    }
+  }
+  
+   /**
+   * Liefert die Nummer einer Spalte
+   * @param name Name der Spalte
+   * @return Nummer der Spalte
+   */
+  public int getColumn(String name) {
+    List<Element> columns = header.getChildren();
+    int i = 0;
+    while (i < columns.size()) {
+      if (columns.get(i).getText().toLowerCase().equals(name.toLowerCase())) {
+        return i;
+      }
+      i++;
+    } // end of while
+    return -1;
+  }
+    
+    
+    /**
+    * Erzeugt eine neue Zeile mit i Spalten
+    * Wenn bisher nicht genügend Spalten vorhanden sind, werden automatisch neue Spalten hinzugefügt (auch zum Header)
+    * @param i Anzahl der Spalten
+    */
+  private Element buildRow(int i) {
+    List<Element> columns = header.getChildren();
+    Element entry=null;
+    for(int j=0; j<=i; j++) {
+      
+      if(j==columns.size()) {
+        Element h = new Element("Column");
+        h.setAttribute("type", "unknown");
+        header.addContent(h);
+        columns = header.getChildren();
+      }
+      if(j==current.getChildren().size()) {
+        entry = new Element("Entry");
+        current.addContent(entry);
+        
+      }
+      
+    }
+    return entry;
+    
+  }
+    
+    /**
+    * Erzeugt eine neue Zeile.
+    * Es werden genügend Spalten erzeugt, dass ein Wert in Spalte "name" eingetragen werden kann
+    * @param name Name der Spalte
+    */
+  private Element buildRow(String name) {
+    List<Element> columns = header.getChildren();
+    int i = 0;
+    for(Element c: columns) {
+      
+      if(c.getText().toLowerCase().equals(name.toLowerCase())) {
+        return buildRow(i);
+      }
+      i++;
+    }
+    return null;
+    
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als String
+    * @param i Nummer der Spalte
+    * @return Wert der Zelle
+    */
+  public String getString(int i) {
+    if(i >= current.getContent().size()) return "";
+    Element e = (Element) current.getContent(i) ;
+    if(e!=null) {
+      return e.getText();
+    } else {
+      return "";
+    }
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als String
+    * @param name Name der Spalte
+    * @return Wert der Zelle
+    */
+  public String getString(String name) {
+   return getString(getColumn(name));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als String
+    * @param i Nummer der Spalte
+    * @param text neuer Wert der Zelle
+    */
+  public void setString(int i, String text) {
+    
+    Element e = buildRow(i);
+    if(e!=null) e.setText(text);
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als String
+    * @param name Name der Spalte
+    * @param text neuer Wert der Zelle
+    */
+  public void setString(String name, String text) {
+    Element e = buildRow(name);
+    if(e!=null) e.setText(text);
+  }
+    
+    
+    /**
+    * Liefert den Wert einer Zelle als Int-Zahl
+    * @param i Nummer der Spalte
+    * @return Wert der Zelle
+    */
+  public int getInt(int i) {
+    try{
+      Element e = (Element) current.getContent(i) ;
+      return Integer.parseInt(e.getText());
+    } catch(Exception e) {
+      return 0;
+    }
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als Int-Zahl
+    * @param name Name der Spalte
+    * @return Wert der Zelle
+    */
+  public int getInt(String name) {
+    return getInt(getColumn(name));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Int-Zahl
+    * @param i Nummer der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setInt(int i,int value) {
+    
+    Element e = buildRow(i);
+    if(e!=null) e.setText(""+value);
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Int-Zahl
+    * @param name Name der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setInt(String name, int value) {
+    Element e = buildRow(name);
+    if(e!=null) e.setText(""+value);
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als Float-Zahl
+    * @param i Nummer der Spalte
+    * @return Wert der Zelle
+    */       
+  public float getFloat(int i) {
+    try{
+      Element e = (Element) current.getContent(i) ;
+      return Float.parseFloat(e.getText().replace(",","."));
+    } catch(Exception e) {
+      return 0;
+    }
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als Float-Zahl
+    * @param name Name der Spalte
+    * @return Wert der Zelle
+    */
+  public float getFloat(String name) {
+    return getFloat(getColumn(name));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Float-Zahl
+    * @param i Nummer der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setFloat(int i,float value) {
+    
+    Element e = buildRow(i);
+    if(e!=null) e.setText(format.format(value));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Float-Zahl
+    * @param name Name der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setFloat(String name, float value) {
+    Element e = buildRow(name);
+    if(e!=null) e.setText(format.format(value));
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als Double-Zahl
+    * @param i Nummer der Spalte
+    * @return Wert der Zelle
+    */
+  public double getDouble(int i) {
+    try{
+      Element e = (Element) current.getContent(i) ;
+      return Double.parseDouble(e.getText().replace(",","."));
+      
+    } catch(Exception e) {
+      return 0;
+    }
+  }
+    
+    /**
+    * Liefert den Wert einer Zelle als Double-Zahl
+    * @param name Name der Spalte
+    * @return Wert der Zelle
+    */
+  public double getDouble(String name) {
+    return getDouble(getColumn(name));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Double-Zahl
+    * @param i Nummer der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setDouble(int i,double value) {
+    
+    Element e = buildRow(i);
+    if(e!=null) e.setText(format.format(value));
+  }
+    
+    /**
+    * Setzt den Wert einer Zelle als Double-Zahl
+    * @param name Name der Spalte
+    * @param value neuer Wert der Zelle
+    */
+  public void setDouble(String name, double value) {
+    Element e = buildRow(name);
+    if(e!=null) e.setText(format.format(value));
+  }
+    
+}

imp/XML.ctxt

@@ -0,0 +1,135 @@
+#BlueJ class context
+comment0.target=XML
+comment1.params=
+comment1.target=XML()
+comment1.text=\ \r\n\ Erzeugt\ ein\ leeres\ XMLDokument\ \r\n
+comment10.params=name
+comment10.target=XML[]\ getChildren(java.lang.String)
+comment10.text=\r\n\ Liefert\ bestimmte\ Kinder\ des\ Elements\ als\ Array\ von\ XML-Objekten.\ \r\n\ Die\ Methode\ gibt\ dabei\ alle\ Kinder\ zur\u00FCck,\ die\ dem\ angegebenen\ Namen\ entsprechen.\ \r\n\ @param\ name\ Name\ der\ gesuchten\ Kind-Objekte\r\n\ @return\ Array\ der\ Kinder\ als\ XML-Objekte\r\n
+comment11.params=name
+comment11.target=XML\ getChild(java.lang.String)
+comment11.text=\r\n\ Liefert\ das\ erste\ Kind\ des\ Elements\ mit\ einem\ bestimmten\ Namen.\ \r\n\ Die\ Methode\ gibt\ das\ erste\ Kind\ zur\u00FCck,\ das\ dem\ angegebenen\ Namen\ entsprechen.\ \r\n\ @param\ name\ Name\ des\ gesuchten\ Kind-Objektes\r\n\ @return\ Kind\ als\ XML-Objekt\r\n
+comment12.params=i
+comment12.target=XML\ getChild(int)
+comment12.text=\r\n\ Liefert\ das\ i.\ Kind\ des\ Elements.\ \r\n\ Die\ Methode\ gibt\ das\ i.\ Kind\ des\ aktuellen\ Elements\ zur\u00FCck.\r\n\ @param\ i\ Nummer\ des\ Kindes\r\n\ @return\ Kind\ als\ XML-Objekt\r\n
+comment13.params=
+comment13.target=java.lang.String\ getName()
+comment13.text=\ \r\n\ Frage\ den\ Namen\ des\ aktuellen\ Elements\ ab\r\n\ @return\ Namen\ des\ Elements\r\n
+comment14.params=name
+comment14.target=void\ setName(java.lang.String)
+comment14.text=\ \r\n\ Setze\ den\ Namen\ des\ aktuellen\ Elements.\ \r\n\ @param\ name\ Neuer\ Name\ des\ Elements\r\n
+comment15.params=
+comment15.target=int\ getAttributeCount()
+comment15.text=\r\n\ liefert\ die\ Anzahl\ der\ Attribute\ eines\ Elements.\r\n\ @return\ Anzahl\ des\ Attribute\r\n
+comment16.params=
+comment16.target=boolean\ hasAttribute()
+comment16.text=\r\n\ liefert\ zur\u00FCck,\ ob\ das\ aktuelle\ Element\ Attribute\ hat\ .\r\n\ @return\ true,\ wenn\ es\ Attribute\ gibt\r\n
+comment17.params=
+comment17.target=java.lang.String[]\ listAttributes()
+comment17.text=\r\n\ Ruft\ alle\ Attribute\ des\ angegebenen\ Elements\ ab\ und\ gibt\ sie\ als\ Array\ von\ Strings\ zur\u00FCck.\r\n\ @return\ Liste\ der\ Attributnamen\r\n
+comment18.params=attribute
+comment18.target=java.lang.String\ getString(java.lang.String)
+comment18.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @return\ Wert\ des\ Attributs\r\n
+comment19.params=attribute\ defaultValue
+comment19.target=java.lang.String\ getString(java.lang.String,\ java.lang.String)
+comment19.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ Sollte\ es\ das\ Attribut\ nicht\ geben,\ wird\ ein\ default-Wert\ zur\u00FCckgegeben\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ defaultValue\ Standardwert,\ falls\ es\ das\ Attribut\ nicht\ gibt\r\n\ @return\ Wert\ des\ Attributs\r\n
+comment2.params=filename
+comment2.target=XML(java.lang.String)
+comment2.text=\ \r\n\ Erzeugt\ ein\ XML-Dokument\ aus\ einer\ Datei\ \r\n\ @param\ filename\ Dateiname\ der\ XML-Datei\r\n
+comment20.params=attribute\ text
+comment20.target=void\ setString(java.lang.String,\ java.lang.String)
+comment20.text=\ \r\n\ Setzt\ einen\ Attributwert\ des\ aktuellen\ Elements\ \r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ text\ neuer\ Wert\ des\ Attributs\r\n
+comment21.params=attribute
+comment21.target=int\ getInt(java.lang.String)
+comment21.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @return\ Wert\ des\ Attributs\ als\ Integer-Zahl\r\n
+comment22.params=attribute\ defaultValue
+comment22.target=int\ getInt(java.lang.String,\ int)
+comment22.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ Sollte\ es\ das\ Attribut\ nicht\ geben,\ wird\ ein\ default-Wert\ zur\u00FCckgegeben\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ defaultValue\ Standardwert,\ falls\ es\ das\ Attribut\ nicht\ gibt\r\n\ @return\ Wert\ des\ Attributs\ als\ Integer-Zahl\r\n
+comment23.params=attribute\ value
+comment23.target=void\ setInt(java.lang.String,\ int)
+comment23.text=\ \r\n\ Setzt\ einen\ Attributwert\ des\ aktuellen\ Elements\ \r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ value\ neuer\ Wert\ des\ Attributs\r\n
+comment24.params=attribute
+comment24.target=float\ getFloat(java.lang.String)
+comment24.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @return\ Wert\ des\ Attributs\ als\ Float-Zahl\r\n
+comment25.params=attribute\ defaultValue
+comment25.target=float\ getFloat(java.lang.String,\ float)
+comment25.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ Sollte\ es\ das\ Attribut\ nicht\ geben,\ wird\ ein\ default-Wert\ zur\u00FCckgegeben\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ defaultValue\ Standardwert,\ falls\ es\ das\ Attribut\ nicht\ gibt\r\n\ @return\ Wert\ des\ Attributs\ als\ Float-Zahl\r\n
+comment26.params=attribute\ value
+comment26.target=void\ setFloat(java.lang.String,\ float)
+comment26.text=\ \r\n\ Setzt\ einen\ Attributwert\ des\ aktuellen\ Elements\ \r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ value\ neuer\ Wert\ des\ Attributs\r\n
+comment27.params=attribute
+comment27.target=double\ getDouble(java.lang.String)
+comment27.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @return\ Wert\ des\ Attributs\ als\ Double-Zahl\r\n
+comment28.params=attribute\ defaultValue
+comment28.target=double\ getDouble(java.lang.String,\ double)
+comment28.text=\ \r\n\ Fragt\ einen\ Attributwert\ des\ aktuellen\ Elements\ ab\r\n\ Sollte\ es\ das\ Attribut\ nicht\ geben,\ wird\ ein\ default-Wert\ zur\u00FCckgegeben\r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ defaultValue\ Standardwert,\ falls\ es\ das\ Attribut\ nicht\ gibt\r\n\ @return\ Wert\ des\ Attributs\ als\ double-Zahl\r\n
+comment29.params=attribute\ value
+comment29.target=void\ setDouble(java.lang.String,\ double)
+comment29.text=\ \r\n\ Setzt\ einen\ Attributwert\ des\ aktuellen\ Elements\ \r\n\ @param\ attribute\ Name\ des\ Attributs\r\n\ @param\ value\ neuer\ Wert\ des\ Attributs\r\n
+comment3.params=doc\ current
+comment3.target=XML(org.jdom.Document,\ org.jdom.Element)
+comment3.text=\r\n\ interner\ Konstruktor,\ um\ ein\ XML\ Objekt\ zu\ erzeugen,\ das\ auf\ einen\ bestimmten\ Knoten\ verweist\r\n\ @param\ doc\ die\ XML-Dokumentstruktur\r\n\ @param\ current\ Zeiger\ auf\ das\ aktuelle\ Element\ \r\n
+comment30.params=
+comment30.target=java.lang.String\ getContent()
+comment30.text=\ \r\n\ Fragt\ den\ Inhalt/Text\ des\ aktuellen\ Elements\ ab\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment31.params=defaultValue
+comment31.target=java.lang.String\ getContent(java.lang.String)
+comment31.text=\ \r\n\ Fragt\ den\ Inhalt/Text\ des\ aktuellen\ Elements\ ab\r\n\ Hat\ das\ Element\ keinen\ Inhalt\ wird\ der\ defaultValue\ zur\u00FCckgegeben.\r\n\ @param\ defaultValue\ Standardtext\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment32.params=text
+comment32.target=void\ setContent(java.lang.String)
+comment32.text=\ \r\n\ Setzt\ den\ Inhalt/Text\ des\ aktuellen\ Elements\r\n\ @param\ text\ Neuer\ Inhalt\ des\ Elements\r\n
+comment33.params=defaultValue
+comment33.target=int\ getIntContent(int)
+comment33.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Integerzahl\ ab\r\n\ Hat\ das\ Element\ keinen\ Inhalt\ wird\ der\ defaultValue\ zur\u00FCckgegeben.\r\n\ @param\ defaultValue\ Standardwert\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment34.params=
+comment34.target=int\ getIntContent()
+comment34.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Integerzahl\ ab\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment35.params=value
+comment35.target=void\ setIntContent(int)
+comment35.text=\ \r\n\ Setzt\ den\ Inhalt\ des\ aktuellen\ Elements\r\n\ @param\ value\ Neuer\ Inhalt\ des\ Elements\r\n
+comment36.params=defaultValue
+comment36.target=float\ getFloatContent(float)
+comment36.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Floatzahl\ ab\r\n\ Hat\ das\ Element\ keinen\ Inhalt\ wird\ der\ defaultValue\ zur\u00FCckgegeben.\r\n\ @param\ defaultValue\ Standardwert\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment37.params=
+comment37.target=float\ getFloatContent()
+comment37.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Floatzahl\ ab\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment38.params=value
+comment38.target=void\ setFloatContent(float)
+comment38.text=\ \r\n\ Setzt\ den\ Inhalt\ des\ aktuellen\ Elements\r\n\ @param\ value\ Neuer\ Inhalt\ des\ Elements\r\n
+comment39.params=defaultValue
+comment39.target=double\ getDoubleContent(double)
+comment39.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Doublezahl\ ab\r\n\ Hat\ das\ Element\ keinen\ Inhalt\ wird\ der\ defaultValue\ zur\u00FCckgegeben.\r\n\ @param\ defaultValue\ Standardwert\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment4.params=filename
+comment4.target=void\ loadXML(java.lang.String)
+comment4.text=\ \u00D6ffnet\ das\ durch\ den\ Dateinamen\ gegebene\ Dokument\ \r\n\ \ @param\ filename\ Dateiname\ des\ XML-Files\r\n
+comment40.params=
+comment40.target=double\ getDoubleContent()
+comment40.text=\ \r\n\ Fragt\ den\ Inhalt\ des\ aktuellen\ Elements\ als\ Doublezahl\ ab\r\n\ @return\ Inhalt\ des\ Elements\r\n
+comment41.params=value
+comment41.target=void\ setDoubleContent(double)
+comment41.text=\ \r\n\ Setzt\ den\ Inhalt\ des\ aktuellen\ Elements\r\n\ @param\ value\ Neuer\ Inhalt\ des\ Elements\r\n
+comment42.params=name
+comment42.target=XML\ addChild(java.lang.String)
+comment42.text=\ Erzeuge\ neues\ Element\ nach\ der\ aktuellen\ Position\ und\ setze\ dieses\ als\ aktuelles\ Element\r\n\ @param\ name\ Name\ des\ neuen\ Elements\r\n\ @return\ neues\ Element\ als\ XML-Objekt\r\n
+comment43.params=
+comment43.target=org.jdom.Element\ getCurrent()
+comment43.text=\ \r\n\ liefert\ das\ aktuelle\ Element\ als\ jdom-Element-Objekt\r\n\ @return\ aktuelles\ Element\r\n
+comment44.params=kid
+comment44.target=void\ removeChild(XML)
+comment44.text=\r\n\ l\u00F6scht\ ein\ Kind\ des\ aktuellen\ Knotens.\r\n\ Ist\ kid\ kein\ Kind\ des\ aktuellen\ Elements\ passiert\ gar\ nichts.\r\n\ @param\ kid\ XML-Objekt\ des\ Kindes\r\n
+comment5.params=filename
+comment5.target=void\ saveXML(java.lang.String)
+comment5.text=\ Speichert\ den\ XML-Baum\ im\ angegebenen\ Dateinamen\r\n\ \ @param\ filename\ Dateiname\ des\ XML-Files\r\n
+comment6.params=
+comment6.target=XML\ getParent()
+comment6.text=\r\n\ liefert\ ein\ XML-Objekt,\ das\ auf\ den\ Vaterknoten\ des\ aktuellen\ Elements\ zeigt.\r\n\ @return\ Vater\ des\ aktuellen\ Objekts.\r\n
+comment7.params=
+comment7.target=boolean\ hasChildren()
+comment7.text=\r\n\ \u00DCberpr\u00FCft,\ ob\ das\ Element\ irgendwelche\ Kinder\ hat\ oder\ nicht,\ und\ gibt\ das\ Ergebnis\ als\ boolean\ zur\u00FCck.\ \r\n\ @return\ true,\ wenn\ Kinder\ vorhanden\ sind,\ sonst\ false\r\n
+comment8.params=
+comment8.target=java.lang.String[]\ listChildren()
+comment8.text=\r\n\ Ermittelt\ die\ Namen\ aller\ Kinder\ des\ Elements\ und\ gibt\ die\ Namen\ als\ ein\ Array\ von\ Strings\ zur\u00FCck.\ \r\n\ Dies\ ist\ dasselbe\ wie\ das\ Durchlaufen\ und\ Aufrufen\ von\ getName()\ auf\ jedem\ untergeordneten\ Element\ einzeln.\ \r\n\ @return\ Liste\ aller\ Namen\ der\ Kinder\r\n
+comment9.params=
+comment9.target=XML[]\ getChildren()
+comment9.text=\r\n\ Liefert\ alle\ Kinder\ des\ Elements\ als\ Array\ von\ XML-Objekten.\ \r\n\ @return\ Array\ der\ Kinder\ als\ XML-Objekte\r\n
+numComments=45

imp/XML.java

@@ -0,0 +1,639 @@
+package imp;  
+
+/**
+ * Klasse zum Vereinfachten Zugriff auf XML-Dokumente
+ * Diese Klasse ist für den Einsatz in der Schule gedacht und soll den Schülern
+ * einen einfachen Zugriff auf XML-Dokumente ermöglichen. Die zur Verfügung 
+ * stehenden Befehle sind wie in Processing realisiert. 
+ * Dabei ist jeder Teilbaum des Dokuments wieder als XML-Objekt zugreifbar, das
+ * intern auf die gleiche XML-Dokumentstruktur zugreift.
+ * Dies ermöglicht bei unsachgemäßem Gebrauch die XML-Struktur zu zerstören. Im
+ * normalen Gebrauch sollte dies aber nicht relevant sein.
+ * 
+ * Benötigt: jdom-1.1.3.jar 
+ 
+ * @author Thomas Schaller 
+ * @version 1.0 vom 31.01.2019
+ */
+import java.io.File; 
+import java.io.IOException; 
+import java.util.List;
+import java.util.ArrayList; 
+import java.io.*;
+
+import org.jdom.Document; 
+import org.jdom.Element; 
+import org.jdom.Attribute; 
+import org.jdom.JDOMException; 
+import org.jdom.input.SAXBuilder; 
+import org.jdom.output.XMLOutputter; 
+import org.jdom.output.Format;
+
+public class XML {
+    // Anfang Attribute
+    // XML-Dokumentstruktur
+    private Document doc; 
+    // Zeiger auf das aktuelle Element
+    private Element current;
+    // Ende Attribute
+
+    /** 
+      * Erzeugt ein leeres XMLDokument 
+      */
+    public XML() {
+        this.doc = new Document();
+        this.current = null;
+    }
+
+    /** 
+      * Erzeugt ein XML-Dokument aus einer Datei 
+      * @param filename Dateiname der XML-Datei
+      */
+    public XML(String filename) {
+        loadXML(filename);
+    }
+  
+    /**
+   * interner Konstruktor, um ein XML Objekt zu erzeugen, das auf einen bestimmten Knoten verweist
+   * @param doc die XML-Dokumentstruktur
+   * @param current Zeiger auf das aktuelle Element 
+   */
+    private XML(Document doc, Element current) {
+        this.doc = doc;
+        this.current = current;
+    }
+
+    // Anfang Methoden
+    /** Öffnet das durch den Dateinamen gegebene Dokument 
+     *  @param filename Dateiname des XML-Files
+     */
+    public void loadXML(String filename) {
+        doc = null; 
+        File f = new File(filename);
+
+        try { 
+            // Das Dokument erstellen 
+            SAXBuilder builder = new SAXBuilder(); 
+            doc = builder.build(f); 
+
+        } catch (JDOMException e) { 
+            e.printStackTrace(); 
+
+        } catch (IOException e) { 
+            e.printStackTrace(); 
+        } 
+        // Zeiger im Baum auf Root-Element
+        current = doc.getRootElement();
+    }
+
+    /** Speichert den XML-Baum im angegebenen Dateinamen
+     *  @param filename Dateiname des XML-Files
+     */
+    public void saveXML(String filename) {
+        try {
+            // new XMLOutputter().output(doc, System.out);
+            XMLOutputter xmlOutput = new XMLOutputter();
+
+            // display nice nice
+            xmlOutput.setFormat(Format.getPrettyFormat());
+            File f = new File(filename);
+            FileOutputStream outputFile = new FileOutputStream(f);
+            System.out.println("Speicher in : "+f.getAbsolutePath() );
+            xmlOutput.output(doc, outputFile);
+            outputFile.close();
+            System.out.println("File Saved!");
+        } catch (IOException io) {
+            System.out.println(io.getMessage());
+        }
+
+    }
+
+    //----------------------------------------------- Zeigerbewegungen --------------------------------------------------
+    /**
+   * liefert ein XML-Objekt, das auf den Vaterknoten des aktuellen Elements zeigt.
+   * @return Vater des aktuellen Objekts.
+   */
+    public XML getParent() {
+        if(current != null) { 
+            Element parent = current.getParentElement();
+            if (parent == null) {
+                return null;
+            } else {
+                return new XML(doc, parent);
+            }
+        }
+        return null;
+    }
+  
+    /**
+   * Überprüft, ob das Element irgendwelche Kinder hat oder nicht, und gibt das Ergebnis als boolean zurück. 
+   * @return true, wenn Kinder vorhanden sind, sonst false
+   */
+    public boolean hasChildren() {
+        if (current == null) {
+            return doc.hasRootElement();
+        } else {
+            return current.getChildren().size()>0;
+        }
+    }
+
+    /**
+   * Ermittelt die Namen aller Kinder des Elements und gibt die Namen als ein Array von Strings zurück. 
+   * Dies ist dasselbe wie das Durchlaufen und Aufrufen von getName() auf jedem untergeordneten Element einzeln. 
+   * @return Liste aller Namen der Kinder
+   */
+    public String[] listChildren() {
+        if (current == null) {
+            if(doc.hasRootElement()) {
+                String[] names = new String[0];
+                names[0] = doc.getRootElement().getName();
+                return names;
+            } else {
+                return null;
+            }
+        } else {
+            List<Element> ch_element = current.getChildren();
+            String[] names = new String[ch_element.size()];
+            for(int i=0; i < ch_element.size() ; i++) {
+                names[i] = ch_element.get(i).getName();
+            }
+            return names;
+        }
+    }
+  
+    /**
+   * Liefert alle Kinder des Elements als Array von XML-Objekten. 
+   * @return Array der Kinder als XML-Objekte
+   */
+    public XML[] getChildren() {
+        if (current == null) {
+            if(doc.hasRootElement()) {
+                XML[] ch_xml = new XML[1];
+                ch_xml[0] = new XML(doc, doc.getRootElement());
+                return ch_xml;
+            } else {
+                return null;
+            }
+        } else {
+            List<Element> ch_element = current.getChildren();
+            XML[] ch_xml = new XML[ch_element.size()];
+            for(int i=0; i < ch_element.size() ; i++) {
+                ch_xml[i] = new XML(doc, ch_element.get(i));
+            }
+            return ch_xml;
+        }
+    }
+
+    /**
+   * Liefert bestimmte Kinder des Elements als Array von XML-Objekten. 
+   * Die Methode gibt dabei alle Kinder zurück, die dem angegebenen Namen entsprechen. 
+   * @param name Name der gesuchten Kind-Objekte
+   * @return Array der Kinder als XML-Objekte
+   */
+    public XML[] getChildren(String name) {
+        if (current == null) {
+            if(doc.hasRootElement()) {
+                XML[] ch_xml = new XML[1];
+                ch_xml[0] = new XML(doc, doc.getRootElement());
+                if(doc.getRootElement().getName().equals(name)){
+                    return ch_xml;
+                } else {
+                    return null;
+                }
+            } else {
+                return null;
+            }
+        } else {
+            List<Element> ch_element = current.getChildren(name);
+            XML[] ch_xml = new XML[ch_element.size()];
+            for(int i=0; i < ch_element.size() ; i++) {
+                ch_xml[i] = new XML(doc, ch_element.get(i));
+            }
+            return ch_xml;
+        }
+    }
+  
+    /**
+   * Liefert das erste Kind des Elements mit einem bestimmten Namen. 
+   * Die Methode gibt das erste Kind zurück, das dem angegebenen Namen entsprechen. 
+   * @param name Name des gesuchten Kind-Objektes
+   * @return Kind als XML-Objekt
+   */
+
+    public XML getChild(String name) {
+        if (current == null) {
+            Element e = doc.getRootElement();
+            if (e.getName().equals(name)) {
+                return new XML(doc, e);
+            } else {
+                return null;
+            }
+        } else {
+            String[] names = name.split("/");
+            Element e = current;
+            int i = 0;
+            while(i < names.length) {
+                e = e.getChild(names[i]);
+                if (e==null) return null;
+                i++;
+            }
+            return new XML(doc, e);
+        }
+    }
+  
+  /**
+   * Liefert das i. Kind des Elements. 
+   * Die Methode gibt das i. Kind des aktuellen Elements zurück.
+   * @param i Nummer des Kindes
+   * @return Kind als XML-Objekt
+   */
+    public XML getChild(int i) {
+        if (current == null) {
+            return new XML(doc, doc.getRootElement());
+        } else {
+            List<Element> ch_element = current.getChildren();
+            if (i>=ch_element.size()) return null;
+            return new XML(doc, ch_element.get(i));
+        }
+    }
+
+    //--------------------------------------------------- Methoden für das aktuelle Element -------------------------------------------------
+  /** 
+   * Frage den Namen des aktuellen Elements ab
+   * @return Namen des Elements
+   */
+    public String getName() {
+        if (current==null) return "";
+        return current.getName();
+    }
+
+  /** 
+   * Setze den Namen des aktuellen Elements. 
+   * @param name Neuer Name des Elements
+   */
+    public void setName(String name) {
+        if (current==null) return;
+        current.setName(name);
+    }
+  
+  /**
+   * liefert die Anzahl der Attribute eines Elements.
+   * @return Anzahl des Attribute
+   */
+    public int getAttributeCount() {
+        if (current == null) return 0;
+        return current.getAttributes().size();
+    }
+  
+ /**
+   * liefert zurück, ob das aktuelle Element Attribute hat .
+   * @return true, wenn es Attribute gibt
+   */
+    public boolean hasAttribute() {
+        if (current == null) return false;
+        return current.getAttributes().size()>0;
+    }
+
+  /**
+   * Ruft alle Attribute des angegebenen Elements ab und gibt sie als Array von Strings zurück.
+   * @return Liste der Attributnamen
+   */
+    public String[] listAttributes() {
+        if (current == null) return null;
+        List<Attribute> attr = current.getAttributes();
+        String[] names = new String[attr.size()];
+        for(int i=0; i < attr.size() ; i++) {
+            names[i] = attr.get(i).getName();
+        }
+        return names;
+    }
+  
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * @param attribute Name des Attributs
+   * @return Wert des Attributs
+   */
+    public String getString(String attribute) {
+        if (current==null) return "";
+        return current.getAttributeValue(attribute);
+    }
+  
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
+   * @param attribute Name des Attributs
+   * @param defaultValue Standardwert, falls es das Attribut nicht gibt
+   * @return Wert des Attributs
+   */
+    public String getString(String attribute, String defaultValue) {
+        if (current==null) return defaultValue;
+        return current.getAttributeValue(attribute,defaultValue);
+    }
+
+  /** 
+   * Setzt einen Attributwert des aktuellen Elements 
+   * @param attribute Name des Attributs
+   * @param text neuer Wert des Attributs
+   */
+    public void setString(String attribute, String text) {
+        if (current==null) return;
+        current.setAttribute(attribute, text);
+    }
+
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * @param attribute Name des Attributs
+   * @return Wert des Attributs als Integer-Zahl
+   */
+    public int getInt(String attribute) {
+        if (current==null) return 0;
+        try{
+            int i = Integer.parseInt(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return 0; }
+
+    }
+
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
+   * @param attribute Name des Attributs
+   * @param defaultValue Standardwert, falls es das Attribut nicht gibt
+   * @return Wert des Attributs als Integer-Zahl
+   */
+    public int getInt(String attribute, int defaultValue) {
+        if (current==null) return defaultValue;
+        try{
+            int i = Integer.parseInt(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return defaultValue; }
+
+    }
+
+  /** 
+   * Setzt einen Attributwert des aktuellen Elements 
+   * @param attribute Name des Attributs
+   * @param value neuer Wert des Attributs
+   */
+    public void setInt(String attribute, int value) {
+        if (current==null) return;
+        current.setAttribute(attribute, ""+value);
+    }
+
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * @param attribute Name des Attributs
+   * @return Wert des Attributs als Float-Zahl
+   */
+    public float getFloat(String attribute) {
+        if (current==null) return 0;
+        try{
+            float i = Float.parseFloat(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return 0; }
+
+    }
+
+ /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
+   * @param attribute Name des Attributs
+   * @param defaultValue Standardwert, falls es das Attribut nicht gibt
+   * @return Wert des Attributs als Float-Zahl
+   */
+      public float getFloat(String attribute, float defaultValue) {
+        if (current==null) return defaultValue;
+        try{
+            float i = Float.parseFloat(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return defaultValue; }
+
+    }
+
+  /** 
+   * Setzt einen Attributwert des aktuellen Elements 
+   * @param attribute Name des Attributs
+   * @param value neuer Wert des Attributs
+   */
+     public void setFloat(String attribute, float value) {
+        if (current==null) return;
+        current.setAttribute(attribute, ""+value);
+    }
+
+  /** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * @param attribute Name des Attributs
+   * @return Wert des Attributs als Double-Zahl
+   */
+    public double getDouble(String attribute) {
+        if (current==null) return 0;
+        try{
+            double i = Double.parseDouble(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return 0; }
+
+    }
+
+/** 
+   * Fragt einen Attributwert des aktuellen Elements ab
+   * Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
+   * @param attribute Name des Attributs
+   * @param defaultValue Standardwert, falls es das Attribut nicht gibt
+   * @return Wert des Attributs als double-Zahl
+   */
+     public double getDouble(String attribute, double defaultValue) {
+        if (current==null) return defaultValue;
+        try{
+            double i = Double.parseDouble(current.getAttributeValue(attribute));
+            return i;
+        } catch(Exception e) { return defaultValue; }
+
+    }
+
+  /** 
+   * Setzt einen Attributwert des aktuellen Elements 
+   * @param attribute Name des Attributs
+   * @param value neuer Wert des Attributs
+   */
+    public void setDouble(String attribute, double value) {
+        if (current==null) return;
+        current.setAttribute(attribute, ""+value);
+    }
+
+   /** 
+    * Fragt den Inhalt/Text des aktuellen Elements ab
+   * @return Inhalt des Elements
+    */
+    public String getContent() {
+        if ( current==null) return "";
+
+        return current.getText();
+    }
+
+   /** 
+    * Fragt den Inhalt/Text des aktuellen Elements ab
+    * Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
+    * @param defaultValue Standardtext
+    * @return Inhalt des Elements
+    */
+    public String getContent(String defaultValue) {
+        if ( current==null) return defaultValue;
+        String t = current.getText();
+        if(t.equals("")) t = defaultValue;
+        return t;
+    }
+
+   /** 
+   * Setzt den Inhalt/Text des aktuellen Elements
+   * @param text Neuer Inhalt des Elements
+   */
+    public void setContent(String text) {
+        if ( current==null) return;
+        current.setText(text);
+    }
+
+
+   /** 
+    * Fragt den Inhalt des aktuellen Elements als Integerzahl ab
+    * Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
+    * @param defaultValue Standardwert
+    * @return Inhalt des Elements
+    */      public int getIntContent(int defaultValue) {
+        if ( current==null) return defaultValue;
+        try{
+            int i = Integer.parseInt(current.getText());
+            return i;
+        } catch(Exception e) { return defaultValue; }
+    }
+
+   /** 
+    * Fragt den Inhalt des aktuellen Elements als Integerzahl ab
+    * @return Inhalt des Elements
+    */    
+    public int getIntContent() {
+        if ( current==null) return 0;
+        try{
+            int i = Integer.parseInt(current.getText());
+            return i;
+        } catch(Exception e) { return 0; }
+    }
+
+   /** 
+   * Setzt den Inhalt des aktuellen Elements
+   * @param value Neuer Inhalt des Elements
+   */
+    public void setIntContent(int value) {
+        if ( current==null) return;
+        current.setText(""+value);
+    }
+
+ 
+  /** 
+    * Fragt den Inhalt des aktuellen Elements als Floatzahl ab
+    * Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
+    * @param defaultValue Standardwert
+    * @return Inhalt des Elements
+    */    
+      public float getFloatContent(float defaultValue) {
+        if ( current==null) return defaultValue;
+        try{
+            float i = Float.parseFloat(current.getText());
+            return i;
+        } catch(Exception e) { return defaultValue; }
+    }
+
+  /** 
+    * Fragt den Inhalt des aktuellen Elements als Floatzahl ab
+    * @return Inhalt des Elements
+    */     
+    public float getFloatContent() {
+        if ( current==null) return 0;
+        try{
+            float i = Float.parseFloat(current.getText());
+            return i;
+        } catch(Exception e) { return 0; }
+    }
+
+   /** 
+   * Setzt den Inhalt des aktuellen Elements
+   * @param value Neuer Inhalt des Elements
+   */
+       public void setFloatContent(float value) {
+        if ( current==null) return;
+        current.setText(""+value);
+    }
+
+/** 
+    * Fragt den Inhalt des aktuellen Elements als Doublezahl ab
+    * Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
+    * @param defaultValue Standardwert
+    * @return Inhalt des Elements
+    */    
+      public double getDoubleContent(double defaultValue) {
+        if ( current==null) return defaultValue;
+        try{
+            double i = Double.parseDouble(current.getText());
+            return i;
+        } catch(Exception e) { return defaultValue; }
+    }
+
+  /** 
+    * Fragt den Inhalt des aktuellen Elements als Doublezahl ab
+    * @return Inhalt des Elements
+    */  
+     public double getDoubleContent() {
+        if ( current==null) return 0;
+        try{
+            double i = Double.parseDouble(current.getText());
+            return i;
+        } catch(Exception e) { return 0; }
+    }
+  
+   /** 
+   * Setzt den Inhalt des aktuellen Elements
+   * @param value Neuer Inhalt des Elements
+   */
+    public void setDoubleContent(double value) {
+        if ( current==null) return;
+        current.setText(""+value);
+    }
+  
+  
+    // ----------------------------------------------- XML-Struktur aufbauen ------------------------------------------------
+    /** Erzeuge neues Element nach der aktuellen Position und setze dieses als aktuelles Element
+     * @param name Name des neuen Elements
+     * @return neues Element als XML-Objekt
+     */
+    public XML addChild(String name) {
+        Element e = new Element(name);
+        if(current == null){    // man ist auf Root-Ebene
+            doc.setRootElement(e);
+
+        }
+        else {
+            current.addContent(e);
+        } // end of if-else
+        return new XML(doc, e);
+    }
+
+    /** 
+    * liefert das aktuelle Element als jdom-Element-Objekt
+    * @return aktuelles Element
+    */
+    private Element getCurrent() {
+        return current;
+    }
+
+    /**
+   * löscht ein Kind des aktuellen Knotens.
+   * Ist kid kein Kind des aktuellen Elements passiert gar nichts.
+   * @param kid XML-Objekt des Kindes
+   */
+    public void removeChild(XML kid) {
+        if (current == null) return;
+        Element e = kid.getCurrent();
+        int index = current.indexOf(e);
+        if(index >= 0) { current.removeContent(e);}
+    }
+
+}

imp/package.bluej

@@ -0,0 +1,79 @@
+#BlueJ package file
+dependency1.from=PictureViewer
+dependency1.to=Picture
+dependency1.type=UsesDependency
+dependency2.from=Table
+dependency2.to=TableRow
+dependency2.type=UsesDependency
+dependency3.from=Picture
+dependency3.to=PictureViewer
+dependency3.type=UsesDependency
+objectbench.height=89
+objectbench.width=451
+package.divider.horizontal=0.599476439790576
+package.divider.vertical=0.808
+package.editor.height=397
+package.editor.width=649
+package.editor.x=161
+package.editor.y=148
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=3
+package.numTargets=7
+package.showExtends=true
+package.showUses=true
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=PictureViewer
+target1.naviview.expanded=true
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=110
+target1.x=280
+target1.y=310
+target2.height=50
+target2.name=Table
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=80
+target2.x=420
+target2.y=200
+target3.height=50
+target3.name=HSB
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=90
+target3.x=40
+target3.y=200
+target4.height=50
+target4.name=Picture
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=80
+target4.x=180
+target4.y=250
+target5.height=50
+target5.name=XML
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=80
+target5.x=520
+target5.y=220
+target6.height=50
+target6.name=TableRow
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=90
+target6.x=520
+target6.y=150
+target7.height=50
+target7.name=NumberField
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=130
+target7.x=380
+target7.y=70