Implementing save/open with RichTextFX?

Question

Here is my code:

private void save(File file) {

    StyledDocument<ParStyle, Either<StyledText<TextStyle>, LinkedImage<TextStyle>>, TextStyle> doc = textarea.getDocument();

    // Use the Codec to save the document in a binary format
    textarea.getStyleCodecs().ifPresent(codecs -> {
        Codec<StyledDocument<ParStyle, Either<StyledText<TextStyle>, LinkedImage<TextStyle>>, TextStyle>> codec
                = ReadOnlyStyledDocument.codec(codecs._1, codecs._2, textarea.getSegOps());
        try {
            FileOutputStream fos = new FileOutputStream(file);
            DataOutputStream dos = new DataOutputStream(fos);
            codec.encode(dos, doc);
            fos.close();
        } catch (IOException fnfe) {
            fnfe.printStackTrace();
        }
    });
}

I am trying to implement the save/loading from the demo from here on the RichTextFX GitHub.

I am getting errors in the following lines:

StyledDocument<ParStyle, Either<StyledText<TextStyle>, LinkedImage<TextStyle>>, TextStyle> doc = textarea.getDocument();

error: incompatible types: StyledDocument<Collection<String>,StyledText<Collection<String>>,Collection<String>> cannot be converted to StyledDocument<ParStyle,Either<StyledText<TextStyle>,LinkedImage<TextStyle>>,TextStyle>

and

= ReadOnlyStyledDocument.codec(codecs._1, codecs._2, textarea.getSegOps());

error: incompatible types: inferred type does not conform to equality constraint(s) inferred: ParStyle equality constraints(s): ParStyle,Collection<String>

I have added all the required .java files and imported them into my main code. I thought it would be relatively trivial to implement this demo but it has been nothing but headaches.

If this cannot be resolved, does anyone know an alternative way to save the text with formatting from RichTextFX?

Thank you

Answer 1

This question is quite old, but since i ran into the same problem i figured a solution might be useful to others as well. In the demo, the code from which you use, ParStyle and TextStyle (Custom Types) are used for defining how information about the style is stored. The error messages you get pretty much just tell you that your way of storing the information about the style (In your case in a String) is not compatible with the way it is done in the demo. If you want to store the style in a String, which i did as well, you need to implement some way of serializing and deserializing the information yourself. You can do that, for example (I used an InlineCssTextArea), in the following way:

public class SerializeManager {
    public static final String PAR_REGEX = "#!par!#";
    public static final String PAR_CONTENT_REGEX = "#!pcr!#";
    public static final String SEG_REGEX = "#!seg!#";
    public static final String SEG_CONTENT_REGEX = "#!scr!#";

    public static String serialized(InlineCssTextArea textArea) {
        StringBuilder builder = new StringBuilder();

        textArea.getDocument().getParagraphs().forEach(par -> {

            builder.append(par.getParagraphStyle());
            builder.append(PAR_CONTENT_REGEX);

            par.getStyledSegments().forEach(seg -> builder
                    .append(
                            seg.getSegment()
                                    .replaceAll(PAR_REGEX, "")
                                    .replaceAll(PAR_CONTENT_REGEX, "")
                                    .replaceAll(SEG_REGEX, "")
                                    .replaceAll(SEG_CONTENT_REGEX, "")
                    )
                    .append(SEG_CONTENT_REGEX)
                    .append(seg.getStyle())
                    .append(SEG_REGEX)
            );
            builder.append(PAR_REGEX);
        });

        String textAreaSerialized = builder.toString();
        return textAreaSerialized;
    }

    public static InlineCssTextArea fromSerialized(String string) {
        InlineCssTextArea textArea = new InlineCssTextArea();
        ReadOnlyStyledDocumentBuilder<String, String, String> builder = new ReadOnlyStyledDocumentBuilder<>(
                SegmentOps.styledTextOps(),
                ""
        );

        if (string.contains(PAR_REGEX)) {
            String[] parsSerialized = string.split(PAR_REGEX);

            for (int i = 0; i < parsSerialized.length; i++) {
                String par = parsSerialized[i];
                String[] parContent = par.split(PAR_CONTENT_REGEX);
                String parStyle = parContent[0];

                List<String> segments = new ArrayList<>();
                StyleSpansBuilder<String> spansBuilder = new StyleSpansBuilder<>();
                String styleSegments = parContent[1];

                Arrays.stream(styleSegments.split(SEG_REGEX)).forEach(seg -> {
                    String[] segContent = seg.split(SEG_CONTENT_REGEX);

                    segments.add(segContent[0]);
                    if (segContent.length > 1) {
                        spansBuilder.add(segContent[1], segContent[0].length());
                    } else {
                        spansBuilder.add("", segContent[0].length());
                    }
                });
                StyleSpans<String> spans = spansBuilder.create();
                builder.addParagraph(segments, spans, parStyle);
            }
            textArea.append(builder.build());
        }
        return textArea;
    }
}

You can then take the serialized InlineCssTextArea, write the resulting String to a file, and load and deserialize it. As you can see in the code, i made up some Strings as regexes which will be removed in the serialization process (We don't want our Serializer to be injectable, do we ;)). You can change these to whatever you like, just note they will be removed if used in the text of the TextArea, so they should be something users wont miss in their TextArea. Also note that this solution serializes the Style of the Text, the Text itself and the Paragraph style, BUT not inserted images or parameters of the TextArea (such as width and height), just the text content of the TextArea with its Style. This issue on github really helped me btw.