Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
";
}
if (val.startsWith("")) {
return;
}
val = XhtmlDt.preprocessXhtmlNamespaceDeclaration(val);
try {
XhtmlDocument fragment = new XhtmlParser().parse(val, "div");
// Skip the declaration if one was present
XhtmlNodeList nodes = fragment.getChildNodes();
XhtmlNode root = nodes.get((nodes.size() > 0 && nodes.get(0) != null && nodes.get(0).getNodeType() == NodeType.Instruction) ? 1 : 0);
this.attributes = root.attributes;
this.childNodes = root.childNodes;
this.content = root.getContent();
this.name = root.getName();
this.nodeType= root.getNodeType();
} catch (Exception e) {
// TODO: composer shouldn't throw exception like this
throw new RuntimeException(e);
}
}
public XhtmlNode getElementByIndex(int i) {
int c = 0;
for (XhtmlNode n : childNodes)
if (n.getNodeType() == NodeType.Element) {
if (c == i)
return n;
else
c++;
}
return null;
}
@Override
public String getValue() {
return getValueAsString();
}
public boolean hasValue() {
return isNotBlank(getValueAsString());
}
@Override
public XhtmlNode setValue(String theValue) throws IllegalArgumentException {
setValueAsString(theValue);
return this;
}
/**
* Returns false
*/
public boolean hasFormatComment() {
return false;
}
/**
* NOT SUPPORTED - Throws {@link UnsupportedOperationException}
*/
public List getFormatCommentsPre() {
throw new UnsupportedOperationException();
}
/**
* NOT SUPPORTED - Throws {@link UnsupportedOperationException}
*/
public List getFormatCommentsPost() {
throw new UnsupportedOperationException();
}
private Map userData;
private boolean isInPara;
public Object getUserData(String theName) {
if (hasUserData(theName)) {
return userData.get(theName);
} else {
return null;
}
}
public boolean hasUserData(String theName) {
return userData != null && userData.containsKey(theName);
}
public void setUserData(String theName, Object theValue) {
if (userData == null) {
userData = new HashMap<>();
}
userData.put(theName, theValue);
}
public Location getLocation() {
return location;
}
public void setLocation(Location location) {
this.location = location;
}
// xhtml easy adders -----------------------------------------------
@Override
public String toString() {
if (nodeType == null) {
return super.toString();
}
switch (nodeType) {
case Document:
case Element:
try {
return new XhtmlComposer(XhtmlComposer.HTML).compose(this);
} catch (IOException e) {
return super.toString();
}
case Text:
return this.content;
case Comment:
return "";
case DocType:
return "";
case Instruction:
return "";
}
return super.toString();
}
public XhtmlNode getNextElement(XhtmlNode c) {
boolean f = false;
for (XhtmlNode n : childNodes) {
if (n == c)
f = true;
else if (f && n.getNodeType() == NodeType.Element)
return n;
}
return null;
}
public XhtmlNode notPretty() {
notPretty = true;
return this;
}
public boolean isNoPretty() {
return notPretty;
}
public XhtmlNode style(String style) {
if (hasAttribute("style")) {
setAttribute("style", getAttribute("style")+"; "+style);
} else {
setAttribute("style", style);
}
return this;
}
public XhtmlNode nbsp() {
addText(NBSP);
return this;
}
public XhtmlNode para(String text) {
XhtmlNode p = para();
p.addText(text);
return p;
}
public XhtmlNode add(XhtmlNode n) {
addChildNode(n);
return this;
}
public XhtmlNode addChildren(List children) {
addChildNodes(children);
return this;
}
public XhtmlNode addChildren(XhtmlNode x) {
if (x != null) {
addChildNodes(x.getChildNodes());
}
return this;
}
public XhtmlNode input(String name, String type, String placeholder, int size) {
XhtmlNode p = new XhtmlNode(NodeType.Element, "input");
p.attribute("name", name);
p.attribute("type", type);
p.attribute("placeholder", placeholder);
p.attribute("size", Integer.toString(size));
addChildNode(p);
return p;
}
public XhtmlNode select(String name) {
XhtmlNode p = new XhtmlNode(NodeType.Element, "select");
p.attribute("name", name);
p.attribute("size", "1");
addChildNode(p);
return p;
}
public XhtmlNode option(String value, String text, boolean selected) {
XhtmlNode p = new XhtmlNode(NodeType.Element, "option");
p.attribute("value", value);
p.attribute("selected", Boolean.toString(selected));
p.tx(text);
addChildNode(p);
return p;
}
public XhtmlNode remove(XhtmlNode x) {
getChildNodes().remove(x);
return this;
}
public void clear() {
getChildNodes().clear();
}
public XhtmlNode backgroundColor(String color) {
style("background-color: "+color);
return this;
}
public boolean isPara() {
return "p".equals(name);
}
public XhtmlNode sep(String separator) {
// if there's already text, add the separator. otherwise, we'll add it next time
if (!seperated) {
seperated = true;
return this;
}
return tx(separator);
}
// more fluent
public XhtmlNode colspan(String n) {
return setAttribute("colspan", n);
}
public XhtmlNode colspan(int n) {
return setAttribute("colspan", Integer.toString(n));
}
public XhtmlNode rowspan(int n) {
if (n > 1) {
return setAttribute("rowspan", Integer.toString(n));
} else {
return this;
}
}
@Override
protected void addChildren(XhtmlNodeList childNodes) {
this.addChildNodes(childNodes);
}
public XhtmlNode color(String color) {
return span("color: "+color, null);
}
public void startScript(String name) {
if (namedParams != null) {
throw new Error("Sequence Error - script is already open @ "+name);
}
namedParams = new HashMap<>();
namedParamValues = new HashMap<>();
}
public XhtmlNode param(String name) {
if (namedParams == null) {
throw new Error("Sequence Error - script is not already open");
}
XhtmlNode node = new XhtmlNode(NodeType.Element, "p"); // this node is dead will never appear anywhere, but we are in paragraph mode
namedParams.put(name, node);
return node;
}
public void paramValue(String name, String value) {
if (namedParamValues == null) {
throw new Error("Sequence Error - script is not already open");
}
namedParamValues.put(name, value);
}
public void paramValue(String name, int value) {
if (namedParamValues == null) {
throw new Error("Sequence Error - script is not already open");
}
namedParamValues.put(name, Integer.toString(value));
}
/**
* To set up a script, you do the following:
*
* * call startScript - setting up the parameter infrastructure
* * define a set of parameters. Parameter values can be provided as string or integer, or:
* * you can use param(name) to render an arbitrarily complicated html fragment that will be inserted by the script
* * you can redefine parameters with the same name
* * call execScript() to execute the script. You can call this any number of times
* * call closeScript
*
* The script format is an xhtml fragment that can have any html in it, and also the following tags:
* param: - replace this tag with the named parameter (or delete it if no value)
* if: - condition is param op value, where value is a string, and op is =, != <, >
*
* @param structure
* @throws FHIRException
* @throws IOException
*/
public void execScript(String structure) throws FHIRException, IOException {
XhtmlNode script = new XhtmlParser().parseFragment("
"+structure+"
");
parseNodes(script.getChildNodes(), this.getChildNodes());
}
private void parseNodes(XhtmlNodeList source, XhtmlNodeList dest) {
for (XhtmlNode n : source) {
if ("param".equals(n.getName())) {
XhtmlNode node = namedParams.get(n.getAttribute("name"));
if (node != null) {
parseNodes(node.getChildNodes(), dest);
}
} else if ("if".equals(n.getName())) {
String test = n.getAttribute("test");
if (passesTest(test)) {
parseNodes(n.getChildNodes(), dest);
}
} else {
dest.add(n);
}
}
}
public void closeScript() {
if (namedParams == null) {
throw new Error("Sequence Error - script is not already open");
}
namedParams = null;
namedParamValues = null;
}
private boolean passesTest(String test) {
String[] p = test.split("\\s+");
if (p.length != 3) {
return false;
}
if (!namedParamValues.containsKey(p[0])) {
return false;
}
String pv = namedParamValues.get(p[0]);
switch (p[1]) {
case "=": return p[2].equalsIgnoreCase(pv);
case "!=": return !p[2].equalsIgnoreCase(pv);
case "<": return Utilities.isInteger(p[2]) && Utilities.isInteger(pv) && Integer.parseInt(pv) < Integer.parseInt(p[2]);
case "<=": return Utilities.isInteger(p[2]) && Utilities.isInteger(pv) && Integer.parseInt(pv) <= Integer.parseInt(p[2]);
case ">": return Utilities.isInteger(p[2]) && Utilities.isInteger(pv) && Integer.parseInt(pv) > Integer.parseInt(p[2]);
case ">=": return Utilities.isInteger(p[2]) && Utilities.isInteger(pv) && Integer.parseInt(pv) >= Integer.parseInt(p[2]);
}
return false;
}
public XhtmlNode getElementById(String id) {
if (id.equals(getAttribute("id"))) {
return this;
}
if (childNodes != null) {
for (XhtmlNode x : childNodes) {
XhtmlNode r = x.getElementById(id);
if (r != null) {
return r;
}
}
}
return null;
}
public List getChildren(String name) {
List res = new ArrayList<>();
XhtmlNode x = getFirstElement();
while (x != null) {
if (name.equals(x.getName())) {
res.add(x);
}
x = getNextElement(x);
}
return res;
}
public XhtmlNode strikethrough() {
return addTag("s");
}
public XhtmlNode svg() {
return addTag("svg");
}
public XhtmlNode path(String value) {
return addTag("path").attribute("d", value);
}
public void copyAllContent(XhtmlNode other) {
addChildNodes(other.getChildNodes());
getAttributes().putAll(other.getAttributes());
if (!Utilities.noString(other.getContent())) {
tx(other.getContent());
}
}
public boolean isClass(String name) {
return hasAttribute("class", name);
}
public void styleCells(XhtmlNode x) {
setUserData("cells", x);
}
public XhtmlNode td(int index) {
XhtmlNode x = addTag(index, "td");
XhtmlNode t = (XhtmlNode) getUserData("cells");
if (t != null) {
x.copyAllContent(t);
}
return x;
}
public XhtmlNode td() {
XhtmlNode x = addTag("td");
XhtmlNode t = (XhtmlNode) getUserData("cells");
if (t != null) {
x.copyAllContent(t);
}
return x;
}
public XhtmlNode td(int index, String width) {
XhtmlNode x = addTag(index, "td");
x.attribute("width", width);
XhtmlNode t = (XhtmlNode) getUserData("cells");
if (t != null) {
x.copyAllContent(t);
}
return x;
}
public XhtmlNode tdW(int width) {
XhtmlNode x = addTag("td");
x.attribute("width", Integer.toString(width));
XhtmlNode t = (XhtmlNode) getUserData("cells");
if (t != null) {
x.copyAllContent(t);
}
return x;
}
// differs from tx because it returns the owner node, not the created text
public XhtmlNode txN(String cnt) {
addText(cnt);
return this;
}
public XhtmlNode txOrCode(boolean code, String cnt) {
if (code) {
XhtmlNode c = code();
boolean first = true;
for (String line : cnt.split("\\r?\\n")) {
if (first) first = false; else c.br();
c.tx(line.replace(" ", Character.toString(0xA0)));
}
} else {
addText(cnt);
}
return this;
}
public XhtmlNode iff(boolean test) {
if (test) {
return this;
} else {
return new XhtmlNode(NodeType.Element, "span"); // which will never be connected
}
}
public XhtmlNode button(String class_, String title) {
XhtmlNode btn = addTag("button");
btn.attribute("class", class_);
if (title != null) {
btn.attribute("title", title);
}
return btn;
}
public XhtmlNode head() {
return addTag("head");
}
public XhtmlNode body() {
return addTag("body");
}
public XhtmlNode title(String title) {
return addTag("title").tx(title);
}
public XhtmlNode link(String rel, String href) {
return addTag("link").attribute("rel", rel).attribute("href", href);
}
public XhtmlNode ahOrNot(String href) {
if (href == null) {
return this;
}
XhtmlNode x = addTag("a").attribute("href", href);
return x;
}
public void wbr() {
addTag("wbr");
}
protected int indexOfNode(XhtmlNode node) {
return getChildNodes().indexOf(node);
}
public int compareTo(XhtmlNode other) {
return compare(this, other);
}
private static int compare(XhtmlNode base, XhtmlNode other) {
if (base == null || other == null) {
return 0;
} else if (base.getNodeType() != other.getNodeType()) {
return base.getNodeType().ordinal() - other.getNodeType().ordinal();
} else switch (base.getNodeType()) {
case Comment: return base.getContent().compareTo(other.getContent());
case DocType: return 0;
case Element:
int r = base.getName().compareTo(other.getName());
if (r != 0) {
return r;
}
case Document:
if (base.getAttributes().size() != other.getAttributes().size()) {
return base.getAttributes().size() - other.getAttributes().size();
} else {
for (String n : base.getAttributes().keySet()) {
String vb = base.getAttributes().get(n);
String vo = other.getAttributes().get(n);
r = vo == null ? -1 : vb.compareTo(vo);
if (r != 0) {
return r;
}
}
}
if (base.getChildNodes().size() != other.getChildNodes().size()) {
return base.getChildNodes().size() - other.getChildNodes().size();
} else {
for (int i = 0; i < base.getChildNodes().size(); i++) {
r = compare(base, other);
if (r != 0) {
return r;
}
}
}
return 0;
case Instruction: return 0;
case Text: return base.getContent().compareTo(other.getContent());
default: return 0;
}
}
public void stripAnchorsByName(Set anchors) {
if (hasChildren()) {
childNodes.removeIf(n -> "a".equals(n.getName()) && anchors.contains(n.getAttribute("name")));
for (XhtmlNode c : childNodes) {
c.stripAnchorsByName(anchors);
}
}
}
public void addChildNodes(List nodes) {
for (XhtmlNode node : nodes) {
addChildNode(node);
}
}
public void addChildNode(XhtmlNode node) {
checkWhenAddingNode(node);
getChildNodes().add(node);
}
private void checkWhenAddingNode(XhtmlNode node) {
node.checkParaTree = checkParaTree;
if (checkParaTree) {
if (isInPara) {
if (Utilities.existsInList(node.name, "div", "blockquote", "table", "ol", "ul", "p")) {
throw new Error("Error: attempt to add "+node.name+" inside an html paragraph");
}
node.isInPara = true;
}
}
}
public void addChildNode(int index, XhtmlNode node) {
checkWhenAddingNode(node);
getChildNodes().add(index, node);
}
public static boolean isCheckParaGeneral() {
return checkParaGeneral;
}
public static void setCheckParaGeneral(boolean checkParaGeneral) {
XhtmlNode.checkParaGeneral = checkParaGeneral;
}
public boolean isCheckParaTree() {
return checkParaTree;
}
public void setCheckParaTree(boolean checkParaTree) {
this.checkParaTree = checkParaTree;
}
}
