mirror of
https://codeberg.org/qg-info-unterricht/zpg-graphentester.git
synced 2026-03-25 04:58:24 +01:00
First Commit (Fobi)
This commit is contained in:
Frank Schiebel
commit
2bff291a51
336 changed files with 88781 additions and 0 deletions
639
imp/XML.java
Normal file
639
imp/XML.java
Normal file
|
|
@ -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);}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue