2017-06-07 14:17:49 +02:00
|
|
|
package dorkbox.systemTray.util;
|
|
|
|
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
import dorkbox.util.FileUtil;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A simple, basic CSS parser
|
|
|
|
*/
|
|
|
|
public
|
|
|
|
class CssParser {
|
|
|
|
private static final boolean DEBUG = false;
|
|
|
|
private static final boolean DEBUG_NODES = false;
|
|
|
|
private static final boolean DEBUG_GETTING_ATTRIBUTE_FROM_NODES = false;
|
|
|
|
|
|
|
|
private static
|
|
|
|
String trim(String s) {
|
|
|
|
s = s.replaceAll("\n", "");
|
|
|
|
s = s.replaceAll("\t", "");
|
|
|
|
// shrink all whitespace more than 1 space wide.
|
|
|
|
while (s.contains(" ")) {
|
|
|
|
s = s.replaceAll(" ", " ");
|
|
|
|
}
|
|
|
|
return s.trim();
|
|
|
|
}
|
|
|
|
|
|
|
|
public static
|
|
|
|
class CssNode {
|
|
|
|
public final String label;
|
|
|
|
public final List<CssAttribute> attributes;
|
|
|
|
|
|
|
|
CssNode(final String label, final List<CssAttribute> attributes) {
|
|
|
|
this.label = trim(label);
|
|
|
|
this.attributes = attributes;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public
|
|
|
|
String toString() {
|
|
|
|
return label + "\n\t" + Arrays.toString(attributes.toArray());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public static
|
|
|
|
class CssAttribute {
|
|
|
|
public final String key;
|
|
|
|
public final String value;
|
|
|
|
|
|
|
|
CssAttribute(final String key, final String value) {
|
|
|
|
this.key = trim(key);
|
|
|
|
this.value = trim(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public
|
|
|
|
String toString() {
|
|
|
|
return key + ':' + value;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public
|
|
|
|
boolean equals(final Object o) {
|
|
|
|
if (this == o) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (o == null || getClass() != o.getClass()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
final CssAttribute attribute = (CssAttribute) o;
|
|
|
|
|
|
|
|
if (key != null ? !key.equals(attribute.key) : attribute.key != null) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return value != null ? value.equals(attribute.value) : attribute.value == null;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public
|
|
|
|
int hashCode() {
|
|
|
|
int result = key != null ? key.hashCode() : 0;
|
|
|
|
result = 31 * result + (value != null ? value.hashCode() : 0);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the sections of text, of the specified CSS nodes.
|
|
|
|
*
|
|
|
|
* @param css the css text, in it's raw form
|
|
|
|
* @param nodes the section nodes we are interested in (ie: .menuitem, *)
|
|
|
|
* @param states the section state we are interested in (ie: focus, hover, active). Null (or empty list) means no state.
|
|
|
|
*/
|
|
|
|
public static
|
|
|
|
List<CssNode> getSections(String css, String[] nodes, String[] states) {
|
|
|
|
if (states == null) {
|
|
|
|
states = new String[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
// collect a list of all of the sections that have what we are interested in
|
|
|
|
List<CssNode> sections = new ArrayList<CssNode>();
|
|
|
|
|
|
|
|
// now check the css nodes to see if they contain a combination of what we are looking for.
|
|
|
|
for (String node : nodes) {
|
|
|
|
int i = 0;
|
|
|
|
while (i != -1) {
|
|
|
|
i = css.indexOf(node, i);
|
|
|
|
if (i > -1) {
|
|
|
|
int endOfNodeLabels = css.indexOf("{", i);
|
|
|
|
int endOfSection = css.indexOf("}", endOfNodeLabels + 1) + 1;
|
|
|
|
int endOfSectionTest = css.indexOf("}", i) + 1;
|
|
|
|
|
|
|
|
// this makes sure that weird parsing errors don't happen as a result of node keywords appearing in node sections
|
|
|
|
if (endOfSection != endOfSectionTest) {
|
|
|
|
// advance the index
|
|
|
|
i = endOfSection;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
String nodeLabel = css.substring(i, endOfNodeLabels);
|
|
|
|
|
|
|
|
List<CssAttribute> attributes = new ArrayList<CssAttribute>();
|
|
|
|
|
|
|
|
// split the section into an arrayList, one per item. Split by attribute element
|
|
|
|
String nodeSection = css.substring(endOfNodeLabels, endOfSection);
|
|
|
|
int start = nodeSection.indexOf('{') + 1;
|
|
|
|
while (start != -1) {
|
|
|
|
int end = nodeSection.indexOf(';', start);
|
|
|
|
if (end != -1) {
|
|
|
|
int separator = nodeSection.indexOf(':', start);
|
|
|
|
|
|
|
|
if (separator < end) {
|
|
|
|
String key = nodeSection.substring(start, separator);
|
|
|
|
String value = nodeSection.substring(separator + 1, end);
|
2017-07-01 22:01:03 +02:00
|
|
|
|
|
|
|
if (value.contains("url(") || value.contains("url (")) {
|
|
|
|
// this is really a URL , so we have to goto to the closing ');'
|
|
|
|
end = nodeSection.indexOf(')', end);
|
|
|
|
end = nodeSection.indexOf(';', end);
|
|
|
|
value = nodeSection.substring(separator + 1, end);
|
|
|
|
}
|
|
|
|
|
2017-06-07 14:17:49 +02:00
|
|
|
attributes.add(new CssAttribute(key, value));
|
|
|
|
}
|
|
|
|
start = end + 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if the label contains ',' this means that MORE that one CssNode has the same attributes. We want to split that up.
|
|
|
|
int multiIndex = nodeLabel.indexOf(',');
|
|
|
|
if (multiIndex != -1) {
|
|
|
|
multiIndex = 0;
|
|
|
|
while (multiIndex != -1) {
|
|
|
|
int multiEndIndex = nodeLabel.indexOf(',', multiIndex);
|
|
|
|
if (multiEndIndex != -1) {
|
|
|
|
String newLabel = nodeLabel.substring(multiIndex, multiEndIndex);
|
|
|
|
|
|
|
|
sections.add(new CssNode(newLabel, attributes));
|
|
|
|
multiIndex = multiEndIndex+1;
|
|
|
|
} else {
|
|
|
|
// now add the last part of the label.
|
|
|
|
String newLabel = nodeLabel.substring(multiIndex);
|
|
|
|
sections.add(new CssNode(newLabel, attributes));
|
|
|
|
multiIndex = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// we are the only one with these attributes
|
|
|
|
sections.add(new CssNode(nodeLabel, attributes));
|
|
|
|
}
|
|
|
|
|
|
|
|
// advance the index
|
|
|
|
i = endOfSection;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// our sections can ONLY contain what we are looking for, as a word.
|
|
|
|
for (Iterator<CssNode> iterator = sections.iterator(); iterator.hasNext(); ) {
|
|
|
|
final CssNode section = iterator.next();
|
|
|
|
String label = section.label;
|
|
|
|
boolean canSave = false;
|
|
|
|
|
|
|
|
if (!section.attributes.isEmpty()) {
|
|
|
|
main:
|
|
|
|
for (String node : nodes) {
|
|
|
|
if (label.equals(node)) {
|
|
|
|
// exactly what our node is
|
|
|
|
canSave = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (label.length() > node.length() && label.startsWith(node)) {
|
|
|
|
// a combination of our node + MAYBE some other node
|
|
|
|
int index = node.length();
|
|
|
|
label = trim(label.substring(index));
|
|
|
|
|
|
|
|
if (label.charAt(0) == '>') {
|
|
|
|
// if it's an override, we have to check what it overrides.
|
|
|
|
label = label.substring(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// then, this MUST be one of our other nodes (that we are looking for, otherwise remove this section)
|
|
|
|
for (String n : nodes) {
|
|
|
|
//noinspection StringEquality
|
|
|
|
if (n != node && label.startsWith(n)) {
|
|
|
|
canSave = true;
|
|
|
|
break main;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (canSave) {
|
|
|
|
// if this section is for a state we DO NOT care about, remove it
|
|
|
|
int stateIndex = label.lastIndexOf(':');
|
|
|
|
if (stateIndex != -1) {
|
|
|
|
String stateValue = label.substring(stateIndex+1);
|
|
|
|
boolean saveState = false;
|
|
|
|
for (String state : states) {
|
|
|
|
if (stateValue.equals(state)) {
|
|
|
|
// this is a state we care about
|
|
|
|
saveState = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!saveState) {
|
|
|
|
canSave = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!canSave) {
|
|
|
|
iterator.remove();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// now merge all nodes that have the same labels.
|
|
|
|
for (Iterator<CssNode> iterator = sections.iterator(); iterator.hasNext(); ) {
|
|
|
|
final CssNode section = iterator.next();
|
|
|
|
|
|
|
|
if (section != null) {
|
|
|
|
String label = section.label;
|
|
|
|
|
|
|
|
for (int i = 0; i < sections.size(); i++) {
|
|
|
|
final CssNode section2 = sections.get(i);
|
|
|
|
if (section != section2 && section2 != null && label.equals(section2.label)) {
|
|
|
|
sections.set(i, null);
|
|
|
|
|
|
|
|
// now merge both lists.
|
|
|
|
for (CssAttribute attribute : section.attributes) {
|
|
|
|
for (Iterator<CssAttribute> iterator2 = section2.attributes.iterator(); iterator2.hasNext(); ) {
|
|
|
|
final CssAttribute attribute2 = iterator2.next();
|
|
|
|
|
|
|
|
if (attribute.equals(attribute2)) {
|
|
|
|
iterator2.remove();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now both lists are unique.
|
|
|
|
section.attributes.addAll(section2.attributes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// clean up the (possible) null entries.
|
|
|
|
iterator.remove();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// final cleanup loop
|
|
|
|
for (Iterator<CssNode> iterator = sections.iterator(); iterator.hasNext(); ) {
|
|
|
|
final CssNode section = iterator.next();
|
|
|
|
|
|
|
|
if (section.attributes.isEmpty()) {
|
|
|
|
iterator.remove();
|
|
|
|
} else {
|
|
|
|
for (Iterator<CssAttribute> iterator1 = section.attributes.iterator(); iterator1.hasNext(); ) {
|
|
|
|
final CssAttribute attribute = iterator1.next();
|
|
|
|
|
|
|
|
if (attribute == null) {
|
|
|
|
iterator1.remove();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (DEBUG_NODES) {
|
|
|
|
for (CssNode section : sections) {
|
|
|
|
System.err.println("--------------");
|
|
|
|
System.err.println(section);
|
|
|
|
System.err.println("--------------");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return sections;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find an attribute name from the list of sections. The incoming sections will all be related to one of the nodes, we prioritize
|
|
|
|
* them on WHO has the attribute we are looking for.
|
|
|
|
*
|
|
|
|
* @param sections the css sections
|
|
|
|
* @param nodes the nodes (array) of strings (in descending importance) of the section titles we are looking for
|
|
|
|
* @param attributeName the name of the attribute we are looking for.
|
|
|
|
* @param equalsOrContained true if we want to EXACT match, false if the attribute key can contain what we are looking for.
|
|
|
|
*
|
|
|
|
* @return the attribute value, if found
|
|
|
|
*/
|
|
|
|
@SuppressWarnings("Duplicates")
|
|
|
|
public static
|
|
|
|
String getAttributeFromSections(final List<CssNode> sections,
|
|
|
|
final String[] nodes,
|
|
|
|
final String attributeName,
|
|
|
|
boolean equalsOrContained) {
|
|
|
|
|
|
|
|
// a list of sections that contains the exact attribute we are looking for
|
|
|
|
List<CssNode> sectionsWithAttribute = new ArrayList<CssNode>();
|
|
|
|
for (CssNode cssNode : sections) {
|
|
|
|
for (CssAttribute attribute : cssNode.attributes) {
|
|
|
|
if (equalsOrContained) {
|
|
|
|
if (attribute.key.equals(attributeName)) {
|
|
|
|
sectionsWithAttribute.add(cssNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (attribute.key.contains(attributeName)) {
|
|
|
|
sectionsWithAttribute.add(cssNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DEBUG_GETTING_ATTRIBUTE_FROM_NODES) {
|
|
|
|
System.err.println("--------------");
|
|
|
|
System.err.println("Cleaned Sections");
|
|
|
|
System.err.println("--------------");
|
|
|
|
for (CssNode section : sectionsWithAttribute) {
|
|
|
|
System.err.println("--------------");
|
|
|
|
System.err.println(section);
|
|
|
|
System.err.println("--------------");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we only have 1, then return that one
|
|
|
|
if (sectionsWithAttribute.size() == 1) {
|
|
|
|
CssNode cssNode = sectionsWithAttribute.get(0);
|
|
|
|
for (CssAttribute attribute : cssNode.attributes) {
|
|
|
|
if (equalsOrContained) {
|
|
|
|
if (attribute.key.equals(attributeName)) {
|
|
|
|
return attribute.value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (attribute.key.contains(attributeName)) {
|
|
|
|
return attribute.value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// now we need to narrow down which sections have the attribute.
|
|
|
|
// This is because a section can override another, and we want to reflect that info.
|
|
|
|
// If a section has more than one node as it's label, then it has a higher priority, and overrides ones that only have a single label.
|
|
|
|
// IE: "GtkPopover .entry" overrides ".entry"
|
|
|
|
|
|
|
|
|
|
|
|
int maxValue = -1;
|
|
|
|
CssNode maxNode = null; // guaranteed to be non-null
|
|
|
|
|
|
|
|
// not the CLEANEST way to do this, but it works by only choosing css nodes that are important
|
|
|
|
for (CssNode cssNode : sectionsWithAttribute) {
|
|
|
|
int count = 0;
|
|
|
|
for (String node : nodes) {
|
|
|
|
String label = cssNode.label;
|
|
|
|
boolean startsWith = label.startsWith(node);
|
|
|
|
// make sure the . version (if we don't have it specified) isn't counted twice.
|
|
|
|
boolean contains = label.contains(node) && !label.contains('.' + node);
|
|
|
|
|
|
|
|
if (startsWith) {
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
else if (contains) {
|
|
|
|
// if it has MORE than just one node label (that we care about), it's more important that one that is by itself.
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count > maxValue) {
|
|
|
|
maxValue = count;
|
|
|
|
maxNode = cssNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// get the attribute from the highest scoring node
|
|
|
|
//noinspection ConstantConditions
|
2017-06-15 01:21:45 +02:00
|
|
|
if (maxNode != null) {
|
|
|
|
for (CssAttribute attribute : maxNode.attributes) {
|
|
|
|
if (equalsOrContained) {
|
|
|
|
if (attribute.key.equals(attributeName)) {
|
|
|
|
return attribute.value;
|
|
|
|
}
|
2017-06-07 14:17:49 +02:00
|
|
|
}
|
2017-06-15 01:21:45 +02:00
|
|
|
else {
|
|
|
|
if (attribute.key.contains(attributeName)) {
|
|
|
|
return attribute.value;
|
|
|
|
}
|
2017-06-07 14:17:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static
|
|
|
|
void injectAdditionalCss(final File parent, final StringBuilder stringBuilder) {
|
|
|
|
// not the BEST way to do this because duplicates are not merged at all.
|
|
|
|
|
|
|
|
int start = 0;
|
|
|
|
while (start != -1) {
|
|
|
|
// now check if it says: @import url("gtk-main.css")
|
|
|
|
start = stringBuilder.indexOf("@import url(", start);
|
|
|
|
|
|
|
|
if (start != -1) {
|
|
|
|
int end = stringBuilder.indexOf("\")", start);
|
|
|
|
if (end != -1) {
|
|
|
|
String url = stringBuilder.substring(start + 13, end);
|
|
|
|
stringBuilder.delete(start, end + 2); // 2 is the size of ")
|
|
|
|
|
|
|
|
if (DEBUG) {
|
|
|
|
System.err.println("import url: " + url);
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
// now inject the new file where the import command was.
|
|
|
|
File file = new File(parent, url);
|
|
|
|
StringBuilder stringBuilder2 = new StringBuilder((int) (file.length()));
|
|
|
|
FileUtil.read(file, stringBuilder2);
|
|
|
|
|
|
|
|
removeComments(stringBuilder2);
|
|
|
|
|
|
|
|
stringBuilder.insert(start, stringBuilder2);
|
|
|
|
} catch (IOException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@SuppressWarnings("Duplicates")
|
|
|
|
public static
|
|
|
|
void removeComments(final StringBuilder stringBuilder) {
|
|
|
|
// remove block comments, /* .... */ This can span multiple lines
|
|
|
|
int start = 0;
|
|
|
|
while (start != -1) {
|
|
|
|
// get the start of a comment
|
|
|
|
start = stringBuilder.indexOf("/*", start);
|
|
|
|
|
|
|
|
if (start != -1) {
|
|
|
|
// get the end of a comment
|
|
|
|
int end = stringBuilder.indexOf("*/", start);
|
|
|
|
if (end != -1) {
|
|
|
|
stringBuilder.delete(start, end + 2); // 2 is the size of */
|
|
|
|
|
|
|
|
// sometimes when the comments are removed, there is a trailing newline. remove that too. Works for windows too
|
|
|
|
if (stringBuilder.charAt(start) == '\n') {
|
|
|
|
stringBuilder.delete(start, start + 1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now remove comments that start with // (line MUST start with //)
|
|
|
|
start = 0;
|
|
|
|
while (start != -1) {
|
|
|
|
// get the start of a comment
|
|
|
|
start = stringBuilder.indexOf("//", start);
|
|
|
|
|
|
|
|
if (start != -1) {
|
|
|
|
// the comment is at the start of a line
|
|
|
|
if (start == 0 || stringBuilder.charAt(start - 1) == '\n') {
|
|
|
|
// get the end of the comment (the end of the line)
|
|
|
|
int end = stringBuilder.indexOf("\n", start);
|
|
|
|
if (end != -1) {
|
|
|
|
stringBuilder.delete(start, end + 1); // 1 is the size of \n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// sometimes when the comments are removed, there is a trailing newline. remove that too. Works for windows too
|
|
|
|
if (stringBuilder.charAt(start) == '\n') {
|
|
|
|
stringBuilder.delete(start, start + 1);
|
|
|
|
}
|
|
|
|
else if (start > 0) {
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now remove comments that start with # (line MUST start with #)
|
|
|
|
start = 0;
|
|
|
|
while (start != -1) {
|
|
|
|
// get the start of a comment
|
|
|
|
start = stringBuilder.indexOf("#", start);
|
|
|
|
|
|
|
|
if (start != -1) {
|
|
|
|
// the comment is at the start of a line
|
|
|
|
if (start == 0 || stringBuilder.charAt(start - 1) == '\n') {
|
|
|
|
// get the end of the comment (the end of the line)
|
|
|
|
int end = stringBuilder.indexOf("\n", start);
|
|
|
|
if (end != -1) {
|
|
|
|
stringBuilder.delete(start, end + 1); // 1 is the size of \n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// sometimes when the comments are removed, there is a trailing newline. remove that too. Works for windows too
|
|
|
|
if (stringBuilder.charAt(start) == '\n') {
|
|
|
|
stringBuilder.delete(start, start + 1);
|
|
|
|
}
|
|
|
|
else if (start > 0) {
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|