问如何将JavaFX javafx.scene.shape.Path的实例保存到文件

EN

public class SVGConverter {

    private enum PathElementType {

        ARC('a', ArcTo.class, ArcTo::new,
                ArcTo::radiusXProperty,
                ArcTo::radiusYProperty,
                ArcTo::XAxisRotationProperty,
                ArcTo::largeArcFlagProperty,
                ArcTo::sweepFlagProperty,
                ArcTo::xProperty,
                ArcTo::yProperty),
        CLOSE_PATH('z', ClosePath.class, ClosePath::new),
        CUBIC_CURVE('c', CubicCurveTo.class, CubicCurveTo::new,
                CubicCurveTo::controlX1Property,
                CubicCurveTo::controlY1Property,
                CubicCurveTo::controlX2Property,
                CubicCurveTo::controlY2Property,
                CubicCurveTo::xProperty,
                CubicCurveTo::yProperty),
        H_LINE_TO('h', HLineTo.class, HLineTo::new,
                HLineTo::xProperty),
        LINE_TO('l', LineTo.class, LineTo::new,
                LineTo::xProperty, LineTo::yProperty),
        MOVE_TO('m', MoveTo.class, MoveTo::new,
                MoveTo::xProperty, MoveTo::yProperty),
        QUAD_CURVE_TO('q', QuadCurveTo.class, QuadCurveTo::new,
                QuadCurveTo::controlXProperty, QuadCurveTo::controlYProperty,
                QuadCurveTo::xProperty, QuadCurveTo::yProperty),
        V_LINE_TO('v', VLineTo.class, VLineTo::new,
                VLineTo::yProperty);

        private final char letter;
        private final String typeName;
        private final Supplier<? extends PathElement> factory;
        private final Function[] propertyGetters;

        <T extends PathElement> PathElementType(char letter, Class<T> type, Supplier<T> factory, Function<T, ? extends Property<?>>... propertyGetters) {
            this.letter = letter;
            this.typeName = type.getName();
            this.factory = factory;
            this.propertyGetters = propertyGetters;
        }
    }

    private final Map<String, PathElementType> ELEMENT_TYPES_BY_TYPE;
    private final Map<Character, PathElementType> ELEMENT_TYPES_BY_LETTER;

    public SVGConverter() {
        ELEMENT_TYPES_BY_LETTER = new HashMap<>();
        ELEMENT_TYPES_BY_TYPE = new HashMap<>();

        for (PathElementType et : PathElementType.values()) {
            ELEMENT_TYPES_BY_LETTER.put(et.letter, et);
            ELEMENT_TYPES_BY_TYPE.put(et.typeName, et);
        }
    }

    public String pathToSvg(Path path) {
        StringBuilder sb = new StringBuilder();

        for (PathElement element : path.getElements()) {
            PathElementType elementType = ELEMENT_TYPES_BY_TYPE.get(element.getClass().getName());
            if (elementType == null) {
                throw new IllegalArgumentException("Unknown PathElement type: " + element.getClass().getName());
            }

            // specify path element type
            char c = elementType.letter;
            if (element.isAbsolute()) {
                c = Character.toUpperCase(c);
            }
            sb.append(c);

            // write property values
            for (Function f : elementType.propertyGetters) {
                Property property = (Property) f.apply(element);
                sb.append((property instanceof BooleanProperty)
                        // special treatment for booleans to convert true/false to 1/0
                        ? (((BooleanProperty) property).get() ? "1" : "0")
                        : property.getValue().toString()).append(' ');
            }
        }

        // trim, if necessary
        int lastIndex = sb.length() - 1;
        if (lastIndex >= 0 && sb.charAt(lastIndex) == ' ') {
            sb.deleteCharAt(lastIndex);
        }
        return sb.toString();
    }

    private static final String NUMBER_PATTERN_STRING = "[+-]?\\d*\\.\\d*(?:[eE][+-]?\\d+)?";
    private static final Pattern NUMBER_PATTERN = Pattern.compile("(?<![\\d.+-])(" + NUMBER_PATTERN_STRING + ')');
    private static final Pattern SVG_PATTERN = Pattern.compile("([aAcChHlLvmMqQVzZ])((?:\\s*" + NUMBER_PATTERN_STRING + "(?:[\\s,]+" + NUMBER_PATTERN_STRING + ")*)?)");

    // parses doubles from number sequence
    private static double[] getNumberMatches(Matcher m, int count) {
        double[] result = new double[count];
        for (int i = 0; i < count; i++) {
            if (!m.find()) {
                throw new IllegalArgumentException("missing numbers");
            }
            result[i] = Double.parseDouble(m.group(1));
        }
        if (m.find()) {
            throw new IllegalArgumentException("too many numbers");
        }
        return result;
    }

    public Path svgToPath(String svg) {
        Path path = new Path();
        Matcher matcher = SVG_PATTERN.matcher(svg);
        while (matcher.find()) {
            // find out path element type
            char c = matcher.group(1).charAt(0);
            PathElementType elementType = ELEMENT_TYPES_BY_LETTER.get(Character.toLowerCase(c));
            if (elementType == null) {
                throw new IllegalArgumentException("Unknown path type " + c);
            }

            PathElement element = (PathElement) elementType.factory.get();
            element.setAbsolute(Character.isUpperCase(c));

            // retrieve parameters
            if (elementType.propertyGetters.length > 0) {
                Matcher numberMatcher = NUMBER_PATTERN.matcher(matcher.group(2));
                double[] numbers = getNumberMatches(numberMatcher, elementType.propertyGetters.length);
                for (int i = 0; i < elementType.propertyGetters.length; i++) {
                    Property property = (Property) elementType.propertyGetters[i].apply(element);
                    property.setValue((property instanceof BooleanProperty)
                            ? (numbers[i] == 1) // convert to boolean (true iff 1.0)
                            : numbers[i]);
                }
            }
            path.getElements().add(element);
        }
        return path;
    }
}