import javafx.css.ParsedValue; //导入依赖的package包/类
private void resolveRoot(Stylesheet css) {
  css.getRules().stream()
      .filter(r -> r.getSelectors().stream()
          .map(Selector::toString)
          .map(String::trim)
          .filter(s -> s.equals(ROOT))
          .findAny()
          .isPresent())
      .flatMap(r -> r.getDeclarations().stream())
      .forEach(d -> {
        ParsedValue<?, ?> pv = d.getParsedValue();
        ParsedValue<?, ?> resolve = resolve(pv);
        if (classifyValue(resolve.getValue(), d.getProperty(), d.getParsedValue()) == false) {
          classifyValue(resolve.convert(FONT), d.getProperty(), Util.createParsedValue(() -> resolve(pv).convert(FONT)));
        }
      });
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Size convert(ParsedValue<String, Size> value, Font font) {
    Matcher matcher = this.getMatcher(value.getValue(), REGEX);

    // nonsensical input
    if (matcher == null) {
        return null;
    }

    BufferedImage reader;
    try {
        File file = new File(matcher.group(1));
        reader = ImageIO.read(file);
    } catch (IOException e) {
        //e.printStackTrace();
        return null;
    }

    return new Size(reader.getHeight(), SizeUnits.PX);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Color convert(ParsedValue<String, Color> value, Font font) {
    Matcher matcher = getMatcher(value.getValue(), REGEX);

    // nonsensical input
    if (matcher == null) {
        return null;
    }

    double color[] = new double[3];

    for (int i = 1; i <= 3; i++) {
        String group = matcher.group(i);
        if (group.charAt(group.length() - 1) == '%') { // value given in percentage
            color[i-1] = Double.valueOf(group.substring(0, group.length() - 1)) / 100;
        } else { // value given in unsigned 8bit integers
            color[i-1] = Double.valueOf(group) / 255;
        }
        if (color[i-1] > 1.0) {
            return null;
        }
    }

    return new Color(color[0], color[1], color[2], 1.0);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Boolean convert(ParsedValue<String, Boolean> value, Font font) {
    Matcher matcher = getMatcher(value.getValue(), REGEX1);

    if (matcher == null) {
        return false;
    }

    try {
        if (Color.web(matcher.group(1)) != null) {
            return true;
        } else {
            matcher = getMatcher(matcher.group(1), REGEX2);
            return matcher != null;
        }
    } catch (IllegalArgumentException e) {
        return false;
    }
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private boolean classifyValue(Object classObject, String key, ParsedValue<?, ?> value) {
  if (classObject instanceof Paint) {
    paints.put(key, (ParsedValue<?, Paint>) value);
    return true;
  }
  return false;
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public <V, T> ParsedValue<V, T> resolve(ParsedValue<V, T> pv) {
  try {
    if (pv instanceof ParsedValueImpl) {
      ParsedValueImpl<V, T> pvi = (ParsedValueImpl<V, T>) pv;
      if (pvi.isContainsLookups() == false) {
        return pv;
      } else if (pvi.isLookup()) {
        T lookup = lookup(pv.getValue());
        // System.out.printf("lookup %s find %s\n", pv.getValue(), lookup);
        return Util.createParsedValue(lookup);
      } else {
        V value = pv.getValue();
        if (value instanceof ParsedValue) {
          return new ParsedValueImpl<V, T>((V) resolve((ParsedValue<?, ?>) value), pv.getConverter());
        } else if (value instanceof ParsedValue[]) {
          ParsedValue[] originPvs = (ParsedValue[]) value;
          ParsedValue[] pvs = new ParsedValue[originPvs.length];
          for (int i = 0; i < pvs.length; i++) {
            pvs[i] = resolve(originPvs[i]);
          }
          return new ParsedValueImpl<V, T>((V) pvs, pv.getConverter());
        }
      }
    }
  } catch (ClassCastException e) {
    return pv;
  }
  return pv;
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testPixel() {
    String input = "isunit(1px, px)";
    ParsedValue<String, Boolean> value = new ParsedValueImpl<>(input, converter);
    boolean result = converter.convert(value, null);

    assertTrue("Pixel", result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Number convert(ParsedValue<String, Number> value, Font font) {
    Matcher matcher = getMatcher(value.getValue(), REGEX);

    // nonsensical input
    if (matcher == null) {
        return null;
    } else if (matcher.group(1).equals("")) {
        return null;
    }

    return Math.asin(Double.parseDouble(matcher.group(1)));
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testNegDouble() {
    String input = "cos(-3.14159)";
    ParsedValue<String, Number> value = new ParsedValueImpl<>(input, converter);
    Number result = converter.convert(value, null);

    assertNotNull(result);
    assertEquals(Math.cos(-3.14159), result.doubleValue(), 0.0001);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testString() {
    String input = "iscolor(\"String!\")";
    ParsedValue<String, Boolean> value = new ParsedValueImpl<>(input, converter);
    boolean result = converter.convert(value, null);

    assertFalse("String", result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testPercentage() {
    String input = "hsla(180, 50%, 50%, 50%)";
    ParsedValue<String, Color> value = new ParsedValueImpl<>(input, converter);
    Color result = converter.convert(value, null);

    assertNotNull("% not null", result);
    assertEquals("R %", (double)63 / 255, result.getRed(), 0.01);
    assertEquals("G %", (double)191 / 255, result.getGreen(), 0.01);
    assertEquals("B %", (double)191 / 255, result.getBlue(), 0.01);
    assertEquals("alpha %", 0.5, result.getOpacity(), 0.01);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testEmptyParam() {
    String input = "color()";
    ParsedValue<String, Color> value = new ParsedValueImpl<>(input, converter);
    Color result = converter.convert(value, null);

    assertNull(result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public String convert(ParsedValue<String, String> value, Font font) {
    Matcher matcher = this.getMatcher(value.getValue(), REGEX);

    // nonsensical input
    if (matcher == null) {
        return null;
    }
    Double val = Double.valueOf(matcher.group(1)) * 100;
    return new DecimalFormat("#.######").format(val) + "%";
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testNaN() {
    String input = "floor(not a number!)";
    ParsedValue<String, Integer> value = new ParsedValueImpl<>(input, converter);
    Integer result = converter.convert(value, null);

    assertNull(result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 * 
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Number convert(ParsedValue<String, Number> value, Font font) {
    Matcher matcher = this.getMatcher(value.getValue(), REGEX1);

    if (matcher == null) {
        return null;
    }

    // The parameters of the function
    String numbers = matcher.group(1);

    // setting the initial value to the smallest possible double value to ensure that the first parameter is
    // also the first one the others are compared to
    double max = Double.NEGATIVE_INFINITY;

    // matcher for the parameters. It matches the parameter one by one
    matcher = this.getMatcher(numbers, REGEX2);

    // check if parameter list isn't invalid.
    if (matcher == null) {
        return null;
    }

    do {
        // get parameter as string
        String stringValue = matcher.group(1);

        // convert to double
        double val = Double.parseDouble(stringValue);

        // check if above last found maximum
        if (val > max) max = val;
    } while (matcher.find()); // check for next parameter

    return max;
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testInteger() {
    String input = "color(1)";
    ParsedValue<String, Color> value = new ParsedValueImpl<>(input, converter);
    Color result = converter.convert(value, null);

    assertNull(result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
/**
 * Converts the given CSS function call to a Java object.
 *
 * @param value ParsedValue containing the function call
 * @param font Font used for functions that depend on the font size
 * @return The result of the function call as a Java object or null if function call failed
 */
@Override
public Integer convert(ParsedValue<String, Integer> value, Font font) {
    Matcher matcher = this.getMatcher(value.getValue(), REGEX);
    Number val;

    // nonsensical input
    if (matcher == null) {
        return null;
    } else {
        val = new Double(matcher.group(1));
    }
    // LessCSS reference says that "ceil()" is returning an integer unlike Java
    return (int)Math.ceil(val.doubleValue());
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Test
public void testNeg1Double() {
    String input = "pow(-3.2, 2.2)";
    ParsedValue<String, Size> value = new ParsedValueImpl<>(input, converter);
    Size result = converter.convert(value, null);

    assertNull(result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testMissingParameters() {
    String input = "rgb(50%, 50%)";
    ParsedValue<String, Color> value = new ParsedValueImpl<>(input, converter);
    Color result = converter.convert(value, null);

    assertNull("Missing parameters", result);
}
 

import javafx.css.ParsedValue; //导入依赖的package包/类
@Override
public void testEmpty() {
    String input = "atan()";
    ParsedValue<String, Number> value = new ParsedValueImpl<>(input, converter);
    Number result = converter.convert(value, null);

    assertNull(result);
}